diff options
Diffstat (limited to 'test/Transforms/WholeProgramDevirt')
27 files changed, 798 insertions, 45 deletions
diff --git a/test/Transforms/WholeProgramDevirt/Inputs/export.yaml b/test/Transforms/WholeProgramDevirt/Inputs/export.yaml new file mode 100644 index 000000000000..0f6f59de7522 --- /dev/null +++ b/test/Transforms/WholeProgramDevirt/Inputs/export.yaml @@ -0,0 +1,20 @@ +--- +GlobalValueMap: + 42: + - TypeTestAssumeVCalls: + - GUID: 14276520915468743435 # typeid1 + Offset: 0 + TypeCheckedLoadVCalls: + - GUID: 15427464259790519041 # typeid2 + Offset: 0 + TypeTestAssumeConstVCalls: + - VFunc: + GUID: 3515965990081467659 # typeid3 + Offset: 0 + Args: [12, 24] + TypeCheckedLoadConstVCalls: + - VFunc: + GUID: 17525413373118030901 # typeid4 + Offset: 0 + Args: [24, 12] +... diff --git a/test/Transforms/WholeProgramDevirt/Inputs/import-indir.yaml b/test/Transforms/WholeProgramDevirt/Inputs/import-indir.yaml new file mode 100644 index 000000000000..1cb3ad3f134c --- /dev/null +++ b/test/Transforms/WholeProgramDevirt/Inputs/import-indir.yaml @@ -0,0 +1,41 @@ +--- +GlobalValueMap: + 42: + - TypeTestAssumeVCalls: + - GUID: 123 + Offset: 0 + - GUID: 456 + Offset: 4 + TypeCheckedLoadVCalls: + - GUID: 789 + Offset: 8 + - GUID: 1234 + Offset: 16 + TypeTestAssumeConstVCalls: + - VFunc: + GUID: 123 + Offset: 4 + Args: [12, 24] + TypeCheckedLoadConstVCalls: + - VFunc: + GUID: 456 + Offset: 8 + Args: [24, 12] +TypeIdMap: + typeid1: + WPDRes: + 0: + Kind: Indir + 4: + Kind: Indir + ResByArg: + "": + Kind: UniformRetVal + Info: 12 + 12: + Kind: UniformRetVal + Info: 24 + "12,24": + Kind: UniformRetVal + Info: 48 +... diff --git a/test/Transforms/WholeProgramDevirt/Inputs/import-single-impl.yaml b/test/Transforms/WholeProgramDevirt/Inputs/import-single-impl.yaml new file mode 100644 index 000000000000..26764eb3b29c --- /dev/null +++ b/test/Transforms/WholeProgramDevirt/Inputs/import-single-impl.yaml @@ -0,0 +1,13 @@ +--- +TypeIdMap: + typeid1: + WPDRes: + 0: + Kind: SingleImpl + SingleImplName: singleimpl1 + typeid2: + WPDRes: + 8: + Kind: SingleImpl + SingleImplName: singleimpl2 +... diff --git a/test/Transforms/WholeProgramDevirt/Inputs/import-uniform-ret-val.yaml b/test/Transforms/WholeProgramDevirt/Inputs/import-uniform-ret-val.yaml new file mode 100644 index 000000000000..f1daae63b678 --- /dev/null +++ b/test/Transforms/WholeProgramDevirt/Inputs/import-uniform-ret-val.yaml @@ -0,0 +1,19 @@ +--- +TypeIdMap: + typeid1: + WPDRes: + 0: + Kind: Indir + ResByArg: + 1: + Kind: UniformRetVal + Info: 42 + typeid2: + WPDRes: + 8: + Kind: Indir + ResByArg: + 1: + Kind: UniformRetVal + Info: 42 +... diff --git a/test/Transforms/WholeProgramDevirt/Inputs/import-unique-ret-val0.yaml b/test/Transforms/WholeProgramDevirt/Inputs/import-unique-ret-val0.yaml new file mode 100644 index 000000000000..597b17877767 --- /dev/null +++ b/test/Transforms/WholeProgramDevirt/Inputs/import-unique-ret-val0.yaml @@ -0,0 +1,11 @@ +--- +TypeIdMap: + typeid2: + WPDRes: + 8: + Kind: Indir + ResByArg: + 3: + Kind: UniqueRetVal + Info: 0 +... diff --git a/test/Transforms/WholeProgramDevirt/Inputs/import-unique-ret-val1.yaml b/test/Transforms/WholeProgramDevirt/Inputs/import-unique-ret-val1.yaml new file mode 100644 index 000000000000..737ef1173c3c --- /dev/null +++ b/test/Transforms/WholeProgramDevirt/Inputs/import-unique-ret-val1.yaml @@ -0,0 +1,11 @@ +--- +TypeIdMap: + typeid2: + WPDRes: + 8: + Kind: Indir + ResByArg: + 3: + Kind: UniqueRetVal + Info: 1 +... diff --git a/test/Transforms/WholeProgramDevirt/Inputs/import-vcp.yaml b/test/Transforms/WholeProgramDevirt/Inputs/import-vcp.yaml new file mode 100644 index 000000000000..4fbee126d0ea --- /dev/null +++ b/test/Transforms/WholeProgramDevirt/Inputs/import-vcp.yaml @@ -0,0 +1,19 @@ +--- +TypeIdMap: + typeid1: + WPDRes: + 0: + Kind: Indir + ResByArg: + 1: + Kind: VirtualConstProp + Info: 0 + typeid2: + WPDRes: + 8: + Kind: Indir + ResByArg: + 3: + Kind: VirtualConstProp + Info: 0 +... diff --git a/test/Transforms/WholeProgramDevirt/bad-read-from-vtable.ll b/test/Transforms/WholeProgramDevirt/bad-read-from-vtable.ll index 4885be777566..e5d0e74b22e2 100644 --- a/test/Transforms/WholeProgramDevirt/bad-read-from-vtable.ll +++ b/test/Transforms/WholeProgramDevirt/bad-read-from-vtable.ll @@ -3,8 +3,8 @@ target datalayout = "e-p:64:64" target triple = "x86_64-unknown-linux-gnu" -@vt1 = global [2 x i8*] [i8* zeroinitializer, i8* bitcast (void (i8*)* @vf to i8*)], !type !0 -@vt2 = global i8* bitcast (void (i8*)* @vf to i8*), !type !1 +@vt1 = constant [2 x i8*] [i8* zeroinitializer, i8* bitcast (void (i8*)* @vf to i8*)], !type !0 +@vt2 = constant i8* bitcast (void (i8*)* @vf to i8*), !type !1 define void @vf(i8* %this) { ret void diff --git a/test/Transforms/WholeProgramDevirt/export-nothing.ll b/test/Transforms/WholeProgramDevirt/export-nothing.ll new file mode 100644 index 000000000000..e0814efbf9c0 --- /dev/null +++ b/test/Transforms/WholeProgramDevirt/export-nothing.ll @@ -0,0 +1,7 @@ +; RUN: opt -wholeprogramdevirt -wholeprogramdevirt-summary-action=export -wholeprogramdevirt-write-summary=%t -o /dev/null %s +; RUN: FileCheck %s < %t + +; CHECK: --- +; CHECK-NEXT: GlobalValueMap: +; CHECK-NEXT: TypeIdMap: +; CHECK-NEXT: ... diff --git a/test/Transforms/WholeProgramDevirt/export-single-impl.ll b/test/Transforms/WholeProgramDevirt/export-single-impl.ll new file mode 100644 index 000000000000..f4f3fd054c46 --- /dev/null +++ b/test/Transforms/WholeProgramDevirt/export-single-impl.ll @@ -0,0 +1,78 @@ +; RUN: opt -wholeprogramdevirt -wholeprogramdevirt-summary-action=export -wholeprogramdevirt-read-summary=%S/Inputs/export.yaml -wholeprogramdevirt-write-summary=%t -S -o - %s | FileCheck %s +; RUN: FileCheck --check-prefix=SUMMARY %s < %t + +; SUMMARY: TypeIdMap: +; SUMMARY-NEXT: typeid1: +; SUMMARY-NEXT: TTRes: +; SUMMARY-NEXT: Kind: Unsat +; SUMMARY-NEXT: SizeM1BitWidth: 0 +; SUMMARY-NEXT: WPDRes: +; SUMMARY-NEXT: 0: +; SUMMARY-NEXT: Kind: SingleImpl +; SUMMARY-NEXT: SingleImplName: vf1 +; SUMMARY-NEXT: ResByArg: +; SUMMARY-NEXT: typeid2: +; SUMMARY-NEXT: TTRes: +; SUMMARY-NEXT: Kind: Unsat +; SUMMARY-NEXT: SizeM1BitWidth: 0 +; SUMMARY-NEXT: WPDRes: +; SUMMARY-NEXT: 0: +; SUMMARY-NEXT: Kind: SingleImpl +; SUMMARY-NEXT: SingleImplName: vf2 +; SUMMARY-NEXT: ResByArg: +; SUMMARY-NEXT: typeid3: +; SUMMARY-NEXT: TTRes: +; SUMMARY-NEXT: Kind: Unsat +; SUMMARY-NEXT: SizeM1BitWidth: 0 +; SUMMARY-NEXT: WPDRes: +; SUMMARY-NEXT: 0: +; SUMMARY-NEXT: Kind: SingleImpl +; SUMMARY-NEXT: SingleImplName: vf3 +; SUMMARY-NEXT: ResByArg: +; SUMMARY-NEXT: typeid4: +; SUMMARY-NEXT: TTRes: +; SUMMARY-NEXT: Kind: Unsat +; SUMMARY-NEXT: SizeM1BitWidth: 0 +; SUMMARY-NEXT: WPDRes: +; SUMMARY-NEXT: 0: +; SUMMARY-NEXT: Kind: SingleImpl +; SUMMARY-NEXT: SingleImplName: 'vf4$merged' +; SUMMARY-NEXT: ResByArg: +; SUMMARY-NEXT: ... + +; CHECK: @vt1 = constant void (i8*)* @vf1 +@vt1 = constant void (i8*)* @vf1, !type !0 + +; CHECK: @vt2 = constant void (i8*)* @vf2 +@vt2 = constant void (i8*)* @vf2, !type !1 + +@vt3 = constant void (i8*)* @vf3, !type !2 + +; CHECK: @vt4 = constant void (i8*)* @"vf4$merged" +@vt4 = constant void (i8*)* @vf4, !type !3 + +@vt5 = constant void (i8*)* @vf5, !type !4 + +; CHECK: declare void @vf1(i8*) +declare void @vf1(i8*) + +; CHECK: define void @vf2(i8*) +define void @vf2(i8*) { + ret void +} + +declare void @vf3(i8*) + +; CHECK: define hidden void @"vf4$merged" +define internal void @vf4(i8*) { + ret void +} + +declare void @vf5(i8*) + +!0 = !{i32 0, !"typeid1"} +!1 = !{i32 0, !"typeid2"} +!2 = !{i32 0, !"typeid3"} +!3 = !{i32 0, !"typeid4"} +!4 = !{i32 0, !5} +!5 = distinct !{} diff --git a/test/Transforms/WholeProgramDevirt/export-uniform-ret-val.ll b/test/Transforms/WholeProgramDevirt/export-uniform-ret-val.ll new file mode 100644 index 000000000000..1d7030c41fd0 --- /dev/null +++ b/test/Transforms/WholeProgramDevirt/export-uniform-ret-val.ll @@ -0,0 +1,36 @@ +; RUN: opt -wholeprogramdevirt -wholeprogramdevirt-summary-action=export -wholeprogramdevirt-read-summary=%S/Inputs/export.yaml -wholeprogramdevirt-write-summary=%t -S -o - %s | FileCheck %s +; RUN: FileCheck --check-prefix=SUMMARY %s < %t + +; SUMMARY: - TypeTests: +; SUMMARY-NEXT: TypeTestAssumeVCalls: + +; SUMMARY: TypeIdMap: +; SUMMARY-NEXT: typeid4: +; SUMMARY-NEXT: TTRes: +; SUMMARY-NEXT: Kind: Unsat +; SUMMARY-NEXT: SizeM1BitWidth: 0 +; SUMMARY-NEXT: WPDRes: +; SUMMARY-NEXT: 0: +; SUMMARY-NEXT: Kind: Indir +; SUMMARY-NEXT: SingleImplName: '' +; SUMMARY-NEXT: ResByArg: +; SUMMARY-NEXT: 24,12: +; SUMMARY-NEXT: Kind: UniformRetVal +; SUMMARY-NEXT: Info: 36 + +; CHECK: @vt4a = constant i32 (i8*, i32, i32)* @vf4a +@vt4a = constant i32 (i8*, i32, i32)* @vf4a, !type !0 + +; CHECK: @vt4b = constant i32 (i8*, i32, i32)* @vf4b +@vt4b = constant i32 (i8*, i32, i32)* @vf4b, !type !0 + +define i32 @vf4a(i8*, i32 %x, i32 %y) { + %z = add i32 %x, %y + ret i32 %z +} + +define i32 @vf4b(i8*, i32 %x, i32 %y) { + ret i32 36 +} + +!0 = !{i32 0, !"typeid4"} diff --git a/test/Transforms/WholeProgramDevirt/export-unique-ret-val.ll b/test/Transforms/WholeProgramDevirt/export-unique-ret-val.ll new file mode 100644 index 000000000000..174a573b5b0d --- /dev/null +++ b/test/Transforms/WholeProgramDevirt/export-unique-ret-val.ll @@ -0,0 +1,79 @@ +; RUN: opt -wholeprogramdevirt -wholeprogramdevirt-summary-action=export -wholeprogramdevirt-read-summary=%S/Inputs/export.yaml -wholeprogramdevirt-write-summary=%t -S -o - %s | FileCheck %s +; RUN: FileCheck --check-prefix=SUMMARY %s < %t + +; SUMMARY: - TypeTests: +; SUMMARY-NEXT: TypeTestAssumeVCalls: + +; SUMMARY: TypeIdMap: +; SUMMARY-NEXT: typeid3: +; SUMMARY-NEXT: TTRes: +; SUMMARY-NEXT: Kind: Unsat +; SUMMARY-NEXT: SizeM1BitWidth: 0 +; SUMMARY-NEXT: WPDRes: +; SUMMARY-NEXT: 0: +; SUMMARY-NEXT: Kind: Indir +; SUMMARY-NEXT: SingleImplName: '' +; SUMMARY-NEXT: ResByArg: +; SUMMARY-NEXT: 12,24: +; SUMMARY-NEXT: Kind: UniqueRetVal +; SUMMARY-NEXT: Info: 0 +; SUMMARY-NEXT: typeid4: +; SUMMARY-NEXT: TTRes: +; SUMMARY-NEXT: Kind: Unsat +; SUMMARY-NEXT: SizeM1BitWidth: 0 +; SUMMARY-NEXT: WPDRes: +; SUMMARY-NEXT: 0: +; SUMMARY-NEXT: Kind: Indir +; SUMMARY-NEXT: SingleImplName: '' +; SUMMARY-NEXT: ResByArg: +; SUMMARY-NEXT: 24,12: +; SUMMARY-NEXT: Kind: UniqueRetVal +; SUMMARY-NEXT: Info: 1 + +; CHECK: @vt3a = constant i1 (i8*, i32, i32)* @vf3a +@vt3a = constant i1 (i8*, i32, i32)* @vf3a, !type !0 + +; CHECK: @vt3b = constant i1 (i8*, i32, i32)* @vf3b +@vt3b = constant i1 (i8*, i32, i32)* @vf3b, !type !0 + +; CHECK: @vt3c = constant i1 (i8*, i32, i32)* @vf3c +@vt3c = constant i1 (i8*, i32, i32)* @vf3c, !type !0 + +; CHECK: @vt4a = constant i1 (i8*, i32, i32)* @vf4a +@vt4a = constant i1 (i8*, i32, i32)* @vf4a, !type !1 + +; CHECK: @vt4b = constant i1 (i8*, i32, i32)* @vf4b +@vt4b = constant i1 (i8*, i32, i32)* @vf4b, !type !1 + +; CHECK: @vt4c = constant i1 (i8*, i32, i32)* @vf4c +@vt4c = constant i1 (i8*, i32, i32)* @vf4c, !type !1 + +; CHECK: @__typeid_typeid3_0_12_24_unique_member = hidden alias i8, bitcast (i1 (i8*, i32, i32)** @vt3b to i8*) +; CHECK: @__typeid_typeid4_0_24_12_unique_member = hidden alias i8, bitcast (i1 (i8*, i32, i32)** @vt4b to i8*) + +define i1 @vf3a(i8*, i32, i32) { + ret i1 true +} + +define i1 @vf3b(i8*, i32, i32) { + ret i1 false +} + +define i1 @vf3c(i8*, i32, i32) { + ret i1 true +} + +define i1 @vf4a(i8*, i32, i32) { + ret i1 false +} + +define i1 @vf4b(i8*, i32, i32) { + ret i1 true +} + +define i1 @vf4c(i8*, i32, i32) { + ret i1 false +} + +!0 = !{i32 0, !"typeid3"} +!1 = !{i32 0, !"typeid4"} diff --git a/test/Transforms/WholeProgramDevirt/export-unsuccessful-checked.ll b/test/Transforms/WholeProgramDevirt/export-unsuccessful-checked.ll new file mode 100644 index 000000000000..0785ade28570 --- /dev/null +++ b/test/Transforms/WholeProgramDevirt/export-unsuccessful-checked.ll @@ -0,0 +1,28 @@ +; RUN: opt -wholeprogramdevirt -wholeprogramdevirt-summary-action=export -wholeprogramdevirt-read-summary=%S/Inputs/export.yaml -wholeprogramdevirt-write-summary=%t -o /dev/null %s +; RUN: FileCheck %s < %t + +; CHECK: - TypeTests: [ 15427464259790519041, 17525413373118030901 ] +; CHECK-NEXT: TypeTestAssumeVCalls: + +@vt1a = constant void (i8*)* @vf1a, !type !0 +@vt1b = constant void (i8*)* @vf1b, !type !0 +@vt2a = constant void (i8*)* @vf2a, !type !1 +@vt2b = constant void (i8*)* @vf2b, !type !1 +@vt3a = constant void (i8*)* @vf3a, !type !2 +@vt3b = constant void (i8*)* @vf3b, !type !2 +@vt4a = constant void (i8*)* @vf4a, !type !3 +@vt4b = constant void (i8*)* @vf4b, !type !3 + +declare void @vf1a(i8*) +declare void @vf1b(i8*) +declare void @vf2a(i8*) +declare void @vf2b(i8*) +declare void @vf3a(i8*) +declare void @vf3b(i8*) +declare void @vf4a(i8*) +declare void @vf4b(i8*) + +!0 = !{i32 0, !"typeid1"} +!1 = !{i32 0, !"typeid2"} +!2 = !{i32 0, !"typeid3"} +!3 = !{i32 0, !"typeid4"} diff --git a/test/Transforms/WholeProgramDevirt/export-vcp.ll b/test/Transforms/WholeProgramDevirt/export-vcp.ll new file mode 100644 index 000000000000..8e6e69b9bd43 --- /dev/null +++ b/test/Transforms/WholeProgramDevirt/export-vcp.ll @@ -0,0 +1,83 @@ +; RUN: opt -wholeprogramdevirt -wholeprogramdevirt-summary-action=export -wholeprogramdevirt-read-summary=%S/Inputs/export.yaml -wholeprogramdevirt-write-summary=%t -S -o - %s | FileCheck %s +; RUN: FileCheck --check-prefix=SUMMARY %s < %t + +target datalayout = "e-p:64:64" +target triple = "x86_64-unknown-linux-gnu" + +; SUMMARY: TypeIdMap: +; SUMMARY-NEXT: typeid3: +; SUMMARY-NEXT: TTRes: +; SUMMARY-NEXT: Kind: Unsat +; SUMMARY-NEXT: SizeM1BitWidth: 0 +; SUMMARY-NEXT: WPDRes: +; SUMMARY-NEXT: 0: +; SUMMARY-NEXT: Kind: Indir +; SUMMARY-NEXT: SingleImplName: '' +; SUMMARY-NEXT: ResByArg: +; SUMMARY-NEXT: 12,24: +; SUMMARY-NEXT: Kind: VirtualConstProp +; SUMMARY-NEXT: Info: 0 +; SUMMARY-NEXT: typeid4: +; SUMMARY-NEXT: TTRes: +; SUMMARY-NEXT: Kind: Unsat +; SUMMARY-NEXT: SizeM1BitWidth: 0 +; SUMMARY-NEXT: WPDRes: +; SUMMARY-NEXT: 0: +; SUMMARY-NEXT: Kind: Indir +; SUMMARY-NEXT: SingleImplName: '' +; SUMMARY-NEXT: ResByArg: +; SUMMARY-NEXT: 24,12: +; SUMMARY-NEXT: Kind: VirtualConstProp +; SUMMARY-NEXT: Info: 0 + +; CHECK: [[CVT3A:.*]] = private constant { [8 x i8], i1 (i8*, i32, i32)*, [0 x i8] } { [8 x i8] zeroinitializer, i1 (i8*, i32, i32)* @vf0i1, [0 x i8] zeroinitializer }, !type !0 +@vt3a = constant i1 (i8*, i32, i32)* @vf0i1, !type !0 + +; CHECK: [[CVT3B:.*]] = private constant { [8 x i8], i1 (i8*, i32, i32)*, [0 x i8] } { [8 x i8] c"\00\00\00\00\00\00\00\01", i1 (i8*, i32, i32)* @vf1i1, [0 x i8] zeroinitializer }, !type !0 +@vt3b = constant i1 (i8*, i32, i32)* @vf1i1, !type !0 + +; CHECK: [[CVT3C:.*]] = private constant { [8 x i8], i1 (i8*, i32, i32)*, [0 x i8] } { [8 x i8] zeroinitializer, i1 (i8*, i32, i32)* @vf0i1, [0 x i8] zeroinitializer }, !type !0 +@vt3c = constant i1 (i8*, i32, i32)* @vf0i1, !type !0 + +; CHECK: [[CVT3D:.*]] = private constant { [8 x i8], i1 (i8*, i32, i32)*, [0 x i8] } { [8 x i8] c"\00\00\00\00\00\00\00\01", i1 (i8*, i32, i32)* @vf1i1, [0 x i8] zeroinitializer }, !type !0 +@vt3d = constant i1 (i8*, i32, i32)* @vf1i1, !type !0 + +; CHECK: [[CVT4A:.*]] = private constant { [8 x i8], i32 (i8*, i32, i32)*, [0 x i8] } { [8 x i8] c"\00\00\00\00\01\00\00\00", i32 (i8*, i32, i32)* @vf1i32, [0 x i8] zeroinitializer }, !type !1 +@vt4a = constant i32 (i8*, i32, i32)* @vf1i32, !type !1 + +; CHECK: [[CVT4B:.*]] = private constant { [8 x i8], i32 (i8*, i32, i32)*, [0 x i8] } { [8 x i8] c"\00\00\00\00\02\00\00\00", i32 (i8*, i32, i32)* @vf2i32, [0 x i8] zeroinitializer }, !type !1 +@vt4b = constant i32 (i8*, i32, i32)* @vf2i32, !type !1 + +; CHECK: @__typeid_typeid3_0_12_24_byte = hidden alias i8, inttoptr (i32 -1 to i8*) +; CHECK: @__typeid_typeid3_0_12_24_bit = hidden alias i8, inttoptr (i8 1 to i8*) +; CHECK: @__typeid_typeid4_0_24_12_byte = hidden alias i8, inttoptr (i32 -4 to i8*) +; CHECK: @__typeid_typeid4_0_24_12_bit = hidden alias i8, inttoptr (i8 1 to i8*) + +; CHECK: @vt3a = alias i1 (i8*, i32, i32)*, getelementptr inbounds ({ [8 x i8], i1 (i8*, i32, i32)*, [0 x i8] }, { [8 x i8], i1 (i8*, i32, i32)*, [0 x i8] }* [[CVT3A]], i32 0, i32 1) +; CHECK: @vt3b = alias i1 (i8*, i32, i32)*, getelementptr inbounds ({ [8 x i8], i1 (i8*, i32, i32)*, [0 x i8] }, { [8 x i8], i1 (i8*, i32, i32)*, [0 x i8] }* [[CVT3B]], i32 0, i32 1) +; CHECK: @vt3c = alias i1 (i8*, i32, i32)*, getelementptr inbounds ({ [8 x i8], i1 (i8*, i32, i32)*, [0 x i8] }, { [8 x i8], i1 (i8*, i32, i32)*, [0 x i8] }* [[CVT3C]], i32 0, i32 1) +; CHECK: @vt3d = alias i1 (i8*, i32, i32)*, getelementptr inbounds ({ [8 x i8], i1 (i8*, i32, i32)*, [0 x i8] }, { [8 x i8], i1 (i8*, i32, i32)*, [0 x i8] }* [[CVT3D]], i32 0, i32 1) +; CHECK: @vt4a = alias i32 (i8*, i32, i32)*, getelementptr inbounds ({ [8 x i8], i32 (i8*, i32, i32)*, [0 x i8] }, { [8 x i8], i32 (i8*, i32, i32)*, [0 x i8] }* [[CVT4A]], i32 0, i32 1) +; CHECK: @vt4b = alias i32 (i8*, i32, i32)*, getelementptr inbounds ({ [8 x i8], i32 (i8*, i32, i32)*, [0 x i8] }, { [8 x i8], i32 (i8*, i32, i32)*, [0 x i8] }* [[CVT4B]], i32 0, i32 1) + +define i1 @vf0i1(i8* %this, i32, i32) readnone { + ret i1 0 +} + +define i1 @vf1i1(i8* %this, i32, i32) readnone { + ret i1 1 +} + +define i32 @vf1i32(i8* %this, i32, i32) readnone { + ret i32 1 +} + +define i32 @vf2i32(i8* %this, i32, i32) readnone { + ret i32 2 +} + +; CHECK: !0 = !{i32 8, !"typeid3"} +; CHECK: !1 = !{i32 8, !"typeid4"} + +!0 = !{i32 0, !"typeid3"} +!1 = !{i32 0, !"typeid4"} diff --git a/test/Transforms/WholeProgramDevirt/import-indir.ll b/test/Transforms/WholeProgramDevirt/import-indir.ll new file mode 100644 index 000000000000..1de9352eeb22 --- /dev/null +++ b/test/Transforms/WholeProgramDevirt/import-indir.ll @@ -0,0 +1,95 @@ +; Test that we correctly import an indir resolution for type identifier "typeid1". +; RUN: opt -S -wholeprogramdevirt -wholeprogramdevirt-summary-action=import -wholeprogramdevirt-read-summary=%S/Inputs/import-indir.yaml -wholeprogramdevirt-write-summary=%t < %s | FileCheck %s +; RUN: FileCheck --check-prefix=SUMMARY %s < %t + +; SUMMARY: GlobalValueMap: +; SUMMARY-NEXT: 42: +; SUMMARY-NEXT: - TypeTests: +; SUMMARY-NEXT: TypeTestAssumeVCalls: +; SUMMARY-NEXT: - GUID: 123 +; SUMMARY-NEXT: Offset: 0 +; SUMMARY-NEXT: - GUID: 456 +; SUMMARY-NEXT: Offset: 4 +; SUMMARY-NEXT: TypeCheckedLoadVCalls: +; SUMMARY-NEXT: - GUID: 789 +; SUMMARY-NEXT: Offset: 8 +; SUMMARY-NEXT: - GUID: 1234 +; SUMMARY-NEXT: Offset: 16 +; SUMMARY-NEXT: TypeTestAssumeConstVCalls: +; SUMMARY-NEXT: - VFunc: +; SUMMARY-NEXT: GUID: 123 +; SUMMARY-NEXT: Offset: 4 +; SUMMARY-NEXT: Args: [ 12, 24 ] +; SUMMARY-NEXT: TypeCheckedLoadConstVCalls: +; SUMMARY-NEXT: - VFunc: +; SUMMARY-NEXT: GUID: 456 +; SUMMARY-NEXT: Offset: 8 +; SUMMARY-NEXT: Args: [ 24, 12 ] +; SUMMARY-NEXT: TypeIdMap: +; SUMMARY-NEXT: typeid1: +; SUMMARY-NEXT: TTRes: +; SUMMARY-NEXT: Kind: Unsat +; SUMMARY-NEXT: SizeM1BitWidth: 0 +; SUMMARY-NEXT: WPDRes: +; SUMMARY-NEXT: 0: +; SUMMARY-NEXT: Kind: Indir +; SUMMARY-NEXT: SingleImplName: '' +; SUMMARY-NEXT: ResByArg: +; SUMMARY-NEXT: 4: +; SUMMARY-NEXT: Kind: Indir +; SUMMARY-NEXT: SingleImplName: '' +; SUMMARY-NEXT: ResByArg: +; SUMMARY-NEXT: : +; SUMMARY-NEXT: Kind: UniformRetVal +; SUMMARY-NEXT: Info: 12 +; SUMMARY-NEXT: 12: +; SUMMARY-NEXT: Kind: UniformRetVal +; SUMMARY-NEXT: Info: 24 +; SUMMARY-NEXT: 12,24: +; SUMMARY-NEXT: Kind: UniformRetVal +; SUMMARY-NEXT: Info: 48 + +target datalayout = "e-p:32:32" + +declare void @llvm.assume(i1) +declare void @llvm.trap() +declare {i8*, i1} @llvm.type.checked.load(i8*, i32, metadata) +declare i1 @llvm.type.test(i8*, metadata) + +; CHECK: define i1 @f1 +define i1 @f1(i8* %obj) { + %vtableptr = bitcast i8* %obj to [1 x i8*]** + %vtable = load [1 x i8*]*, [1 x i8*]** %vtableptr + %vtablei8 = bitcast [1 x i8*]* %vtable to i8* + %p = call i1 @llvm.type.test(i8* %vtablei8, metadata !"typeid1") + call void @llvm.assume(i1 %p) + %fptrptr = getelementptr [1 x i8*], [1 x i8*]* %vtable, i32 0, i32 0 + %fptr = load i8*, i8** %fptrptr + %fptr_casted = bitcast i8* %fptr to i1 (i8*, i32)* + ; CHECK: call i1 % + %result = call i1 %fptr_casted(i8* %obj, i32 5) + ret i1 %result +} + +; CHECK: define i1 @f2 +define i1 @f2(i8* %obj) { + %vtableptr = bitcast i8* %obj to [1 x i8*]** + %vtable = load [1 x i8*]*, [1 x i8*]** %vtableptr + %vtablei8 = bitcast [1 x i8*]* %vtable to i8* + %pair = call {i8*, i1} @llvm.type.checked.load(i8* %vtablei8, i32 4, metadata !"typeid1") + %fptr = extractvalue {i8*, i1} %pair, 0 + %p = extractvalue {i8*, i1} %pair, 1 + ; CHECK: [[P:%.*]] = call i1 @llvm.type.test + ; CHECK: br i1 [[P]] + br i1 %p, label %cont, label %trap + +cont: + %fptr_casted = bitcast i8* %fptr to i1 (i8*, i32)* + ; CHECK: call i1 % + %result = call i1 %fptr_casted(i8* %obj, i32 undef) + ret i1 %result + +trap: + call void @llvm.trap() + unreachable +} diff --git a/test/Transforms/WholeProgramDevirt/import.ll b/test/Transforms/WholeProgramDevirt/import.ll new file mode 100644 index 000000000000..7f34b04ce119 --- /dev/null +++ b/test/Transforms/WholeProgramDevirt/import.ll @@ -0,0 +1,108 @@ +; RUN: opt -S -wholeprogramdevirt -wholeprogramdevirt-summary-action=import -wholeprogramdevirt-read-summary=%S/Inputs/import-single-impl.yaml < %s | FileCheck --check-prefixes=CHECK,SINGLE-IMPL %s +; RUN: opt -S -wholeprogramdevirt -wholeprogramdevirt-summary-action=import -wholeprogramdevirt-read-summary=%S/Inputs/import-uniform-ret-val.yaml < %s | FileCheck --check-prefixes=CHECK,UNIFORM-RET-VAL %s +; RUN: opt -S -wholeprogramdevirt -wholeprogramdevirt-summary-action=import -wholeprogramdevirt-read-summary=%S/Inputs/import-unique-ret-val0.yaml < %s | FileCheck --check-prefixes=CHECK,UNIQUE-RET-VAL0 %s +; RUN: opt -S -wholeprogramdevirt -wholeprogramdevirt-summary-action=import -wholeprogramdevirt-read-summary=%S/Inputs/import-unique-ret-val1.yaml < %s | FileCheck --check-prefixes=CHECK,UNIQUE-RET-VAL1 %s +; RUN: opt -S -wholeprogramdevirt -wholeprogramdevirt-summary-action=import -wholeprogramdevirt-read-summary=%S/Inputs/import-vcp.yaml < %s | FileCheck --check-prefixes=CHECK,VCP,VCP64 %s +; RUN: opt -S -wholeprogramdevirt -wholeprogramdevirt-summary-action=import -wholeprogramdevirt-read-summary=%S/Inputs/import-vcp.yaml -mtriple=i686-unknown-linux -data-layout=e-p:32:32 < %s | FileCheck --check-prefixes=CHECK,VCP,VCP32 %s + +target datalayout = "e-p:64:64" +target triple = "x86_64-unknown-linux-gnu" + +; VCP: @__typeid_typeid1_0_1_byte = external hidden global i8, !absolute_symbol !0 +; VCP: @__typeid_typeid1_0_1_bit = external hidden global i8, !absolute_symbol !1 +; VCP: @__typeid_typeid2_8_3_byte = external hidden global i8, !absolute_symbol !0 +; VCP: @__typeid_typeid2_8_3_bit = external hidden global i8, !absolute_symbol !1 + +; Test cases where the argument values are known and we can apply virtual +; constant propagation. + +; CHECK: define i32 @call1 +define i32 @call1(i8* %obj) { + %vtableptr = bitcast i8* %obj to [3 x i8*]** + %vtable = load [3 x i8*]*, [3 x i8*]** %vtableptr + %vtablei8 = bitcast [3 x i8*]* %vtable to i8* + %p = call i1 @llvm.type.test(i8* %vtablei8, metadata !"typeid1") + call void @llvm.assume(i1 %p) + %fptrptr = getelementptr [3 x i8*], [3 x i8*]* %vtable, i32 0, i32 0 + %fptr = load i8*, i8** %fptrptr + %fptr_casted = bitcast i8* %fptr to i32 (i8*, i32)* + ; SINGLE-IMPL: call i32 bitcast (void ()* @singleimpl1 to i32 (i8*, i32)*) + %result = call i32 %fptr_casted(i8* %obj, i32 1) + ; UNIFORM-RET-VAL: ret i32 42 + ; VCP: [[VT1:%.*]] = bitcast {{.*}} to i8* + ; VCP: [[GEP1:%.*]] = getelementptr i8, i8* [[VT1]], i32 ptrtoint (i8* @__typeid_typeid1_0_1_byte to i32) + ; VCP: [[BC1:%.*]] = bitcast i8* [[GEP1]] to i32* + ; VCP: [[LOAD1:%.*]] = load i32, i32* [[BC1]] + ; VCP: ret i32 [[LOAD1]] + ret i32 %result +} + +; Test cases where the argument values are unknown, so we cannot apply virtual +; constant propagation. + +; CHECK: define i1 @call2 +define i1 @call2(i8* %obj) { + %vtableptr = bitcast i8* %obj to [1 x i8*]** + %vtable = load [1 x i8*]*, [1 x i8*]** %vtableptr + %vtablei8 = bitcast [1 x i8*]* %vtable to i8* + %pair = call {i8*, i1} @llvm.type.checked.load(i8* %vtablei8, i32 8, metadata !"typeid2") + %fptr = extractvalue {i8*, i1} %pair, 0 + %p = extractvalue {i8*, i1} %pair, 1 + ; SINGLE-IMPL: br i1 true, + br i1 %p, label %cont, label %trap + +cont: + %fptr_casted = bitcast i8* %fptr to i1 (i8*, i32)* + ; SINGLE-IMPL: call i1 bitcast (void ()* @singleimpl2 to i1 (i8*, i32)*) + ; UNIFORM-RET-VAL: call i1 % + ; UNIQUE-RET-VAL0: call i1 % + ; UNIQUE-RET-VAL1: call i1 % + %result = call i1 %fptr_casted(i8* %obj, i32 undef) + ret i1 %result + +trap: + call void @llvm.trap() + unreachable +} + +; CHECK: define i1 @call3 +define i1 @call3(i8* %obj) { + %vtableptr = bitcast i8* %obj to [1 x i8*]** + %vtable = load [1 x i8*]*, [1 x i8*]** %vtableptr + %vtablei8 = bitcast [1 x i8*]* %vtable to i8* + %pair = call {i8*, i1} @llvm.type.checked.load(i8* %vtablei8, i32 8, metadata !"typeid2") + %fptr = extractvalue {i8*, i1} %pair, 0 + %p = extractvalue {i8*, i1} %pair, 1 + br i1 %p, label %cont, label %trap + +cont: + %fptr_casted = bitcast i8* %fptr to i1 (i8*, i32)* + %result = call i1 %fptr_casted(i8* %obj, i32 3) + ; UNIQUE-RET-VAL0: icmp ne i8* %vtablei8, @__typeid_typeid2_8_3_unique_member + ; UNIQUE-RET-VAL1: icmp eq i8* %vtablei8, @__typeid_typeid2_8_3_unique_member + ; VCP: [[VT2:%.*]] = bitcast {{.*}} to i8* + ; VCP: [[GEP2:%.*]] = getelementptr i8, i8* [[VT2]], i32 ptrtoint (i8* @__typeid_typeid2_8_3_byte to i32) + ; VCP: [[LOAD2:%.*]] = load i8, i8* [[GEP2]] + ; VCP: [[AND2:%.*]] = and i8 [[LOAD2]], ptrtoint (i8* @__typeid_typeid2_8_3_bit to i8) + ; VCP: [[ICMP2:%.*]] = icmp ne i8 [[AND2]], 0 + ; VCP: ret i1 [[ICMP2]] + ret i1 %result + +trap: + call void @llvm.trap() + unreachable +} + +; SINGLE-IMPL-DAG: declare void @singleimpl1() +; SINGLE-IMPL-DAG: declare void @singleimpl2() + +; VCP32: !0 = !{i32 -1, i32 -1} +; VCP64: !0 = !{i64 0, i64 4294967296} + +; VCP32: !1 = !{i32 0, i32 256} +; VCP64: !1 = !{i64 0, i64 256} + +declare void @llvm.assume(i1) +declare void @llvm.trap() +declare {i8*, i1} @llvm.type.checked.load(i8*, i32, metadata) +declare i1 @llvm.type.test(i8*, metadata) diff --git a/test/Transforms/WholeProgramDevirt/unique-retval.ll b/test/Transforms/WholeProgramDevirt/unique-retval.ll index 50b938c43e4a..e9ae176fe8ac 100644 --- a/test/Transforms/WholeProgramDevirt/unique-retval.ll +++ b/test/Transforms/WholeProgramDevirt/unique-retval.ll @@ -33,8 +33,8 @@ define i1 @call1(i8* %obj) { ret i1 %result } -; CHECK: define i1 @call2 -define i1 @call2(i8* %obj) { +; CHECK: define i32 @call2 +define i32 @call2(i8* %obj) { %vtableptr = bitcast i8* %obj to [1 x i8*]** %vtable = load [1 x i8*]*, [1 x i8*]** %vtableptr ; CHECK: [[VT2:%[^ ]*]] = bitcast [1 x i8*]* {{.*}} to i8* @@ -43,10 +43,13 @@ define i1 @call2(i8* %obj) { call void @llvm.assume(i1 %p) %fptrptr = getelementptr [1 x i8*], [1 x i8*]* %vtable, i32 0, i32 0 %fptr = load i8*, i8** %fptrptr - %fptr_casted = bitcast i8* %fptr to i1 (i8*)* - ; CHECK: [[RES1:%[^ ]*]] = icmp ne i8* [[VT1]], bitcast ([1 x i8*]* @vt2 to i8*) - %result = call i1 %fptr_casted(i8* %obj) - ret i1 %result + ; Intentional type mismatch to test zero extend. + %fptr_casted = bitcast i8* %fptr to i32 (i8*)* + ; CHECK: [[RES2:%[^ ]*]] = icmp ne i8* [[VT1]], bitcast ([1 x i8*]* @vt2 to i8*) + %result = call i32 %fptr_casted(i8* %obj) + ; CHECK: [[ZEXT2:%[^ ]*]] = zext i1 [[RES2]] to i32 + ; CHECK: ret i32 [[ZEXT2:%[^ ]*]] + ret i32 %result } declare i1 @llvm.type.test(i8*, metadata) diff --git a/test/Transforms/WholeProgramDevirt/vcp-accesses-memory.ll b/test/Transforms/WholeProgramDevirt/vcp-accesses-memory.ll index b5d51f2d4637..ca76383c4943 100644 --- a/test/Transforms/WholeProgramDevirt/vcp-accesses-memory.ll +++ b/test/Transforms/WholeProgramDevirt/vcp-accesses-memory.ll @@ -1,21 +1,37 @@ ; RUN: opt -S -wholeprogramdevirt %s | FileCheck %s +; RUN: opt -S -passes=wholeprogramdevirt %s | FileCheck %s target datalayout = "e-p:64:64" target triple = "x86_64-unknown-linux-gnu" -@vt1 = global [1 x i8*] [i8* bitcast (i32 (i8*, i32)* @vf1 to i8*)], !type !0 -@vt2 = global [1 x i8*] [i8* bitcast (i32 (i8*, i32)* @vf2 to i8*)], !type !0 +@vt1 = constant [2 x i8*] [i8* bitcast (i32 (i8*, i32)* @vf1a to i8*), i8* bitcast (i32 (i8*, i32)* @vf1b to i8*)], !type !0 +@vt2 = constant [2 x i8*] [i8* bitcast (i32 (i8*, i32)* @vf2a to i8*), i8* bitcast (i32 (i8*, i32)* @vf2b to i8*)], !type !0 -define i32 @vf1(i8* %this, i32 %arg) { +@sink = external global i32 + +define i32 @vf1a(i8* %this, i32 %arg) { + store i32 %arg, i32* @sink + ret i32 %arg +} + +define i32 @vf2a(i8* %this, i32 %arg) { + store i32 %arg, i32* @sink + ret i32 %arg +} + +define i32 @vf1b(i8* %this, i32 %arg) { ret i32 %arg } -define i32 @vf2(i8* %this, i32 %arg) { +define i32 @vf2b(i8* %this, i32 %arg) { ret i32 %arg } -; CHECK: define i32 @call -define i32 @call(i8* %obj) { +; Test that we don't apply VCP if the virtual function body accesses memory, +; even if the function returns a constant. + +; CHECK: define i32 @call1 +define i32 @call1(i8* %obj) { %vtableptr = bitcast i8* %obj to [1 x i8*]** %vtable = load [1 x i8*]*, [1 x i8*]** %vtableptr %vtablei8 = bitcast [1 x i8*]* %vtable to i8* @@ -29,6 +45,24 @@ define i32 @call(i8* %obj) { ret i32 %result } +; Test that we can apply VCP regardless of the function attributes by analyzing +; the function body itself. + +; CHECK: define i32 @call2 +define i32 @call2(i8* %obj) { + %vtableptr = bitcast i8* %obj to [1 x i8*]** + %vtable = load [1 x i8*]*, [1 x i8*]** %vtableptr + %vtablei8 = bitcast [1 x i8*]* %vtable to i8* + %p = call i1 @llvm.type.test(i8* %vtablei8, metadata !"typeid") + call void @llvm.assume(i1 %p) + %fptrptr = getelementptr [1 x i8*], [1 x i8*]* %vtable, i32 0, i32 1 + %fptr = load i8*, i8** %fptrptr + %fptr_casted = bitcast i8* %fptr to i32 (i8*, i32)* + %result = call i32 %fptr_casted(i8* %obj, i32 1) + ; CHECK: ret i32 1 + ret i32 %result +} + declare i1 @llvm.type.test(i8*, metadata) declare void @llvm.assume(i1) diff --git a/test/Transforms/WholeProgramDevirt/vcp-decl.ll b/test/Transforms/WholeProgramDevirt/vcp-decl.ll new file mode 100644 index 000000000000..1c4e2fbe97aa --- /dev/null +++ b/test/Transforms/WholeProgramDevirt/vcp-decl.ll @@ -0,0 +1,32 @@ +; RUN: opt -S -wholeprogramdevirt %s | FileCheck %s + +target datalayout = "e-p:64:64" +target triple = "x86_64-unknown-linux-gnu" + +@vt1 = constant [1 x i8*] [i8* bitcast (i32 (i8*, i32)* @vf1 to i8*)], !type !0 +@vt2 = constant [1 x i8*] [i8* bitcast (i32 (i8*, i32)* @vf2 to i8*)], !type !0 + +declare i32 @vf1(i8* %this, i32 %arg) readnone + +define i32 @vf2(i8* %this, i32 %arg) readnone { + ret i32 %arg +} + +; CHECK: define i32 @fn +define i32 @fn(i8* %obj) { + %vtableptr = bitcast i8* %obj to [1 x i8*]** + %vtable = load [1 x i8*]*, [1 x i8*]** %vtableptr + %vtablei8 = bitcast [1 x i8*]* %vtable to i8* + %p = call i1 @llvm.type.test(i8* %vtablei8, metadata !"typeid") + call void @llvm.assume(i1 %p) + %fptrptr = getelementptr [1 x i8*], [1 x i8*]* %vtable, i32 0, i32 0 + %fptr = load i8*, i8** %fptrptr + %fptr_casted = bitcast i8* %fptr to i32 (i8*, i32)* + ; CHECK: call i32 % + %result = call i32 %fptr_casted(i8* %obj, i32 1) + ret i32 %result +} +declare i1 @llvm.type.test(i8*, metadata) +declare void @llvm.assume(i1) + +!0 = !{i32 0, !"typeid"} diff --git a/test/Transforms/WholeProgramDevirt/vcp-no-this.ll b/test/Transforms/WholeProgramDevirt/vcp-no-this.ll index c564665471cf..ce76c8e6797e 100644 --- a/test/Transforms/WholeProgramDevirt/vcp-no-this.ll +++ b/test/Transforms/WholeProgramDevirt/vcp-no-this.ll @@ -3,8 +3,8 @@ target datalayout = "e-p:64:64" target triple = "x86_64-unknown-linux-gnu" -@vt1 = global [1 x i8*] [i8* bitcast (i32 ()* @vf1 to i8*)], !type !0 -@vt2 = global [1 x i8*] [i8* bitcast (i32 ()* @vf2 to i8*)], !type !0 +@vt1 = constant [1 x i8*] [i8* bitcast (i32 ()* @vf1 to i8*)], !type !0 +@vt2 = constant [1 x i8*] [i8* bitcast (i32 ()* @vf2 to i8*)], !type !0 define i32 @vf1() readnone { ret i32 1 diff --git a/test/Transforms/WholeProgramDevirt/vcp-non-constant-arg.ll b/test/Transforms/WholeProgramDevirt/vcp-non-constant-arg.ll index 197c923c3a1c..cc2ff33296a9 100644 --- a/test/Transforms/WholeProgramDevirt/vcp-non-constant-arg.ll +++ b/test/Transforms/WholeProgramDevirt/vcp-non-constant-arg.ll @@ -3,8 +3,8 @@ target datalayout = "e-p:64:64" target triple = "x86_64-unknown-linux-gnu" -@vt1 = global [1 x i8*] [i8* bitcast (i32 (i8*, i32)* @vf1 to i8*)], !type !0 -@vt2 = global [1 x i8*] [i8* bitcast (i32 (i8*, i32)* @vf2 to i8*)], !type !0 +@vt1 = constant [1 x i8*] [i8* bitcast (i32 (i8*, i32)* @vf1 to i8*)], !type !0 +@vt2 = constant [1 x i8*] [i8* bitcast (i32 (i8*, i32)* @vf2 to i8*)], !type !0 define i32 @vf1(i8* %this, i32 %arg) readnone { ret i32 %arg diff --git a/test/Transforms/WholeProgramDevirt/vcp-too-wide-ints.ll b/test/Transforms/WholeProgramDevirt/vcp-too-wide-ints.ll index 93936d5e1d27..c24c3b4be683 100644 --- a/test/Transforms/WholeProgramDevirt/vcp-too-wide-ints.ll +++ b/test/Transforms/WholeProgramDevirt/vcp-too-wide-ints.ll @@ -3,33 +3,63 @@ target datalayout = "e-p:64:64" target triple = "x86_64-unknown-linux-gnu" -@vt1 = global [1 x i8*] [i8* bitcast (i128 (i8*, i128)* @vf1 to i8*)], !type !0 -@vt2 = global [1 x i8*] [i8* bitcast (i128 (i8*, i128)* @vf2 to i8*)], !type !0 +@vt1 = constant [1 x i8*] [i8* bitcast (i64 (i8*, i128)* @vf1 to i8*)], !type !0 +@vt2 = constant [1 x i8*] [i8* bitcast (i64 (i8*, i128)* @vf2 to i8*)], !type !0 +@vt3 = constant [1 x i8*] [i8* bitcast (i128 (i8*, i64)* @vf3 to i8*)], !type !1 +@vt4 = constant [1 x i8*] [i8* bitcast (i128 (i8*, i64)* @vf4 to i8*)], !type !1 -define i128 @vf1(i8* %this, i128 %arg) readnone { - ret i128 %arg +define i64 @vf1(i8* %this, i128 %arg) readnone { + %argtrunc = trunc i128 %arg to i64 + ret i64 %argtrunc } -define i128 @vf2(i8* %this, i128 %arg) readnone { - ret i128 %arg +define i64 @vf2(i8* %this, i128 %arg) readnone { + %argtrunc = trunc i128 %arg to i64 + ret i64 %argtrunc } -; CHECK: define i128 @call -define i128 @call(i8* %obj) { +define i128 @vf3(i8* %this, i64 %arg) readnone { + %argzext = zext i64 %arg to i128 + ret i128 %argzext +} + +define i128 @vf4(i8* %this, i64 %arg) readnone { + %argzext = zext i64 %arg to i128 + ret i128 %argzext +} + +; CHECK: define i64 @call1 +define i64 @call1(i8* %obj) { + %vtableptr = bitcast i8* %obj to [1 x i8*]** + %vtable = load [1 x i8*]*, [1 x i8*]** %vtableptr + %vtablei8 = bitcast [1 x i8*]* %vtable to i8* + %p = call i1 @llvm.type.test(i8* %vtablei8, metadata !"typeid1") + call void @llvm.assume(i1 %p) + %fptrptr = getelementptr [1 x i8*], [1 x i8*]* %vtable, i32 0, i32 0 + %fptr = load i8*, i8** %fptrptr + %fptr_casted = bitcast i8* %fptr to i64 (i8*, i128)* + ; CHECK: call i64 % + %result = call i64 %fptr_casted(i8* %obj, i128 1) + ret i64 %result +} + +; CHECK: define i128 @call2 +define i128 @call2(i8* %obj) { %vtableptr = bitcast i8* %obj to [1 x i8*]** %vtable = load [1 x i8*]*, [1 x i8*]** %vtableptr %vtablei8 = bitcast [1 x i8*]* %vtable to i8* - %p = call i1 @llvm.type.test(i8* %vtablei8, metadata !"typeid") + %p = call i1 @llvm.type.test(i8* %vtablei8, metadata !"typeid2") call void @llvm.assume(i1 %p) %fptrptr = getelementptr [1 x i8*], [1 x i8*]* %vtable, i32 0, i32 0 %fptr = load i8*, i8** %fptrptr - %fptr_casted = bitcast i8* %fptr to i128 (i8*, i128)* + %fptr_casted = bitcast i8* %fptr to i128 (i8*, i64)* ; CHECK: call i128 % - %result = call i128 %fptr_casted(i8* %obj, i128 1) + %result = call i128 %fptr_casted(i8* %obj, i64 1) ret i128 %result } declare i1 @llvm.type.test(i8*, metadata) declare void @llvm.assume(i1) -!0 = !{i32 0, !"typeid"} +!0 = !{i32 0, !"typeid1"} +!1 = !{i32 0, !"typeid2"} diff --git a/test/Transforms/WholeProgramDevirt/vcp-type-mismatch.ll b/test/Transforms/WholeProgramDevirt/vcp-type-mismatch.ll index 3124889a7070..7016263f8f7b 100644 --- a/test/Transforms/WholeProgramDevirt/vcp-type-mismatch.ll +++ b/test/Transforms/WholeProgramDevirt/vcp-type-mismatch.ll @@ -1,10 +1,16 @@ ; RUN: opt -S -wholeprogramdevirt %s | FileCheck %s +; Test that we correctly handle function type mismatches in argument counts +; and bitwidths. We handle an argument count mismatch by refusing +; to optimize. For bitwidth mismatches, we allow the optimization in order +; to simplify the implementation. This is legal because the bitwidth mismatch +; gives the call undefined behavior. + target datalayout = "e-p:64:64" target triple = "x86_64-unknown-linux-gnu" -@vt1 = global [1 x i8*] [i8* bitcast (i32 (i8*, i32)* @vf1 to i8*)], !type !0 -@vt2 = global [1 x i8*] [i8* bitcast (i32 (i8*, i32)* @vf2 to i8*)], !type !0 +@vt1 = constant [1 x i8*] [i8* bitcast (i32 (i8*, i32)* @vf1 to i8*)], !type !0 +@vt2 = constant [1 x i8*] [i8* bitcast (i32 (i8*, i32)* @vf2 to i8*)], !type !0 define i32 @vf1(i8* %this, i32 %arg) readnone { ret i32 %arg @@ -24,8 +30,8 @@ define i32 @bad_arg_type(i8* %obj) { %fptrptr = getelementptr [1 x i8*], [1 x i8*]* %vtable, i32 0, i32 0 %fptr = load i8*, i8** %fptrptr %fptr_casted = bitcast i8* %fptr to i32 (i8*, i64)* - ; CHECK: call i32 % %result = call i32 %fptr_casted(i8* %obj, i64 1) + ; CHECK: ret i32 1 ret i32 %result } @@ -54,8 +60,8 @@ define i64 @bad_return_type(i8* %obj) { %fptrptr = getelementptr [1 x i8*], [1 x i8*]* %vtable, i32 0, i32 0 %fptr = load i8*, i8** %fptrptr %fptr_casted = bitcast i8* %fptr to i64 (i8*, i32)* - ; CHECK: call i64 % %result = call i64 %fptr_casted(i8* %obj, i32 1) + ; CHECK: ret i64 1 ret i64 %result } diff --git a/test/Transforms/WholeProgramDevirt/vcp-uses-this.ll b/test/Transforms/WholeProgramDevirt/vcp-uses-this.ll index fc4dee37dba7..542402e16577 100644 --- a/test/Transforms/WholeProgramDevirt/vcp-uses-this.ll +++ b/test/Transforms/WholeProgramDevirt/vcp-uses-this.ll @@ -3,8 +3,8 @@ target datalayout = "e-p:64:64" target triple = "x86_64-unknown-linux-gnu" -@vt1 = global [1 x i8*] [i8* bitcast (i32 (i8*)* @vf1 to i8*)], !type !0 -@vt2 = global [1 x i8*] [i8* bitcast (i32 (i8*)* @vf2 to i8*)], !type !0 +@vt1 = constant [1 x i8*] [i8* bitcast (i32 (i8*)* @vf1 to i8*)], !type !0 +@vt2 = constant [1 x i8*] [i8* bitcast (i32 (i8*)* @vf2 to i8*)], !type !0 define i32 @vf1(i8* %this) readnone { %this_int = ptrtoint i8* %this to i32 diff --git a/test/Transforms/WholeProgramDevirt/virtual-const-prop-begin.ll b/test/Transforms/WholeProgramDevirt/virtual-const-prop-begin.ll index 530fe8aa89d0..080ed6caac5e 100644 --- a/test/Transforms/WholeProgramDevirt/virtual-const-prop-begin.ll +++ b/test/Transforms/WholeProgramDevirt/virtual-const-prop-begin.ll @@ -78,7 +78,7 @@ define i1 @call1(i8* %obj) { %fptrptr = getelementptr [3 x i8*], [3 x i8*]* %vtable, i32 0, i32 0 %fptr = load i8*, i8** %fptrptr %fptr_casted = bitcast i8* %fptr to i1 (i8*)* - ; CHECK: [[VTGEP1:%[^ ]*]] = getelementptr i8, i8* [[VT1]], i64 -5 + ; CHECK: [[VTGEP1:%[^ ]*]] = getelementptr i8, i8* [[VT1]], i32 -5 ; CHECK: [[VTLOAD1:%[^ ]*]] = load i8, i8* [[VTGEP1]] ; CHECK: [[VTAND1:%[^ ]*]] = and i8 [[VTLOAD1]], 2 ; CHECK: [[VTCMP1:%[^ ]*]] = icmp ne i8 [[VTAND1]], 0 @@ -98,7 +98,7 @@ define i1 @call2(i8* %obj) { %fptrptr = getelementptr [3 x i8*], [3 x i8*]* %vtable, i32 0, i32 1 %fptr = load i8*, i8** %fptrptr %fptr_casted = bitcast i8* %fptr to i1 (i8*)* - ; CHECK: [[VTGEP2:%[^ ]*]] = getelementptr i8, i8* [[VT2]], i64 -5 + ; CHECK: [[VTGEP2:%[^ ]*]] = getelementptr i8, i8* [[VT2]], i32 -5 ; CHECK: [[VTLOAD2:%[^ ]*]] = load i8, i8* [[VTGEP2]] ; CHECK: [[VTAND2:%[^ ]*]] = and i8 [[VTLOAD2]], 1 ; CHECK: [[VTCMP2:%[^ ]*]] = icmp ne i8 [[VTAND2]], 0 @@ -118,7 +118,7 @@ define i32 @call3(i8* %obj) { %fptrptr = getelementptr [3 x i8*], [3 x i8*]* %vtable, i32 0, i32 2 %fptr = load i8*, i8** %fptrptr %fptr_casted = bitcast i8* %fptr to i32 (i8*)* - ; CHECK: [[VTGEP3:%[^ ]*]] = getelementptr i8, i8* [[VT3]], i64 -4 + ; CHECK: [[VTGEP3:%[^ ]*]] = getelementptr i8, i8* [[VT3]], i32 -4 ; CHECK: [[VTBC3:%[^ ]*]] = bitcast i8* [[VTGEP3]] to i32* ; CHECK: [[VTLOAD3:%[^ ]*]] = load i32, i32* [[VTBC3]] %result = call i32 %fptr_casted(i8* %obj) diff --git a/test/Transforms/WholeProgramDevirt/virtual-const-prop-check.ll b/test/Transforms/WholeProgramDevirt/virtual-const-prop-check.ll index fcf00d6d86c2..3299f7bce65b 100644 --- a/test/Transforms/WholeProgramDevirt/virtual-const-prop-check.ll +++ b/test/Transforms/WholeProgramDevirt/virtual-const-prop-check.ll @@ -87,7 +87,7 @@ define i1 @call1(i8* %obj) { %pair = call {i8*, i1} @llvm.type.checked.load(i8* %vtablei8, i32 0, metadata !"typeid") %fptr = extractvalue {i8*, i1} %pair, 0 %fptr_casted = bitcast i8* %fptr to i1 (i8*)* - ; CHECK: [[VTGEP1:%[^ ]*]] = getelementptr i8, i8* [[VT1]], i64 -5 + ; CHECK: [[VTGEP1:%[^ ]*]] = getelementptr i8, i8* [[VT1]], i32 -5 ; CHECK: [[VTLOAD1:%[^ ]*]] = load i8, i8* [[VTGEP1]] ; CHECK: [[VTAND1:%[^ ]*]] = and i8 [[VTLOAD1]], 2 ; CHECK: [[VTCMP1:%[^ ]*]] = icmp ne i8 [[VTAND1]], 0 @@ -108,7 +108,7 @@ define i1 @call2(i8* %obj) { %pair = call {i8*, i1} @llvm.type.checked.load(i8* %vtablei8, i32 8, metadata !"typeid") %fptr = extractvalue {i8*, i1} %pair, 0 %fptr_casted = bitcast i8* %fptr to i1 (i8*)* - ; CHECK: [[VTGEP2:%[^ ]*]] = getelementptr i8, i8* [[VT2]], i64 -5 + ; CHECK: [[VTGEP2:%[^ ]*]] = getelementptr i8, i8* [[VT2]], i32 -5 ; CHECK: [[VTLOAD2:%[^ ]*]] = load i8, i8* [[VTGEP2]] ; CHECK: [[VTAND2:%[^ ]*]] = and i8 [[VTLOAD2]], 1 ; CHECK: [[VTCMP2:%[^ ]*]] = icmp ne i8 [[VTAND2]], 0 @@ -129,7 +129,7 @@ define i32 @call3(i8* %obj) { %pair = call {i8*, i1} @llvm.type.checked.load(i8* %vtablei8, i32 16, metadata !"typeid") %fptr = extractvalue {i8*, i1} %pair, 0 %fptr_casted = bitcast i8* %fptr to i32 (i8*)* - ; CHECK: [[VTGEP3:%[^ ]*]] = getelementptr i8, i8* [[VT3]], i64 -4 + ; CHECK: [[VTGEP3:%[^ ]*]] = getelementptr i8, i8* [[VT3]], i32 -4 ; CHECK: [[VTBC3:%[^ ]*]] = bitcast i8* [[VTGEP3]] to i32* ; CHECK: [[VTLOAD3:%[^ ]*]] = load i32, i32* [[VTBC3]] %result = call i32 %fptr_casted(i8* %obj) diff --git a/test/Transforms/WholeProgramDevirt/virtual-const-prop-end.ll b/test/Transforms/WholeProgramDevirt/virtual-const-prop-end.ll index 75ec6ba95ef1..14360c78d950 100644 --- a/test/Transforms/WholeProgramDevirt/virtual-const-prop-end.ll +++ b/test/Transforms/WholeProgramDevirt/virtual-const-prop-end.ll @@ -73,7 +73,7 @@ define i1 @call1(i8* %obj) { %fptrptr = getelementptr [3 x i8*], [3 x i8*]* %vtable, i32 0, i32 0 %fptr = load i8*, i8** %fptrptr %fptr_casted = bitcast i8* %fptr to i1 (i8*)* - ; CHECK: [[VTGEP1:%[^ ]*]] = getelementptr i8, i8* [[VT1]], i64 28 + ; CHECK: [[VTGEP1:%[^ ]*]] = getelementptr i8, i8* [[VT1]], i32 28 ; CHECK: [[VTLOAD1:%[^ ]*]] = load i8, i8* [[VTGEP1]] ; CHECK: [[VTAND1:%[^ ]*]] = and i8 [[VTLOAD1]], 2 ; CHECK: [[VTCMP1:%[^ ]*]] = icmp ne i8 [[VTAND1]], 0 @@ -93,7 +93,7 @@ define i1 @call2(i8* %obj) { %fptrptr = getelementptr [3 x i8*], [3 x i8*]* %vtable, i32 0, i32 1 %fptr = load i8*, i8** %fptrptr %fptr_casted = bitcast i8* %fptr to i1 (i8*)* - ; CHECK: [[VTGEP2:%[^ ]*]] = getelementptr i8, i8* [[VT2]], i64 28 + ; CHECK: [[VTGEP2:%[^ ]*]] = getelementptr i8, i8* [[VT2]], i32 28 ; CHECK: [[VTLOAD2:%[^ ]*]] = load i8, i8* [[VTGEP2]] ; CHECK: [[VTAND2:%[^ ]*]] = and i8 [[VTLOAD2]], 1 ; CHECK: [[VTCMP2:%[^ ]*]] = icmp ne i8 [[VTAND2]], 0 @@ -113,7 +113,7 @@ define i32 @call3(i8* %obj) { %fptrptr = getelementptr [3 x i8*], [3 x i8*]* %vtable, i32 0, i32 2 %fptr = load i8*, i8** %fptrptr %fptr_casted = bitcast i8* %fptr to i32 (i8*)* - ; CHECK: [[VTGEP3:%[^ ]*]] = getelementptr i8, i8* [[VT3]], i64 24 + ; CHECK: [[VTGEP3:%[^ ]*]] = getelementptr i8, i8* [[VT3]], i32 24 ; CHECK: [[VTBC3:%[^ ]*]] = bitcast i8* [[VTGEP3]] to i32* ; CHECK: [[VTLOAD3:%[^ ]*]] = load i32, i32* [[VTBC3]] %result = call i32 %fptr_casted(i8* %obj) |