This is an archive of the discontinued LLVM Phabricator instance.

Differential D157518

Avoid running optimization passes in frontend test
ClosedPublic

Authored by MatzeB on Aug 9 2023, 9:39 AM.

Details

Reviewers
wenlei
Mordante
aeubanks
hoy
Commits
rGf8431a0e4008: Avoid running optimization passes in frontend test

Diff Detail

Event Timeline

MatzeB created this revision.Aug 9 2023, 9:39 AM
Herald added a project: Restricted Project. · View Herald TranscriptAug 9 2023, 9:39 AM
Herald added subscribers: modimo, mcrosier. · View Herald Transcript
MatzeB requested review of this revision.Aug 9 2023, 9:39 AM
Herald added a project: Restricted Project. · View Herald TranscriptAug 9 2023, 9:39 AM
Herald added a subscriber: cfe-commits. · View Herald Transcript
MatzeB added a child revision: D157462: LoopRotate: Add code to update branch weights.Aug 9 2023, 9:41 AM
MatzeB updated this revision to Diff 548655.Aug 9 2023, 9:50 AM

Decided to just use "utils/update_cc_test_checks.py" so we can inspect the generate llvm.expect calls directly.

MatzeB edited the summary of this revision. (Show Details)Aug 9 2023, 9:50 AM
aeubanks accepted this revision.Aug 9 2023, 9:53 AM

seems fine if nobody else objects

This revision is now accepted and ready to land.Aug 9 2023, 9:53 AM
MatzeB updated this revision to Diff 548657.Aug 9 2023, 9:56 AM
Harbormaster completed remote builds in B251414: Diff 548657.Aug 9 2023, 3:28 PM
wenlei added inline comments.Sep 5 2023, 7:29 AM
clang/test/CodeGenCXX/attr-likelihood-if-branch-weights.cpp
147–148

I thought this is the purpose of the test, which is no longer checked after change?

aeubanks added inline comments.Sep 5 2023, 9:58 AM
clang/test/CodeGenCXX/attr-likelihood-if-branch-weights.cpp
147–148

those should be covered by LowerExpectIntrinsic tests

MatzeB marked 2 inline comments as done.Sep 5 2023, 11:21 AM
MatzeB added inline comments.
clang/test/CodeGenCXX/attr-likelihood-if-branch-weights.cpp
147–148

The frontend rewrites [[likely]] and [[unlikely]] into calls to llvm.expect. And this is still tested here. Running lower-expect-intrinsic pass to lower the llvm.expect to !prof annotations doesn't need to be tested here as we have separate tests for that pass.

wenlei accepted this revision.Sep 5 2023, 11:35 AM

lgtm, thanks.

clang/test/CodeGenCXX/attr-likelihood-if-branch-weights.cpp
147–148

Ah, makes sense. I see that we have existing coverage for lowering llvm.expect to !prof in expect-*.ll, so we're good.

Closed by commit rGf8431a0e4008: Avoid running optimization passes in frontend test (authored by MatzeB). · Explain WhySep 11 2023, 10:39 AM
This revision was automatically updated to reflect the committed changes.
MatzeB added a commit: rGf8431a0e4008: Avoid running optimization passes in frontend test.

Revision Contents

PathSize
clang/
test/
CodeGenCXX/
293 lines

Diff 556454

clang/test/CodeGenCXX/attr-likelihood-if-branch-weights.cpp

// RUN: %clang_cc1 -O1 -emit-llvm %s -o - -triple=x86_64-linux-gnu | FileCheck -DLIKELY=2000 -DUNLIKELY=1 %s // NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py
// RUN: %clang_cc1 -O1 -emit-llvm %s -triple=x86_64-linux-gnu -mllvm -likely-branch-weight=99 -mllvm -unlikely-branch-weight=42 -o - | FileCheck -DLIKELY=99 -DUNLIKELY=42 %s // RUN: %clang_cc1 -O1 -disable-llvm-passes -emit-llvm %s -o - -triple=x86_64-- | FileCheck %s
extern volatile bool b; extern volatile bool b;
extern volatile int i; extern volatile int i;
extern bool A(); extern bool A();
extern bool B(); extern bool B();
// CHECK-LABEL: @_Z1fv(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[RETVAL:%.*]] = alloca i1, align 1
// CHECK-NEXT: [[TMP0:%.*]] = load volatile i8, ptr @b, align 1, !tbaa [[TBAA2:![0-9]+]], !range [[RNG6:![0-9]+]]
// CHECK-NEXT: [[TOBOOL:%.*]] = trunc i8 [[TMP0]] to i1
// CHECK-NEXT: [[TOBOOL_EXPVAL:%.*]] = call i1 @llvm.expect.i1(i1 [[TOBOOL]], i1 true)
// CHECK-NEXT: br i1 [[TOBOOL_EXPVAL]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
// CHECK: if.then:
// CHECK-NEXT: [[CALL:%.*]] = call noundef zeroext i1 @_Z1Av()
// CHECK-NEXT: store i1 [[CALL]], ptr [[RETVAL]], align 1
// CHECK-NEXT: br label [[RETURN:%.*]]
// CHECK: if.end:
// CHECK-NEXT: [[CALL1:%.*]] = call noundef zeroext i1 @_Z1Bv()
// CHECK-NEXT: store i1 [[CALL1]], ptr [[RETVAL]], align 1
// CHECK-NEXT: br label [[RETURN]]
// CHECK: return:
// CHECK-NEXT: [[TMP1:%.*]] = load i1, ptr [[RETVAL]], align 1
// CHECK-NEXT: ret i1 [[TMP1]]
//
bool f() { bool f() {
// CHECK-LABEL: define{{.*}} zeroext i1 @_Z1fv
// CHECK: br {{.*}} !prof ![[PROF_LIKELY:[0-9]+]]
if (b) if (b)
[[likely]] { [[likely]] {
return A(); return A();
} }
return B(); return B();
} }
// CHECK-LABEL: @_Z1gv(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[RETVAL:%.*]] = alloca i1, align 1
// CHECK-NEXT: [[TMP0:%.*]] = load volatile i8, ptr @b, align 1, !tbaa [[TBAA2]], !range [[RNG6]]
// CHECK-NEXT: [[TOBOOL:%.*]] = trunc i8 [[TMP0]] to i1
// CHECK-NEXT: [[TOBOOL_EXPVAL:%.*]] = call i1 @llvm.expect.i1(i1 [[TOBOOL]], i1 false)
// CHECK-NEXT: br i1 [[TOBOOL_EXPVAL]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
// CHECK: if.then:
// CHECK-NEXT: [[CALL:%.*]] = call noundef zeroext i1 @_Z1Av()
// CHECK-NEXT: store i1 [[CALL]], ptr [[RETVAL]], align 1
// CHECK-NEXT: br label [[RETURN:%.*]]
// CHECK: if.end:
// CHECK-NEXT: [[CALL1:%.*]] = call noundef zeroext i1 @_Z1Bv()
// CHECK-NEXT: store i1 [[CALL1]], ptr [[RETVAL]], align 1
// CHECK-NEXT: br label [[RETURN]]
// CHECK: return:
// CHECK-NEXT: [[TMP1:%.*]] = load i1, ptr [[RETVAL]], align 1
// CHECK-NEXT: ret i1 [[TMP1]]
//
bool g() { bool g() {
// CHECK-LABEL: define{{.*}} zeroext i1 @_Z1gv
// CHECK: br {{.*}} !prof ![[PROF_UNLIKELY:[0-9]+]]
if (b) if (b)
[[unlikely]] { [[unlikely]] {
return A(); return A();
} }
return B(); return B();
} }
// CHECK-LABEL: @_Z1hv(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[RETVAL:%.*]] = alloca i1, align 1
// CHECK-NEXT: [[TMP0:%.*]] = load volatile i8, ptr @b, align 1, !tbaa [[TBAA2]], !range [[RNG6]]
// CHECK-NEXT: [[TOBOOL:%.*]] = trunc i8 [[TMP0]] to i1
// CHECK-NEXT: [[TOBOOL_EXPVAL:%.*]] = call i1 @llvm.expect.i1(i1 [[TOBOOL]], i1 false)
// CHECK-NEXT: br i1 [[TOBOOL_EXPVAL]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
// CHECK: if.then:
// CHECK-NEXT: [[CALL:%.*]] = call noundef zeroext i1 @_Z1Av()
// CHECK-NEXT: store i1 [[CALL]], ptr [[RETVAL]], align 1
// CHECK-NEXT: br label [[RETURN:%.*]]
// CHECK: if.end:
// CHECK-NEXT: [[CALL1:%.*]] = call noundef zeroext i1 @_Z1Bv()
// CHECK-NEXT: store i1 [[CALL1]], ptr [[RETVAL]], align 1
// CHECK-NEXT: br label [[RETURN]]
// CHECK: return:
// CHECK-NEXT: [[TMP1:%.*]] = load i1, ptr [[RETVAL]], align 1
// CHECK-NEXT: ret i1 [[TMP1]]
//
bool h() { bool h() {
// CHECK-LABEL: define{{.*}} zeroext i1 @_Z1hv
// CHECK: br {{.*}} !prof ![[PROF_UNLIKELY]]
if (b) if (b)
[[unlikely]] return A(); [[unlikely]] return A();
return B(); return B();
} }
// CHECK-LABEL: @_Z8NullStmtv(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = load volatile i8, ptr @b, align 1, !tbaa [[TBAA2]], !range [[RNG6]]
// CHECK-NEXT: [[TOBOOL:%.*]] = trunc i8 [[TMP0]] to i1
// CHECK-NEXT: [[TOBOOL_EXPVAL:%.*]] = call i1 @llvm.expect.i1(i1 [[TOBOOL]], i1 false)
// CHECK-NEXT: br i1 [[TOBOOL_EXPVAL]], label [[IF_THEN:%.*]], label [[IF_ELSE:%.*]]
// CHECK: if.then:
// CHECK-NEXT: br label [[IF_END:%.*]]
// CHECK: if.else:
// CHECK-NEXT: store volatile i8 1, ptr @b, align 1, !tbaa [[TBAA2]]
// CHECK-NEXT: br label [[IF_END]]
// CHECK: if.end:
// CHECK-NEXT: ret void
//
void NullStmt() { void NullStmt() {
// CHECK-LABEL: define{{.*}}NullStmt
// CHECK: br {{.*}} !prof ![[PROF_UNLIKELY]]
if (b) if (b)
[[unlikely]]; [[unlikely]];
else { else {
// Make sure the branches aren't optimized away. // Make sure the branches aren't optimized away.
b = true; b = true;
} }
} }
// CHECK-LABEL: @_Z6IfStmtv(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = load volatile i8, ptr @b, align 1, !tbaa [[TBAA2]], !range [[RNG6]]
// CHECK-NEXT: [[TOBOOL:%.*]] = trunc i8 [[TMP0]] to i1
// CHECK-NEXT: [[TOBOOL_EXPVAL:%.*]] = call i1 @llvm.expect.i1(i1 [[TOBOOL]], i1 false)
// CHECK-NEXT: br i1 [[TOBOOL_EXPVAL]], label [[IF_THEN:%.*]], label [[IF_END2:%.*]]
// CHECK: if.then:
// CHECK-NEXT: [[CALL:%.*]] = call noundef zeroext i1 @_Z1Bv()
// CHECK-NEXT: br i1 [[CALL]], label [[IF_THEN1:%.*]], label [[IF_END:%.*]]
// CHECK: if.then1:
// CHECK-NEXT: br label [[IF_END]]
// CHECK: if.end:
// CHECK-NEXT: br label [[IF_END2]]
// CHECK: if.end2:
// CHECK-NEXT: [[TMP1:%.*]] = load volatile i8, ptr @b, align 1, !tbaa [[TBAA2]], !range [[RNG6]]
// CHECK-NEXT: [[TOBOOL3:%.*]] = trunc i8 [[TMP1]] to i1
// CHECK-NEXT: br i1 [[TOBOOL3]], label [[IF_THEN4:%.*]], label [[IF_END8:%.*]]
// CHECK: if.then4:
// CHECK-NEXT: [[CALL5:%.*]] = call noundef zeroext i1 @_Z1Bv()
// CHECK-NEXT: [[CALL5_EXPVAL:%.*]] = call i1 @llvm.expect.i1(i1 [[CALL5]], i1 false)
// CHECK-NEXT: br i1 [[CALL5_EXPVAL]], label [[IF_THEN6:%.*]], label [[IF_END7:%.*]]
// CHECK: if.then6:
// CHECK-NEXT: store volatile i8 0, ptr @b, align 1, !tbaa [[TBAA2]]
// CHECK-NEXT: br label [[IF_END7]]
// CHECK: if.end7:
// CHECK-NEXT: br label [[IF_END8]]
// CHECK: if.end8:
// CHECK-NEXT: ret void
//
void IfStmt() { void IfStmt() {
// CHECK-LABEL: define{{.*}}IfStmt
// CHECK: br {{.*}} !prof ![[PROF_UNLIKELY]]
if (b) if (b)
[[unlikely]] if (B()) {} [[unlikely]] if (B()) {}
// CHECK-NOT: br {{.*}} !prof
// CHECK: br {{.*}} !prof
if (b) { if (b) {
if (B()) if (B())
[[unlikely]] { b = false; } [[unlikely]] { b = false; }
} }
} }
// CHECK-LABEL: @_Z9WhileStmtv(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = load volatile i8, ptr @b, align 1, !tbaa [[TBAA2]], !range [[RNG6]]
// CHECK-NEXT: [[TOBOOL:%.*]] = trunc i8 [[TMP0]] to i1
// CHECK-NEXT: [[TOBOOL_EXPVAL:%.*]] = call i1 @llvm.expect.i1(i1 [[TOBOOL]], i1 false)
// CHECK-NEXT: br i1 [[TOBOOL_EXPVAL]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
// CHECK: if.then:
// CHECK-NEXT: br label [[WHILE_COND:%.*]]
// CHECK: while.cond:
// CHECK-NEXT: [[CALL:%.*]] = call noundef zeroext i1 @_Z1Bv()
// CHECK-NEXT: br i1 [[CALL]], label [[WHILE_BODY:%.*]], label [[WHILE_END:%.*]]
// CHECK: while.body:
// CHECK-NEXT: br label [[WHILE_COND]], !llvm.loop [[LOOP7:![0-9]+]]
// CHECK: while.end:
// CHECK-NEXT: br label [[IF_END]]
// CHECK: if.end:
// CHECK-NEXT: [[TMP1:%.*]] = load volatile i8, ptr @b, align 1, !tbaa [[TBAA2]], !range [[RNG6]]
// CHECK-NEXT: [[TOBOOL1:%.*]] = trunc i8 [[TMP1]] to i1
// CHECK-NEXT: br i1 [[TOBOOL1]], label [[IF_THEN2:%.*]], label [[IF_END7:%.*]]
// CHECK: if.then2:
// CHECK-NEXT: br label [[WHILE_COND3:%.*]]
// CHECK: while.cond3:
// CHECK-NEXT: [[CALL4:%.*]] = call noundef zeroext i1 @_Z1Bv()
// CHECK-NEXT: [[CALL4_EXPVAL:%.*]] = call i1 @llvm.expect.i1(i1 [[CALL4]], i1 false)
// CHECK-NEXT: br i1 [[CALL4_EXPVAL]], label [[WHILE_BODY5:%.*]], label [[WHILE_END6:%.*]]
// CHECK: while.body5:
// CHECK-NEXT: store volatile i8 0, ptr @b, align 1, !tbaa [[TBAA2]]
// CHECK-NEXT: br label [[WHILE_COND3]], !llvm.loop [[LOOP10:![0-9]+]]
// CHECK: while.end6:
// CHECK-NEXT: br label [[IF_END7]]
// CHECK: if.end7:
// CHECK-NEXT: ret void
//
void WhileStmt() { void WhileStmt() {
// CHECK-LABEL: define{{.*}}WhileStmt
// CHECK: br {{.*}} !prof ![[PROF_UNLIKELY]]
if (b) if (b)
[[unlikely]] while (B()) {} [[unlikely]] while (B()) {}
// CHECK-NOT: br {{.*}} %if.end{{.*}} !prof
if (b) if (b)
// CHECK: br {{.*}} !prof ![[PROF_LIKELY]]
while (B()) while (B())
[[unlikely]] { b = false; } [[unlikely]] { b = false; }
} }
// CHECK-LABEL: @_Z6DoStmtv(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = load volatile i8, ptr @b, align 1, !tbaa [[TBAA2]], !range [[RNG6]]
// CHECK-NEXT: [[TOBOOL:%.*]] = trunc i8 [[TMP0]] to i1
// CHECK-NEXT: [[TOBOOL_EXPVAL:%.*]] = call i1 @llvm.expect.i1(i1 [[TOBOOL]], i1 false)
// CHECK-NEXT: br i1 [[TOBOOL_EXPVAL]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
// CHECK: if.then:
// CHECK-NEXT: br label [[DO_BODY:%.*]]
// CHECK: do.body:
// CHECK-NEXT: br label [[DO_COND:%.*]]
// CHECK: do.cond:
// CHECK-NEXT: [[CALL:%.*]] = call noundef zeroext i1 @_Z1Bv()
// CHECK-NEXT: br i1 [[CALL]], label [[DO_BODY]], label [[DO_END:%.*]], !llvm.loop [[LOOP11:![0-9]+]]
// CHECK: do.end:
// CHECK-NEXT: br label [[IF_END]]
// CHECK: if.end:
// CHECK-NEXT: [[TMP1:%.*]] = load volatile i8, ptr @b, align 1, !tbaa [[TBAA2]], !range [[RNG6]]
// CHECK-NEXT: [[TOBOOL1:%.*]] = trunc i8 [[TMP1]] to i1
// CHECK-NEXT: br i1 [[TOBOOL1]], label [[IF_THEN2:%.*]], label [[IF_END7:%.*]]
// CHECK: if.then2:
// CHECK-NEXT: br label [[DO_BODY3:%.*]]
// CHECK: do.body3:
// CHECK-NEXT: br label [[DO_COND4:%.*]]
// CHECK: do.cond4:
// CHECK-NEXT: [[CALL5:%.*]] = call noundef zeroext i1 @_Z1Bv()
// CHECK-NEXT: br i1 [[CALL5]], label [[DO_BODY3]], label [[DO_END6:%.*]], !llvm.loop [[LOOP12:![0-9]+]]
// CHECK: do.end6:
// CHECK-NEXT: br label [[IF_END7]]
// CHECK: if.end7:
// CHECK-NEXT: ret void
//
void DoStmt() { void DoStmt() {
// CHECK-LABEL: define{{.*}}DoStmt
// CHECK: br {{.*}} !prof ![[PROF_UNLIKELY]]
if (b) if (b)
[[unlikely]] do {} [[unlikely]] do {}
while (B()) while (B())
; ;
// CHECK-NOT: br {{.*}} %if.end{{.*}} !prof
if (b) if (b)
do do
[[unlikely]] {} [[unlikely]] {}
while (B()); while (B());
} }
// CHECK-LABEL: @_Z7ForStmtv(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = load volatile i8, ptr @b, align 1, !tbaa [[TBAA2]], !range [[RNG6]]
// CHECK-NEXT: [[TOBOOL:%.*]] = trunc i8 [[TMP0]] to i1
// CHECK-NEXT: [[TOBOOL_EXPVAL:%.*]] = call i1 @llvm.expect.i1(i1 [[TOBOOL]], i1 false)
// CHECK-NEXT: br i1 [[TOBOOL_EXPVAL]], label [[IF_THEN:%.*]], label [[IF_END:%.*]]
// CHECK: if.then:
// CHECK-NEXT: br label [[FOR_COND:%.*]]
// CHECK: for.cond:
// CHECK-NEXT: [[CALL:%.*]] = call noundef zeroext i1 @_Z1Bv()
// CHECK-NEXT: br i1 [[CALL]], label [[FOR_BODY:%.*]], label [[FOR_END:%.*]]
// CHECK: for.body:
// CHECK-NEXT: br label [[FOR_COND]], !llvm.loop [[LOOP13:![0-9]+]]
// CHECK: for.end:
// CHECK-NEXT: br label [[IF_END]]
// CHECK: if.end:
// CHECK-NEXT: [[TMP1:%.*]] = load volatile i8, ptr @b, align 1, !tbaa [[TBAA2]], !range [[RNG6]]
// CHECK-NEXT: [[TOBOOL1:%.*]] = trunc i8 [[TMP1]] to i1
// CHECK-NEXT: br i1 [[TOBOOL1]], label [[IF_THEN2:%.*]], label [[IF_END7:%.*]]
// CHECK: if.then2:
// CHECK-NEXT: br label [[FOR_COND3:%.*]]
// CHECK: for.cond3:
// CHECK-NEXT: [[CALL4:%.*]] = call noundef zeroext i1 @_Z1Bv()
// CHECK-NEXT: [[CALL4_EXPVAL:%.*]] = call i1 @llvm.expect.i1(i1 [[CALL4]], i1 false)
// CHECK-NEXT: br i1 [[CALL4_EXPVAL]], label [[FOR_BODY5:%.*]], label [[FOR_END6:%.*]]
// CHECK: for.body5:
// CHECK-NEXT: br label [[FOR_COND3]], !llvm.loop [[LOOP14:![0-9]+]]
// CHECK: for.end6:
// CHECK-NEXT: br label [[IF_END7]]
// CHECK: if.end7:
// CHECK-NEXT: ret void
//
void ForStmt() { void ForStmt() {
// CHECK-LABEL: define{{.*}}ForStmt
// CHECK: br {{.*}} !prof ![[PROF_UNLIKELY]]
if (b) if (b)
[[unlikely]] for (; B();) {} [[unlikely]] for (; B();) {}
// CHECK-NOT: br {{.*}} %if.end{{.*}} !prof
if (b) if (b)
// CHECK: br {{.*}} !prof ![[PROF_LIKELY]]
for (; B();) for (; B();)
[[unlikely]] {} [[unlikely]] {}
} }
// CHECK-LABEL: @_Z8GotoStmtv(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = load volatile i8, ptr @b, align 1, !tbaa [[TBAA2]], !range [[RNG6]]
// CHECK-NEXT: [[TOBOOL:%.*]] = trunc i8 [[TMP0]] to i1
// CHECK-NEXT: [[TOBOOL_EXPVAL:%.*]] = call i1 @llvm.expect.i1(i1 [[TOBOOL]], i1 false)
// CHECK-NEXT: br i1 [[TOBOOL_EXPVAL]], label [[IF_THEN:%.*]], label [[IF_ELSE:%.*]]
// CHECK: if.then:
// CHECK-NEXT: br label [[END:%.*]]
// CHECK: if.else:
// CHECK-NEXT: store volatile i8 1, ptr @b, align 1, !tbaa [[TBAA2]]
// CHECK-NEXT: br label [[IF_END:%.*]]
// CHECK: if.end:
// CHECK-NEXT: br label [[END]]
// CHECK: end:
// CHECK-NEXT: ret void
//
void GotoStmt() { void GotoStmt() {
// CHECK-LABEL: define{{.*}}GotoStmt
// CHECK: br {{.*}} !prof ![[PROF_UNLIKELY]]
if (b) if (b)
[[unlikely]] goto end; [[unlikely]] goto end;
else { else {
// Make sure the branches aren't optimized away. // Make sure the branches aren't optimized away.
b = true; b = true;
} }
end:; end:;
} }
// CHECK-LABEL: @_Z10ReturnStmtv(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = load volatile i8, ptr @b, align 1, !tbaa [[TBAA2]], !range [[RNG6]]
// CHECK-NEXT: [[TOBOOL:%.*]] = trunc i8 [[TMP0]] to i1
// CHECK-NEXT: [[TOBOOL_EXPVAL:%.*]] = call i1 @llvm.expect.i1(i1 [[TOBOOL]], i1 false)
// CHECK-NEXT: br i1 [[TOBOOL_EXPVAL]], label [[IF_THEN:%.*]], label [[IF_ELSE:%.*]]
// CHECK: if.then:
// CHECK-NEXT: br label [[IF_END:%.*]]
// CHECK: if.else:
// CHECK-NEXT: store volatile i8 1, ptr @b, align 1, !tbaa [[TBAA2]]
// CHECK-NEXT: br label [[IF_END]]
// CHECK: if.end:
// CHECK-NEXT: ret void
//
void ReturnStmt() { void ReturnStmt() {
// CHECK-LABEL: define{{.*}}ReturnStmt
// CHECK: br {{.*}} !prof ![[PROF_UNLIKELY]]
if (b) if (b)
[[unlikely]] return; [[unlikely]] return;
else { else {
// Make sure the branches aren't optimized away. // Make sure the branches aren't optimized away.
b = true; b = true;
} }
} }
// CHECK-LABEL: @_Z10SwitchStmtv(
// CHECK-NEXT: entry:
// CHECK-NEXT: [[TMP0:%.*]] = load volatile i8, ptr @b, align 1, !tbaa [[TBAA2]], !range [[RNG6]]
// CHECK-NEXT: [[TOBOOL:%.*]] = trunc i8 [[TMP0]] to i1
// CHECK-NEXT: [[TOBOOL_EXPVAL:%.*]] = call i1 @llvm.expect.i1(i1 [[TOBOOL]], i1 false)
// CHECK-NEXT: br i1 [[TOBOOL_EXPVAL]], label [[IF_THEN:%.*]], label [[IF_ELSE:%.*]]
// CHECK: if.then:
// CHECK-NEXT: [[TMP1:%.*]] = load volatile i32, ptr @i, align 4, !tbaa [[TBAA15:![0-9]+]]
// CHECK-NEXT: switch i32 [[TMP1]], label [[SW_EPILOG:%.*]] [
// CHECK-NEXT: ]
// CHECK: sw.epilog:
// CHECK-NEXT: br label [[IF_END:%.*]]
// CHECK: if.else:
// CHECK-NEXT: store volatile i8 1, ptr @b, align 1, !tbaa [[TBAA2]]
// CHECK-NEXT: br label [[IF_END]]
// CHECK: if.end:
// CHECK-NEXT: [[TMP2:%.*]] = load volatile i8, ptr @b, align 1, !tbaa [[TBAA2]], !range [[RNG6]]
// CHECK-NEXT: [[TOBOOL1:%.*]] = trunc i8 [[TMP2]] to i1
// CHECK-NEXT: br i1 [[TOBOOL1]], label [[IF_THEN2:%.*]], label [[IF_ELSE4:%.*]]
// CHECK: if.then2:
// CHECK-NEXT: [[TMP3:%.*]] = load volatile i32, ptr @i, align 4, !tbaa [[TBAA15]]
// CHECK-NEXT: switch i32 [[TMP3]], label [[SW_EPILOG3:%.*]] [
// CHECK-NEXT: ]
// CHECK: sw.epilog3:
// CHECK-NEXT: br label [[IF_END5:%.*]]
// CHECK: if.else4:
// CHECK-NEXT: store volatile i8 1, ptr @b, align 1, !tbaa [[TBAA2]]
// CHECK-NEXT: br label [[IF_END5]]
// CHECK: if.end5:
// CHECK-NEXT: ret void
//
void SwitchStmt() { void SwitchStmt() {
// CHECK-LABEL: define{{.*}}SwitchStmt
// CHECK: br {{.*}} !prof ![[PROF_UNLIKELY]]
if (b) if (b)
[[unlikely]] switch (i) {} [[unlikely]] switch (i) {}
else { else {
// Make sure the branches aren't optimized away. // Make sure the branches aren't optimized away.
b = true; b = true;
} }
// CHECK-NOT: br {{.*}} %if.end{{.*}} !prof
if (b) if (b)
switch (i) switch (i)
[[unlikely]] {} [[unlikely]] {}
else { else {
// Make sure the branches aren't optimized away. // Make sure the branches aren't optimized away.
b = true; b = true;
} }
} }
// CHECK: ![[PROF_LIKELY]] = !{!"branch_weights", i32 [[UNLIKELY]], i32 [[LIKELY]]}
// CHECK: ![[PROF_UNLIKELY]] = !{!"branch_weights", i32 [[LIKELY]], i32 [[UNLIKELY]]}
wenleiUnsubmitted
Done
ReplyInline Actions

I thought this is the purpose of the test, which is no longer checked after change?

wenlei: I thought this is the purpose of the test, which is no longer checked after change?
aeubanksUnsubmitted
Done
ReplyInline Actions

those should be covered by LowerExpectIntrinsic tests

aeubanks: those should be covered by LowerExpectIntrinsic tests
MatzeBAuthorUnsubmitted
Done
ReplyInline Actions

The frontend rewrites [[likely]] and [[unlikely]] into calls to llvm.expect. And this is still tested here. Running lower-expect-intrinsic pass to lower the llvm.expect to !prof annotations doesn't need to be tested here as we have separate tests for that pass.

MatzeB: The frontend rewrites `[[likely]]` and `[[unlikely]]` into calls to `llvm.expect`. And this is…
wenleiUnsubmitted
Not Done
ReplyInline Actions

Ah, makes sense. I see that we have existing coverage for lowering llvm.expect to !prof in expect-*.ll, so we're good.

wenlei: Ah, makes sense. I see that we have existing coverage for lowering `llvm.expect` to `!prof` in…