This is an archive of the discontinued LLVM Phabricator instance.

Differential D30016

WholeProgramDevirt: For VCP use a 32-bit ConstantInt for the byte offset.
ClosedPublic

Authored by pcc on Feb 15 2017, 5:53 PM.

Details

Reviewers
tejohnson
mehdi_amini
Commits
rG184773d81feb: WholeProgramDevirt: For VCP use a 32-bit ConstantInt for the byte offset.
rL295487: WholeProgramDevirt: For VCP use a 32-bit ConstantInt for the byte offset.
Summary

A future change will cause this byte offset to be inttoptr'd and then exported
via an absolute symbol. On the importing end we will expect the symbol to be
in range [0,2^32) so that it will fit into a 32-bit relocation. The problem
is that on 64-bit architectures if the offset is negative it will not be in
the correct range once we inttoptr it.

This change causes us to use a 32-bit integer so that it can be inttoptr'd
(which zero extends) into the correct range.

Diff Detail

Event Timeline

pcc created this revision.Feb 15 2017, 5:53 PM
pcc added a child revision: D30017: WholeProgramDevirt: Implement export/import support for VCP..
tejohnson added inline comments.Feb 16 2017, 1:51 PM
llvm/lib/Transforms/IPO/WholeProgramDevirt.cpp
934

What happens if OffsetByte is bigger than 2^32? Is that possible?

pcc added inline comments.Feb 17 2017, 10:52 AM
llvm/lib/Transforms/IPO/WholeProgramDevirt.cpp
934

Not without exceeding limits that are already in place. You would either need a vtable larger than 2^31 bytes (i.e. a vtable containing more than 2^29 (32-bit) or 2^28 (64-bit) virtual functions, which not only far exceeds the recommended minimum limits of the C++ standard, but by itself exceeds the limits of the small memory model) or enough VCP eligible virtual calls to cause the size of the vtable's constant region to extend beyond 2^31 (that would require at least 2^28 such vcalls, and most likely the instructions making up those vcalls would by themselves push the size beyond the small memory model limit).

And of course, neither scenario is very realistic.

tejohnson accepted this revision.Feb 17 2017, 11:15 AM

LGTM

llvm/lib/Transforms/IPO/WholeProgramDevirt.cpp
934

I have seen a couple of apps that exceeded the small memory model, although it seems unlikely that we would have something with a vtable or virtual calls by themselves to hit this limit. Unlikely, but might be nice to have a reasonable failure mode if we need to go to to a larger memory model...

This revision is now accepted and ready to land.Feb 17 2017, 11:15 AM
Closed by commit rL295487: WholeProgramDevirt: For VCP use a 32-bit ConstantInt for the byte offset. (authored by pcc). · Explain WhyFeb 17 2017, 2:32 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents

PathSize
llvm/
lib/
Transforms/
IPO/
2 lines
test/
Transforms/
WholeProgramDevirt/
6 lines
6 lines
6 lines

Diff 88634

llvm/lib/Transforms/IPO/WholeProgramDevirt.cpp

Show First 20 Lines • Show All 925 Lines • ▼ Show 20 Lines else
setAfterReturnValues(TargetsForSlot, AllocAfter, BitWidth, OffsetByte, setAfterReturnValues(TargetsForSlot, AllocAfter, BitWidth, OffsetByte,
OffsetBit); OffsetBit);
if (RemarksEnabled) if (RemarksEnabled)
for (auto &&Target : TargetsForSlot) for (auto &&Target : TargetsForSlot)
Target.WasDevirt = true; Target.WasDevirt = true;
// Rewrite each call to a load from OffsetByte/OffsetBit. // Rewrite each call to a load from OffsetByte/OffsetBit.
Constant *ByteConst = ConstantInt::get(Int64Ty, OffsetByte); Constant *ByteConst = ConstantInt::get(Int32Ty, OffsetByte);
tejohnsonUnsubmitted
Not Done
ReplyInline Actions

What happens if OffsetByte is bigger than 2^32? Is that possible?

tejohnson: What happens if OffsetByte is bigger than 2^32? Is that possible?
pccAuthorUnsubmitted
Not Done
ReplyInline Actions

Not without exceeding limits that are already in place. You would either need a vtable larger than 2^31 bytes (i.e. a vtable containing more than 2^29 (32-bit) or 2^28 (64-bit) virtual functions, which not only far exceeds the recommended minimum limits of the C++ standard, but by itself exceeds the limits of the small memory model) or enough VCP eligible virtual calls to cause the size of the vtable's constant region to extend beyond 2^31 (that would require at least 2^28 such vcalls, and most likely the instructions making up those vcalls would by themselves push the size beyond the small memory model limit).

And of course, neither scenario is very realistic.

pcc: Not without exceeding limits that are already in place. You would either need a vtable larger…
tejohnsonUnsubmitted
Not Done
ReplyInline Actions

I have seen a couple of apps that exceeded the small memory model, although it seems unlikely that we would have something with a vtable or virtual calls by themselves to hit this limit. Unlikely, but might be nice to have a reasonable failure mode if we need to go to to a larger memory model...

tejohnson: I have seen a couple of apps that exceeded the small memory model, although it seems unlikely…
Constant *BitConst = ConstantInt::get(Int8Ty, 1ULL << OffsetBit); Constant *BitConst = ConstantInt::get(Int8Ty, 1ULL << OffsetBit);
applyVirtualConstProp(CSByConstantArg.second, applyVirtualConstProp(CSByConstantArg.second,
TargetsForSlot[0].Fn->getName(), ByteConst, BitConst); TargetsForSlot[0].Fn->getName(), ByteConst, BitConst);
} }
return true; return true;
} }
void DevirtModule::rebuildGlobal(VTableBits &B) { void DevirtModule::rebuildGlobal(VTableBits &B) {
▲ Show 20 Lines • Show All 361 Lines • Show Last 20 Lines

llvm/test/Transforms/WholeProgramDevirt/virtual-const-prop-begin.ll

Show First 20 Lines • Show All 72 Lines • ▼ Show 20 Linesdefine i1 @call1(i8* %obj) {
%vtable = load [3 x i8*]*, [3 x i8*]** %vtableptr %vtable = load [3 x i8*]*, [3 x i8*]** %vtableptr
; CHECK: [[VT1:%[^ ]*]] = bitcast [3 x i8*]* {{.*}} to i8* ; CHECK: [[VT1:%[^ ]*]] = bitcast [3 x i8*]* {{.*}} to i8*
%vtablei8 = bitcast [3 x i8*]* %vtable to i8* %vtablei8 = bitcast [3 x i8*]* %vtable to i8*
%p = call i1 @llvm.type.test(i8* %vtablei8, metadata !"typeid") %p = call i1 @llvm.type.test(i8* %vtablei8, metadata !"typeid")
call void @llvm.assume(i1 %p) call void @llvm.assume(i1 %p)
%fptrptr = getelementptr [3 x i8*], [3 x i8*]* %vtable, i32 0, i32 0 %fptrptr = getelementptr [3 x i8*], [3 x i8*]* %vtable, i32 0, i32 0
%fptr = load i8*, i8** %fptrptr %fptr = load i8*, i8** %fptrptr
%fptr_casted = bitcast i8* %fptr to i1 (i8*)* %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: [[VTLOAD1:%[^ ]*]] = load i8, i8* [[VTGEP1]]
; CHECK: [[VTAND1:%[^ ]*]] = and i8 [[VTLOAD1]], 2 ; CHECK: [[VTAND1:%[^ ]*]] = and i8 [[VTLOAD1]], 2
; CHECK: [[VTCMP1:%[^ ]*]] = icmp ne i8 [[VTAND1]], 0 ; CHECK: [[VTCMP1:%[^ ]*]] = icmp ne i8 [[VTAND1]], 0
%result = call i1 %fptr_casted(i8* %obj) %result = call i1 %fptr_casted(i8* %obj)
; CHECK: ret i1 [[VTCMP1]] ; CHECK: ret i1 [[VTCMP1]]
ret i1 %result ret i1 %result
} }
; CHECK: define i1 @call2( ; CHECK: define i1 @call2(
define i1 @call2(i8* %obj) { define i1 @call2(i8* %obj) {
%vtableptr = bitcast i8* %obj to [3 x i8*]** %vtableptr = bitcast i8* %obj to [3 x i8*]**
%vtable = load [3 x i8*]*, [3 x i8*]** %vtableptr %vtable = load [3 x i8*]*, [3 x i8*]** %vtableptr
; CHECK: [[VT2:%[^ ]*]] = bitcast [3 x i8*]* {{.*}} to i8* ; CHECK: [[VT2:%[^ ]*]] = bitcast [3 x i8*]* {{.*}} to i8*
%vtablei8 = bitcast [3 x i8*]* %vtable to i8* %vtablei8 = bitcast [3 x i8*]* %vtable to i8*
%p = call i1 @llvm.type.test(i8* %vtablei8, metadata !"typeid") %p = call i1 @llvm.type.test(i8* %vtablei8, metadata !"typeid")
call void @llvm.assume(i1 %p) call void @llvm.assume(i1 %p)
%fptrptr = getelementptr [3 x i8*], [3 x i8*]* %vtable, i32 0, i32 1 %fptrptr = getelementptr [3 x i8*], [3 x i8*]* %vtable, i32 0, i32 1
%fptr = load i8*, i8** %fptrptr %fptr = load i8*, i8** %fptrptr
%fptr_casted = bitcast i8* %fptr to i1 (i8*)* %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: [[VTLOAD2:%[^ ]*]] = load i8, i8* [[VTGEP2]]
; CHECK: [[VTAND2:%[^ ]*]] = and i8 [[VTLOAD2]], 1 ; CHECK: [[VTAND2:%[^ ]*]] = and i8 [[VTLOAD2]], 1
; CHECK: [[VTCMP2:%[^ ]*]] = icmp ne i8 [[VTAND2]], 0 ; CHECK: [[VTCMP2:%[^ ]*]] = icmp ne i8 [[VTAND2]], 0
%result = call i1 %fptr_casted(i8* %obj) %result = call i1 %fptr_casted(i8* %obj)
; CHECK: ret i1 [[VTCMP2]] ; CHECK: ret i1 [[VTCMP2]]
ret i1 %result ret i1 %result
} }
; CHECK: define i32 @call3( ; CHECK: define i32 @call3(
define i32 @call3(i8* %obj) { define i32 @call3(i8* %obj) {
%vtableptr = bitcast i8* %obj to [3 x i8*]** %vtableptr = bitcast i8* %obj to [3 x i8*]**
%vtable = load [3 x i8*]*, [3 x i8*]** %vtableptr %vtable = load [3 x i8*]*, [3 x i8*]** %vtableptr
; CHECK: [[VT3:%[^ ]*]] = bitcast [3 x i8*]* {{.*}} to i8* ; CHECK: [[VT3:%[^ ]*]] = bitcast [3 x i8*]* {{.*}} to i8*
%vtablei8 = bitcast [3 x i8*]* %vtable to i8* %vtablei8 = bitcast [3 x i8*]* %vtable to i8*
%p = call i1 @llvm.type.test(i8* %vtablei8, metadata !"typeid") %p = call i1 @llvm.type.test(i8* %vtablei8, metadata !"typeid")
call void @llvm.assume(i1 %p) call void @llvm.assume(i1 %p)
%fptrptr = getelementptr [3 x i8*], [3 x i8*]* %vtable, i32 0, i32 2 %fptrptr = getelementptr [3 x i8*], [3 x i8*]* %vtable, i32 0, i32 2
%fptr = load i8*, i8** %fptrptr %fptr = load i8*, i8** %fptrptr
%fptr_casted = bitcast i8* %fptr to i32 (i8*)* %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: [[VTBC3:%[^ ]*]] = bitcast i8* [[VTGEP3]] to i32*
; CHECK: [[VTLOAD3:%[^ ]*]] = load i32, i32* [[VTBC3]] ; CHECK: [[VTLOAD3:%[^ ]*]] = load i32, i32* [[VTBC3]]
%result = call i32 %fptr_casted(i8* %obj) %result = call i32 %fptr_casted(i8* %obj)
; CHECK: ret i32 [[VTLOAD3]] ; CHECK: ret i32 [[VTLOAD3]]
ret i32 %result ret i32 %result
} }
declare i1 @llvm.type.test(i8*, metadata) declare i1 @llvm.type.test(i8*, metadata)
declare void @llvm.assume(i1) declare void @llvm.assume(i1)
declare void @__cxa_pure_virtual() declare void @__cxa_pure_virtual()
; CHECK: [[T8]] = !{i32 8, !"typeid"} ; CHECK: [[T8]] = !{i32 8, !"typeid"}
; CHECK: [[T0]] = !{i32 0, !"typeid"} ; CHECK: [[T0]] = !{i32 0, !"typeid"}
!0 = !{i32 0, !"typeid"} !0 = !{i32 0, !"typeid"}

llvm/test/Transforms/WholeProgramDevirt/virtual-const-prop-check.ll

Show First 20 Lines • Show All 81 Lines • ▼ Show 20 Lines
define i1 @call1(i8* %obj) { define i1 @call1(i8* %obj) {
%vtableptr = bitcast i8* %obj to [3 x i8*]** %vtableptr = bitcast i8* %obj to [3 x i8*]**
%vtable = load [3 x i8*]*, [3 x i8*]** %vtableptr %vtable = load [3 x i8*]*, [3 x i8*]** %vtableptr
; CHECK: [[VT1:%[^ ]*]] = bitcast [3 x i8*]* {{.*}} to i8* ; CHECK: [[VT1:%[^ ]*]] = bitcast [3 x i8*]* {{.*}} to i8*
%vtablei8 = bitcast [3 x i8*]* %vtable to i8* %vtablei8 = bitcast [3 x i8*]* %vtable to i8*
%pair = call {i8*, i1} @llvm.type.checked.load(i8* %vtablei8, i32 0, metadata !"typeid") %pair = call {i8*, i1} @llvm.type.checked.load(i8* %vtablei8, i32 0, metadata !"typeid")
%fptr = extractvalue {i8*, i1} %pair, 0 %fptr = extractvalue {i8*, i1} %pair, 0
%fptr_casted = bitcast i8* %fptr to i1 (i8*)* %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: [[VTLOAD1:%[^ ]*]] = load i8, i8* [[VTGEP1]]
; CHECK: [[VTAND1:%[^ ]*]] = and i8 [[VTLOAD1]], 2 ; CHECK: [[VTAND1:%[^ ]*]] = and i8 [[VTLOAD1]], 2
; CHECK: [[VTCMP1:%[^ ]*]] = icmp ne i8 [[VTAND1]], 0 ; CHECK: [[VTCMP1:%[^ ]*]] = icmp ne i8 [[VTAND1]], 0
%result = call i1 %fptr_casted(i8* %obj) %result = call i1 %fptr_casted(i8* %obj)
; CHECK: [[AND1:%[^ ]*]] = and i1 [[VTCMP1]], true ; CHECK: [[AND1:%[^ ]*]] = and i1 [[VTCMP1]], true
%p = extractvalue {i8*, i1} %pair, 1 %p = extractvalue {i8*, i1} %pair, 1
%and = and i1 %result, %p %and = and i1 %result, %p
; CHECK: ret i1 [[AND1]] ; CHECK: ret i1 [[AND1]]
ret i1 %and ret i1 %and
} }
; CHECK: define i1 @call2( ; CHECK: define i1 @call2(
define i1 @call2(i8* %obj) { define i1 @call2(i8* %obj) {
%vtableptr = bitcast i8* %obj to [3 x i8*]** %vtableptr = bitcast i8* %obj to [3 x i8*]**
%vtable = load [3 x i8*]*, [3 x i8*]** %vtableptr %vtable = load [3 x i8*]*, [3 x i8*]** %vtableptr
; CHECK: [[VT2:%[^ ]*]] = bitcast [3 x i8*]* {{.*}} to i8* ; CHECK: [[VT2:%[^ ]*]] = bitcast [3 x i8*]* {{.*}} to i8*
%vtablei8 = bitcast [3 x i8*]* %vtable to i8* %vtablei8 = bitcast [3 x i8*]* %vtable to i8*
%pair = call {i8*, i1} @llvm.type.checked.load(i8* %vtablei8, i32 8, metadata !"typeid") %pair = call {i8*, i1} @llvm.type.checked.load(i8* %vtablei8, i32 8, metadata !"typeid")
%fptr = extractvalue {i8*, i1} %pair, 0 %fptr = extractvalue {i8*, i1} %pair, 0
%fptr_casted = bitcast i8* %fptr to i1 (i8*)* %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: [[VTLOAD2:%[^ ]*]] = load i8, i8* [[VTGEP2]]
; CHECK: [[VTAND2:%[^ ]*]] = and i8 [[VTLOAD2]], 1 ; CHECK: [[VTAND2:%[^ ]*]] = and i8 [[VTLOAD2]], 1
; CHECK: [[VTCMP2:%[^ ]*]] = icmp ne i8 [[VTAND2]], 0 ; CHECK: [[VTCMP2:%[^ ]*]] = icmp ne i8 [[VTAND2]], 0
%result = call i1 %fptr_casted(i8* %obj) %result = call i1 %fptr_casted(i8* %obj)
; CHECK: [[AND2:%[^ ]*]] = and i1 [[VTCMP2]], true ; CHECK: [[AND2:%[^ ]*]] = and i1 [[VTCMP2]], true
%p = extractvalue {i8*, i1} %pair, 1 %p = extractvalue {i8*, i1} %pair, 1
%and = and i1 %result, %p %and = and i1 %result, %p
; CHECK: ret i1 [[AND2]] ; CHECK: ret i1 [[AND2]]
ret i1 %and ret i1 %and
} }
; CHECK: define i32 @call3( ; CHECK: define i32 @call3(
define i32 @call3(i8* %obj) { define i32 @call3(i8* %obj) {
%vtableptr = bitcast i8* %obj to [3 x i8*]** %vtableptr = bitcast i8* %obj to [3 x i8*]**
%vtable = load [3 x i8*]*, [3 x i8*]** %vtableptr %vtable = load [3 x i8*]*, [3 x i8*]** %vtableptr
; CHECK: [[VT3:%[^ ]*]] = bitcast [3 x i8*]* {{.*}} to i8* ; CHECK: [[VT3:%[^ ]*]] = bitcast [3 x i8*]* {{.*}} to i8*
%vtablei8 = bitcast [3 x i8*]* %vtable to i8* %vtablei8 = bitcast [3 x i8*]* %vtable to i8*
%pair = call {i8*, i1} @llvm.type.checked.load(i8* %vtablei8, i32 16, metadata !"typeid") %pair = call {i8*, i1} @llvm.type.checked.load(i8* %vtablei8, i32 16, metadata !"typeid")
%fptr = extractvalue {i8*, i1} %pair, 0 %fptr = extractvalue {i8*, i1} %pair, 0
%fptr_casted = bitcast i8* %fptr to i32 (i8*)* %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: [[VTBC3:%[^ ]*]] = bitcast i8* [[VTGEP3]] to i32*
; CHECK: [[VTLOAD3:%[^ ]*]] = load i32, i32* [[VTBC3]] ; CHECK: [[VTLOAD3:%[^ ]*]] = load i32, i32* [[VTBC3]]
%result = call i32 %fptr_casted(i8* %obj) %result = call i32 %fptr_casted(i8* %obj)
; CHECK: ret i32 [[VTLOAD3]] ; CHECK: ret i32 [[VTLOAD3]]
ret i32 %result ret i32 %result
} }
declare {i8*, i1} @llvm.type.checked.load(i8*, i32, metadata) declare {i8*, i1} @llvm.type.checked.load(i8*, i32, metadata)
declare void @llvm.assume(i1) declare void @llvm.assume(i1)
declare void @__cxa_pure_virtual() declare void @__cxa_pure_virtual()
; CHECK: [[T8]] = !{i32 8, !"typeid"} ; CHECK: [[T8]] = !{i32 8, !"typeid"}
; CHECK: [[T0]] = !{i32 0, !"typeid"} ; CHECK: [[T0]] = !{i32 0, !"typeid"}
!0 = !{i32 0, !"typeid"} !0 = !{i32 0, !"typeid"}

llvm/test/Transforms/WholeProgramDevirt/virtual-const-prop-end.ll

Show First 20 Lines • Show All 67 Lines • ▼ Show 20 Linesdefine i1 @call1(i8* %obj) {
%vtable = load [3 x i8*]*, [3 x i8*]** %vtableptr %vtable = load [3 x i8*]*, [3 x i8*]** %vtableptr
; CHECK: [[VT1:%[^ ]*]] = bitcast [3 x i8*]* {{.*}} to i8* ; CHECK: [[VT1:%[^ ]*]] = bitcast [3 x i8*]* {{.*}} to i8*
%vtablei8 = bitcast [3 x i8*]* %vtable to i8* %vtablei8 = bitcast [3 x i8*]* %vtable to i8*
%p = call i1 @llvm.type.test(i8* %vtablei8, metadata !"typeid") %p = call i1 @llvm.type.test(i8* %vtablei8, metadata !"typeid")
call void @llvm.assume(i1 %p) call void @llvm.assume(i1 %p)
%fptrptr = getelementptr [3 x i8*], [3 x i8*]* %vtable, i32 0, i32 0 %fptrptr = getelementptr [3 x i8*], [3 x i8*]* %vtable, i32 0, i32 0
%fptr = load i8*, i8** %fptrptr %fptr = load i8*, i8** %fptrptr
%fptr_casted = bitcast i8* %fptr to i1 (i8*)* %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: [[VTLOAD1:%[^ ]*]] = load i8, i8* [[VTGEP1]]
; CHECK: [[VTAND1:%[^ ]*]] = and i8 [[VTLOAD1]], 2 ; CHECK: [[VTAND1:%[^ ]*]] = and i8 [[VTLOAD1]], 2
; CHECK: [[VTCMP1:%[^ ]*]] = icmp ne i8 [[VTAND1]], 0 ; CHECK: [[VTCMP1:%[^ ]*]] = icmp ne i8 [[VTAND1]], 0
%result = call i1 %fptr_casted(i8* %obj) %result = call i1 %fptr_casted(i8* %obj)
; CHECK: ret i1 [[VTCMP1]] ; CHECK: ret i1 [[VTCMP1]]
ret i1 %result ret i1 %result
} }
; CHECK: define i1 @call2( ; CHECK: define i1 @call2(
define i1 @call2(i8* %obj) { define i1 @call2(i8* %obj) {
%vtableptr = bitcast i8* %obj to [3 x i8*]** %vtableptr = bitcast i8* %obj to [3 x i8*]**
%vtable = load [3 x i8*]*, [3 x i8*]** %vtableptr %vtable = load [3 x i8*]*, [3 x i8*]** %vtableptr
; CHECK: [[VT2:%[^ ]*]] = bitcast [3 x i8*]* {{.*}} to i8* ; CHECK: [[VT2:%[^ ]*]] = bitcast [3 x i8*]* {{.*}} to i8*
%vtablei8 = bitcast [3 x i8*]* %vtable to i8* %vtablei8 = bitcast [3 x i8*]* %vtable to i8*
%p = call i1 @llvm.type.test(i8* %vtablei8, metadata !"typeid") %p = call i1 @llvm.type.test(i8* %vtablei8, metadata !"typeid")
call void @llvm.assume(i1 %p) call void @llvm.assume(i1 %p)
%fptrptr = getelementptr [3 x i8*], [3 x i8*]* %vtable, i32 0, i32 1 %fptrptr = getelementptr [3 x i8*], [3 x i8*]* %vtable, i32 0, i32 1
%fptr = load i8*, i8** %fptrptr %fptr = load i8*, i8** %fptrptr
%fptr_casted = bitcast i8* %fptr to i1 (i8*)* %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: [[VTLOAD2:%[^ ]*]] = load i8, i8* [[VTGEP2]]
; CHECK: [[VTAND2:%[^ ]*]] = and i8 [[VTLOAD2]], 1 ; CHECK: [[VTAND2:%[^ ]*]] = and i8 [[VTLOAD2]], 1
; CHECK: [[VTCMP2:%[^ ]*]] = icmp ne i8 [[VTAND2]], 0 ; CHECK: [[VTCMP2:%[^ ]*]] = icmp ne i8 [[VTAND2]], 0
%result = call i1 %fptr_casted(i8* %obj) %result = call i1 %fptr_casted(i8* %obj)
; CHECK: ret i1 [[VTCMP2]] ; CHECK: ret i1 [[VTCMP2]]
ret i1 %result ret i1 %result
} }
; CHECK: define i32 @call3( ; CHECK: define i32 @call3(
define i32 @call3(i8* %obj) { define i32 @call3(i8* %obj) {
%vtableptr = bitcast i8* %obj to [3 x i8*]** %vtableptr = bitcast i8* %obj to [3 x i8*]**
%vtable = load [3 x i8*]*, [3 x i8*]** %vtableptr %vtable = load [3 x i8*]*, [3 x i8*]** %vtableptr
; CHECK: [[VT3:%[^ ]*]] = bitcast [3 x i8*]* {{.*}} to i8* ; CHECK: [[VT3:%[^ ]*]] = bitcast [3 x i8*]* {{.*}} to i8*
%vtablei8 = bitcast [3 x i8*]* %vtable to i8* %vtablei8 = bitcast [3 x i8*]* %vtable to i8*
%p = call i1 @llvm.type.test(i8* %vtablei8, metadata !"typeid") %p = call i1 @llvm.type.test(i8* %vtablei8, metadata !"typeid")
call void @llvm.assume(i1 %p) call void @llvm.assume(i1 %p)
%fptrptr = getelementptr [3 x i8*], [3 x i8*]* %vtable, i32 0, i32 2 %fptrptr = getelementptr [3 x i8*], [3 x i8*]* %vtable, i32 0, i32 2
%fptr = load i8*, i8** %fptrptr %fptr = load i8*, i8** %fptrptr
%fptr_casted = bitcast i8* %fptr to i32 (i8*)* %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: [[VTBC3:%[^ ]*]] = bitcast i8* [[VTGEP3]] to i32*
; CHECK: [[VTLOAD3:%[^ ]*]] = load i32, i32* [[VTBC3]] ; CHECK: [[VTLOAD3:%[^ ]*]] = load i32, i32* [[VTBC3]]
%result = call i32 %fptr_casted(i8* %obj) %result = call i32 %fptr_casted(i8* %obj)
; CHECK: ret i32 [[VTLOAD3]] ; CHECK: ret i32 [[VTLOAD3]]
ret i32 %result ret i32 %result
} }
declare i1 @llvm.type.test(i8*, metadata) declare i1 @llvm.type.test(i8*, metadata)
declare void @llvm.assume(i1) declare void @llvm.assume(i1)
; CHECK: [[T8]] = !{i32 8, !"typeid"} ; CHECK: [[T8]] = !{i32 8, !"typeid"}
; CHECK: [[T0]] = !{i32 0, !"typeid"} ; CHECK: [[T0]] = !{i32 0, !"typeid"}
!0 = !{i32 0, !"typeid"} !0 = !{i32 0, !"typeid"}
!1 = !{i32 8, !"typeid"} !1 = !{i32 8, !"typeid"}