This is an archive of the discontinued LLVM Phabricator instance.

Differential D156338

[NewGVN] Regenerate test checks (NFC)
ClosedPublic

Authored by ManuelJBrito on Jul 26 2023, 8:02 AM.

Details

Reviewers
nlopes
Summary

In preparation for a patch that fixes https://github.com/llvm/llvm-project/issues/53218.

Diff Detail

Event Timeline

ManuelJBrito created this revision.Jul 26 2023, 8:02 AM
Herald added a project: Restricted Project. · View Herald TranscriptJul 26 2023, 8:02 AM
Herald added a subscriber: kmitropoulou. · View Herald Transcript
ManuelJBrito requested review of this revision.Jul 26 2023, 8:02 AM
Herald added a project: Restricted Project. · View Herald TranscriptJul 26 2023, 8:02 AM
Herald added a subscriber: llvm-commits. · View Herald Transcript
nlopes added inline comments.Jul 26 2023, 8:41 AM
llvm/test/Transforms/NewGVN/propagate-ir-flags.ll
4

I suggest you remove these old checks and keep just the autogenerated ones

ManuelJBrito updated this revision to Diff 544388.Jul 26 2023, 8:55 AM

Remove old checks.

nlopes accepted this revision.Jul 26 2023, 9:04 AM
This revision is now accepted and ready to land.Jul 26 2023, 9:04 AM
ManuelJBrito closed this revision.Jul 26 2023, 9:29 AM

Forgot to add the diff link to the commit message, closing manually.

Harbormaster completed remote builds in B248282: Diff 544388.Jul 26 2023, 1:40 PM

Revision Contents

PathSize
llvm/
test/
Transforms/
NewGVN/
12 lines
75 lines
17 lines

Diff 544372

llvm/test/Transforms/NewGVN/flags.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 2
; RUN: opt -passes=newgvn -S < %s | FileCheck %s ; RUN: opt -passes=newgvn -S < %s | FileCheck %s
declare void @use(i1) declare void @use(i1)
define void @test1(float %x, float %y) { define void @test1(float %x, float %y) {
; CHECK-LABEL: define void @test1
; CHECK-SAME: (float [[X:%.*]], float [[Y:%.*]]) {
; CHECK-NEXT: entry:
; CHECK-NEXT: [[CMP1:%.*]] = fcmp oeq float [[Y]], [[X]]
; CHECK-NEXT: call void @use(i1 [[CMP1]])
; CHECK-NEXT: call void @use(i1 [[CMP1]])
; CHECK-NEXT: ret void
;
entry: entry:
%cmp1 = fcmp nnan oeq float %y, %x %cmp1 = fcmp nnan oeq float %y, %x
%cmp2 = fcmp oeq float %x, %y %cmp2 = fcmp oeq float %x, %y
call void @use(i1 %cmp1) call void @use(i1 %cmp1)
call void @use(i1 %cmp2) call void @use(i1 %cmp2)
ret void ret void
} }
; CHECK-LABEL: define void @test1( ; CHECK-LABEL: define void @test1(
; CHECK: %[[cmp:.*]] = fcmp oeq float %y, %x
; CHECK-NEXT: call void @use(i1 %[[cmp]])
; CHECK-NEXT: call void @use(i1 %[[cmp]])
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void

llvm/test/Transforms/NewGVN/pr12979.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 2
; RUN: opt -passes=newgvn -S < %s | FileCheck %s ; RUN: opt -passes=newgvn -S < %s | FileCheck %s
define i32 @test1(i32 %x, i32 %y) { define i32 @test1(i32 %x, i32 %y) {
; CHECK: @test1(i32 %x, i32 %y) ; CHECK-LABEL: define i32 @test1
; CHECK: %add1 = add i32 %x, %y ; CHECK-SAME: (i32 [[X:%.*]], i32 [[Y:%.*]]) {
; CHECK: %foo = add i32 %add1, %add1 ; CHECK-NEXT: [[ADD1:%.*]] = add i32 [[X]], [[Y]]
; CHECK-NEXT: [[FOO:%.*]] = add i32 [[ADD1]], [[ADD1]]
; CHECK-NEXT: ret i32 [[FOO]]
;
%add1 = add nsw i32 %x, %y %add1 = add nsw i32 %x, %y
%add2 = add i32 %x, %y %add2 = add i32 %x, %y
%foo = add i32 %add1, %add2 %foo = add i32 %add1, %add2
ret i32 %foo ret i32 %foo
} }
define i32 @test2(i32 %x, i32 %y) { define i32 @test2(i32 %x, i32 %y) {
; CHECK: @test2(i32 %x, i32 %y) ; CHECK-LABEL: define i32 @test2
; CHECK: %add1 = add i32 %x, %y ; CHECK-SAME: (i32 [[X:%.*]], i32 [[Y:%.*]]) {
; CHECK: %foo = add i32 %add1, %add1 ; CHECK-NEXT: [[ADD1:%.*]] = add i32 [[X]], [[Y]]
; CHECK-NEXT: [[FOO:%.*]] = add i32 [[ADD1]], [[ADD1]]
; CHECK-NEXT: ret i32 [[FOO]]
;
%add1 = add nuw i32 %x, %y %add1 = add nuw i32 %x, %y
%add2 = add i32 %x, %y %add2 = add i32 %x, %y
%foo = add i32 %add1, %add2 %foo = add i32 %add1, %add2
ret i32 %foo ret i32 %foo
} }
define i32 @test3(i32 %x, i32 %y) { define i32 @test3(i32 %x, i32 %y) {
; CHECK: @test3(i32 %x, i32 %y) ; CHECK-LABEL: define i32 @test3
; CHECK: %add1 = add i32 %x, %y ; CHECK-SAME: (i32 [[X:%.*]], i32 [[Y:%.*]]) {
; CHECK: %foo = add i32 %add1, %add1 ; CHECK-NEXT: [[ADD1:%.*]] = add i32 [[X]], [[Y]]
; CHECK-NEXT: [[FOO:%.*]] = add i32 [[ADD1]], [[ADD1]]
; CHECK-NEXT: ret i32 [[FOO]]
;
%add1 = add nuw nsw i32 %x, %y %add1 = add nuw nsw i32 %x, %y
%add2 = add i32 %x, %y %add2 = add i32 %x, %y
%foo = add i32 %add1, %add2 %foo = add i32 %add1, %add2
ret i32 %foo ret i32 %foo
} }
define i32 @test4(i32 %x, i32 %y) { define i32 @test4(i32 %x, i32 %y) {
; CHECK: @test4(i32 %x, i32 %y) ; CHECK-LABEL: define i32 @test4
; CHECK: %add1 = add nsw i32 %x, %y ; CHECK-SAME: (i32 [[X:%.*]], i32 [[Y:%.*]]) {
; CHECK: %foo = add i32 %add1, %add1 ; CHECK-NEXT: [[ADD1:%.*]] = add nsw i32 [[X]], [[Y]]
; CHECK-NEXT: [[FOO:%.*]] = add i32 [[ADD1]], [[ADD1]]
; CHECK-NEXT: ret i32 [[FOO]]
;
%add1 = add nsw i32 %x, %y %add1 = add nsw i32 %x, %y
%add2 = add nsw i32 %x, %y %add2 = add nsw i32 %x, %y
%foo = add i32 %add1, %add2 %foo = add i32 %add1, %add2
ret i32 %foo ret i32 %foo
} }
define i32 @test5(i32 %x, i32 %y) { define i32 @test5(i32 %x, i32 %y) {
; CHECK: @test5(i32 %x, i32 %y) ; CHECK-LABEL: define i32 @test5
; CHECK: %add1 = add i32 %x, %y ; CHECK-SAME: (i32 [[X:%.*]], i32 [[Y:%.*]]) {
; CHECK: %foo = add i32 %add1, %add1 ; CHECK-NEXT: [[ADD1:%.*]] = add i32 [[X]], [[Y]]
; CHECK-NEXT: [[FOO:%.*]] = add i32 [[ADD1]], [[ADD1]]
; CHECK-NEXT: ret i32 [[FOO]]
;
%add1 = add nuw i32 %x, %y %add1 = add nuw i32 %x, %y
%add2 = add nsw i32 %x, %y %add2 = add nsw i32 %x, %y
%foo = add i32 %add1, %add2 %foo = add i32 %add1, %add2
ret i32 %foo ret i32 %foo
} }
define i32 @test6(i32 %x, i32 %y) { define i32 @test6(i32 %x, i32 %y) {
; CHECK: @test6(i32 %x, i32 %y) ; CHECK-LABEL: define i32 @test6
; CHECK: %add1 = add nsw i32 %x, %y ; CHECK-SAME: (i32 [[X:%.*]], i32 [[Y:%.*]]) {
; CHECK: %foo = add i32 %add1, %add1 ; CHECK-NEXT: [[ADD1:%.*]] = add nsw i32 [[X]], [[Y]]
; CHECK-NEXT: [[FOO:%.*]] = add i32 [[ADD1]], [[ADD1]]
; CHECK-NEXT: ret i32 [[FOO]]
;
%add1 = add nuw nsw i32 %x, %y %add1 = add nuw nsw i32 %x, %y
%add2 = add nsw i32 %x, %y %add2 = add nsw i32 %x, %y
%foo = add i32 %add1, %add2 %foo = add i32 %add1, %add2
ret i32 %foo ret i32 %foo
} }
define i32 @test7(i32 %x, i32 %y) { define i32 @test7(i32 %x, i32 %y) {
; CHECK: @test7(i32 %x, i32 %y) ; CHECK-LABEL: define i32 @test7
; CHECK: %add1 = add i32 %x, %y ; CHECK-SAME: (i32 [[X:%.*]], i32 [[Y:%.*]]) {
; CHECK-NOT: what_is_this ; CHECK-NEXT: [[ADD1:%.*]] = add i32 [[X]], [[Y]]
; CHECK: %foo = add i32 %add1, %add1 ; CHECK-NEXT: [[FOO:%.*]] = add i32 [[ADD1]], [[ADD1]]
; CHECK-NEXT: ret i32 [[FOO]]
;
%add1 = add i32 %x, %y, !what_is_this !{} %add1 = add i32 %x, %y, !what_is_this !{}
%add2 = add i32 %x, %y %add2 = add i32 %x, %y
%foo = add i32 %add1, %add2 %foo = add i32 %add1, %add2
ret i32 %foo ret i32 %foo
} }
declare void @mumble(i2, i2) declare void @mumble(i2, i2)
define void @test8(i2 %x) { define void @test8(i2 %x) {
; CHECK-LABEL: @test8( ; CHECK-LABEL: define void @test8
; CHECK: %[[ashr:.*]] = ashr i2 %x, 1 ; CHECK-SAME: (i2 [[X:%.*]]) {
; CHECK-NEXT: call void @mumble(i2 %[[ashr]], i2 %[[ashr]]) ; CHECK-NEXT: [[ASHR0:%.*]] = ashr i2 [[X]], 1
; CHECK-NEXT: call void @mumble(i2 [[ASHR0]], i2 [[ASHR0]])
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
;
%ashr0 = ashr exact i2 %x, 1 %ashr0 = ashr exact i2 %x, 1
%ashr1 = ashr i2 %x, 1 %ashr1 = ashr i2 %x, 1
call void @mumble(i2 %ashr0, i2 %ashr1) call void @mumble(i2 %ashr0, i2 %ashr1)
ret void ret void
} }

llvm/test/Transforms/NewGVN/propagate-ir-flags.ll

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 2
; RUN: opt < %s -passes=newgvn -S | FileCheck %s ; RUN: opt < %s -passes=newgvn -S | FileCheck %s
; CHECK-LABEL: func_fast ; CHECK-LABEL: func_fast
nlopesUnsubmitted
Not Done
ReplyInline Actions

I suggest you remove these old checks and keep just the autogenerated ones

nlopes: I suggest you remove these old checks and keep just the autogenerated ones
; CHECK: fadd fast double ; CHECK: fadd fast double
; CHECK-NEXT: store ; CHECK-NEXT: store
; CHECK-NEXT: ret ; CHECK-NEXT: ret
define double @func_fast(double %a, double %b) { define double @func_fast(double %a, double %b) {
; CHECK-LABEL: define double @func_fast
; CHECK-SAME: (double [[A:%.*]], double [[B:%.*]]) {
; CHECK-NEXT: entry:
; CHECK-NEXT: [[A_ADDR:%.*]] = alloca double, align 8
; CHECK-NEXT: [[ADD:%.*]] = fadd fast double [[B]], 3.000000e+00
; CHECK-NEXT: store double [[ADD]], ptr [[A_ADDR]], align 8
; CHECK-NEXT: ret double [[ADD]]
;
entry: entry:
%a.addr = alloca double, align 8 %a.addr = alloca double, align 8
%add = fadd fast double %b, 3.000000e+00 %add = fadd fast double %b, 3.000000e+00
store double %add, ptr %a.addr, align 8 store double %add, ptr %a.addr, align 8
%load_add = load double, ptr %a.addr, align 8 %load_add = load double, ptr %a.addr, align 8
ret double %load_add ret double %load_add
} }
; CHECK-LABEL: func_no_fast ; CHECK-LABEL: func_no_fast
; CHECK: fadd double ; CHECK: fadd double
; CHECK-NEXT: store ; CHECK-NEXT: store
; CHECK-NEXT: ret ; CHECK-NEXT: ret
define double @func_no_fast(double %a, double %b) { define double @func_no_fast(double %a, double %b) {
; CHECK-LABEL: define double @func_no_fast
; CHECK-SAME: (double [[A:%.*]], double [[B:%.*]]) {
; CHECK-NEXT: entry:
; CHECK-NEXT: [[A_ADDR:%.*]] = alloca double, align 8
; CHECK-NEXT: [[ADD:%.*]] = fadd double [[B]], 3.000000e+00
; CHECK-NEXT: store double [[ADD]], ptr [[A_ADDR]], align 8
; CHECK-NEXT: ret double [[ADD]]
;
entry: entry:
%a.addr = alloca double, align 8 %a.addr = alloca double, align 8
%add = fadd fast double %b, 3.000000e+00 %add = fadd fast double %b, 3.000000e+00
store double %add, ptr %a.addr, align 8 store double %add, ptr %a.addr, align 8
%duplicated_add = fadd double %b, 3.000000e+00 %duplicated_add = fadd double %b, 3.000000e+00
ret double %duplicated_add ret double %duplicated_add
} }