This is an archive of the discontinued LLVM Phabricator instance.

Differential D18466

WholeProgramDevirt: Recognize the llvm.load.relative intrinsic.
Needs ReviewPublic

Authored by pcc on Mar 24 2016, 4:49 PM.

Details

Reviewers
pete
mehdi_amini
Summary

Depends on http://reviews.llvm.org/D18367

Diff Detail

Event Timeline

pcc updated this revision to Diff 51618.Mar 24 2016, 4:49 PM
pcc retitled this revision from to WholeProgramDevirt: Recognize the llvm.load.relative intrinsic..
pcc updated this object.
pcc added reviewers: mehdi_amini, pete.
pcc added a subscriber: llvm-commits.

Revision Contents

PathSize
lib/
Transforms/
IPO/
116 lines
test/
Transforms/
WholeProgramDevirt/
64 lines
49 lines
33 lines
33 lines
33 lines

Diff 51618

lib/Transforms/IPO/WholeProgramDevirt.cpp

Show All 25 Lines
// call with a comparison of the vptr against that vtable's address. // call with a comparison of the vptr against that vtable's address.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "llvm/Transforms/IPO/WholeProgramDevirt.h" #include "llvm/Transforms/IPO/WholeProgramDevirt.h"
#include "llvm/Transforms/IPO.h" #include "llvm/Transforms/IPO.h"
#include "llvm/ADT/DenseSet.h" #include "llvm/ADT/DenseSet.h"
#include "llvm/ADT/MapVector.h" #include "llvm/ADT/MapVector.h"
#include "llvm/Analysis/ConstantFolding.h"
#include "llvm/IR/CallSite.h" #include "llvm/IR/CallSite.h"
#include "llvm/IR/Constants.h" #include "llvm/IR/Constants.h"
#include "llvm/IR/DataLayout.h" #include "llvm/IR/DataLayout.h"
#include "llvm/IR/IRBuilder.h" #include "llvm/IR/IRBuilder.h"
#include "llvm/IR/Instructions.h" #include "llvm/IR/Instructions.h"
#include "llvm/IR/IntrinsicInst.h"
#include "llvm/IR/Intrinsics.h" #include "llvm/IR/Intrinsics.h"
#include "llvm/IR/Module.h" #include "llvm/IR/Module.h"
#include "llvm/Pass.h" #include "llvm/Pass.h"
#include "llvm/Support/raw_ostream.h" #include "llvm/Support/raw_ostream.h"
#include "llvm/Transforms/Utils/Evaluator.h" #include "llvm/Transforms/Utils/Evaluator.h"
#include "llvm/Transforms/Utils/Local.h" #include "llvm/Transforms/Utils/Local.h"
#include <set> #include <set>
▲ Show 20 Lines • Show All 121 Lines • ▼ Show 20 Lines
namespace { namespace {
// A slot in a set of virtual tables. The BitSetID identifies the set of virtual // A slot in a set of virtual tables. The BitSetID identifies the set of virtual
// tables, and the ByteOffset is the offset in bytes from the address point to // tables, and the ByteOffset is the offset in bytes from the address point to
// the virtual function pointer. // the virtual function pointer.
struct VTableSlot { struct VTableSlot {
Metadata *BitSetID; Metadata *BitSetID;
uint64_t ByteOffset; uint64_t ByteOffset;
bool IsRelative;
}; };
} }
namespace llvm { namespace llvm {
template <> struct DenseMapInfo<VTableSlot> { template <> struct DenseMapInfo<VTableSlot> {
static VTableSlot getEmptyKey() { static VTableSlot getEmptyKey() {
return {DenseMapInfo<Metadata *>::getEmptyKey(), return {DenseMapInfo<Metadata *>::getEmptyKey(),
DenseMapInfo<uint64_t>::getEmptyKey()}; DenseMapInfo<uint64_t>::getEmptyKey(),
false};
} }
static VTableSlot getTombstoneKey() { static VTableSlot getTombstoneKey() {
return {DenseMapInfo<Metadata *>::getTombstoneKey(), return {DenseMapInfo<Metadata *>::getTombstoneKey(),
DenseMapInfo<uint64_t>::getTombstoneKey()}; DenseMapInfo<uint64_t>::getTombstoneKey(),
true};
} }
static unsigned getHashValue(const VTableSlot &I) { static unsigned getHashValue(const VTableSlot &I) {
return DenseMapInfo<Metadata *>::getHashValue(I.BitSetID) ^ return DenseMapInfo<Metadata *>::getHashValue(I.BitSetID) ^
DenseMapInfo<uint64_t>::getHashValue(I.ByteOffset); DenseMapInfo<uint64_t>::getHashValue(I.ByteOffset) + I.IsRelative;
} }
static bool isEqual(const VTableSlot &LHS, static bool isEqual(const VTableSlot &LHS,
const VTableSlot &RHS) { const VTableSlot &RHS) {
return LHS.BitSetID == RHS.BitSetID && LHS.ByteOffset == RHS.ByteOffset; return LHS.BitSetID == RHS.BitSetID && LHS.ByteOffset == RHS.ByteOffset &&
LHS.IsRelative == RHS.IsRelative;
} }
}; };
} }
namespace { namespace {
// A virtual call site. VTable is the loaded virtual table pointer, and CS is // A virtual call site. VTable is the loaded virtual table pointer, and CS is
Show All 22 Linesstruct DevirtModule {
DevirtModule(Module &M) DevirtModule(Module &M)
: M(M), Int8Ty(Type::getInt8Ty(M.getContext())), : M(M), Int8Ty(Type::getInt8Ty(M.getContext())),
Int8PtrTy(Type::getInt8PtrTy(M.getContext())), Int8PtrTy(Type::getInt8PtrTy(M.getContext())),
Int32Ty(Type::getInt32Ty(M.getContext())) {} Int32Ty(Type::getInt32Ty(M.getContext())) {}
void findLoadCallsAtConstantOffset(Metadata *BitSet, Value *Ptr, void findLoadCallsAtConstantOffset(Metadata *BitSet, Value *Ptr,
uint64_t Offset, Value *VTable); uint64_t Offset, Value *VTable);
void findCallsAtConstantOffset(Metadata *BitSet, Value *Ptr, uint64_t Offset, void findCallsAtConstantOffset(Metadata *BitSet, Value *Ptr, uint64_t Offset,
Value *VTable); bool IsRelative, Value *VTable);
void buildBitSets(std::vector<VTableBits> &Bits, void buildBitSets(std::vector<VTableBits> &Bits,
DenseMap<Metadata *, std::set<BitSetInfo>> &BitSets); DenseMap<Metadata *, std::set<BitSetInfo>> &BitSets);
bool tryFindVirtualCallTargets(std::vector<VirtualCallTarget> &TargetsForSlot, bool tryFindVirtualCallTargets(std::vector<VirtualCallTarget> &TargetsForSlot,
const std::set<BitSetInfo> &BitSetInfos, const std::set<BitSetInfo> &BitSetInfos,
uint64_t ByteOffset); uint64_t ByteOffset, bool IsRelative);
bool trySingleImplDevirt(ArrayRef<VirtualCallTarget> TargetsForSlot, bool trySingleImplDevirt(ArrayRef<VirtualCallTarget> TargetsForSlot,
MutableArrayRef<VirtualCallSite> CallSites); MutableArrayRef<VirtualCallSite> CallSites);
bool tryEvaluateFunctionsWithArgs( bool tryEvaluateFunctionsWithArgs(
MutableArrayRef<VirtualCallTarget> TargetsForSlot, MutableArrayRef<VirtualCallTarget> TargetsForSlot,
ArrayRef<ConstantInt *> Args); ArrayRef<ConstantInt *> Args);
bool tryUniformRetValOpt(IntegerType *RetType, bool tryUniformRetValOpt(IntegerType *RetType,
ArrayRef<VirtualCallTarget> TargetsForSlot, ArrayRef<VirtualCallTarget> TargetsForSlot,
MutableArrayRef<VirtualCallSite> CallSites); MutableArrayRef<VirtualCallSite> CallSites);
Show All 23 Lines
char WholeProgramDevirt::ID = 0; char WholeProgramDevirt::ID = 0;
ModulePass *llvm::createWholeProgramDevirtPass() { ModulePass *llvm::createWholeProgramDevirtPass() {
return new WholeProgramDevirt; return new WholeProgramDevirt;
} }
// Search for virtual calls that call FPtr and add them to CallSlots. // Search for virtual calls that call FPtr and add them to CallSlots.
void DevirtModule::findCallsAtConstantOffset(Metadata *BitSet, Value *FPtr, void DevirtModule::findCallsAtConstantOffset(Metadata *BitSet, Value *FPtr,
uint64_t Offset, Value *VTable) { uint64_t Offset, bool IsRelative,
Value *VTable) {
for (const Use &U : FPtr->uses()) { for (const Use &U : FPtr->uses()) {
Value *User = U.getUser(); Value *User = U.getUser();
if (isa<BitCastInst>(User)) { if (isa<BitCastInst>(User)) {
findCallsAtConstantOffset(BitSet, User, Offset, VTable); findCallsAtConstantOffset(BitSet, User, Offset, IsRelative, VTable);
} else if (auto CI = dyn_cast<CallInst>(User)) { } else if (auto CI = dyn_cast<CallInst>(User)) {
CallSlots[{BitSet, Offset}].push_back({VTable, CI}); CallSlots[{BitSet, Offset, IsRelative}].push_back({VTable, CI});
} else if (auto II = dyn_cast<InvokeInst>(User)) { } else if (auto II = dyn_cast<InvokeInst>(User)) {
CallSlots[{BitSet, Offset}].push_back({VTable, II}); CallSlots[{BitSet, Offset, IsRelative}].push_back({VTable, II});
} }
} }
} }
// Search for virtual calls that load from VPtr and add them to CallSlots. // Search for virtual calls that load from VPtr and add them to CallSlots.
void DevirtModule::findLoadCallsAtConstantOffset(Metadata *BitSet, Value *VPtr, void DevirtModule::findLoadCallsAtConstantOffset(Metadata *BitSet, Value *VPtr,
uint64_t Offset, uint64_t Offset,
Value *VTable) { Value *VTable) {
for (const Use &U : VPtr->uses()) { for (const Use &U : VPtr->uses()) {
Value *User = U.getUser(); Value *User = U.getUser();
if (isa<BitCastInst>(User)) { if (isa<BitCastInst>(User)) {
findLoadCallsAtConstantOffset(BitSet, User, Offset, VTable); findLoadCallsAtConstantOffset(BitSet, User, Offset, VTable);
} else if (isa<LoadInst>(User)) { } else if (isa<LoadInst>(User)) {
findCallsAtConstantOffset(BitSet, User, Offset, VTable); findCallsAtConstantOffset(BitSet, User, Offset, false, VTable);
} else if (auto II = dyn_cast<IntrinsicInst>(User)) {
if (II->getIntrinsicID() == Intrinsic::load_relative &&
isa<ConstantInt>(II->getArgOperand(1))) {
uint64_t LoadOffset =
cast<ConstantInt>(II->getArgOperand(1))->getZExtValue();
findCallsAtConstantOffset(BitSet, User, Offset + LoadOffset, true,
VTable);
}
} else if (auto GEP = dyn_cast<GetElementPtrInst>(User)) { } else if (auto GEP = dyn_cast<GetElementPtrInst>(User)) {
// Take into account the GEP offset. // Take into account the GEP offset.
if (VPtr == GEP->getPointerOperand() && GEP->hasAllConstantIndices()) { if (VPtr == GEP->getPointerOperand() && GEP->hasAllConstantIndices()) {
SmallVector<Value *, 8> Indices(GEP->op_begin() + 1, GEP->op_end()); SmallVector<Value *, 8> Indices(GEP->op_begin() + 1, GEP->op_end());
uint64_t GEPOffset = M.getDataLayout().getIndexedOffsetInType( uint64_t GEPOffset = M.getDataLayout().getIndexedOffsetInType(
GEP->getSourceElementType(), Indices); GEP->getSourceElementType(), Indices);
findLoadCallsAtConstantOffset(BitSet, User, Offset + GEPOffset, VTable); findLoadCallsAtConstantOffset(BitSet, User, Offset + GEPOffset, VTable);
} }
Show All 35 Lines if (!BitsPtr) {
Bits.back().ObjectSize = M.getDataLayout().getTypeAllocSize( Bits.back().ObjectSize = M.getDataLayout().getTypeAllocSize(
OpGlobal->getInitializer()->getType()); OpGlobal->getInitializer()->getType());
BitsPtr = &Bits.back(); BitsPtr = &Bits.back();
} }
BitSets[BitSetID].insert({BitsPtr, Offset}); BitSets[BitSetID].insert({BitsPtr, Offset});
} }
} }
namespace {
Constant *getElementAtOffset(Constant *Init, uint64_t Offset, const DataLayout &DL) {
if (auto *CA = dyn_cast<ConstantArray>(Init)) {
ArrayType *InitTy = CA->getType();
uint64_t ElemSize = DL.getTypeAllocSize(InitTy->getElementType());
if (Offset % ElemSize != 0)
return nullptr;
unsigned Op = Offset / ElemSize;
if (Op >= Init->getNumOperands())
return nullptr;
return CA->getOperand(Op);
} else if (auto *CS = dyn_cast<ConstantStruct>(Init)) {
StructType *InitTy = CS->getType();
const StructLayout *SL = DL.getStructLayout(InitTy);
unsigned Elem = SL->getElementContainingOffset(Offset);
if (SL->getElementOffset(Elem) != Offset)
return nullptr;
return CS->getOperand(Elem);
} else {
return nullptr;
}
}
}
bool DevirtModule::tryFindVirtualCallTargets( bool DevirtModule::tryFindVirtualCallTargets(
std::vector<VirtualCallTarget> &TargetsForSlot, std::vector<VirtualCallTarget> &TargetsForSlot,
const std::set<BitSetInfo> &BitSetInfos, uint64_t ByteOffset) { const std::set<BitSetInfo> &BitSetInfos, uint64_t ByteOffset,
bool IsRelative) {
for (const BitSetInfo &BS : BitSetInfos) { for (const BitSetInfo &BS : BitSetInfos) {
if (!BS.Bits->GV->isConstant()) if (!BS.Bits->GV->isConstant())
return false; return false;
auto Init = dyn_cast<ConstantArray>(BS.Bits->GV->getInitializer()); Constant *Elem =
if (!Init) getElementAtOffset(BS.Bits->GV->getInitializer(),
BS.Offset + ByteOffset, M.getDataLayout());
if (!Elem)
return false; return false;
ArrayType *VTableTy = Init->getType();
uint64_t ElemSize = if (IsRelative) {
M.getDataLayout().getTypeAllocSize(VTableTy->getElementType()); auto *CE = dyn_cast<ConstantExpr>(Elem);
uint64_t GlobalSlotOffset = BS.Offset + ByteOffset; if (!CE)
if (GlobalSlotOffset % ElemSize != 0)
return false; return false;
if (CE->getOpcode() == Instruction::Trunc) {
CE = dyn_cast<ConstantExpr>(CE->getOperand(0));
if (!CE)
return false;
}
unsigned Op = GlobalSlotOffset / ElemSize; if (CE->getOpcode() != Instruction::Sub)
if (Op >= Init->getNumOperands())
return false; return false;
auto Fn = dyn_cast<Function>(Init->getOperand(Op)->stripPointerCasts()); auto *RHS = dyn_cast<ConstantExpr>(CE->getOperand(1));
GlobalValue *RHSGV;
APInt RHSOffset;
if (!RHS || RHS->getOpcode() != Instruction::PtrToInt ||
!IsConstantOffsetFromGlobal(RHS->getOperand(0), RHSGV, RHSOffset,
M.getDataLayout()) ||
RHSGV != BS.Bits->GV || RHSOffset != BS.Offset)
return false;
CE = dyn_cast<ConstantExpr>(CE->getOperand(0));
if (!CE || CE->getOpcode() != Instruction::PtrToInt)
return false;
Elem = CE->getOperand(0);
}
auto *Fn = dyn_cast<Function>(Elem->stripPointerCasts());
if (!Fn) if (!Fn)
return false; return false;
// We can disregard __cxa_pure_virtual as a possible call target, as // We can disregard __cxa_pure_virtual as a possible call target, as
// calls to pure virtuals are UB. // calls to pure virtuals are UB.
if (Fn->getName() == "__cxa_pure_virtual") if (Fn->getName() == "__cxa_pure_virtual")
continue; continue;
▲ Show 20 Lines • Show All 317 Lines • ▼ Show 20 Linesbool DevirtModule::run() {
// For each (bitset, offset) pair: // For each (bitset, offset) pair:
bool DidVirtualConstProp = false; bool DidVirtualConstProp = false;
for (auto &S : CallSlots) { for (auto &S : CallSlots) {
// Search each of the vtables in the bitset for the virtual function // Search each of the vtables in the bitset for the virtual function
// implementation at offset S.first.ByteOffset, and add to TargetsForSlot. // implementation at offset S.first.ByteOffset, and add to TargetsForSlot.
std::vector<VirtualCallTarget> TargetsForSlot; std::vector<VirtualCallTarget> TargetsForSlot;
if (!tryFindVirtualCallTargets(TargetsForSlot, BitSets[S.first.BitSetID], if (!tryFindVirtualCallTargets(TargetsForSlot, BitSets[S.first.BitSetID],
S.first.ByteOffset)) S.first.ByteOffset, S.first.IsRelative))
continue; continue;
if (trySingleImplDevirt(TargetsForSlot, S.second)) if (trySingleImplDevirt(TargetsForSlot, S.second))
continue; continue;
DidVirtualConstProp |= tryVirtualConstProp(TargetsForSlot, S.second); DidVirtualConstProp |= tryVirtualConstProp(TargetsForSlot, S.second);
} }
// Rebuild each global we touched as part of virtual constant propagation to // Rebuild each global we touched as part of virtual constant propagation to
// include the before and after bytes. // include the before and after bytes.
if (DidVirtualConstProp) if (DidVirtualConstProp)
for (VTableBits &B : Bits) for (VTableBits &B : Bits)
rebuildGlobal(B); rebuildGlobal(B);
return true; return true;
} }

test/Transforms/WholeProgramDevirt/bad-read-from-vtable-struct.ll

  • This file was added.
; RUN: opt -S -wholeprogramdevirt %s | FileCheck %s
target datalayout = "e-p:64:64"
target triple = "x86_64-unknown-linux-gnu"
@vt = global { i8*, i8* } { i8* zeroinitializer, i8* bitcast (void (i8*)* @vf to i8*) }
define void @vf(i8* %this) {
ret void
}
; CHECK: define void @unaligned
define void @unaligned(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.bitset.test(i8* %vtablei8, metadata !"bitset")
call void @llvm.assume(i1 %p)
%fptrptr = getelementptr i8, i8* %vtablei8, i32 1
%fptrptr_casted = bitcast i8* %fptrptr to i8**
%fptr = load i8*, i8** %fptrptr_casted
%fptr_casted = bitcast i8* %fptr to void (i8*)*
; CHECK: call void %
call void %fptr_casted(i8* %obj)
ret void
}
; CHECK: define void @outofbounds
define void @outofbounds(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.bitset.test(i8* %vtablei8, metadata !"bitset")
call void @llvm.assume(i1 %p)
%fptrptr = getelementptr i8, i8* %vtablei8, i32 16
%fptrptr_casted = bitcast i8* %fptrptr to i8**
%fptr = load i8*, i8** %fptrptr_casted
%fptr_casted = bitcast i8* %fptr to void (i8*)*
; CHECK: call void %
call void %fptr_casted(i8* %obj)
ret void
}
; CHECK: define void @nonfunction
define void @nonfunction(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.bitset.test(i8* %vtablei8, metadata !"bitset")
call void @llvm.assume(i1 %p)
%fptrptr = getelementptr i8, i8* %vtablei8, i32 0
%fptrptr_casted = bitcast i8* %fptrptr to i8**
%fptr = load i8*, i8** %fptrptr_casted
%fptr_casted = bitcast i8* %fptr to void (i8*)*
; CHECK: call void %
call void %fptr_casted(i8* %obj)
ret void
}
declare i1 @llvm.bitset.test(i8*, metadata)
declare void @llvm.assume(i1)
!0 = !{!"bitset", { i8*, i8* }* @vt, i32 0}
!llvm.bitsets = !{!0}

test/Transforms/WholeProgramDevirt/bad-relative-vtable.ll

  • This file was added.
; RUN: opt -S -wholeprogramdevirt %s | FileCheck %s
target datalayout = "e-p:64:64"
target triple = "x86_64-unknown-linux-gnu"
@g = external constant i32
@vt1 = constant { i32, i32, i32 } { i32 0,
i32 trunc (i64 sub (i64 ptrtoint (void (i8*)* @vf to i64), i64 ptrtoint (i32* getelementptr ({ i32, i32, i32 }, { i32, i32, i32 }* @vt1, i32 0, i32 1) to i64)) to i32),
i32 trunc (i64 sub (i64 ptrtoint (void (i8*)* @vf to i64), i64 ptrtoint (i32* @g to i64)) to i32)
}
define void @vf(i8* %this) {
ret void
}
; CHECK: define void @call1
define void @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.bitset.test(i8* %vtablei8, metadata !"bitset")
call void @llvm.assume(i1 %p)
%fptr = call i8* @llvm.load.relative.i32(i8* %vtablei8, i32 4)
%fptr_casted = bitcast i8* %fptr to void (i8*)*
; CHECK: call void %
call void %fptr_casted(i8* %obj)
ret void
}
; CHECK: define void @call2
define void @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.bitset.test(i8* %vtablei8, metadata !"bitset")
call void @llvm.assume(i1 %p)
%fptr = call i8* @llvm.load.relative.i32(i8* %vtablei8, i32 8)
%fptr_casted = bitcast i8* %fptr to void (i8*)*
; CHECK: call void %
call void %fptr_casted(i8* %obj)
ret void
}
declare i1 @llvm.bitset.test(i8*, metadata)
declare i8* @llvm.load.relative.i32(i8*, i32)
declare void @llvm.assume(i1)
!0 = !{!"bitset", { i32, i32, i32 }* @vt1, i32 0}
!llvm.bitsets = !{!0}

test/Transforms/WholeProgramDevirt/devirt-single-impl-relative-32.ll

  • This file was added.
; RUN: opt -S -wholeprogramdevirt %s | FileCheck %s
target datalayout = "e-p:32:32"
target triple = "i386-unknown-linux-gnu"
@vt1 = constant { i32, i32 } { i32 0, i32 sub (i32 ptrtoint (void (i8*)* @vf to i32), i32 ptrtoint ({ i32, i32 }* @vt1 to i32)) }
@vt2 = constant { i32, i32 } { i32 0, i32 sub (i32 ptrtoint (void (i8*)* @vf to i32), i32 ptrtoint ({ i32, i32 }* @vt2 to i32)) }
define void @vf(i8* %this) {
ret void
}
; CHECK: define void @call
define void @call(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.bitset.test(i8* %vtablei8, metadata !"bitset")
call void @llvm.assume(i1 %p)
%fptr = call i8* @llvm.load.relative.i32(i8* %vtablei8, i32 4)
%fptr_casted = bitcast i8* %fptr to void (i8*)*
; CHECK: call void @vf(
call void %fptr_casted(i8* %obj)
ret void
}
declare i1 @llvm.bitset.test(i8*, metadata)
declare i8* @llvm.load.relative.i32(i8*, i32)
declare void @llvm.assume(i1)
!0 = !{!"bitset", { i32, i32 }* @vt1, i32 0}
!1 = !{!"bitset", { i32, i32 }* @vt2, i32 0}
!llvm.bitsets = !{!0, !1}

test/Transforms/WholeProgramDevirt/devirt-single-impl-relative.ll

  • This file was added.
; RUN: opt -S -wholeprogramdevirt %s | FileCheck %s
target datalayout = "e-p:64:64"
target triple = "x86_64-unknown-linux-gnu"
@vt1 = constant { i32, i32 } { i32 0, i32 trunc (i64 sub (i64 ptrtoint (void (i8*)* @vf to i64), i64 ptrtoint ({ i32, i32 }* @vt1 to i64)) to i32) }
@vt2 = constant { i32, i32 } { i32 0, i32 trunc (i64 sub (i64 ptrtoint (void (i8*)* @vf to i64), i64 ptrtoint ({ i32, i32 }* @vt2 to i64)) to i32) }
define void @vf(i8* %this) {
ret void
}
; CHECK: define void @call
define void @call(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.bitset.test(i8* %vtablei8, metadata !"bitset")
call void @llvm.assume(i1 %p)
%fptr = call i8* @llvm.load.relative.i32(i8* %vtablei8, i32 4)
%fptr_casted = bitcast i8* %fptr to void (i8*)*
; CHECK: call void @vf(
call void %fptr_casted(i8* %obj)
ret void
}
declare i1 @llvm.bitset.test(i8*, metadata)
declare i8* @llvm.load.relative.i32(i8*, i32)
declare void @llvm.assume(i1)
!0 = !{!"bitset", { i32, i32 }* @vt1, i32 0}
!1 = !{!"bitset", { i32, i32 }* @vt2, i32 0}
!llvm.bitsets = !{!0, !1}

test/Transforms/WholeProgramDevirt/non-relative.ll

  • This file was added.
; RUN: opt -S -wholeprogramdevirt %s | FileCheck %s
target datalayout = "e-p:64:64"
target triple = "x86_64-unknown-linux-gnu"
@vt1 = constant { i32, i32 } { i32 0, i32 trunc (i64 sub (i64 ptrtoint (void (i8*)* @vf to i64), i64 ptrtoint ({ i32, i32 }* @vt1 to i64)) to i32) }
@vt2 = constant { i32, i32 } { i32 0, i32 trunc (i64 sub (i64 ptrtoint (void (i8*)* @vf to i64), i64 ptrtoint ({ i32, i32 }* @vt2 to i64)) to i32) }
define void @vf(i8* %this) {
ret void
}
; CHECK: define void @call
define void @call(i8* %obj) {
%vtableptr = bitcast i8* %obj to { i32, i8* }**
%vtable = load { i32, i8* }*, { i32, i8* }** %vtableptr
%vtablei8 = bitcast { i32, i8* }* %vtable to i8*
%p = call i1 @llvm.bitset.test(i8* %vtablei8, metadata !"bitset")
call void @llvm.assume(i1 %p)
%fptrptr = getelementptr { i32, i8* }, { i32, i8* }* %vtable, i32 0, i32 1
%fptr = load i8*, i8** %fptrptr
%fptr_casted = bitcast i8* %fptr to void (i8*)*
; CHECK: call void %
call void %fptr_casted(i8* %obj)
ret void
}
declare i1 @llvm.bitset.test(i8*, metadata)
declare void @llvm.assume(i1)
!0 = !{!"bitset", { i32, i32 }* @vt1, i32 0}
!1 = !{!"bitset", { i32, i32 }* @vt2, i32 0}
!llvm.bitsets = !{!0, !1}