2016-02-10 06:50:34 +08:00
|
|
|
//===- WholeProgramDevirt.cpp - Whole program virtual call optimization ---===//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// This pass implements whole program optimization of virtual calls in cases
|
IR: New representation for CFI and virtual call optimization pass metadata.
The bitset metadata currently used in LLVM has a few problems:
1. It has the wrong name. The name "bitset" refers to an implementation
detail of one use of the metadata (i.e. its original use case, CFI).
This makes it harder to understand, as the name makes no sense in the
context of virtual call optimization.
2. It is represented using a global named metadata node, rather than
being directly associated with a global. This makes it harder to
manipulate the metadata when rebuilding global variables, summarise it
as part of ThinLTO and drop unused metadata when associated globals are
dropped. For this reason, CFI does not currently work correctly when
both CFI and vcall opt are enabled, as vcall opt needs to rebuild vtable
globals, and fails to associate metadata with the rebuilt globals. As I
understand it, the same problem could also affect ASan, which rebuilds
globals with a red zone.
This patch solves both of those problems in the following way:
1. Rename the metadata to "type metadata". This new name reflects how
the metadata is currently being used (i.e. to represent type information
for CFI and vtable opt). The new name is reflected in the name for the
associated intrinsic (llvm.type.test) and pass (LowerTypeTests).
2. Attach metadata directly to the globals that it pertains to, rather
than using the "llvm.bitsets" global metadata node as we are doing now.
This is done using the newly introduced capability to attach
metadata to global variables (r271348 and r271358).
See also: http://lists.llvm.org/pipermail/llvm-dev/2016-June/100462.html
Differential Revision: http://reviews.llvm.org/D21053
llvm-svn: 273729
2016-06-25 05:21:32 +08:00
|
|
|
// where we know (via !type metadata) that the list of callees is fixed. This
|
2016-02-10 06:50:34 +08:00
|
|
|
// includes the following:
|
|
|
|
// - Single implementation devirtualization: if a virtual call has a single
|
|
|
|
// possible callee, replace all calls with a direct call to that callee.
|
|
|
|
// - Virtual constant propagation: if the virtual function's return type is an
|
|
|
|
// integer <=64 bits and all possible callees are readnone, for each class and
|
|
|
|
// each list of constant arguments: evaluate the function, store the return
|
|
|
|
// value alongside the virtual table, and rewrite each virtual call as a load
|
|
|
|
// from the virtual table.
|
|
|
|
// - Uniform return value optimization: if the conditions for virtual constant
|
|
|
|
// propagation hold and each function returns the same constant value, replace
|
|
|
|
// each virtual call with that constant.
|
|
|
|
// - Unique return value optimization for i1 return values: if the conditions
|
|
|
|
// for virtual constant propagation hold and a single vtable's function
|
|
|
|
// returns 0, or a single vtable's function returns 1, replace each virtual
|
|
|
|
// call with a comparison of the vptr against that vtable's address.
|
|
|
|
//
|
2017-03-04 09:23:30 +08:00
|
|
|
// This pass is intended to be used during the regular and thin LTO pipelines.
|
|
|
|
// During regular LTO, the pass determines the best optimization for each
|
|
|
|
// virtual call and applies the resolutions directly to virtual calls that are
|
|
|
|
// eligible for virtual call optimization (i.e. calls that use either of the
|
|
|
|
// llvm.assume(llvm.type.test) or llvm.type.checked.load intrinsics). During
|
|
|
|
// ThinLTO, the pass operates in two phases:
|
|
|
|
// - Export phase: this is run during the thin link over a single merged module
|
|
|
|
// that contains all vtables with !type metadata that participate in the link.
|
|
|
|
// The pass computes a resolution for each virtual call and stores it in the
|
|
|
|
// type identifier summary.
|
|
|
|
// - Import phase: this is run during the thin backends over the individual
|
|
|
|
// modules. The pass applies the resolutions previously computed during the
|
|
|
|
// import phase to each eligible virtual call.
|
|
|
|
//
|
2016-02-10 06:50:34 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#include "llvm/Transforms/IPO/WholeProgramDevirt.h"
|
2016-04-18 17:17:29 +08:00
|
|
|
#include "llvm/ADT/ArrayRef.h"
|
2016-08-12 01:20:18 +08:00
|
|
|
#include "llvm/ADT/DenseMap.h"
|
|
|
|
#include "llvm/ADT/DenseMapInfo.h"
|
2016-02-10 06:50:34 +08:00
|
|
|
#include "llvm/ADT/DenseSet.h"
|
|
|
|
#include "llvm/ADT/MapVector.h"
|
2016-08-12 01:20:18 +08:00
|
|
|
#include "llvm/ADT/SmallVector.h"
|
2017-06-06 19:49:48 +08:00
|
|
|
#include "llvm/ADT/iterator_range.h"
|
2017-02-18 02:17:04 +08:00
|
|
|
#include "llvm/Analysis/AliasAnalysis.h"
|
|
|
|
#include "llvm/Analysis/BasicAliasAnalysis.h"
|
IR: New representation for CFI and virtual call optimization pass metadata.
The bitset metadata currently used in LLVM has a few problems:
1. It has the wrong name. The name "bitset" refers to an implementation
detail of one use of the metadata (i.e. its original use case, CFI).
This makes it harder to understand, as the name makes no sense in the
context of virtual call optimization.
2. It is represented using a global named metadata node, rather than
being directly associated with a global. This makes it harder to
manipulate the metadata when rebuilding global variables, summarise it
as part of ThinLTO and drop unused metadata when associated globals are
dropped. For this reason, CFI does not currently work correctly when
both CFI and vcall opt are enabled, as vcall opt needs to rebuild vtable
globals, and fails to associate metadata with the rebuilt globals. As I
understand it, the same problem could also affect ASan, which rebuilds
globals with a red zone.
This patch solves both of those problems in the following way:
1. Rename the metadata to "type metadata". This new name reflects how
the metadata is currently being used (i.e. to represent type information
for CFI and vtable opt). The new name is reflected in the name for the
associated intrinsic (llvm.type.test) and pass (LowerTypeTests).
2. Attach metadata directly to the globals that it pertains to, rather
than using the "llvm.bitsets" global metadata node as we are doing now.
This is done using the newly introduced capability to attach
metadata to global variables (r271348 and r271358).
See also: http://lists.llvm.org/pipermail/llvm-dev/2016-June/100462.html
Differential Revision: http://reviews.llvm.org/D21053
llvm-svn: 273729
2016-06-25 05:21:32 +08:00
|
|
|
#include "llvm/Analysis/TypeMetadataUtils.h"
|
2016-02-10 06:50:34 +08:00
|
|
|
#include "llvm/IR/CallSite.h"
|
|
|
|
#include "llvm/IR/Constants.h"
|
|
|
|
#include "llvm/IR/DataLayout.h"
|
2016-08-06 03:45:16 +08:00
|
|
|
#include "llvm/IR/DebugInfoMetadata.h"
|
2016-08-12 01:20:18 +08:00
|
|
|
#include "llvm/IR/DebugLoc.h"
|
|
|
|
#include "llvm/IR/DerivedTypes.h"
|
2016-07-12 10:38:37 +08:00
|
|
|
#include "llvm/IR/DiagnosticInfo.h"
|
2016-08-12 01:20:18 +08:00
|
|
|
#include "llvm/IR/Function.h"
|
|
|
|
#include "llvm/IR/GlobalAlias.h"
|
|
|
|
#include "llvm/IR/GlobalVariable.h"
|
2016-02-10 06:50:34 +08:00
|
|
|
#include "llvm/IR/IRBuilder.h"
|
2016-08-12 01:20:18 +08:00
|
|
|
#include "llvm/IR/InstrTypes.h"
|
|
|
|
#include "llvm/IR/Instruction.h"
|
2016-02-10 06:50:34 +08:00
|
|
|
#include "llvm/IR/Instructions.h"
|
|
|
|
#include "llvm/IR/Intrinsics.h"
|
2016-08-12 01:20:18 +08:00
|
|
|
#include "llvm/IR/LLVMContext.h"
|
|
|
|
#include "llvm/IR/Metadata.h"
|
2016-02-10 06:50:34 +08:00
|
|
|
#include "llvm/IR/Module.h"
|
2017-02-14 03:26:18 +08:00
|
|
|
#include "llvm/IR/ModuleSummaryIndexYAML.h"
|
2016-02-10 06:50:34 +08:00
|
|
|
#include "llvm/Pass.h"
|
2016-08-12 01:20:18 +08:00
|
|
|
#include "llvm/PassRegistry.h"
|
|
|
|
#include "llvm/PassSupport.h"
|
|
|
|
#include "llvm/Support/Casting.h"
|
2017-02-14 03:26:18 +08:00
|
|
|
#include "llvm/Support/Error.h"
|
|
|
|
#include "llvm/Support/FileSystem.h"
|
2016-08-12 01:20:18 +08:00
|
|
|
#include "llvm/Support/MathExtras.h"
|
2016-04-18 17:17:29 +08:00
|
|
|
#include "llvm/Transforms/IPO.h"
|
2017-02-18 02:17:04 +08:00
|
|
|
#include "llvm/Transforms/IPO/FunctionAttrs.h"
|
2016-02-10 06:50:34 +08:00
|
|
|
#include "llvm/Transforms/Utils/Evaluator.h"
|
2016-08-12 01:20:18 +08:00
|
|
|
#include <algorithm>
|
|
|
|
#include <cstddef>
|
|
|
|
#include <map>
|
2016-02-10 06:50:34 +08:00
|
|
|
#include <set>
|
2016-08-12 01:20:18 +08:00
|
|
|
#include <string>
|
2016-02-10 06:50:34 +08:00
|
|
|
|
|
|
|
using namespace llvm;
|
|
|
|
using namespace wholeprogramdevirt;
|
|
|
|
|
|
|
|
#define DEBUG_TYPE "wholeprogramdevirt"
|
|
|
|
|
2017-02-14 03:26:18 +08:00
|
|
|
static cl::opt<PassSummaryAction> ClSummaryAction(
|
|
|
|
"wholeprogramdevirt-summary-action",
|
|
|
|
cl::desc("What to do with the summary when running this pass"),
|
|
|
|
cl::values(clEnumValN(PassSummaryAction::None, "none", "Do nothing"),
|
|
|
|
clEnumValN(PassSummaryAction::Import, "import",
|
|
|
|
"Import typeid resolutions from summary and globals"),
|
|
|
|
clEnumValN(PassSummaryAction::Export, "export",
|
|
|
|
"Export typeid resolutions to summary and globals")),
|
|
|
|
cl::Hidden);
|
|
|
|
|
|
|
|
static cl::opt<std::string> ClReadSummary(
|
|
|
|
"wholeprogramdevirt-read-summary",
|
|
|
|
cl::desc("Read summary from given YAML file before running pass"),
|
|
|
|
cl::Hidden);
|
|
|
|
|
|
|
|
static cl::opt<std::string> ClWriteSummary(
|
|
|
|
"wholeprogramdevirt-write-summary",
|
|
|
|
cl::desc("Write summary to given YAML file after running pass"),
|
|
|
|
cl::Hidden);
|
|
|
|
|
2016-02-10 06:50:34 +08:00
|
|
|
// Find the minimum offset that we may store a value of size Size bits at. If
|
|
|
|
// IsAfter is set, look for an offset before the object, otherwise look for an
|
|
|
|
// offset after the object.
|
|
|
|
uint64_t
|
|
|
|
wholeprogramdevirt::findLowestOffset(ArrayRef<VirtualCallTarget> Targets,
|
|
|
|
bool IsAfter, uint64_t Size) {
|
|
|
|
// Find a minimum offset taking into account only vtable sizes.
|
|
|
|
uint64_t MinByte = 0;
|
|
|
|
for (const VirtualCallTarget &Target : Targets) {
|
|
|
|
if (IsAfter)
|
|
|
|
MinByte = std::max(MinByte, Target.minAfterBytes());
|
|
|
|
else
|
|
|
|
MinByte = std::max(MinByte, Target.minBeforeBytes());
|
|
|
|
}
|
|
|
|
|
|
|
|
// Build a vector of arrays of bytes covering, for each target, a slice of the
|
|
|
|
// used region (see AccumBitVector::BytesUsed in
|
|
|
|
// llvm/Transforms/IPO/WholeProgramDevirt.h) starting at MinByte. Effectively,
|
|
|
|
// this aligns the used regions to start at MinByte.
|
|
|
|
//
|
|
|
|
// In this example, A, B and C are vtables, # is a byte already allocated for
|
|
|
|
// a virtual function pointer, AAAA... (etc.) are the used regions for the
|
|
|
|
// vtables and Offset(X) is the value computed for the Offset variable below
|
|
|
|
// for X.
|
|
|
|
//
|
|
|
|
// Offset(A)
|
|
|
|
// | |
|
|
|
|
// |MinByte
|
|
|
|
// A: ################AAAAAAAA|AAAAAAAA
|
|
|
|
// B: ########BBBBBBBBBBBBBBBB|BBBB
|
|
|
|
// C: ########################|CCCCCCCCCCCCCCCC
|
|
|
|
// | Offset(B) |
|
|
|
|
//
|
|
|
|
// This code produces the slices of A, B and C that appear after the divider
|
|
|
|
// at MinByte.
|
|
|
|
std::vector<ArrayRef<uint8_t>> Used;
|
|
|
|
for (const VirtualCallTarget &Target : Targets) {
|
IR: New representation for CFI and virtual call optimization pass metadata.
The bitset metadata currently used in LLVM has a few problems:
1. It has the wrong name. The name "bitset" refers to an implementation
detail of one use of the metadata (i.e. its original use case, CFI).
This makes it harder to understand, as the name makes no sense in the
context of virtual call optimization.
2. It is represented using a global named metadata node, rather than
being directly associated with a global. This makes it harder to
manipulate the metadata when rebuilding global variables, summarise it
as part of ThinLTO and drop unused metadata when associated globals are
dropped. For this reason, CFI does not currently work correctly when
both CFI and vcall opt are enabled, as vcall opt needs to rebuild vtable
globals, and fails to associate metadata with the rebuilt globals. As I
understand it, the same problem could also affect ASan, which rebuilds
globals with a red zone.
This patch solves both of those problems in the following way:
1. Rename the metadata to "type metadata". This new name reflects how
the metadata is currently being used (i.e. to represent type information
for CFI and vtable opt). The new name is reflected in the name for the
associated intrinsic (llvm.type.test) and pass (LowerTypeTests).
2. Attach metadata directly to the globals that it pertains to, rather
than using the "llvm.bitsets" global metadata node as we are doing now.
This is done using the newly introduced capability to attach
metadata to global variables (r271348 and r271358).
See also: http://lists.llvm.org/pipermail/llvm-dev/2016-June/100462.html
Differential Revision: http://reviews.llvm.org/D21053
llvm-svn: 273729
2016-06-25 05:21:32 +08:00
|
|
|
ArrayRef<uint8_t> VTUsed = IsAfter ? Target.TM->Bits->After.BytesUsed
|
|
|
|
: Target.TM->Bits->Before.BytesUsed;
|
2016-02-10 06:50:34 +08:00
|
|
|
uint64_t Offset = IsAfter ? MinByte - Target.minAfterBytes()
|
|
|
|
: MinByte - Target.minBeforeBytes();
|
|
|
|
|
|
|
|
// Disregard used regions that are smaller than Offset. These are
|
|
|
|
// effectively all-free regions that do not need to be checked.
|
|
|
|
if (VTUsed.size() > Offset)
|
|
|
|
Used.push_back(VTUsed.slice(Offset));
|
|
|
|
}
|
|
|
|
|
|
|
|
if (Size == 1) {
|
|
|
|
// Find a free bit in each member of Used.
|
|
|
|
for (unsigned I = 0;; ++I) {
|
|
|
|
uint8_t BitsUsed = 0;
|
|
|
|
for (auto &&B : Used)
|
|
|
|
if (I < B.size())
|
|
|
|
BitsUsed |= B[I];
|
|
|
|
if (BitsUsed != 0xff)
|
|
|
|
return (MinByte + I) * 8 +
|
|
|
|
countTrailingZeros(uint8_t(~BitsUsed), ZB_Undefined);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
// Find a free (Size/8) byte region in each member of Used.
|
|
|
|
// FIXME: see if alignment helps.
|
|
|
|
for (unsigned I = 0;; ++I) {
|
|
|
|
for (auto &&B : Used) {
|
|
|
|
unsigned Byte = 0;
|
|
|
|
while ((I + Byte) < B.size() && Byte < (Size / 8)) {
|
|
|
|
if (B[I + Byte])
|
|
|
|
goto NextI;
|
|
|
|
++Byte;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return (MinByte + I) * 8;
|
|
|
|
NextI:;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void wholeprogramdevirt::setBeforeReturnValues(
|
|
|
|
MutableArrayRef<VirtualCallTarget> Targets, uint64_t AllocBefore,
|
|
|
|
unsigned BitWidth, int64_t &OffsetByte, uint64_t &OffsetBit) {
|
|
|
|
if (BitWidth == 1)
|
|
|
|
OffsetByte = -(AllocBefore / 8 + 1);
|
|
|
|
else
|
|
|
|
OffsetByte = -((AllocBefore + 7) / 8 + (BitWidth + 7) / 8);
|
|
|
|
OffsetBit = AllocBefore % 8;
|
|
|
|
|
|
|
|
for (VirtualCallTarget &Target : Targets) {
|
|
|
|
if (BitWidth == 1)
|
|
|
|
Target.setBeforeBit(AllocBefore);
|
|
|
|
else
|
|
|
|
Target.setBeforeBytes(AllocBefore, (BitWidth + 7) / 8);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void wholeprogramdevirt::setAfterReturnValues(
|
|
|
|
MutableArrayRef<VirtualCallTarget> Targets, uint64_t AllocAfter,
|
|
|
|
unsigned BitWidth, int64_t &OffsetByte, uint64_t &OffsetBit) {
|
|
|
|
if (BitWidth == 1)
|
|
|
|
OffsetByte = AllocAfter / 8;
|
|
|
|
else
|
|
|
|
OffsetByte = (AllocAfter + 7) / 8;
|
|
|
|
OffsetBit = AllocAfter % 8;
|
|
|
|
|
|
|
|
for (VirtualCallTarget &Target : Targets) {
|
|
|
|
if (BitWidth == 1)
|
|
|
|
Target.setAfterBit(AllocAfter);
|
|
|
|
else
|
|
|
|
Target.setAfterBytes(AllocAfter, (BitWidth + 7) / 8);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
IR: New representation for CFI and virtual call optimization pass metadata.
The bitset metadata currently used in LLVM has a few problems:
1. It has the wrong name. The name "bitset" refers to an implementation
detail of one use of the metadata (i.e. its original use case, CFI).
This makes it harder to understand, as the name makes no sense in the
context of virtual call optimization.
2. It is represented using a global named metadata node, rather than
being directly associated with a global. This makes it harder to
manipulate the metadata when rebuilding global variables, summarise it
as part of ThinLTO and drop unused metadata when associated globals are
dropped. For this reason, CFI does not currently work correctly when
both CFI and vcall opt are enabled, as vcall opt needs to rebuild vtable
globals, and fails to associate metadata with the rebuilt globals. As I
understand it, the same problem could also affect ASan, which rebuilds
globals with a red zone.
This patch solves both of those problems in the following way:
1. Rename the metadata to "type metadata". This new name reflects how
the metadata is currently being used (i.e. to represent type information
for CFI and vtable opt). The new name is reflected in the name for the
associated intrinsic (llvm.type.test) and pass (LowerTypeTests).
2. Attach metadata directly to the globals that it pertains to, rather
than using the "llvm.bitsets" global metadata node as we are doing now.
This is done using the newly introduced capability to attach
metadata to global variables (r271348 and r271358).
See also: http://lists.llvm.org/pipermail/llvm-dev/2016-June/100462.html
Differential Revision: http://reviews.llvm.org/D21053
llvm-svn: 273729
2016-06-25 05:21:32 +08:00
|
|
|
VirtualCallTarget::VirtualCallTarget(Function *Fn, const TypeMemberInfo *TM)
|
|
|
|
: Fn(Fn), TM(TM),
|
2016-08-12 09:40:10 +08:00
|
|
|
IsBigEndian(Fn->getParent()->getDataLayout().isBigEndian()), WasDevirt(false) {}
|
2016-02-10 06:50:34 +08:00
|
|
|
|
|
|
|
namespace {
|
|
|
|
|
IR: New representation for CFI and virtual call optimization pass metadata.
The bitset metadata currently used in LLVM has a few problems:
1. It has the wrong name. The name "bitset" refers to an implementation
detail of one use of the metadata (i.e. its original use case, CFI).
This makes it harder to understand, as the name makes no sense in the
context of virtual call optimization.
2. It is represented using a global named metadata node, rather than
being directly associated with a global. This makes it harder to
manipulate the metadata when rebuilding global variables, summarise it
as part of ThinLTO and drop unused metadata when associated globals are
dropped. For this reason, CFI does not currently work correctly when
both CFI and vcall opt are enabled, as vcall opt needs to rebuild vtable
globals, and fails to associate metadata with the rebuilt globals. As I
understand it, the same problem could also affect ASan, which rebuilds
globals with a red zone.
This patch solves both of those problems in the following way:
1. Rename the metadata to "type metadata". This new name reflects how
the metadata is currently being used (i.e. to represent type information
for CFI and vtable opt). The new name is reflected in the name for the
associated intrinsic (llvm.type.test) and pass (LowerTypeTests).
2. Attach metadata directly to the globals that it pertains to, rather
than using the "llvm.bitsets" global metadata node as we are doing now.
This is done using the newly introduced capability to attach
metadata to global variables (r271348 and r271358).
See also: http://lists.llvm.org/pipermail/llvm-dev/2016-June/100462.html
Differential Revision: http://reviews.llvm.org/D21053
llvm-svn: 273729
2016-06-25 05:21:32 +08:00
|
|
|
// A slot in a set of virtual tables. The TypeID identifies the set of virtual
|
2016-02-10 06:50:34 +08:00
|
|
|
// tables, and the ByteOffset is the offset in bytes from the address point to
|
|
|
|
// the virtual function pointer.
|
|
|
|
struct VTableSlot {
|
IR: New representation for CFI and virtual call optimization pass metadata.
The bitset metadata currently used in LLVM has a few problems:
1. It has the wrong name. The name "bitset" refers to an implementation
detail of one use of the metadata (i.e. its original use case, CFI).
This makes it harder to understand, as the name makes no sense in the
context of virtual call optimization.
2. It is represented using a global named metadata node, rather than
being directly associated with a global. This makes it harder to
manipulate the metadata when rebuilding global variables, summarise it
as part of ThinLTO and drop unused metadata when associated globals are
dropped. For this reason, CFI does not currently work correctly when
both CFI and vcall opt are enabled, as vcall opt needs to rebuild vtable
globals, and fails to associate metadata with the rebuilt globals. As I
understand it, the same problem could also affect ASan, which rebuilds
globals with a red zone.
This patch solves both of those problems in the following way:
1. Rename the metadata to "type metadata". This new name reflects how
the metadata is currently being used (i.e. to represent type information
for CFI and vtable opt). The new name is reflected in the name for the
associated intrinsic (llvm.type.test) and pass (LowerTypeTests).
2. Attach metadata directly to the globals that it pertains to, rather
than using the "llvm.bitsets" global metadata node as we are doing now.
This is done using the newly introduced capability to attach
metadata to global variables (r271348 and r271358).
See also: http://lists.llvm.org/pipermail/llvm-dev/2016-June/100462.html
Differential Revision: http://reviews.llvm.org/D21053
llvm-svn: 273729
2016-06-25 05:21:32 +08:00
|
|
|
Metadata *TypeID;
|
2016-02-10 06:50:34 +08:00
|
|
|
uint64_t ByteOffset;
|
|
|
|
};
|
|
|
|
|
2016-08-12 01:20:18 +08:00
|
|
|
} // end anonymous namespace
|
2016-02-10 06:50:34 +08:00
|
|
|
|
2016-02-10 07:01:38 +08:00
|
|
|
namespace llvm {
|
|
|
|
|
2016-02-10 06:50:34 +08:00
|
|
|
template <> struct DenseMapInfo<VTableSlot> {
|
|
|
|
static VTableSlot getEmptyKey() {
|
|
|
|
return {DenseMapInfo<Metadata *>::getEmptyKey(),
|
|
|
|
DenseMapInfo<uint64_t>::getEmptyKey()};
|
|
|
|
}
|
|
|
|
static VTableSlot getTombstoneKey() {
|
|
|
|
return {DenseMapInfo<Metadata *>::getTombstoneKey(),
|
|
|
|
DenseMapInfo<uint64_t>::getTombstoneKey()};
|
|
|
|
}
|
|
|
|
static unsigned getHashValue(const VTableSlot &I) {
|
IR: New representation for CFI and virtual call optimization pass metadata.
The bitset metadata currently used in LLVM has a few problems:
1. It has the wrong name. The name "bitset" refers to an implementation
detail of one use of the metadata (i.e. its original use case, CFI).
This makes it harder to understand, as the name makes no sense in the
context of virtual call optimization.
2. It is represented using a global named metadata node, rather than
being directly associated with a global. This makes it harder to
manipulate the metadata when rebuilding global variables, summarise it
as part of ThinLTO and drop unused metadata when associated globals are
dropped. For this reason, CFI does not currently work correctly when
both CFI and vcall opt are enabled, as vcall opt needs to rebuild vtable
globals, and fails to associate metadata with the rebuilt globals. As I
understand it, the same problem could also affect ASan, which rebuilds
globals with a red zone.
This patch solves both of those problems in the following way:
1. Rename the metadata to "type metadata". This new name reflects how
the metadata is currently being used (i.e. to represent type information
for CFI and vtable opt). The new name is reflected in the name for the
associated intrinsic (llvm.type.test) and pass (LowerTypeTests).
2. Attach metadata directly to the globals that it pertains to, rather
than using the "llvm.bitsets" global metadata node as we are doing now.
This is done using the newly introduced capability to attach
metadata to global variables (r271348 and r271358).
See also: http://lists.llvm.org/pipermail/llvm-dev/2016-June/100462.html
Differential Revision: http://reviews.llvm.org/D21053
llvm-svn: 273729
2016-06-25 05:21:32 +08:00
|
|
|
return DenseMapInfo<Metadata *>::getHashValue(I.TypeID) ^
|
2016-02-10 06:50:34 +08:00
|
|
|
DenseMapInfo<uint64_t>::getHashValue(I.ByteOffset);
|
|
|
|
}
|
|
|
|
static bool isEqual(const VTableSlot &LHS,
|
|
|
|
const VTableSlot &RHS) {
|
IR: New representation for CFI and virtual call optimization pass metadata.
The bitset metadata currently used in LLVM has a few problems:
1. It has the wrong name. The name "bitset" refers to an implementation
detail of one use of the metadata (i.e. its original use case, CFI).
This makes it harder to understand, as the name makes no sense in the
context of virtual call optimization.
2. It is represented using a global named metadata node, rather than
being directly associated with a global. This makes it harder to
manipulate the metadata when rebuilding global variables, summarise it
as part of ThinLTO and drop unused metadata when associated globals are
dropped. For this reason, CFI does not currently work correctly when
both CFI and vcall opt are enabled, as vcall opt needs to rebuild vtable
globals, and fails to associate metadata with the rebuilt globals. As I
understand it, the same problem could also affect ASan, which rebuilds
globals with a red zone.
This patch solves both of those problems in the following way:
1. Rename the metadata to "type metadata". This new name reflects how
the metadata is currently being used (i.e. to represent type information
for CFI and vtable opt). The new name is reflected in the name for the
associated intrinsic (llvm.type.test) and pass (LowerTypeTests).
2. Attach metadata directly to the globals that it pertains to, rather
than using the "llvm.bitsets" global metadata node as we are doing now.
This is done using the newly introduced capability to attach
metadata to global variables (r271348 and r271358).
See also: http://lists.llvm.org/pipermail/llvm-dev/2016-June/100462.html
Differential Revision: http://reviews.llvm.org/D21053
llvm-svn: 273729
2016-06-25 05:21:32 +08:00
|
|
|
return LHS.TypeID == RHS.TypeID && LHS.ByteOffset == RHS.ByteOffset;
|
2016-02-10 06:50:34 +08:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2016-08-12 01:20:18 +08:00
|
|
|
} // end namespace llvm
|
2016-02-10 07:01:38 +08:00
|
|
|
|
2016-02-10 06:50:34 +08:00
|
|
|
namespace {
|
|
|
|
|
|
|
|
// A virtual call site. VTable is the loaded virtual table pointer, and CS is
|
|
|
|
// the indirect virtual call.
|
|
|
|
struct VirtualCallSite {
|
|
|
|
Value *VTable;
|
|
|
|
CallSite CS;
|
|
|
|
|
2016-06-25 08:23:04 +08:00
|
|
|
// If non-null, this field points to the associated unsafe use count stored in
|
|
|
|
// the DevirtModule::NumUnsafeUsesForTypeTest map below. See the description
|
|
|
|
// of that field for details.
|
|
|
|
unsigned *NumUnsafeUses;
|
|
|
|
|
2016-08-12 03:09:02 +08:00
|
|
|
void emitRemark(const Twine &OptName, const Twine &TargetName) {
|
2016-07-12 10:38:37 +08:00
|
|
|
Function *F = CS.getCaller();
|
2016-08-12 03:09:02 +08:00
|
|
|
emitOptimizationRemark(
|
|
|
|
F->getContext(), DEBUG_TYPE, *F,
|
|
|
|
CS.getInstruction()->getDebugLoc(),
|
|
|
|
OptName + ": devirtualized a call to " + TargetName);
|
2016-07-12 10:38:37 +08:00
|
|
|
}
|
|
|
|
|
2016-08-12 03:09:02 +08:00
|
|
|
void replaceAndErase(const Twine &OptName, const Twine &TargetName,
|
|
|
|
bool RemarksEnabled, Value *New) {
|
|
|
|
if (RemarksEnabled)
|
|
|
|
emitRemark(OptName, TargetName);
|
2016-02-10 06:50:34 +08:00
|
|
|
CS->replaceAllUsesWith(New);
|
|
|
|
if (auto II = dyn_cast<InvokeInst>(CS.getInstruction())) {
|
|
|
|
BranchInst::Create(II->getNormalDest(), CS.getInstruction());
|
|
|
|
II->getUnwindDest()->removePredecessor(II->getParent());
|
|
|
|
}
|
|
|
|
CS->eraseFromParent();
|
2016-06-25 08:23:04 +08:00
|
|
|
// This use is no longer unsafe.
|
|
|
|
if (NumUnsafeUses)
|
|
|
|
--*NumUnsafeUses;
|
2016-02-10 06:50:34 +08:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2017-02-16 05:56:51 +08:00
|
|
|
// Call site information collected for a specific VTableSlot and possibly a list
|
|
|
|
// of constant integer arguments. The grouping by arguments is handled by the
|
|
|
|
// VTableSlotInfo class.
|
|
|
|
struct CallSiteInfo {
|
2017-03-04 09:23:30 +08:00
|
|
|
/// The set of call sites for this slot. Used during regular LTO and the
|
|
|
|
/// import phase of ThinLTO (as well as the export phase of ThinLTO for any
|
|
|
|
/// call sites that appear in the merged module itself); in each of these
|
|
|
|
/// cases we are directly operating on the call sites at the IR level.
|
2017-02-16 05:56:51 +08:00
|
|
|
std::vector<VirtualCallSite> CallSites;
|
2017-03-04 09:23:30 +08:00
|
|
|
|
|
|
|
// These fields are used during the export phase of ThinLTO and reflect
|
|
|
|
// information collected from function summaries.
|
|
|
|
|
2017-03-04 09:31:01 +08:00
|
|
|
/// Whether any function summary contains an llvm.assume(llvm.type.test) for
|
|
|
|
/// this slot.
|
|
|
|
bool SummaryHasTypeTestAssumeUsers;
|
|
|
|
|
2017-03-04 09:23:30 +08:00
|
|
|
/// CFI-specific: a vector containing the list of function summaries that use
|
|
|
|
/// the llvm.type.checked.load intrinsic and therefore will require
|
|
|
|
/// resolutions for llvm.type.test in order to implement CFI checks if
|
|
|
|
/// devirtualization was unsuccessful. If devirtualization was successful, the
|
2017-03-11 04:09:11 +08:00
|
|
|
/// pass will clear this vector by calling markDevirt(). If at the end of the
|
|
|
|
/// pass the vector is non-empty, we will need to add a use of llvm.type.test
|
|
|
|
/// to each of the function summaries in the vector.
|
2017-03-04 09:23:30 +08:00
|
|
|
std::vector<FunctionSummary *> SummaryTypeCheckedLoadUsers;
|
2017-03-04 09:31:01 +08:00
|
|
|
|
|
|
|
bool isExported() const {
|
|
|
|
return SummaryHasTypeTestAssumeUsers ||
|
|
|
|
!SummaryTypeCheckedLoadUsers.empty();
|
|
|
|
}
|
2017-03-11 04:09:11 +08:00
|
|
|
|
|
|
|
/// As explained in the comment for SummaryTypeCheckedLoadUsers.
|
|
|
|
void markDevirt() { SummaryTypeCheckedLoadUsers.clear(); }
|
2017-02-16 05:56:51 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
// Call site information collected for a specific VTableSlot.
|
|
|
|
struct VTableSlotInfo {
|
|
|
|
// The set of call sites which do not have all constant integer arguments
|
|
|
|
// (excluding "this").
|
|
|
|
CallSiteInfo CSInfo;
|
|
|
|
|
|
|
|
// The set of call sites with all constant integer arguments (excluding
|
|
|
|
// "this"), grouped by argument list.
|
|
|
|
std::map<std::vector<uint64_t>, CallSiteInfo> ConstCSInfo;
|
|
|
|
|
|
|
|
void addCallSite(Value *VTable, CallSite CS, unsigned *NumUnsafeUses);
|
|
|
|
|
|
|
|
private:
|
|
|
|
CallSiteInfo &findCallSiteInfo(CallSite CS);
|
|
|
|
};
|
|
|
|
|
|
|
|
CallSiteInfo &VTableSlotInfo::findCallSiteInfo(CallSite CS) {
|
|
|
|
std::vector<uint64_t> Args;
|
|
|
|
auto *CI = dyn_cast<IntegerType>(CS.getType());
|
|
|
|
if (!CI || CI->getBitWidth() > 64 || CS.arg_empty())
|
|
|
|
return CSInfo;
|
|
|
|
for (auto &&Arg : make_range(CS.arg_begin() + 1, CS.arg_end())) {
|
|
|
|
auto *CI = dyn_cast<ConstantInt>(Arg);
|
|
|
|
if (!CI || CI->getBitWidth() > 64)
|
|
|
|
return CSInfo;
|
|
|
|
Args.push_back(CI->getZExtValue());
|
|
|
|
}
|
|
|
|
return ConstCSInfo[Args];
|
|
|
|
}
|
|
|
|
|
|
|
|
void VTableSlotInfo::addCallSite(Value *VTable, CallSite CS,
|
|
|
|
unsigned *NumUnsafeUses) {
|
|
|
|
findCallSiteInfo(CS).CallSites.push_back({VTable, CS, NumUnsafeUses});
|
|
|
|
}
|
|
|
|
|
2016-02-10 06:50:34 +08:00
|
|
|
struct DevirtModule {
|
|
|
|
Module &M;
|
2017-02-18 02:17:04 +08:00
|
|
|
function_ref<AAResults &(Function &)> AARGetter;
|
2017-02-14 03:26:18 +08:00
|
|
|
|
2017-03-23 02:22:59 +08:00
|
|
|
ModuleSummaryIndex *ExportSummary;
|
|
|
|
const ModuleSummaryIndex *ImportSummary;
|
2017-02-14 03:26:18 +08:00
|
|
|
|
2016-02-10 06:50:34 +08:00
|
|
|
IntegerType *Int8Ty;
|
|
|
|
PointerType *Int8PtrTy;
|
|
|
|
IntegerType *Int32Ty;
|
2017-02-16 05:56:51 +08:00
|
|
|
IntegerType *Int64Ty;
|
2017-03-11 04:13:58 +08:00
|
|
|
IntegerType *IntPtrTy;
|
2016-02-10 06:50:34 +08:00
|
|
|
|
2016-08-12 03:09:02 +08:00
|
|
|
bool RemarksEnabled;
|
|
|
|
|
2017-02-16 05:56:51 +08:00
|
|
|
MapVector<VTableSlot, VTableSlotInfo> CallSlots;
|
2016-02-10 06:50:34 +08:00
|
|
|
|
2016-06-25 08:23:04 +08:00
|
|
|
// This map keeps track of the number of "unsafe" uses of a loaded function
|
|
|
|
// pointer. The key is the associated llvm.type.test intrinsic call generated
|
|
|
|
// by this pass. An unsafe use is one that calls the loaded function pointer
|
|
|
|
// directly. Every time we eliminate an unsafe use (for example, by
|
|
|
|
// devirtualizing it or by applying virtual constant propagation), we
|
|
|
|
// decrement the value stored in this map. If a value reaches zero, we can
|
|
|
|
// eliminate the type check by RAUWing the associated llvm.type.test call with
|
|
|
|
// true.
|
|
|
|
std::map<CallInst *, unsigned> NumUnsafeUsesForTypeTest;
|
|
|
|
|
2017-02-18 02:17:04 +08:00
|
|
|
DevirtModule(Module &M, function_ref<AAResults &(Function &)> AARGetter,
|
2017-03-23 02:22:59 +08:00
|
|
|
ModuleSummaryIndex *ExportSummary,
|
|
|
|
const ModuleSummaryIndex *ImportSummary)
|
|
|
|
: M(M), AARGetter(AARGetter), ExportSummary(ExportSummary),
|
|
|
|
ImportSummary(ImportSummary), Int8Ty(Type::getInt8Ty(M.getContext())),
|
2016-02-10 06:50:34 +08:00
|
|
|
Int8PtrTy(Type::getInt8PtrTy(M.getContext())),
|
2016-08-12 03:09:02 +08:00
|
|
|
Int32Ty(Type::getInt32Ty(M.getContext())),
|
2017-02-16 05:56:51 +08:00
|
|
|
Int64Ty(Type::getInt64Ty(M.getContext())),
|
2017-03-11 04:13:58 +08:00
|
|
|
IntPtrTy(M.getDataLayout().getIntPtrType(M.getContext(), 0)),
|
2017-03-23 02:22:59 +08:00
|
|
|
RemarksEnabled(areRemarksEnabled()) {
|
|
|
|
assert(!(ExportSummary && ImportSummary));
|
|
|
|
}
|
2016-08-12 03:09:02 +08:00
|
|
|
|
|
|
|
bool areRemarksEnabled();
|
2016-02-10 06:50:34 +08:00
|
|
|
|
2016-06-25 08:23:04 +08:00
|
|
|
void scanTypeTestUsers(Function *TypeTestFunc, Function *AssumeFunc);
|
|
|
|
void scanTypeCheckedLoadUsers(Function *TypeCheckedLoadFunc);
|
|
|
|
|
IR: New representation for CFI and virtual call optimization pass metadata.
The bitset metadata currently used in LLVM has a few problems:
1. It has the wrong name. The name "bitset" refers to an implementation
detail of one use of the metadata (i.e. its original use case, CFI).
This makes it harder to understand, as the name makes no sense in the
context of virtual call optimization.
2. It is represented using a global named metadata node, rather than
being directly associated with a global. This makes it harder to
manipulate the metadata when rebuilding global variables, summarise it
as part of ThinLTO and drop unused metadata when associated globals are
dropped. For this reason, CFI does not currently work correctly when
both CFI and vcall opt are enabled, as vcall opt needs to rebuild vtable
globals, and fails to associate metadata with the rebuilt globals. As I
understand it, the same problem could also affect ASan, which rebuilds
globals with a red zone.
This patch solves both of those problems in the following way:
1. Rename the metadata to "type metadata". This new name reflects how
the metadata is currently being used (i.e. to represent type information
for CFI and vtable opt). The new name is reflected in the name for the
associated intrinsic (llvm.type.test) and pass (LowerTypeTests).
2. Attach metadata directly to the globals that it pertains to, rather
than using the "llvm.bitsets" global metadata node as we are doing now.
This is done using the newly introduced capability to attach
metadata to global variables (r271348 and r271358).
See also: http://lists.llvm.org/pipermail/llvm-dev/2016-June/100462.html
Differential Revision: http://reviews.llvm.org/D21053
llvm-svn: 273729
2016-06-25 05:21:32 +08:00
|
|
|
void buildTypeIdentifierMap(
|
|
|
|
std::vector<VTableBits> &Bits,
|
|
|
|
DenseMap<Metadata *, std::set<TypeMemberInfo>> &TypeIdMap);
|
2016-12-09 09:10:11 +08:00
|
|
|
Constant *getPointerAtOffset(Constant *I, uint64_t Offset);
|
IR: New representation for CFI and virtual call optimization pass metadata.
The bitset metadata currently used in LLVM has a few problems:
1. It has the wrong name. The name "bitset" refers to an implementation
detail of one use of the metadata (i.e. its original use case, CFI).
This makes it harder to understand, as the name makes no sense in the
context of virtual call optimization.
2. It is represented using a global named metadata node, rather than
being directly associated with a global. This makes it harder to
manipulate the metadata when rebuilding global variables, summarise it
as part of ThinLTO and drop unused metadata when associated globals are
dropped. For this reason, CFI does not currently work correctly when
both CFI and vcall opt are enabled, as vcall opt needs to rebuild vtable
globals, and fails to associate metadata with the rebuilt globals. As I
understand it, the same problem could also affect ASan, which rebuilds
globals with a red zone.
This patch solves both of those problems in the following way:
1. Rename the metadata to "type metadata". This new name reflects how
the metadata is currently being used (i.e. to represent type information
for CFI and vtable opt). The new name is reflected in the name for the
associated intrinsic (llvm.type.test) and pass (LowerTypeTests).
2. Attach metadata directly to the globals that it pertains to, rather
than using the "llvm.bitsets" global metadata node as we are doing now.
This is done using the newly introduced capability to attach
metadata to global variables (r271348 and r271358).
See also: http://lists.llvm.org/pipermail/llvm-dev/2016-June/100462.html
Differential Revision: http://reviews.llvm.org/D21053
llvm-svn: 273729
2016-06-25 05:21:32 +08:00
|
|
|
bool
|
|
|
|
tryFindVirtualCallTargets(std::vector<VirtualCallTarget> &TargetsForSlot,
|
|
|
|
const std::set<TypeMemberInfo> &TypeMemberInfos,
|
|
|
|
uint64_t ByteOffset);
|
2017-02-16 05:56:51 +08:00
|
|
|
|
2017-03-04 09:31:01 +08:00
|
|
|
void applySingleImplDevirt(VTableSlotInfo &SlotInfo, Constant *TheFn,
|
|
|
|
bool &IsExported);
|
2016-08-12 03:09:02 +08:00
|
|
|
bool trySingleImplDevirt(MutableArrayRef<VirtualCallTarget> TargetsForSlot,
|
2017-03-04 09:31:01 +08:00
|
|
|
VTableSlotInfo &SlotInfo,
|
|
|
|
WholeProgramDevirtResolution *Res);
|
2017-02-16 05:56:51 +08:00
|
|
|
|
2016-02-10 06:50:34 +08:00
|
|
|
bool tryEvaluateFunctionsWithArgs(
|
|
|
|
MutableArrayRef<VirtualCallTarget> TargetsForSlot,
|
2017-02-16 05:56:51 +08:00
|
|
|
ArrayRef<uint64_t> Args);
|
|
|
|
|
|
|
|
void applyUniformRetValOpt(CallSiteInfo &CSInfo, StringRef FnName,
|
|
|
|
uint64_t TheRetVal);
|
|
|
|
bool tryUniformRetValOpt(MutableArrayRef<VirtualCallTarget> TargetsForSlot,
|
2017-03-04 09:34:53 +08:00
|
|
|
CallSiteInfo &CSInfo,
|
|
|
|
WholeProgramDevirtResolution::ByArg *Res);
|
2017-02-16 05:56:51 +08:00
|
|
|
|
2017-03-11 04:09:11 +08:00
|
|
|
// Returns the global symbol name that is used to export information about the
|
|
|
|
// given vtable slot and list of arguments.
|
|
|
|
std::string getGlobalName(VTableSlot Slot, ArrayRef<uint64_t> Args,
|
|
|
|
StringRef Name);
|
|
|
|
|
|
|
|
// This function is called during the export phase to create a symbol
|
|
|
|
// definition containing information about the given vtable slot and list of
|
|
|
|
// arguments.
|
|
|
|
void exportGlobal(VTableSlot Slot, ArrayRef<uint64_t> Args, StringRef Name,
|
|
|
|
Constant *C);
|
|
|
|
|
|
|
|
// This function is called during the import phase to create a reference to
|
|
|
|
// the symbol definition created during the export phase.
|
|
|
|
Constant *importGlobal(VTableSlot Slot, ArrayRef<uint64_t> Args,
|
2017-03-11 04:13:58 +08:00
|
|
|
StringRef Name, unsigned AbsWidth = 0);
|
2017-03-11 04:09:11 +08:00
|
|
|
|
2017-02-16 05:56:51 +08:00
|
|
|
void applyUniqueRetValOpt(CallSiteInfo &CSInfo, StringRef FnName, bool IsOne,
|
|
|
|
Constant *UniqueMemberAddr);
|
2016-02-10 06:50:34 +08:00
|
|
|
bool tryUniqueRetValOpt(unsigned BitWidth,
|
2016-08-12 03:09:02 +08:00
|
|
|
MutableArrayRef<VirtualCallTarget> TargetsForSlot,
|
2017-03-11 04:09:11 +08:00
|
|
|
CallSiteInfo &CSInfo,
|
|
|
|
WholeProgramDevirtResolution::ByArg *Res,
|
|
|
|
VTableSlot Slot, ArrayRef<uint64_t> Args);
|
2017-02-16 05:56:51 +08:00
|
|
|
|
|
|
|
void applyVirtualConstProp(CallSiteInfo &CSInfo, StringRef FnName,
|
|
|
|
Constant *Byte, Constant *Bit);
|
2016-02-10 06:50:34 +08:00
|
|
|
bool tryVirtualConstProp(MutableArrayRef<VirtualCallTarget> TargetsForSlot,
|
2017-03-04 09:34:53 +08:00
|
|
|
VTableSlotInfo &SlotInfo,
|
2017-03-11 04:09:11 +08:00
|
|
|
WholeProgramDevirtResolution *Res, VTableSlot Slot);
|
2016-02-10 06:50:34 +08:00
|
|
|
|
|
|
|
void rebuildGlobal(VTableBits &B);
|
|
|
|
|
2017-03-09 08:21:25 +08:00
|
|
|
// Apply the summary resolution for Slot to all virtual calls in SlotInfo.
|
|
|
|
void importResolution(VTableSlot Slot, VTableSlotInfo &SlotInfo);
|
|
|
|
|
|
|
|
// If we were able to eliminate all unsafe uses for a type checked load,
|
|
|
|
// eliminate the associated type tests by replacing them with true.
|
|
|
|
void removeRedundantTypeTests();
|
|
|
|
|
2016-02-10 06:50:34 +08:00
|
|
|
bool run();
|
2017-02-14 03:26:18 +08:00
|
|
|
|
|
|
|
// Lower the module using the action and summary passed as command line
|
|
|
|
// arguments. For testing purposes only.
|
2017-02-18 02:17:04 +08:00
|
|
|
static bool runForTesting(Module &M,
|
|
|
|
function_ref<AAResults &(Function &)> AARGetter);
|
2016-02-10 06:50:34 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
struct WholeProgramDevirt : public ModulePass {
|
|
|
|
static char ID;
|
2016-08-12 01:20:18 +08:00
|
|
|
|
2017-02-14 03:26:18 +08:00
|
|
|
bool UseCommandLine = false;
|
|
|
|
|
2017-03-23 02:22:59 +08:00
|
|
|
ModuleSummaryIndex *ExportSummary;
|
|
|
|
const ModuleSummaryIndex *ImportSummary;
|
2017-02-14 03:26:18 +08:00
|
|
|
|
|
|
|
WholeProgramDevirt() : ModulePass(ID), UseCommandLine(true) {
|
|
|
|
initializeWholeProgramDevirtPass(*PassRegistry::getPassRegistry());
|
|
|
|
}
|
|
|
|
|
2017-03-23 02:22:59 +08:00
|
|
|
WholeProgramDevirt(ModuleSummaryIndex *ExportSummary,
|
|
|
|
const ModuleSummaryIndex *ImportSummary)
|
|
|
|
: ModulePass(ID), ExportSummary(ExportSummary),
|
|
|
|
ImportSummary(ImportSummary) {
|
2016-02-10 06:50:34 +08:00
|
|
|
initializeWholeProgramDevirtPass(*PassRegistry::getPassRegistry());
|
|
|
|
}
|
2016-08-12 01:20:18 +08:00
|
|
|
|
|
|
|
bool runOnModule(Module &M) override {
|
2016-04-23 06:06:11 +08:00
|
|
|
if (skipModule(M))
|
|
|
|
return false;
|
2017-02-14 03:26:18 +08:00
|
|
|
if (UseCommandLine)
|
2017-02-18 02:17:04 +08:00
|
|
|
return DevirtModule::runForTesting(M, LegacyAARGetter(*this));
|
2017-03-23 02:22:59 +08:00
|
|
|
return DevirtModule(M, LegacyAARGetter(*this), ExportSummary, ImportSummary)
|
|
|
|
.run();
|
2017-02-18 02:17:04 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void getAnalysisUsage(AnalysisUsage &AU) const override {
|
|
|
|
AU.addRequired<AssumptionCacheTracker>();
|
|
|
|
AU.addRequired<TargetLibraryInfoWrapperPass>();
|
2016-04-23 06:06:11 +08:00
|
|
|
}
|
2016-02-10 06:50:34 +08:00
|
|
|
};
|
|
|
|
|
2016-08-12 01:20:18 +08:00
|
|
|
} // end anonymous namespace
|
2016-02-10 06:50:34 +08:00
|
|
|
|
2017-02-18 02:17:04 +08:00
|
|
|
INITIALIZE_PASS_BEGIN(WholeProgramDevirt, "wholeprogramdevirt",
|
|
|
|
"Whole program devirtualization", false, false)
|
|
|
|
INITIALIZE_PASS_DEPENDENCY(AssumptionCacheTracker)
|
|
|
|
INITIALIZE_PASS_DEPENDENCY(TargetLibraryInfoWrapperPass)
|
|
|
|
INITIALIZE_PASS_END(WholeProgramDevirt, "wholeprogramdevirt",
|
|
|
|
"Whole program devirtualization", false, false)
|
2016-02-10 06:50:34 +08:00
|
|
|
char WholeProgramDevirt::ID = 0;
|
|
|
|
|
2017-03-23 02:22:59 +08:00
|
|
|
ModulePass *
|
|
|
|
llvm::createWholeProgramDevirtPass(ModuleSummaryIndex *ExportSummary,
|
|
|
|
const ModuleSummaryIndex *ImportSummary) {
|
|
|
|
return new WholeProgramDevirt(ExportSummary, ImportSummary);
|
2016-02-10 06:50:34 +08:00
|
|
|
}
|
|
|
|
|
2016-06-17 08:11:01 +08:00
|
|
|
PreservedAnalyses WholeProgramDevirtPass::run(Module &M,
|
2017-02-18 02:17:04 +08:00
|
|
|
ModuleAnalysisManager &AM) {
|
|
|
|
auto &FAM = AM.getResult<FunctionAnalysisManagerModuleProxy>(M).getManager();
|
|
|
|
auto AARGetter = [&](Function &F) -> AAResults & {
|
|
|
|
return FAM.getResult<AAManager>(F);
|
|
|
|
};
|
2017-03-23 02:22:59 +08:00
|
|
|
if (!DevirtModule(M, AARGetter, nullptr, nullptr).run())
|
2016-06-15 05:44:19 +08:00
|
|
|
return PreservedAnalyses::all();
|
|
|
|
return PreservedAnalyses::none();
|
|
|
|
}
|
|
|
|
|
2017-02-18 02:17:04 +08:00
|
|
|
bool DevirtModule::runForTesting(
|
|
|
|
Module &M, function_ref<AAResults &(Function &)> AARGetter) {
|
2017-02-14 03:26:18 +08:00
|
|
|
ModuleSummaryIndex Summary;
|
|
|
|
|
|
|
|
// Handle the command-line summary arguments. This code is for testing
|
|
|
|
// purposes only, so we handle errors directly.
|
|
|
|
if (!ClReadSummary.empty()) {
|
|
|
|
ExitOnError ExitOnErr("-wholeprogramdevirt-read-summary: " + ClReadSummary +
|
|
|
|
": ");
|
|
|
|
auto ReadSummaryFile =
|
|
|
|
ExitOnErr(errorOrToExpected(MemoryBuffer::getFile(ClReadSummary)));
|
|
|
|
|
|
|
|
yaml::Input In(ReadSummaryFile->getBuffer());
|
|
|
|
In >> Summary;
|
|
|
|
ExitOnErr(errorCodeToError(In.error()));
|
|
|
|
}
|
|
|
|
|
2017-03-23 02:22:59 +08:00
|
|
|
bool Changed =
|
|
|
|
DevirtModule(
|
|
|
|
M, AARGetter,
|
|
|
|
ClSummaryAction == PassSummaryAction::Export ? &Summary : nullptr,
|
|
|
|
ClSummaryAction == PassSummaryAction::Import ? &Summary : nullptr)
|
|
|
|
.run();
|
2017-02-14 03:26:18 +08:00
|
|
|
|
|
|
|
if (!ClWriteSummary.empty()) {
|
|
|
|
ExitOnError ExitOnErr(
|
|
|
|
"-wholeprogramdevirt-write-summary: " + ClWriteSummary + ": ");
|
|
|
|
std::error_code EC;
|
|
|
|
raw_fd_ostream OS(ClWriteSummary, EC, sys::fs::F_Text);
|
|
|
|
ExitOnErr(errorCodeToError(EC));
|
|
|
|
|
|
|
|
yaml::Output Out(OS);
|
|
|
|
Out << Summary;
|
|
|
|
}
|
|
|
|
|
|
|
|
return Changed;
|
|
|
|
}
|
|
|
|
|
IR: New representation for CFI and virtual call optimization pass metadata.
The bitset metadata currently used in LLVM has a few problems:
1. It has the wrong name. The name "bitset" refers to an implementation
detail of one use of the metadata (i.e. its original use case, CFI).
This makes it harder to understand, as the name makes no sense in the
context of virtual call optimization.
2. It is represented using a global named metadata node, rather than
being directly associated with a global. This makes it harder to
manipulate the metadata when rebuilding global variables, summarise it
as part of ThinLTO and drop unused metadata when associated globals are
dropped. For this reason, CFI does not currently work correctly when
both CFI and vcall opt are enabled, as vcall opt needs to rebuild vtable
globals, and fails to associate metadata with the rebuilt globals. As I
understand it, the same problem could also affect ASan, which rebuilds
globals with a red zone.
This patch solves both of those problems in the following way:
1. Rename the metadata to "type metadata". This new name reflects how
the metadata is currently being used (i.e. to represent type information
for CFI and vtable opt). The new name is reflected in the name for the
associated intrinsic (llvm.type.test) and pass (LowerTypeTests).
2. Attach metadata directly to the globals that it pertains to, rather
than using the "llvm.bitsets" global metadata node as we are doing now.
This is done using the newly introduced capability to attach
metadata to global variables (r271348 and r271358).
See also: http://lists.llvm.org/pipermail/llvm-dev/2016-June/100462.html
Differential Revision: http://reviews.llvm.org/D21053
llvm-svn: 273729
2016-06-25 05:21:32 +08:00
|
|
|
void DevirtModule::buildTypeIdentifierMap(
|
2016-02-10 06:50:34 +08:00
|
|
|
std::vector<VTableBits> &Bits,
|
IR: New representation for CFI and virtual call optimization pass metadata.
The bitset metadata currently used in LLVM has a few problems:
1. It has the wrong name. The name "bitset" refers to an implementation
detail of one use of the metadata (i.e. its original use case, CFI).
This makes it harder to understand, as the name makes no sense in the
context of virtual call optimization.
2. It is represented using a global named metadata node, rather than
being directly associated with a global. This makes it harder to
manipulate the metadata when rebuilding global variables, summarise it
as part of ThinLTO and drop unused metadata when associated globals are
dropped. For this reason, CFI does not currently work correctly when
both CFI and vcall opt are enabled, as vcall opt needs to rebuild vtable
globals, and fails to associate metadata with the rebuilt globals. As I
understand it, the same problem could also affect ASan, which rebuilds
globals with a red zone.
This patch solves both of those problems in the following way:
1. Rename the metadata to "type metadata". This new name reflects how
the metadata is currently being used (i.e. to represent type information
for CFI and vtable opt). The new name is reflected in the name for the
associated intrinsic (llvm.type.test) and pass (LowerTypeTests).
2. Attach metadata directly to the globals that it pertains to, rather
than using the "llvm.bitsets" global metadata node as we are doing now.
This is done using the newly introduced capability to attach
metadata to global variables (r271348 and r271358).
See also: http://lists.llvm.org/pipermail/llvm-dev/2016-June/100462.html
Differential Revision: http://reviews.llvm.org/D21053
llvm-svn: 273729
2016-06-25 05:21:32 +08:00
|
|
|
DenseMap<Metadata *, std::set<TypeMemberInfo>> &TypeIdMap) {
|
2016-02-10 06:50:34 +08:00
|
|
|
DenseMap<GlobalVariable *, VTableBits *> GVToBits;
|
IR: New representation for CFI and virtual call optimization pass metadata.
The bitset metadata currently used in LLVM has a few problems:
1. It has the wrong name. The name "bitset" refers to an implementation
detail of one use of the metadata (i.e. its original use case, CFI).
This makes it harder to understand, as the name makes no sense in the
context of virtual call optimization.
2. It is represented using a global named metadata node, rather than
being directly associated with a global. This makes it harder to
manipulate the metadata when rebuilding global variables, summarise it
as part of ThinLTO and drop unused metadata when associated globals are
dropped. For this reason, CFI does not currently work correctly when
both CFI and vcall opt are enabled, as vcall opt needs to rebuild vtable
globals, and fails to associate metadata with the rebuilt globals. As I
understand it, the same problem could also affect ASan, which rebuilds
globals with a red zone.
This patch solves both of those problems in the following way:
1. Rename the metadata to "type metadata". This new name reflects how
the metadata is currently being used (i.e. to represent type information
for CFI and vtable opt). The new name is reflected in the name for the
associated intrinsic (llvm.type.test) and pass (LowerTypeTests).
2. Attach metadata directly to the globals that it pertains to, rather
than using the "llvm.bitsets" global metadata node as we are doing now.
This is done using the newly introduced capability to attach
metadata to global variables (r271348 and r271358).
See also: http://lists.llvm.org/pipermail/llvm-dev/2016-June/100462.html
Differential Revision: http://reviews.llvm.org/D21053
llvm-svn: 273729
2016-06-25 05:21:32 +08:00
|
|
|
Bits.reserve(M.getGlobalList().size());
|
|
|
|
SmallVector<MDNode *, 2> Types;
|
|
|
|
for (GlobalVariable &GV : M.globals()) {
|
|
|
|
Types.clear();
|
|
|
|
GV.getMetadata(LLVMContext::MD_type, Types);
|
|
|
|
if (Types.empty())
|
2016-02-10 06:50:34 +08:00
|
|
|
continue;
|
|
|
|
|
IR: New representation for CFI and virtual call optimization pass metadata.
The bitset metadata currently used in LLVM has a few problems:
1. It has the wrong name. The name "bitset" refers to an implementation
detail of one use of the metadata (i.e. its original use case, CFI).
This makes it harder to understand, as the name makes no sense in the
context of virtual call optimization.
2. It is represented using a global named metadata node, rather than
being directly associated with a global. This makes it harder to
manipulate the metadata when rebuilding global variables, summarise it
as part of ThinLTO and drop unused metadata when associated globals are
dropped. For this reason, CFI does not currently work correctly when
both CFI and vcall opt are enabled, as vcall opt needs to rebuild vtable
globals, and fails to associate metadata with the rebuilt globals. As I
understand it, the same problem could also affect ASan, which rebuilds
globals with a red zone.
This patch solves both of those problems in the following way:
1. Rename the metadata to "type metadata". This new name reflects how
the metadata is currently being used (i.e. to represent type information
for CFI and vtable opt). The new name is reflected in the name for the
associated intrinsic (llvm.type.test) and pass (LowerTypeTests).
2. Attach metadata directly to the globals that it pertains to, rather
than using the "llvm.bitsets" global metadata node as we are doing now.
This is done using the newly introduced capability to attach
metadata to global variables (r271348 and r271358).
See also: http://lists.llvm.org/pipermail/llvm-dev/2016-June/100462.html
Differential Revision: http://reviews.llvm.org/D21053
llvm-svn: 273729
2016-06-25 05:21:32 +08:00
|
|
|
VTableBits *&BitsPtr = GVToBits[&GV];
|
2016-02-10 06:50:34 +08:00
|
|
|
if (!BitsPtr) {
|
|
|
|
Bits.emplace_back();
|
IR: New representation for CFI and virtual call optimization pass metadata.
The bitset metadata currently used in LLVM has a few problems:
1. It has the wrong name. The name "bitset" refers to an implementation
detail of one use of the metadata (i.e. its original use case, CFI).
This makes it harder to understand, as the name makes no sense in the
context of virtual call optimization.
2. It is represented using a global named metadata node, rather than
being directly associated with a global. This makes it harder to
manipulate the metadata when rebuilding global variables, summarise it
as part of ThinLTO and drop unused metadata when associated globals are
dropped. For this reason, CFI does not currently work correctly when
both CFI and vcall opt are enabled, as vcall opt needs to rebuild vtable
globals, and fails to associate metadata with the rebuilt globals. As I
understand it, the same problem could also affect ASan, which rebuilds
globals with a red zone.
This patch solves both of those problems in the following way:
1. Rename the metadata to "type metadata". This new name reflects how
the metadata is currently being used (i.e. to represent type information
for CFI and vtable opt). The new name is reflected in the name for the
associated intrinsic (llvm.type.test) and pass (LowerTypeTests).
2. Attach metadata directly to the globals that it pertains to, rather
than using the "llvm.bitsets" global metadata node as we are doing now.
This is done using the newly introduced capability to attach
metadata to global variables (r271348 and r271358).
See also: http://lists.llvm.org/pipermail/llvm-dev/2016-June/100462.html
Differential Revision: http://reviews.llvm.org/D21053
llvm-svn: 273729
2016-06-25 05:21:32 +08:00
|
|
|
Bits.back().GV = &GV;
|
|
|
|
Bits.back().ObjectSize =
|
|
|
|
M.getDataLayout().getTypeAllocSize(GV.getInitializer()->getType());
|
2016-02-10 06:50:34 +08:00
|
|
|
BitsPtr = &Bits.back();
|
|
|
|
}
|
IR: New representation for CFI and virtual call optimization pass metadata.
The bitset metadata currently used in LLVM has a few problems:
1. It has the wrong name. The name "bitset" refers to an implementation
detail of one use of the metadata (i.e. its original use case, CFI).
This makes it harder to understand, as the name makes no sense in the
context of virtual call optimization.
2. It is represented using a global named metadata node, rather than
being directly associated with a global. This makes it harder to
manipulate the metadata when rebuilding global variables, summarise it
as part of ThinLTO and drop unused metadata when associated globals are
dropped. For this reason, CFI does not currently work correctly when
both CFI and vcall opt are enabled, as vcall opt needs to rebuild vtable
globals, and fails to associate metadata with the rebuilt globals. As I
understand it, the same problem could also affect ASan, which rebuilds
globals with a red zone.
This patch solves both of those problems in the following way:
1. Rename the metadata to "type metadata". This new name reflects how
the metadata is currently being used (i.e. to represent type information
for CFI and vtable opt). The new name is reflected in the name for the
associated intrinsic (llvm.type.test) and pass (LowerTypeTests).
2. Attach metadata directly to the globals that it pertains to, rather
than using the "llvm.bitsets" global metadata node as we are doing now.
This is done using the newly introduced capability to attach
metadata to global variables (r271348 and r271358).
See also: http://lists.llvm.org/pipermail/llvm-dev/2016-June/100462.html
Differential Revision: http://reviews.llvm.org/D21053
llvm-svn: 273729
2016-06-25 05:21:32 +08:00
|
|
|
|
|
|
|
for (MDNode *Type : Types) {
|
|
|
|
auto TypeID = Type->getOperand(1).get();
|
|
|
|
|
|
|
|
uint64_t Offset =
|
|
|
|
cast<ConstantInt>(
|
|
|
|
cast<ConstantAsMetadata>(Type->getOperand(0))->getValue())
|
|
|
|
->getZExtValue();
|
|
|
|
|
|
|
|
TypeIdMap[TypeID].insert({BitsPtr, Offset});
|
|
|
|
}
|
2016-02-10 06:50:34 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-12-09 09:10:11 +08:00
|
|
|
Constant *DevirtModule::getPointerAtOffset(Constant *I, uint64_t Offset) {
|
|
|
|
if (I->getType()->isPointerTy()) {
|
|
|
|
if (Offset == 0)
|
|
|
|
return I;
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
2016-12-09 08:33:27 +08:00
|
|
|
const DataLayout &DL = M.getDataLayout();
|
|
|
|
|
|
|
|
if (auto *C = dyn_cast<ConstantStruct>(I)) {
|
|
|
|
const StructLayout *SL = DL.getStructLayout(C->getType());
|
|
|
|
if (Offset >= SL->getSizeInBytes())
|
|
|
|
return nullptr;
|
|
|
|
|
2016-12-09 09:10:11 +08:00
|
|
|
unsigned Op = SL->getElementContainingOffset(Offset);
|
|
|
|
return getPointerAtOffset(cast<Constant>(I->getOperand(Op)),
|
|
|
|
Offset - SL->getElementOffset(Op));
|
|
|
|
}
|
|
|
|
if (auto *C = dyn_cast<ConstantArray>(I)) {
|
2016-12-09 08:33:27 +08:00
|
|
|
ArrayType *VTableTy = C->getType();
|
|
|
|
uint64_t ElemSize = DL.getTypeAllocSize(VTableTy->getElementType());
|
|
|
|
|
2016-12-09 09:10:11 +08:00
|
|
|
unsigned Op = Offset / ElemSize;
|
2016-12-09 08:33:27 +08:00
|
|
|
if (Op >= C->getNumOperands())
|
|
|
|
return nullptr;
|
|
|
|
|
2016-12-09 09:10:11 +08:00
|
|
|
return getPointerAtOffset(cast<Constant>(I->getOperand(Op)),
|
|
|
|
Offset % ElemSize);
|
|
|
|
}
|
|
|
|
return nullptr;
|
2016-12-09 08:33:27 +08:00
|
|
|
}
|
|
|
|
|
2016-02-10 06:50:34 +08:00
|
|
|
bool DevirtModule::tryFindVirtualCallTargets(
|
|
|
|
std::vector<VirtualCallTarget> &TargetsForSlot,
|
IR: New representation for CFI and virtual call optimization pass metadata.
The bitset metadata currently used in LLVM has a few problems:
1. It has the wrong name. The name "bitset" refers to an implementation
detail of one use of the metadata (i.e. its original use case, CFI).
This makes it harder to understand, as the name makes no sense in the
context of virtual call optimization.
2. It is represented using a global named metadata node, rather than
being directly associated with a global. This makes it harder to
manipulate the metadata when rebuilding global variables, summarise it
as part of ThinLTO and drop unused metadata when associated globals are
dropped. For this reason, CFI does not currently work correctly when
both CFI and vcall opt are enabled, as vcall opt needs to rebuild vtable
globals, and fails to associate metadata with the rebuilt globals. As I
understand it, the same problem could also affect ASan, which rebuilds
globals with a red zone.
This patch solves both of those problems in the following way:
1. Rename the metadata to "type metadata". This new name reflects how
the metadata is currently being used (i.e. to represent type information
for CFI and vtable opt). The new name is reflected in the name for the
associated intrinsic (llvm.type.test) and pass (LowerTypeTests).
2. Attach metadata directly to the globals that it pertains to, rather
than using the "llvm.bitsets" global metadata node as we are doing now.
This is done using the newly introduced capability to attach
metadata to global variables (r271348 and r271358).
See also: http://lists.llvm.org/pipermail/llvm-dev/2016-June/100462.html
Differential Revision: http://reviews.llvm.org/D21053
llvm-svn: 273729
2016-06-25 05:21:32 +08:00
|
|
|
const std::set<TypeMemberInfo> &TypeMemberInfos, uint64_t ByteOffset) {
|
|
|
|
for (const TypeMemberInfo &TM : TypeMemberInfos) {
|
|
|
|
if (!TM.Bits->GV->isConstant())
|
2016-02-10 06:50:34 +08:00
|
|
|
return false;
|
|
|
|
|
2016-12-09 09:10:11 +08:00
|
|
|
Constant *Ptr = getPointerAtOffset(TM.Bits->GV->getInitializer(),
|
|
|
|
TM.Offset + ByteOffset);
|
|
|
|
if (!Ptr)
|
2016-02-10 06:50:34 +08:00
|
|
|
return false;
|
|
|
|
|
2016-12-09 09:10:11 +08:00
|
|
|
auto Fn = dyn_cast<Function>(Ptr->stripPointerCasts());
|
2016-02-10 06:50:34 +08:00
|
|
|
if (!Fn)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// We can disregard __cxa_pure_virtual as a possible call target, as
|
|
|
|
// calls to pure virtuals are UB.
|
|
|
|
if (Fn->getName() == "__cxa_pure_virtual")
|
|
|
|
continue;
|
|
|
|
|
IR: New representation for CFI and virtual call optimization pass metadata.
The bitset metadata currently used in LLVM has a few problems:
1. It has the wrong name. The name "bitset" refers to an implementation
detail of one use of the metadata (i.e. its original use case, CFI).
This makes it harder to understand, as the name makes no sense in the
context of virtual call optimization.
2. It is represented using a global named metadata node, rather than
being directly associated with a global. This makes it harder to
manipulate the metadata when rebuilding global variables, summarise it
as part of ThinLTO and drop unused metadata when associated globals are
dropped. For this reason, CFI does not currently work correctly when
both CFI and vcall opt are enabled, as vcall opt needs to rebuild vtable
globals, and fails to associate metadata with the rebuilt globals. As I
understand it, the same problem could also affect ASan, which rebuilds
globals with a red zone.
This patch solves both of those problems in the following way:
1. Rename the metadata to "type metadata". This new name reflects how
the metadata is currently being used (i.e. to represent type information
for CFI and vtable opt). The new name is reflected in the name for the
associated intrinsic (llvm.type.test) and pass (LowerTypeTests).
2. Attach metadata directly to the globals that it pertains to, rather
than using the "llvm.bitsets" global metadata node as we are doing now.
This is done using the newly introduced capability to attach
metadata to global variables (r271348 and r271358).
See also: http://lists.llvm.org/pipermail/llvm-dev/2016-June/100462.html
Differential Revision: http://reviews.llvm.org/D21053
llvm-svn: 273729
2016-06-25 05:21:32 +08:00
|
|
|
TargetsForSlot.push_back({Fn, &TM});
|
2016-02-10 06:50:34 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// Give up if we couldn't find any targets.
|
|
|
|
return !TargetsForSlot.empty();
|
|
|
|
}
|
|
|
|
|
2017-02-16 05:56:51 +08:00
|
|
|
void DevirtModule::applySingleImplDevirt(VTableSlotInfo &SlotInfo,
|
2017-03-04 09:31:01 +08:00
|
|
|
Constant *TheFn, bool &IsExported) {
|
2017-02-16 05:56:51 +08:00
|
|
|
auto Apply = [&](CallSiteInfo &CSInfo) {
|
|
|
|
for (auto &&VCallSite : CSInfo.CallSites) {
|
|
|
|
if (RemarksEnabled)
|
|
|
|
VCallSite.emitRemark("single-impl", TheFn->getName());
|
|
|
|
VCallSite.CS.setCalledFunction(ConstantExpr::getBitCast(
|
|
|
|
TheFn, VCallSite.CS.getCalledValue()->getType()));
|
|
|
|
// This use is no longer unsafe.
|
|
|
|
if (VCallSite.NumUnsafeUses)
|
|
|
|
--*VCallSite.NumUnsafeUses;
|
|
|
|
}
|
2017-03-04 09:31:01 +08:00
|
|
|
if (CSInfo.isExported()) {
|
|
|
|
IsExported = true;
|
2017-03-11 04:09:11 +08:00
|
|
|
CSInfo.markDevirt();
|
2017-03-04 09:31:01 +08:00
|
|
|
}
|
2017-02-16 05:56:51 +08:00
|
|
|
};
|
|
|
|
Apply(SlotInfo.CSInfo);
|
|
|
|
for (auto &P : SlotInfo.ConstCSInfo)
|
|
|
|
Apply(P.second);
|
|
|
|
}
|
|
|
|
|
2017-02-15 10:13:08 +08:00
|
|
|
bool DevirtModule::trySingleImplDevirt(
|
|
|
|
MutableArrayRef<VirtualCallTarget> TargetsForSlot,
|
2017-03-04 09:31:01 +08:00
|
|
|
VTableSlotInfo &SlotInfo, WholeProgramDevirtResolution *Res) {
|
2017-02-15 10:13:08 +08:00
|
|
|
// See if the program contains a single implementation of this virtual
|
|
|
|
// function.
|
|
|
|
Function *TheFn = TargetsForSlot[0].Fn;
|
|
|
|
for (auto &&Target : TargetsForSlot)
|
|
|
|
if (TheFn != Target.Fn)
|
|
|
|
return false;
|
|
|
|
|
2017-02-16 05:56:51 +08:00
|
|
|
// If so, update each call site to call that implementation directly.
|
2017-02-15 10:13:08 +08:00
|
|
|
if (RemarksEnabled)
|
|
|
|
TargetsForSlot[0].WasDevirt = true;
|
2017-03-04 09:31:01 +08:00
|
|
|
|
|
|
|
bool IsExported = false;
|
|
|
|
applySingleImplDevirt(SlotInfo, TheFn, IsExported);
|
|
|
|
if (!IsExported)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
// If the only implementation has local linkage, we must promote to external
|
|
|
|
// to make it visible to thin LTO objects. We can only get here during the
|
|
|
|
// ThinLTO export phase.
|
|
|
|
if (TheFn->hasLocalLinkage()) {
|
|
|
|
TheFn->setLinkage(GlobalValue::ExternalLinkage);
|
|
|
|
TheFn->setVisibility(GlobalValue::HiddenVisibility);
|
|
|
|
TheFn->setName(TheFn->getName() + "$merged");
|
|
|
|
}
|
|
|
|
|
|
|
|
Res->TheKind = WholeProgramDevirtResolution::SingleImpl;
|
|
|
|
Res->SingleImplName = TheFn->getName();
|
|
|
|
|
2016-02-10 06:50:34 +08:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool DevirtModule::tryEvaluateFunctionsWithArgs(
|
|
|
|
MutableArrayRef<VirtualCallTarget> TargetsForSlot,
|
2017-02-16 05:56:51 +08:00
|
|
|
ArrayRef<uint64_t> Args) {
|
2016-02-10 06:50:34 +08:00
|
|
|
// Evaluate each function and store the result in each target's RetVal
|
|
|
|
// field.
|
|
|
|
for (VirtualCallTarget &Target : TargetsForSlot) {
|
|
|
|
if (Target.Fn->arg_size() != Args.size() + 1)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
Evaluator Eval(M.getDataLayout(), nullptr);
|
|
|
|
SmallVector<Constant *, 2> EvalArgs;
|
|
|
|
EvalArgs.push_back(
|
|
|
|
Constant::getNullValue(Target.Fn->getFunctionType()->getParamType(0)));
|
2017-02-16 05:56:51 +08:00
|
|
|
for (unsigned I = 0; I != Args.size(); ++I) {
|
|
|
|
auto *ArgTy = dyn_cast<IntegerType>(
|
|
|
|
Target.Fn->getFunctionType()->getParamType(I + 1));
|
|
|
|
if (!ArgTy)
|
|
|
|
return false;
|
|
|
|
EvalArgs.push_back(ConstantInt::get(ArgTy, Args[I]));
|
|
|
|
}
|
|
|
|
|
2016-02-10 06:50:34 +08:00
|
|
|
Constant *RetVal;
|
|
|
|
if (!Eval.EvaluateFunction(Target.Fn, RetVal, EvalArgs) ||
|
|
|
|
!isa<ConstantInt>(RetVal))
|
|
|
|
return false;
|
|
|
|
Target.RetVal = cast<ConstantInt>(RetVal)->getZExtValue();
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2017-02-16 05:56:51 +08:00
|
|
|
void DevirtModule::applyUniformRetValOpt(CallSiteInfo &CSInfo, StringRef FnName,
|
|
|
|
uint64_t TheRetVal) {
|
|
|
|
for (auto Call : CSInfo.CallSites)
|
|
|
|
Call.replaceAndErase(
|
|
|
|
"uniform-ret-val", FnName, RemarksEnabled,
|
|
|
|
ConstantInt::get(cast<IntegerType>(Call.CS.getType()), TheRetVal));
|
2017-03-11 04:09:11 +08:00
|
|
|
CSInfo.markDevirt();
|
2017-02-16 05:56:51 +08:00
|
|
|
}
|
|
|
|
|
2016-02-10 06:50:34 +08:00
|
|
|
bool DevirtModule::tryUniformRetValOpt(
|
2017-03-04 09:34:53 +08:00
|
|
|
MutableArrayRef<VirtualCallTarget> TargetsForSlot, CallSiteInfo &CSInfo,
|
|
|
|
WholeProgramDevirtResolution::ByArg *Res) {
|
2016-02-10 06:50:34 +08:00
|
|
|
// Uniform return value optimization. If all functions return the same
|
|
|
|
// constant, replace all calls with that constant.
|
|
|
|
uint64_t TheRetVal = TargetsForSlot[0].RetVal;
|
|
|
|
for (const VirtualCallTarget &Target : TargetsForSlot)
|
|
|
|
if (Target.RetVal != TheRetVal)
|
|
|
|
return false;
|
|
|
|
|
2017-03-04 09:34:53 +08:00
|
|
|
if (CSInfo.isExported()) {
|
|
|
|
Res->TheKind = WholeProgramDevirtResolution::ByArg::UniformRetVal;
|
|
|
|
Res->Info = TheRetVal;
|
|
|
|
}
|
|
|
|
|
2017-02-16 05:56:51 +08:00
|
|
|
applyUniformRetValOpt(CSInfo, TargetsForSlot[0].Fn->getName(), TheRetVal);
|
2016-08-12 03:09:02 +08:00
|
|
|
if (RemarksEnabled)
|
|
|
|
for (auto &&Target : TargetsForSlot)
|
|
|
|
Target.WasDevirt = true;
|
2016-02-10 06:50:34 +08:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2017-03-11 04:09:11 +08:00
|
|
|
std::string DevirtModule::getGlobalName(VTableSlot Slot,
|
|
|
|
ArrayRef<uint64_t> Args,
|
|
|
|
StringRef Name) {
|
|
|
|
std::string FullName = "__typeid_";
|
|
|
|
raw_string_ostream OS(FullName);
|
|
|
|
OS << cast<MDString>(Slot.TypeID)->getString() << '_' << Slot.ByteOffset;
|
|
|
|
for (uint64_t Arg : Args)
|
|
|
|
OS << '_' << Arg;
|
|
|
|
OS << '_' << Name;
|
|
|
|
return OS.str();
|
|
|
|
}
|
|
|
|
|
|
|
|
void DevirtModule::exportGlobal(VTableSlot Slot, ArrayRef<uint64_t> Args,
|
|
|
|
StringRef Name, Constant *C) {
|
|
|
|
GlobalAlias *GA = GlobalAlias::create(Int8Ty, 0, GlobalValue::ExternalLinkage,
|
|
|
|
getGlobalName(Slot, Args, Name), C, &M);
|
|
|
|
GA->setVisibility(GlobalValue::HiddenVisibility);
|
|
|
|
}
|
|
|
|
|
|
|
|
Constant *DevirtModule::importGlobal(VTableSlot Slot, ArrayRef<uint64_t> Args,
|
2017-03-11 04:13:58 +08:00
|
|
|
StringRef Name, unsigned AbsWidth) {
|
2017-03-11 04:09:11 +08:00
|
|
|
Constant *C = M.getOrInsertGlobal(getGlobalName(Slot, Args, Name), Int8Ty);
|
|
|
|
auto *GV = dyn_cast<GlobalVariable>(C);
|
2017-03-11 04:13:58 +08:00
|
|
|
// We only need to set metadata if the global is newly created, in which
|
|
|
|
// case it would not have hidden visibility.
|
|
|
|
if (!GV || GV->getVisibility() == GlobalValue::HiddenVisibility)
|
2017-03-11 04:09:11 +08:00
|
|
|
return C;
|
2017-03-11 04:13:58 +08:00
|
|
|
|
2017-03-11 04:09:11 +08:00
|
|
|
GV->setVisibility(GlobalValue::HiddenVisibility);
|
2017-03-11 04:13:58 +08:00
|
|
|
auto SetAbsRange = [&](uint64_t Min, uint64_t Max) {
|
|
|
|
auto *MinC = ConstantAsMetadata::get(ConstantInt::get(IntPtrTy, Min));
|
|
|
|
auto *MaxC = ConstantAsMetadata::get(ConstantInt::get(IntPtrTy, Max));
|
|
|
|
GV->setMetadata(LLVMContext::MD_absolute_symbol,
|
|
|
|
MDNode::get(M.getContext(), {MinC, MaxC}));
|
|
|
|
};
|
|
|
|
if (AbsWidth == IntPtrTy->getBitWidth())
|
|
|
|
SetAbsRange(~0ull, ~0ull); // Full set.
|
|
|
|
else if (AbsWidth)
|
|
|
|
SetAbsRange(0, 1ull << AbsWidth);
|
2017-03-11 04:09:11 +08:00
|
|
|
return GV;
|
|
|
|
}
|
|
|
|
|
2017-02-16 05:56:51 +08:00
|
|
|
void DevirtModule::applyUniqueRetValOpt(CallSiteInfo &CSInfo, StringRef FnName,
|
|
|
|
bool IsOne,
|
|
|
|
Constant *UniqueMemberAddr) {
|
|
|
|
for (auto &&Call : CSInfo.CallSites) {
|
|
|
|
IRBuilder<> B(Call.CS.getInstruction());
|
|
|
|
Value *Cmp = B.CreateICmp(IsOne ? ICmpInst::ICMP_EQ : ICmpInst::ICMP_NE,
|
|
|
|
Call.VTable, UniqueMemberAddr);
|
|
|
|
Cmp = B.CreateZExt(Cmp, Call.CS->getType());
|
|
|
|
Call.replaceAndErase("unique-ret-val", FnName, RemarksEnabled, Cmp);
|
|
|
|
}
|
2017-03-11 04:09:11 +08:00
|
|
|
CSInfo.markDevirt();
|
2017-02-16 05:56:51 +08:00
|
|
|
}
|
|
|
|
|
2016-02-10 06:50:34 +08:00
|
|
|
bool DevirtModule::tryUniqueRetValOpt(
|
2016-08-12 03:09:02 +08:00
|
|
|
unsigned BitWidth, MutableArrayRef<VirtualCallTarget> TargetsForSlot,
|
2017-03-11 04:09:11 +08:00
|
|
|
CallSiteInfo &CSInfo, WholeProgramDevirtResolution::ByArg *Res,
|
|
|
|
VTableSlot Slot, ArrayRef<uint64_t> Args) {
|
2016-02-10 06:50:34 +08:00
|
|
|
// IsOne controls whether we look for a 0 or a 1.
|
|
|
|
auto tryUniqueRetValOptFor = [&](bool IsOne) {
|
2016-08-12 01:20:18 +08:00
|
|
|
const TypeMemberInfo *UniqueMember = nullptr;
|
2016-02-10 06:50:34 +08:00
|
|
|
for (const VirtualCallTarget &Target : TargetsForSlot) {
|
2016-03-08 11:50:36 +08:00
|
|
|
if (Target.RetVal == (IsOne ? 1 : 0)) {
|
IR: New representation for CFI and virtual call optimization pass metadata.
The bitset metadata currently used in LLVM has a few problems:
1. It has the wrong name. The name "bitset" refers to an implementation
detail of one use of the metadata (i.e. its original use case, CFI).
This makes it harder to understand, as the name makes no sense in the
context of virtual call optimization.
2. It is represented using a global named metadata node, rather than
being directly associated with a global. This makes it harder to
manipulate the metadata when rebuilding global variables, summarise it
as part of ThinLTO and drop unused metadata when associated globals are
dropped. For this reason, CFI does not currently work correctly when
both CFI and vcall opt are enabled, as vcall opt needs to rebuild vtable
globals, and fails to associate metadata with the rebuilt globals. As I
understand it, the same problem could also affect ASan, which rebuilds
globals with a red zone.
This patch solves both of those problems in the following way:
1. Rename the metadata to "type metadata". This new name reflects how
the metadata is currently being used (i.e. to represent type information
for CFI and vtable opt). The new name is reflected in the name for the
associated intrinsic (llvm.type.test) and pass (LowerTypeTests).
2. Attach metadata directly to the globals that it pertains to, rather
than using the "llvm.bitsets" global metadata node as we are doing now.
This is done using the newly introduced capability to attach
metadata to global variables (r271348 and r271358).
See also: http://lists.llvm.org/pipermail/llvm-dev/2016-June/100462.html
Differential Revision: http://reviews.llvm.org/D21053
llvm-svn: 273729
2016-06-25 05:21:32 +08:00
|
|
|
if (UniqueMember)
|
2016-02-10 06:50:34 +08:00
|
|
|
return false;
|
IR: New representation for CFI and virtual call optimization pass metadata.
The bitset metadata currently used in LLVM has a few problems:
1. It has the wrong name. The name "bitset" refers to an implementation
detail of one use of the metadata (i.e. its original use case, CFI).
This makes it harder to understand, as the name makes no sense in the
context of virtual call optimization.
2. It is represented using a global named metadata node, rather than
being directly associated with a global. This makes it harder to
manipulate the metadata when rebuilding global variables, summarise it
as part of ThinLTO and drop unused metadata when associated globals are
dropped. For this reason, CFI does not currently work correctly when
both CFI and vcall opt are enabled, as vcall opt needs to rebuild vtable
globals, and fails to associate metadata with the rebuilt globals. As I
understand it, the same problem could also affect ASan, which rebuilds
globals with a red zone.
This patch solves both of those problems in the following way:
1. Rename the metadata to "type metadata". This new name reflects how
the metadata is currently being used (i.e. to represent type information
for CFI and vtable opt). The new name is reflected in the name for the
associated intrinsic (llvm.type.test) and pass (LowerTypeTests).
2. Attach metadata directly to the globals that it pertains to, rather
than using the "llvm.bitsets" global metadata node as we are doing now.
This is done using the newly introduced capability to attach
metadata to global variables (r271348 and r271358).
See also: http://lists.llvm.org/pipermail/llvm-dev/2016-June/100462.html
Differential Revision: http://reviews.llvm.org/D21053
llvm-svn: 273729
2016-06-25 05:21:32 +08:00
|
|
|
UniqueMember = Target.TM;
|
2016-02-10 06:50:34 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
IR: New representation for CFI and virtual call optimization pass metadata.
The bitset metadata currently used in LLVM has a few problems:
1. It has the wrong name. The name "bitset" refers to an implementation
detail of one use of the metadata (i.e. its original use case, CFI).
This makes it harder to understand, as the name makes no sense in the
context of virtual call optimization.
2. It is represented using a global named metadata node, rather than
being directly associated with a global. This makes it harder to
manipulate the metadata when rebuilding global variables, summarise it
as part of ThinLTO and drop unused metadata when associated globals are
dropped. For this reason, CFI does not currently work correctly when
both CFI and vcall opt are enabled, as vcall opt needs to rebuild vtable
globals, and fails to associate metadata with the rebuilt globals. As I
understand it, the same problem could also affect ASan, which rebuilds
globals with a red zone.
This patch solves both of those problems in the following way:
1. Rename the metadata to "type metadata". This new name reflects how
the metadata is currently being used (i.e. to represent type information
for CFI and vtable opt). The new name is reflected in the name for the
associated intrinsic (llvm.type.test) and pass (LowerTypeTests).
2. Attach metadata directly to the globals that it pertains to, rather
than using the "llvm.bitsets" global metadata node as we are doing now.
This is done using the newly introduced capability to attach
metadata to global variables (r271348 and r271358).
See also: http://lists.llvm.org/pipermail/llvm-dev/2016-June/100462.html
Differential Revision: http://reviews.llvm.org/D21053
llvm-svn: 273729
2016-06-25 05:21:32 +08:00
|
|
|
// We should have found a unique member or bailed out by now. We already
|
2016-02-10 06:50:34 +08:00
|
|
|
// checked for a uniform return value in tryUniformRetValOpt.
|
IR: New representation for CFI and virtual call optimization pass metadata.
The bitset metadata currently used in LLVM has a few problems:
1. It has the wrong name. The name "bitset" refers to an implementation
detail of one use of the metadata (i.e. its original use case, CFI).
This makes it harder to understand, as the name makes no sense in the
context of virtual call optimization.
2. It is represented using a global named metadata node, rather than
being directly associated with a global. This makes it harder to
manipulate the metadata when rebuilding global variables, summarise it
as part of ThinLTO and drop unused metadata when associated globals are
dropped. For this reason, CFI does not currently work correctly when
both CFI and vcall opt are enabled, as vcall opt needs to rebuild vtable
globals, and fails to associate metadata with the rebuilt globals. As I
understand it, the same problem could also affect ASan, which rebuilds
globals with a red zone.
This patch solves both of those problems in the following way:
1. Rename the metadata to "type metadata". This new name reflects how
the metadata is currently being used (i.e. to represent type information
for CFI and vtable opt). The new name is reflected in the name for the
associated intrinsic (llvm.type.test) and pass (LowerTypeTests).
2. Attach metadata directly to the globals that it pertains to, rather
than using the "llvm.bitsets" global metadata node as we are doing now.
This is done using the newly introduced capability to attach
metadata to global variables (r271348 and r271358).
See also: http://lists.llvm.org/pipermail/llvm-dev/2016-June/100462.html
Differential Revision: http://reviews.llvm.org/D21053
llvm-svn: 273729
2016-06-25 05:21:32 +08:00
|
|
|
assert(UniqueMember);
|
2016-02-10 06:50:34 +08:00
|
|
|
|
2017-02-16 05:56:51 +08:00
|
|
|
Constant *UniqueMemberAddr =
|
|
|
|
ConstantExpr::getBitCast(UniqueMember->Bits->GV, Int8PtrTy);
|
|
|
|
UniqueMemberAddr = ConstantExpr::getGetElementPtr(
|
|
|
|
Int8Ty, UniqueMemberAddr,
|
|
|
|
ConstantInt::get(Int64Ty, UniqueMember->Offset));
|
|
|
|
|
2017-03-11 04:09:11 +08:00
|
|
|
if (CSInfo.isExported()) {
|
|
|
|
Res->TheKind = WholeProgramDevirtResolution::ByArg::UniqueRetVal;
|
|
|
|
Res->Info = IsOne;
|
|
|
|
|
|
|
|
exportGlobal(Slot, Args, "unique_member", UniqueMemberAddr);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Replace each call with the comparison.
|
2017-02-16 05:56:51 +08:00
|
|
|
applyUniqueRetValOpt(CSInfo, TargetsForSlot[0].Fn->getName(), IsOne,
|
|
|
|
UniqueMemberAddr);
|
|
|
|
|
2016-08-12 03:09:02 +08:00
|
|
|
// Update devirtualization statistics for targets.
|
|
|
|
if (RemarksEnabled)
|
|
|
|
for (auto &&Target : TargetsForSlot)
|
|
|
|
Target.WasDevirt = true;
|
|
|
|
|
2016-02-10 06:50:34 +08:00
|
|
|
return true;
|
|
|
|
};
|
|
|
|
|
|
|
|
if (BitWidth == 1) {
|
|
|
|
if (tryUniqueRetValOptFor(true))
|
|
|
|
return true;
|
|
|
|
if (tryUniqueRetValOptFor(false))
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2017-02-16 05:56:51 +08:00
|
|
|
void DevirtModule::applyVirtualConstProp(CallSiteInfo &CSInfo, StringRef FnName,
|
|
|
|
Constant *Byte, Constant *Bit) {
|
|
|
|
for (auto Call : CSInfo.CallSites) {
|
|
|
|
auto *RetType = cast<IntegerType>(Call.CS.getType());
|
|
|
|
IRBuilder<> B(Call.CS.getInstruction());
|
|
|
|
Value *Addr = B.CreateGEP(Int8Ty, Call.VTable, Byte);
|
|
|
|
if (RetType->getBitWidth() == 1) {
|
|
|
|
Value *Bits = B.CreateLoad(Addr);
|
|
|
|
Value *BitsAndBit = B.CreateAnd(Bits, Bit);
|
|
|
|
auto IsBitSet = B.CreateICmpNE(BitsAndBit, ConstantInt::get(Int8Ty, 0));
|
|
|
|
Call.replaceAndErase("virtual-const-prop-1-bit", FnName, RemarksEnabled,
|
|
|
|
IsBitSet);
|
|
|
|
} else {
|
|
|
|
Value *ValAddr = B.CreateBitCast(Addr, RetType->getPointerTo());
|
|
|
|
Value *Val = B.CreateLoad(RetType, ValAddr);
|
|
|
|
Call.replaceAndErase("virtual-const-prop", FnName, RemarksEnabled, Val);
|
|
|
|
}
|
|
|
|
}
|
2017-03-11 04:13:58 +08:00
|
|
|
CSInfo.markDevirt();
|
2017-02-16 05:56:51 +08:00
|
|
|
}
|
|
|
|
|
2016-02-10 06:50:34 +08:00
|
|
|
bool DevirtModule::tryVirtualConstProp(
|
2017-03-11 04:09:11 +08:00
|
|
|
MutableArrayRef<VirtualCallTarget> TargetsForSlot, VTableSlotInfo &SlotInfo,
|
|
|
|
WholeProgramDevirtResolution *Res, VTableSlot Slot) {
|
2016-02-10 06:50:34 +08:00
|
|
|
// This only works if the function returns an integer.
|
|
|
|
auto RetType = dyn_cast<IntegerType>(TargetsForSlot[0].Fn->getReturnType());
|
|
|
|
if (!RetType)
|
|
|
|
return false;
|
|
|
|
unsigned BitWidth = RetType->getBitWidth();
|
|
|
|
if (BitWidth > 64)
|
|
|
|
return false;
|
|
|
|
|
2017-02-10 07:46:26 +08:00
|
|
|
// Make sure that each function is defined, does not access memory, takes at
|
|
|
|
// least one argument, does not use its first argument (which we assume is
|
|
|
|
// 'this'), and has the same return type.
|
2017-02-18 02:17:04 +08:00
|
|
|
//
|
|
|
|
// Note that we test whether this copy of the function is readnone, rather
|
|
|
|
// than testing function attributes, which must hold for any copy of the
|
|
|
|
// function, even a less optimized version substituted at link time. This is
|
|
|
|
// sound because the virtual constant propagation optimizations effectively
|
|
|
|
// inline all implementations of the virtual function into each call site,
|
|
|
|
// rather than using function attributes to perform local optimization.
|
2016-02-10 06:50:34 +08:00
|
|
|
for (VirtualCallTarget &Target : TargetsForSlot) {
|
2017-02-18 02:17:04 +08:00
|
|
|
if (Target.Fn->isDeclaration() ||
|
|
|
|
computeFunctionBodyMemoryAccess(*Target.Fn, AARGetter(*Target.Fn)) !=
|
|
|
|
MAK_ReadNone ||
|
2017-02-10 07:46:26 +08:00
|
|
|
Target.Fn->arg_empty() || !Target.Fn->arg_begin()->use_empty() ||
|
2016-02-10 06:50:34 +08:00
|
|
|
Target.Fn->getReturnType() != RetType)
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2017-02-16 05:56:51 +08:00
|
|
|
for (auto &&CSByConstantArg : SlotInfo.ConstCSInfo) {
|
2016-02-10 06:50:34 +08:00
|
|
|
if (!tryEvaluateFunctionsWithArgs(TargetsForSlot, CSByConstantArg.first))
|
|
|
|
continue;
|
|
|
|
|
2017-03-04 09:34:53 +08:00
|
|
|
WholeProgramDevirtResolution::ByArg *ResByArg = nullptr;
|
|
|
|
if (Res)
|
|
|
|
ResByArg = &Res->ResByArg[CSByConstantArg.first];
|
|
|
|
|
|
|
|
if (tryUniformRetValOpt(TargetsForSlot, CSByConstantArg.second, ResByArg))
|
2016-02-10 06:50:34 +08:00
|
|
|
continue;
|
|
|
|
|
2017-03-11 04:09:11 +08:00
|
|
|
if (tryUniqueRetValOpt(BitWidth, TargetsForSlot, CSByConstantArg.second,
|
|
|
|
ResByArg, Slot, CSByConstantArg.first))
|
2016-02-10 06:50:34 +08:00
|
|
|
continue;
|
|
|
|
|
IR: New representation for CFI and virtual call optimization pass metadata.
The bitset metadata currently used in LLVM has a few problems:
1. It has the wrong name. The name "bitset" refers to an implementation
detail of one use of the metadata (i.e. its original use case, CFI).
This makes it harder to understand, as the name makes no sense in the
context of virtual call optimization.
2. It is represented using a global named metadata node, rather than
being directly associated with a global. This makes it harder to
manipulate the metadata when rebuilding global variables, summarise it
as part of ThinLTO and drop unused metadata when associated globals are
dropped. For this reason, CFI does not currently work correctly when
both CFI and vcall opt are enabled, as vcall opt needs to rebuild vtable
globals, and fails to associate metadata with the rebuilt globals. As I
understand it, the same problem could also affect ASan, which rebuilds
globals with a red zone.
This patch solves both of those problems in the following way:
1. Rename the metadata to "type metadata". This new name reflects how
the metadata is currently being used (i.e. to represent type information
for CFI and vtable opt). The new name is reflected in the name for the
associated intrinsic (llvm.type.test) and pass (LowerTypeTests).
2. Attach metadata directly to the globals that it pertains to, rather
than using the "llvm.bitsets" global metadata node as we are doing now.
This is done using the newly introduced capability to attach
metadata to global variables (r271348 and r271358).
See also: http://lists.llvm.org/pipermail/llvm-dev/2016-June/100462.html
Differential Revision: http://reviews.llvm.org/D21053
llvm-svn: 273729
2016-06-25 05:21:32 +08:00
|
|
|
// Find an allocation offset in bits in all vtables associated with the
|
|
|
|
// type.
|
2016-02-10 06:50:34 +08:00
|
|
|
uint64_t AllocBefore =
|
|
|
|
findLowestOffset(TargetsForSlot, /*IsAfter=*/false, BitWidth);
|
|
|
|
uint64_t AllocAfter =
|
|
|
|
findLowestOffset(TargetsForSlot, /*IsAfter=*/true, BitWidth);
|
|
|
|
|
|
|
|
// Calculate the total amount of padding needed to store a value at both
|
|
|
|
// ends of the object.
|
|
|
|
uint64_t TotalPaddingBefore = 0, TotalPaddingAfter = 0;
|
|
|
|
for (auto &&Target : TargetsForSlot) {
|
|
|
|
TotalPaddingBefore += std::max<int64_t>(
|
|
|
|
(AllocBefore + 7) / 8 - Target.allocatedBeforeBytes() - 1, 0);
|
|
|
|
TotalPaddingAfter += std::max<int64_t>(
|
|
|
|
(AllocAfter + 7) / 8 - Target.allocatedAfterBytes() - 1, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
// If the amount of padding is too large, give up.
|
|
|
|
// FIXME: do something smarter here.
|
|
|
|
if (std::min(TotalPaddingBefore, TotalPaddingAfter) > 128)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
// Calculate the offset to the value as a (possibly negative) byte offset
|
|
|
|
// and (if applicable) a bit offset, and store the values in the targets.
|
|
|
|
int64_t OffsetByte;
|
|
|
|
uint64_t OffsetBit;
|
|
|
|
if (TotalPaddingBefore <= TotalPaddingAfter)
|
|
|
|
setBeforeReturnValues(TargetsForSlot, AllocBefore, BitWidth, OffsetByte,
|
|
|
|
OffsetBit);
|
|
|
|
else
|
|
|
|
setAfterReturnValues(TargetsForSlot, AllocAfter, BitWidth, OffsetByte,
|
|
|
|
OffsetBit);
|
|
|
|
|
2016-08-12 03:09:02 +08:00
|
|
|
if (RemarksEnabled)
|
|
|
|
for (auto &&Target : TargetsForSlot)
|
|
|
|
Target.WasDevirt = true;
|
|
|
|
|
2017-02-18 03:43:45 +08:00
|
|
|
Constant *ByteConst = ConstantInt::get(Int32Ty, OffsetByte);
|
2017-02-16 05:56:51 +08:00
|
|
|
Constant *BitConst = ConstantInt::get(Int8Ty, 1ULL << OffsetBit);
|
2017-03-11 04:13:58 +08:00
|
|
|
|
|
|
|
if (CSByConstantArg.second.isExported()) {
|
|
|
|
ResByArg->TheKind = WholeProgramDevirtResolution::ByArg::VirtualConstProp;
|
|
|
|
exportGlobal(Slot, CSByConstantArg.first, "byte",
|
|
|
|
ConstantExpr::getIntToPtr(ByteConst, Int8PtrTy));
|
|
|
|
exportGlobal(Slot, CSByConstantArg.first, "bit",
|
|
|
|
ConstantExpr::getIntToPtr(BitConst, Int8PtrTy));
|
|
|
|
}
|
|
|
|
|
|
|
|
// Rewrite each call to a load from OffsetByte/OffsetBit.
|
2017-02-16 05:56:51 +08:00
|
|
|
applyVirtualConstProp(CSByConstantArg.second,
|
|
|
|
TargetsForSlot[0].Fn->getName(), ByteConst, BitConst);
|
2016-02-10 06:50:34 +08:00
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
void DevirtModule::rebuildGlobal(VTableBits &B) {
|
|
|
|
if (B.Before.Bytes.empty() && B.After.Bytes.empty())
|
|
|
|
return;
|
|
|
|
|
|
|
|
// Align each byte array to pointer width.
|
|
|
|
unsigned PointerSize = M.getDataLayout().getPointerSize();
|
|
|
|
B.Before.Bytes.resize(alignTo(B.Before.Bytes.size(), PointerSize));
|
|
|
|
B.After.Bytes.resize(alignTo(B.After.Bytes.size(), PointerSize));
|
|
|
|
|
|
|
|
// Before was stored in reverse order; flip it now.
|
|
|
|
for (size_t I = 0, Size = B.Before.Bytes.size(); I != Size / 2; ++I)
|
|
|
|
std::swap(B.Before.Bytes[I], B.Before.Bytes[Size - 1 - I]);
|
|
|
|
|
|
|
|
// Build an anonymous global containing the before bytes, followed by the
|
|
|
|
// original initializer, followed by the after bytes.
|
|
|
|
auto NewInit = ConstantStruct::getAnon(
|
|
|
|
{ConstantDataArray::get(M.getContext(), B.Before.Bytes),
|
|
|
|
B.GV->getInitializer(),
|
|
|
|
ConstantDataArray::get(M.getContext(), B.After.Bytes)});
|
|
|
|
auto NewGV =
|
|
|
|
new GlobalVariable(M, NewInit->getType(), B.GV->isConstant(),
|
|
|
|
GlobalVariable::PrivateLinkage, NewInit, "", B.GV);
|
|
|
|
NewGV->setSection(B.GV->getSection());
|
|
|
|
NewGV->setComdat(B.GV->getComdat());
|
|
|
|
|
2016-06-25 08:23:04 +08:00
|
|
|
// Copy the original vtable's metadata to the anonymous global, adjusting
|
|
|
|
// offsets as required.
|
|
|
|
NewGV->copyMetadata(B.GV, B.Before.Bytes.size());
|
|
|
|
|
2016-02-10 06:50:34 +08:00
|
|
|
// Build an alias named after the original global, pointing at the second
|
|
|
|
// element (the original initializer).
|
|
|
|
auto Alias = GlobalAlias::create(
|
|
|
|
B.GV->getInitializer()->getType(), 0, B.GV->getLinkage(), "",
|
|
|
|
ConstantExpr::getGetElementPtr(
|
|
|
|
NewInit->getType(), NewGV,
|
|
|
|
ArrayRef<Constant *>{ConstantInt::get(Int32Ty, 0),
|
|
|
|
ConstantInt::get(Int32Ty, 1)}),
|
|
|
|
&M);
|
|
|
|
Alias->setVisibility(B.GV->getVisibility());
|
|
|
|
Alias->takeName(B.GV);
|
|
|
|
|
|
|
|
B.GV->replaceAllUsesWith(Alias);
|
|
|
|
B.GV->eraseFromParent();
|
|
|
|
}
|
|
|
|
|
2016-08-12 03:09:02 +08:00
|
|
|
bool DevirtModule::areRemarksEnabled() {
|
|
|
|
const auto &FL = M.getFunctionList();
|
|
|
|
if (FL.empty())
|
|
|
|
return false;
|
|
|
|
const Function &Fn = FL.front();
|
2017-02-24 07:11:11 +08:00
|
|
|
|
|
|
|
const auto &BBL = Fn.getBasicBlockList();
|
|
|
|
if (BBL.empty())
|
|
|
|
return false;
|
|
|
|
auto DI = OptimizationRemark(DEBUG_TYPE, "", DebugLoc(), &BBL.front());
|
2016-08-12 03:09:02 +08:00
|
|
|
return DI.isEnabled();
|
|
|
|
}
|
|
|
|
|
2016-06-25 08:23:04 +08:00
|
|
|
void DevirtModule::scanTypeTestUsers(Function *TypeTestFunc,
|
|
|
|
Function *AssumeFunc) {
|
2016-02-10 06:50:34 +08:00
|
|
|
// Find all virtual calls via a virtual table pointer %p under an assumption
|
IR: New representation for CFI and virtual call optimization pass metadata.
The bitset metadata currently used in LLVM has a few problems:
1. It has the wrong name. The name "bitset" refers to an implementation
detail of one use of the metadata (i.e. its original use case, CFI).
This makes it harder to understand, as the name makes no sense in the
context of virtual call optimization.
2. It is represented using a global named metadata node, rather than
being directly associated with a global. This makes it harder to
manipulate the metadata when rebuilding global variables, summarise it
as part of ThinLTO and drop unused metadata when associated globals are
dropped. For this reason, CFI does not currently work correctly when
both CFI and vcall opt are enabled, as vcall opt needs to rebuild vtable
globals, and fails to associate metadata with the rebuilt globals. As I
understand it, the same problem could also affect ASan, which rebuilds
globals with a red zone.
This patch solves both of those problems in the following way:
1. Rename the metadata to "type metadata". This new name reflects how
the metadata is currently being used (i.e. to represent type information
for CFI and vtable opt). The new name is reflected in the name for the
associated intrinsic (llvm.type.test) and pass (LowerTypeTests).
2. Attach metadata directly to the globals that it pertains to, rather
than using the "llvm.bitsets" global metadata node as we are doing now.
This is done using the newly introduced capability to attach
metadata to global variables (r271348 and r271358).
See also: http://lists.llvm.org/pipermail/llvm-dev/2016-June/100462.html
Differential Revision: http://reviews.llvm.org/D21053
llvm-svn: 273729
2016-06-25 05:21:32 +08:00
|
|
|
// of the form llvm.assume(llvm.type.test(%p, %md)). This indicates that %p
|
|
|
|
// points to a member of the type identifier %md. Group calls by (type ID,
|
|
|
|
// offset) pair (effectively the identity of the virtual function) and store
|
|
|
|
// to CallSlots.
|
2016-02-10 06:50:34 +08:00
|
|
|
DenseSet<Value *> SeenPtrs;
|
IR: New representation for CFI and virtual call optimization pass metadata.
The bitset metadata currently used in LLVM has a few problems:
1. It has the wrong name. The name "bitset" refers to an implementation
detail of one use of the metadata (i.e. its original use case, CFI).
This makes it harder to understand, as the name makes no sense in the
context of virtual call optimization.
2. It is represented using a global named metadata node, rather than
being directly associated with a global. This makes it harder to
manipulate the metadata when rebuilding global variables, summarise it
as part of ThinLTO and drop unused metadata when associated globals are
dropped. For this reason, CFI does not currently work correctly when
both CFI and vcall opt are enabled, as vcall opt needs to rebuild vtable
globals, and fails to associate metadata with the rebuilt globals. As I
understand it, the same problem could also affect ASan, which rebuilds
globals with a red zone.
This patch solves both of those problems in the following way:
1. Rename the metadata to "type metadata". This new name reflects how
the metadata is currently being used (i.e. to represent type information
for CFI and vtable opt). The new name is reflected in the name for the
associated intrinsic (llvm.type.test) and pass (LowerTypeTests).
2. Attach metadata directly to the globals that it pertains to, rather
than using the "llvm.bitsets" global metadata node as we are doing now.
This is done using the newly introduced capability to attach
metadata to global variables (r271348 and r271358).
See also: http://lists.llvm.org/pipermail/llvm-dev/2016-June/100462.html
Differential Revision: http://reviews.llvm.org/D21053
llvm-svn: 273729
2016-06-25 05:21:32 +08:00
|
|
|
for (auto I = TypeTestFunc->use_begin(), E = TypeTestFunc->use_end();
|
2016-02-10 06:50:34 +08:00
|
|
|
I != E;) {
|
|
|
|
auto CI = dyn_cast<CallInst>(I->getUser());
|
|
|
|
++I;
|
|
|
|
if (!CI)
|
|
|
|
continue;
|
|
|
|
|
2016-05-11 02:07:21 +08:00
|
|
|
// Search for virtual calls based on %p and add them to DevirtCalls.
|
|
|
|
SmallVector<DevirtCallSite, 1> DevirtCalls;
|
2016-02-10 06:50:34 +08:00
|
|
|
SmallVector<CallInst *, 1> Assumes;
|
2016-06-25 08:23:04 +08:00
|
|
|
findDevirtualizableCallsForTypeTest(DevirtCalls, Assumes, CI);
|
2016-02-10 06:50:34 +08:00
|
|
|
|
2016-05-11 02:07:21 +08:00
|
|
|
// If we found any, add them to CallSlots. Only do this if we haven't seen
|
|
|
|
// the vtable pointer before, as it may have been CSE'd with pointers from
|
|
|
|
// other call sites, and we don't want to process call sites multiple times.
|
2016-02-10 06:50:34 +08:00
|
|
|
if (!Assumes.empty()) {
|
IR: New representation for CFI and virtual call optimization pass metadata.
The bitset metadata currently used in LLVM has a few problems:
1. It has the wrong name. The name "bitset" refers to an implementation
detail of one use of the metadata (i.e. its original use case, CFI).
This makes it harder to understand, as the name makes no sense in the
context of virtual call optimization.
2. It is represented using a global named metadata node, rather than
being directly associated with a global. This makes it harder to
manipulate the metadata when rebuilding global variables, summarise it
as part of ThinLTO and drop unused metadata when associated globals are
dropped. For this reason, CFI does not currently work correctly when
both CFI and vcall opt are enabled, as vcall opt needs to rebuild vtable
globals, and fails to associate metadata with the rebuilt globals. As I
understand it, the same problem could also affect ASan, which rebuilds
globals with a red zone.
This patch solves both of those problems in the following way:
1. Rename the metadata to "type metadata". This new name reflects how
the metadata is currently being used (i.e. to represent type information
for CFI and vtable opt). The new name is reflected in the name for the
associated intrinsic (llvm.type.test) and pass (LowerTypeTests).
2. Attach metadata directly to the globals that it pertains to, rather
than using the "llvm.bitsets" global metadata node as we are doing now.
This is done using the newly introduced capability to attach
metadata to global variables (r271348 and r271358).
See also: http://lists.llvm.org/pipermail/llvm-dev/2016-June/100462.html
Differential Revision: http://reviews.llvm.org/D21053
llvm-svn: 273729
2016-06-25 05:21:32 +08:00
|
|
|
Metadata *TypeId =
|
2016-02-10 06:50:34 +08:00
|
|
|
cast<MetadataAsValue>(CI->getArgOperand(1))->getMetadata();
|
|
|
|
Value *Ptr = CI->getArgOperand(0)->stripPointerCasts();
|
2016-05-11 02:07:21 +08:00
|
|
|
if (SeenPtrs.insert(Ptr).second) {
|
|
|
|
for (DevirtCallSite Call : DevirtCalls) {
|
2017-02-16 05:56:51 +08:00
|
|
|
CallSlots[{TypeId, Call.Offset}].addCallSite(CI->getArgOperand(0),
|
|
|
|
Call.CS, nullptr);
|
2016-05-11 02:07:21 +08:00
|
|
|
}
|
|
|
|
}
|
2016-02-10 06:50:34 +08:00
|
|
|
}
|
|
|
|
|
IR: New representation for CFI and virtual call optimization pass metadata.
The bitset metadata currently used in LLVM has a few problems:
1. It has the wrong name. The name "bitset" refers to an implementation
detail of one use of the metadata (i.e. its original use case, CFI).
This makes it harder to understand, as the name makes no sense in the
context of virtual call optimization.
2. It is represented using a global named metadata node, rather than
being directly associated with a global. This makes it harder to
manipulate the metadata when rebuilding global variables, summarise it
as part of ThinLTO and drop unused metadata when associated globals are
dropped. For this reason, CFI does not currently work correctly when
both CFI and vcall opt are enabled, as vcall opt needs to rebuild vtable
globals, and fails to associate metadata with the rebuilt globals. As I
understand it, the same problem could also affect ASan, which rebuilds
globals with a red zone.
This patch solves both of those problems in the following way:
1. Rename the metadata to "type metadata". This new name reflects how
the metadata is currently being used (i.e. to represent type information
for CFI and vtable opt). The new name is reflected in the name for the
associated intrinsic (llvm.type.test) and pass (LowerTypeTests).
2. Attach metadata directly to the globals that it pertains to, rather
than using the "llvm.bitsets" global metadata node as we are doing now.
This is done using the newly introduced capability to attach
metadata to global variables (r271348 and r271358).
See also: http://lists.llvm.org/pipermail/llvm-dev/2016-June/100462.html
Differential Revision: http://reviews.llvm.org/D21053
llvm-svn: 273729
2016-06-25 05:21:32 +08:00
|
|
|
// We no longer need the assumes or the type test.
|
2016-02-10 06:50:34 +08:00
|
|
|
for (auto Assume : Assumes)
|
|
|
|
Assume->eraseFromParent();
|
|
|
|
// We can't use RecursivelyDeleteTriviallyDeadInstructions here because we
|
|
|
|
// may use the vtable argument later.
|
|
|
|
if (CI->use_empty())
|
|
|
|
CI->eraseFromParent();
|
|
|
|
}
|
2016-06-25 08:23:04 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void DevirtModule::scanTypeCheckedLoadUsers(Function *TypeCheckedLoadFunc) {
|
|
|
|
Function *TypeTestFunc = Intrinsic::getDeclaration(&M, Intrinsic::type_test);
|
|
|
|
|
|
|
|
for (auto I = TypeCheckedLoadFunc->use_begin(),
|
|
|
|
E = TypeCheckedLoadFunc->use_end();
|
|
|
|
I != E;) {
|
|
|
|
auto CI = dyn_cast<CallInst>(I->getUser());
|
|
|
|
++I;
|
|
|
|
if (!CI)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
Value *Ptr = CI->getArgOperand(0);
|
|
|
|
Value *Offset = CI->getArgOperand(1);
|
|
|
|
Value *TypeIdValue = CI->getArgOperand(2);
|
|
|
|
Metadata *TypeId = cast<MetadataAsValue>(TypeIdValue)->getMetadata();
|
|
|
|
|
|
|
|
SmallVector<DevirtCallSite, 1> DevirtCalls;
|
|
|
|
SmallVector<Instruction *, 1> LoadedPtrs;
|
|
|
|
SmallVector<Instruction *, 1> Preds;
|
|
|
|
bool HasNonCallUses = false;
|
|
|
|
findDevirtualizableCallsForTypeCheckedLoad(DevirtCalls, LoadedPtrs, Preds,
|
|
|
|
HasNonCallUses, CI);
|
|
|
|
|
|
|
|
// Start by generating "pessimistic" code that explicitly loads the function
|
|
|
|
// pointer from the vtable and performs the type check. If possible, we will
|
|
|
|
// eliminate the load and the type check later.
|
|
|
|
|
|
|
|
// If possible, only generate the load at the point where it is used.
|
|
|
|
// This helps avoid unnecessary spills.
|
|
|
|
IRBuilder<> LoadB(
|
|
|
|
(LoadedPtrs.size() == 1 && !HasNonCallUses) ? LoadedPtrs[0] : CI);
|
|
|
|
Value *GEP = LoadB.CreateGEP(Int8Ty, Ptr, Offset);
|
|
|
|
Value *GEPPtr = LoadB.CreateBitCast(GEP, PointerType::getUnqual(Int8PtrTy));
|
|
|
|
Value *LoadedValue = LoadB.CreateLoad(Int8PtrTy, GEPPtr);
|
|
|
|
|
|
|
|
for (Instruction *LoadedPtr : LoadedPtrs) {
|
|
|
|
LoadedPtr->replaceAllUsesWith(LoadedValue);
|
|
|
|
LoadedPtr->eraseFromParent();
|
|
|
|
}
|
|
|
|
|
|
|
|
// Likewise for the type test.
|
|
|
|
IRBuilder<> CallB((Preds.size() == 1 && !HasNonCallUses) ? Preds[0] : CI);
|
|
|
|
CallInst *TypeTestCall = CallB.CreateCall(TypeTestFunc, {Ptr, TypeIdValue});
|
|
|
|
|
|
|
|
for (Instruction *Pred : Preds) {
|
|
|
|
Pred->replaceAllUsesWith(TypeTestCall);
|
|
|
|
Pred->eraseFromParent();
|
|
|
|
}
|
|
|
|
|
|
|
|
// We have already erased any extractvalue instructions that refer to the
|
|
|
|
// intrinsic call, but the intrinsic may have other non-extractvalue uses
|
|
|
|
// (although this is unlikely). In that case, explicitly build a pair and
|
|
|
|
// RAUW it.
|
|
|
|
if (!CI->use_empty()) {
|
|
|
|
Value *Pair = UndefValue::get(CI->getType());
|
|
|
|
IRBuilder<> B(CI);
|
|
|
|
Pair = B.CreateInsertValue(Pair, LoadedValue, {0});
|
|
|
|
Pair = B.CreateInsertValue(Pair, TypeTestCall, {1});
|
|
|
|
CI->replaceAllUsesWith(Pair);
|
|
|
|
}
|
|
|
|
|
|
|
|
// The number of unsafe uses is initially the number of uses.
|
|
|
|
auto &NumUnsafeUses = NumUnsafeUsesForTypeTest[TypeTestCall];
|
|
|
|
NumUnsafeUses = DevirtCalls.size();
|
|
|
|
|
|
|
|
// If the function pointer has a non-call user, we cannot eliminate the type
|
|
|
|
// check, as one of those users may eventually call the pointer. Increment
|
|
|
|
// the unsafe use count to make sure it cannot reach zero.
|
|
|
|
if (HasNonCallUses)
|
|
|
|
++NumUnsafeUses;
|
|
|
|
for (DevirtCallSite Call : DevirtCalls) {
|
2017-02-16 05:56:51 +08:00
|
|
|
CallSlots[{TypeId, Call.Offset}].addCallSite(Ptr, Call.CS,
|
|
|
|
&NumUnsafeUses);
|
2016-06-25 08:23:04 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
CI->eraseFromParent();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-03-09 08:21:25 +08:00
|
|
|
void DevirtModule::importResolution(VTableSlot Slot, VTableSlotInfo &SlotInfo) {
|
2017-03-23 02:04:39 +08:00
|
|
|
const TypeIdSummary *TidSummary =
|
2017-03-23 02:22:59 +08:00
|
|
|
ImportSummary->getTypeIdSummary(cast<MDString>(Slot.TypeID)->getString());
|
2017-03-23 02:04:39 +08:00
|
|
|
if (!TidSummary)
|
|
|
|
return;
|
|
|
|
auto ResI = TidSummary->WPDRes.find(Slot.ByteOffset);
|
|
|
|
if (ResI == TidSummary->WPDRes.end())
|
|
|
|
return;
|
|
|
|
const WholeProgramDevirtResolution &Res = ResI->second;
|
2017-03-09 08:21:25 +08:00
|
|
|
|
|
|
|
if (Res.TheKind == WholeProgramDevirtResolution::SingleImpl) {
|
|
|
|
// The type of the function in the declaration is irrelevant because every
|
|
|
|
// call site will cast it to the correct type.
|
2017-04-07 04:23:57 +08:00
|
|
|
auto *SingleImpl = M.getOrInsertFunction(
|
2017-04-11 23:01:18 +08:00
|
|
|
Res.SingleImplName, Type::getVoidTy(M.getContext()));
|
2017-03-09 08:21:25 +08:00
|
|
|
|
|
|
|
// This is the import phase so we should not be exporting anything.
|
|
|
|
bool IsExported = false;
|
|
|
|
applySingleImplDevirt(SlotInfo, SingleImpl, IsExported);
|
|
|
|
assert(!IsExported);
|
|
|
|
}
|
2017-03-09 09:11:15 +08:00
|
|
|
|
|
|
|
for (auto &CSByConstantArg : SlotInfo.ConstCSInfo) {
|
|
|
|
auto I = Res.ResByArg.find(CSByConstantArg.first);
|
|
|
|
if (I == Res.ResByArg.end())
|
|
|
|
continue;
|
|
|
|
auto &ResByArg = I->second;
|
|
|
|
// FIXME: We should figure out what to do about the "function name" argument
|
|
|
|
// to the apply* functions, as the function names are unavailable during the
|
|
|
|
// importing phase. For now we just pass the empty string. This does not
|
|
|
|
// impact correctness because the function names are just used for remarks.
|
|
|
|
switch (ResByArg.TheKind) {
|
|
|
|
case WholeProgramDevirtResolution::ByArg::UniformRetVal:
|
|
|
|
applyUniformRetValOpt(CSByConstantArg.second, "", ResByArg.Info);
|
|
|
|
break;
|
2017-03-11 04:09:11 +08:00
|
|
|
case WholeProgramDevirtResolution::ByArg::UniqueRetVal: {
|
|
|
|
Constant *UniqueMemberAddr =
|
|
|
|
importGlobal(Slot, CSByConstantArg.first, "unique_member");
|
|
|
|
applyUniqueRetValOpt(CSByConstantArg.second, "", ResByArg.Info,
|
|
|
|
UniqueMemberAddr);
|
|
|
|
break;
|
|
|
|
}
|
2017-03-11 04:13:58 +08:00
|
|
|
case WholeProgramDevirtResolution::ByArg::VirtualConstProp: {
|
|
|
|
Constant *Byte = importGlobal(Slot, CSByConstantArg.first, "byte", 32);
|
|
|
|
Byte = ConstantExpr::getPtrToInt(Byte, Int32Ty);
|
|
|
|
Constant *Bit = importGlobal(Slot, CSByConstantArg.first, "bit", 8);
|
|
|
|
Bit = ConstantExpr::getPtrToInt(Bit, Int8Ty);
|
|
|
|
applyVirtualConstProp(CSByConstantArg.second, "", Byte, Bit);
|
|
|
|
}
|
2017-03-09 09:11:15 +08:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2017-03-09 08:21:25 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void DevirtModule::removeRedundantTypeTests() {
|
|
|
|
auto True = ConstantInt::getTrue(M.getContext());
|
|
|
|
for (auto &&U : NumUnsafeUsesForTypeTest) {
|
|
|
|
if (U.second == 0) {
|
|
|
|
U.first->replaceAllUsesWith(True);
|
|
|
|
U.first->eraseFromParent();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-06-25 08:23:04 +08:00
|
|
|
bool DevirtModule::run() {
|
|
|
|
Function *TypeTestFunc =
|
|
|
|
M.getFunction(Intrinsic::getName(Intrinsic::type_test));
|
|
|
|
Function *TypeCheckedLoadFunc =
|
|
|
|
M.getFunction(Intrinsic::getName(Intrinsic::type_checked_load));
|
|
|
|
Function *AssumeFunc = M.getFunction(Intrinsic::getName(Intrinsic::assume));
|
|
|
|
|
2017-03-04 09:23:30 +08:00
|
|
|
// Normally if there are no users of the devirtualization intrinsics in the
|
|
|
|
// module, this pass has nothing to do. But if we are exporting, we also need
|
|
|
|
// to handle any users that appear only in the function summaries.
|
2017-03-23 02:22:59 +08:00
|
|
|
if (!ExportSummary &&
|
2017-03-04 09:23:30 +08:00
|
|
|
(!TypeTestFunc || TypeTestFunc->use_empty() || !AssumeFunc ||
|
2016-06-25 08:23:04 +08:00
|
|
|
AssumeFunc->use_empty()) &&
|
|
|
|
(!TypeCheckedLoadFunc || TypeCheckedLoadFunc->use_empty()))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (TypeTestFunc && AssumeFunc)
|
|
|
|
scanTypeTestUsers(TypeTestFunc, AssumeFunc);
|
|
|
|
|
|
|
|
if (TypeCheckedLoadFunc)
|
|
|
|
scanTypeCheckedLoadUsers(TypeCheckedLoadFunc);
|
2016-02-10 06:50:34 +08:00
|
|
|
|
2017-03-23 02:22:59 +08:00
|
|
|
if (ImportSummary) {
|
2017-03-09 08:21:25 +08:00
|
|
|
for (auto &S : CallSlots)
|
|
|
|
importResolution(S.first, S.second);
|
|
|
|
|
|
|
|
removeRedundantTypeTests();
|
|
|
|
|
|
|
|
// The rest of the code is only necessary when exporting or during regular
|
|
|
|
// LTO, so we are done.
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
IR: New representation for CFI and virtual call optimization pass metadata.
The bitset metadata currently used in LLVM has a few problems:
1. It has the wrong name. The name "bitset" refers to an implementation
detail of one use of the metadata (i.e. its original use case, CFI).
This makes it harder to understand, as the name makes no sense in the
context of virtual call optimization.
2. It is represented using a global named metadata node, rather than
being directly associated with a global. This makes it harder to
manipulate the metadata when rebuilding global variables, summarise it
as part of ThinLTO and drop unused metadata when associated globals are
dropped. For this reason, CFI does not currently work correctly when
both CFI and vcall opt are enabled, as vcall opt needs to rebuild vtable
globals, and fails to associate metadata with the rebuilt globals. As I
understand it, the same problem could also affect ASan, which rebuilds
globals with a red zone.
This patch solves both of those problems in the following way:
1. Rename the metadata to "type metadata". This new name reflects how
the metadata is currently being used (i.e. to represent type information
for CFI and vtable opt). The new name is reflected in the name for the
associated intrinsic (llvm.type.test) and pass (LowerTypeTests).
2. Attach metadata directly to the globals that it pertains to, rather
than using the "llvm.bitsets" global metadata node as we are doing now.
This is done using the newly introduced capability to attach
metadata to global variables (r271348 and r271358).
See also: http://lists.llvm.org/pipermail/llvm-dev/2016-June/100462.html
Differential Revision: http://reviews.llvm.org/D21053
llvm-svn: 273729
2016-06-25 05:21:32 +08:00
|
|
|
// Rebuild type metadata into a map for easy lookup.
|
2016-02-10 06:50:34 +08:00
|
|
|
std::vector<VTableBits> Bits;
|
IR: New representation for CFI and virtual call optimization pass metadata.
The bitset metadata currently used in LLVM has a few problems:
1. It has the wrong name. The name "bitset" refers to an implementation
detail of one use of the metadata (i.e. its original use case, CFI).
This makes it harder to understand, as the name makes no sense in the
context of virtual call optimization.
2. It is represented using a global named metadata node, rather than
being directly associated with a global. This makes it harder to
manipulate the metadata when rebuilding global variables, summarise it
as part of ThinLTO and drop unused metadata when associated globals are
dropped. For this reason, CFI does not currently work correctly when
both CFI and vcall opt are enabled, as vcall opt needs to rebuild vtable
globals, and fails to associate metadata with the rebuilt globals. As I
understand it, the same problem could also affect ASan, which rebuilds
globals with a red zone.
This patch solves both of those problems in the following way:
1. Rename the metadata to "type metadata". This new name reflects how
the metadata is currently being used (i.e. to represent type information
for CFI and vtable opt). The new name is reflected in the name for the
associated intrinsic (llvm.type.test) and pass (LowerTypeTests).
2. Attach metadata directly to the globals that it pertains to, rather
than using the "llvm.bitsets" global metadata node as we are doing now.
This is done using the newly introduced capability to attach
metadata to global variables (r271348 and r271358).
See also: http://lists.llvm.org/pipermail/llvm-dev/2016-June/100462.html
Differential Revision: http://reviews.llvm.org/D21053
llvm-svn: 273729
2016-06-25 05:21:32 +08:00
|
|
|
DenseMap<Metadata *, std::set<TypeMemberInfo>> TypeIdMap;
|
|
|
|
buildTypeIdentifierMap(Bits, TypeIdMap);
|
|
|
|
if (TypeIdMap.empty())
|
2016-02-10 06:50:34 +08:00
|
|
|
return true;
|
|
|
|
|
2017-03-04 09:23:30 +08:00
|
|
|
// Collect information from summary about which calls to try to devirtualize.
|
2017-03-23 02:22:59 +08:00
|
|
|
if (ExportSummary) {
|
2017-03-04 09:23:30 +08:00
|
|
|
DenseMap<GlobalValue::GUID, TinyPtrVector<Metadata *>> MetadataByGUID;
|
|
|
|
for (auto &P : TypeIdMap) {
|
|
|
|
if (auto *TypeId = dyn_cast<MDString>(P.first))
|
|
|
|
MetadataByGUID[GlobalValue::getGUID(TypeId->getString())].push_back(
|
|
|
|
TypeId);
|
|
|
|
}
|
|
|
|
|
2017-03-23 02:22:59 +08:00
|
|
|
for (auto &P : *ExportSummary) {
|
2017-05-05 02:03:25 +08:00
|
|
|
for (auto &S : P.second.SummaryList) {
|
2017-03-04 09:23:30 +08:00
|
|
|
auto *FS = dyn_cast<FunctionSummary>(S.get());
|
|
|
|
if (!FS)
|
|
|
|
continue;
|
|
|
|
// FIXME: Only add live functions.
|
2017-03-10 18:31:56 +08:00
|
|
|
for (FunctionSummary::VFuncId VF : FS->type_test_assume_vcalls()) {
|
|
|
|
for (Metadata *MD : MetadataByGUID[VF.GUID]) {
|
2017-03-04 09:31:01 +08:00
|
|
|
CallSlots[{MD, VF.Offset}].CSInfo.SummaryHasTypeTestAssumeUsers =
|
|
|
|
true;
|
2017-03-10 18:31:56 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
for (FunctionSummary::VFuncId VF : FS->type_checked_load_vcalls()) {
|
|
|
|
for (Metadata *MD : MetadataByGUID[VF.GUID]) {
|
2017-03-04 09:23:30 +08:00
|
|
|
CallSlots[{MD, VF.Offset}]
|
|
|
|
.CSInfo.SummaryTypeCheckedLoadUsers.push_back(FS);
|
2017-03-10 18:31:56 +08:00
|
|
|
}
|
|
|
|
}
|
2017-03-04 09:31:01 +08:00
|
|
|
for (const FunctionSummary::ConstVCall &VC :
|
2017-03-10 18:31:56 +08:00
|
|
|
FS->type_test_assume_const_vcalls()) {
|
|
|
|
for (Metadata *MD : MetadataByGUID[VC.VFunc.GUID]) {
|
2017-03-04 09:31:01 +08:00
|
|
|
CallSlots[{MD, VC.VFunc.Offset}]
|
2017-03-10 18:31:56 +08:00
|
|
|
.ConstCSInfo[VC.Args]
|
|
|
|
.SummaryHasTypeTestAssumeUsers = true;
|
|
|
|
}
|
|
|
|
}
|
2017-03-04 09:23:30 +08:00
|
|
|
for (const FunctionSummary::ConstVCall &VC :
|
2017-03-10 18:31:56 +08:00
|
|
|
FS->type_checked_load_const_vcalls()) {
|
|
|
|
for (Metadata *MD : MetadataByGUID[VC.VFunc.GUID]) {
|
2017-03-04 09:23:30 +08:00
|
|
|
CallSlots[{MD, VC.VFunc.Offset}]
|
|
|
|
.ConstCSInfo[VC.Args]
|
|
|
|
.SummaryTypeCheckedLoadUsers.push_back(FS);
|
2017-03-10 18:31:56 +08:00
|
|
|
}
|
|
|
|
}
|
2017-03-04 09:23:30 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
IR: New representation for CFI and virtual call optimization pass metadata.
The bitset metadata currently used in LLVM has a few problems:
1. It has the wrong name. The name "bitset" refers to an implementation
detail of one use of the metadata (i.e. its original use case, CFI).
This makes it harder to understand, as the name makes no sense in the
context of virtual call optimization.
2. It is represented using a global named metadata node, rather than
being directly associated with a global. This makes it harder to
manipulate the metadata when rebuilding global variables, summarise it
as part of ThinLTO and drop unused metadata when associated globals are
dropped. For this reason, CFI does not currently work correctly when
both CFI and vcall opt are enabled, as vcall opt needs to rebuild vtable
globals, and fails to associate metadata with the rebuilt globals. As I
understand it, the same problem could also affect ASan, which rebuilds
globals with a red zone.
This patch solves both of those problems in the following way:
1. Rename the metadata to "type metadata". This new name reflects how
the metadata is currently being used (i.e. to represent type information
for CFI and vtable opt). The new name is reflected in the name for the
associated intrinsic (llvm.type.test) and pass (LowerTypeTests).
2. Attach metadata directly to the globals that it pertains to, rather
than using the "llvm.bitsets" global metadata node as we are doing now.
This is done using the newly introduced capability to attach
metadata to global variables (r271348 and r271358).
See also: http://lists.llvm.org/pipermail/llvm-dev/2016-June/100462.html
Differential Revision: http://reviews.llvm.org/D21053
llvm-svn: 273729
2016-06-25 05:21:32 +08:00
|
|
|
// For each (type, offset) pair:
|
2016-02-10 06:50:34 +08:00
|
|
|
bool DidVirtualConstProp = false;
|
2016-08-12 03:09:02 +08:00
|
|
|
std::map<std::string, Function*> DevirtTargets;
|
2016-02-10 06:50:34 +08:00
|
|
|
for (auto &S : CallSlots) {
|
IR: New representation for CFI and virtual call optimization pass metadata.
The bitset metadata currently used in LLVM has a few problems:
1. It has the wrong name. The name "bitset" refers to an implementation
detail of one use of the metadata (i.e. its original use case, CFI).
This makes it harder to understand, as the name makes no sense in the
context of virtual call optimization.
2. It is represented using a global named metadata node, rather than
being directly associated with a global. This makes it harder to
manipulate the metadata when rebuilding global variables, summarise it
as part of ThinLTO and drop unused metadata when associated globals are
dropped. For this reason, CFI does not currently work correctly when
both CFI and vcall opt are enabled, as vcall opt needs to rebuild vtable
globals, and fails to associate metadata with the rebuilt globals. As I
understand it, the same problem could also affect ASan, which rebuilds
globals with a red zone.
This patch solves both of those problems in the following way:
1. Rename the metadata to "type metadata". This new name reflects how
the metadata is currently being used (i.e. to represent type information
for CFI and vtable opt). The new name is reflected in the name for the
associated intrinsic (llvm.type.test) and pass (LowerTypeTests).
2. Attach metadata directly to the globals that it pertains to, rather
than using the "llvm.bitsets" global metadata node as we are doing now.
This is done using the newly introduced capability to attach
metadata to global variables (r271348 and r271358).
See also: http://lists.llvm.org/pipermail/llvm-dev/2016-June/100462.html
Differential Revision: http://reviews.llvm.org/D21053
llvm-svn: 273729
2016-06-25 05:21:32 +08:00
|
|
|
// Search each of the members of the type identifier for the virtual
|
|
|
|
// function implementation at offset S.first.ByteOffset, and add to
|
|
|
|
// TargetsForSlot.
|
2016-02-10 06:50:34 +08:00
|
|
|
std::vector<VirtualCallTarget> TargetsForSlot;
|
2017-03-04 09:23:30 +08:00
|
|
|
if (tryFindVirtualCallTargets(TargetsForSlot, TypeIdMap[S.first.TypeID],
|
|
|
|
S.first.ByteOffset)) {
|
2017-03-04 09:31:01 +08:00
|
|
|
WholeProgramDevirtResolution *Res = nullptr;
|
2017-03-23 02:22:59 +08:00
|
|
|
if (ExportSummary && isa<MDString>(S.first.TypeID))
|
|
|
|
Res = &ExportSummary
|
2017-03-23 02:04:39 +08:00
|
|
|
->getOrInsertTypeIdSummary(
|
|
|
|
cast<MDString>(S.first.TypeID)->getString())
|
|
|
|
.WPDRes[S.first.ByteOffset];
|
2017-03-04 09:31:01 +08:00
|
|
|
|
|
|
|
if (!trySingleImplDevirt(TargetsForSlot, S.second, Res) &&
|
2017-03-11 04:09:11 +08:00
|
|
|
tryVirtualConstProp(TargetsForSlot, S.second, Res, S.first))
|
2016-08-12 03:09:02 +08:00
|
|
|
DidVirtualConstProp = true;
|
|
|
|
|
2017-03-04 09:23:30 +08:00
|
|
|
// Collect functions devirtualized at least for one call site for stats.
|
|
|
|
if (RemarksEnabled)
|
|
|
|
for (const auto &T : TargetsForSlot)
|
|
|
|
if (T.WasDevirt)
|
|
|
|
DevirtTargets[T.Fn->getName()] = T.Fn;
|
|
|
|
}
|
|
|
|
|
|
|
|
// CFI-specific: if we are exporting and any llvm.type.checked.load
|
|
|
|
// intrinsics were *not* devirtualized, we need to add the resulting
|
|
|
|
// llvm.type.test intrinsics to the function summaries so that the
|
|
|
|
// LowerTypeTests pass will export them.
|
2017-03-23 02:22:59 +08:00
|
|
|
if (ExportSummary && isa<MDString>(S.first.TypeID)) {
|
2017-03-04 09:23:30 +08:00
|
|
|
auto GUID =
|
|
|
|
GlobalValue::getGUID(cast<MDString>(S.first.TypeID)->getString());
|
|
|
|
for (auto FS : S.second.CSInfo.SummaryTypeCheckedLoadUsers)
|
|
|
|
FS->addTypeTest(GUID);
|
|
|
|
for (auto &CCS : S.second.ConstCSInfo)
|
|
|
|
for (auto FS : CCS.second.SummaryTypeCheckedLoadUsers)
|
|
|
|
FS->addTypeTest(GUID);
|
|
|
|
}
|
2016-08-12 03:09:02 +08:00
|
|
|
}
|
2016-02-10 06:50:34 +08:00
|
|
|
|
2016-08-12 03:09:02 +08:00
|
|
|
if (RemarksEnabled) {
|
|
|
|
// Generate remarks for each devirtualized function.
|
|
|
|
for (const auto &DT : DevirtTargets) {
|
|
|
|
Function *F = DT.second;
|
|
|
|
DISubprogram *SP = F->getSubprogram();
|
2017-02-18 10:00:27 +08:00
|
|
|
emitOptimizationRemark(F->getContext(), DEBUG_TYPE, *F, SP,
|
2016-08-12 03:09:02 +08:00
|
|
|
Twine("devirtualized ") + F->getName());
|
2016-08-06 03:45:16 +08:00
|
|
|
}
|
2016-02-10 06:50:34 +08:00
|
|
|
}
|
|
|
|
|
2017-03-09 08:21:25 +08:00
|
|
|
removeRedundantTypeTests();
|
2016-06-25 08:23:04 +08:00
|
|
|
|
2016-02-10 06:50:34 +08:00
|
|
|
// Rebuild each global we touched as part of virtual constant propagation to
|
|
|
|
// include the before and after bytes.
|
|
|
|
if (DidVirtualConstProp)
|
|
|
|
for (VTableBits &B : Bits)
|
|
|
|
rebuildGlobal(B);
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|