2010-05-29 00:19:17 +08:00
|
|
|
//===- Loads.cpp - Local load analysis ------------------------------------===//
|
|
|
|
//
|
2019-01-19 16:50:56 +08:00
|
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
2010-05-29 00:19:17 +08:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// This file defines simple local analyses for load instructions.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#include "llvm/Analysis/Loads.h"
|
|
|
|
#include "llvm/Analysis/AliasAnalysis.h"
|
2019-09-11 05:33:53 +08:00
|
|
|
#include "llvm/Analysis/LoopInfo.h"
|
|
|
|
#include "llvm/Analysis/ScalarEvolution.h"
|
|
|
|
#include "llvm/Analysis/ScalarEvolutionExpressions.h"
|
2013-01-01 01:42:11 +08:00
|
|
|
#include "llvm/Analysis/ValueTracking.h"
|
2013-01-02 19:36:10 +08:00
|
|
|
#include "llvm/IR/DataLayout.h"
|
|
|
|
#include "llvm/IR/GlobalAlias.h"
|
|
|
|
#include "llvm/IR/GlobalVariable.h"
|
|
|
|
#include "llvm/IR/IntrinsicInst.h"
|
|
|
|
#include "llvm/IR/LLVMContext.h"
|
2015-03-04 06:01:13 +08:00
|
|
|
#include "llvm/IR/Module.h"
|
2013-01-02 19:36:10 +08:00
|
|
|
#include "llvm/IR/Operator.h"
|
2016-02-24 20:49:04 +08:00
|
|
|
#include "llvm/IR/Statepoint.h"
|
|
|
|
|
2010-05-29 00:19:17 +08:00
|
|
|
using namespace llvm;
|
|
|
|
|
2019-10-15 21:58:22 +08:00
|
|
|
static MaybeAlign getBaseAlign(const Value *Base, const DataLayout &DL) {
|
|
|
|
if (const MaybeAlign PA = Base->getPointerAlignment(DL))
|
|
|
|
return *PA;
|
|
|
|
Type *const Ty = Base->getType()->getPointerElementType();
|
|
|
|
if (!Ty->isSized())
|
|
|
|
return None;
|
|
|
|
return Align(DL.getABITypeAlignment(Ty));
|
|
|
|
}
|
2016-02-24 20:49:04 +08:00
|
|
|
|
2019-10-15 21:58:22 +08:00
|
|
|
static bool isAligned(const Value *Base, const APInt &Offset, Align Alignment,
|
|
|
|
const DataLayout &DL) {
|
|
|
|
if (MaybeAlign BA = getBaseAlign(Base, DL)) {
|
|
|
|
const APInt APBaseAlign(Offset.getBitWidth(), BA->value());
|
|
|
|
const APInt APAlign(Offset.getBitWidth(), Alignment.value());
|
|
|
|
assert(APAlign.isPowerOf2() && "must be a power of 2!");
|
|
|
|
return APBaseAlign.uge(APAlign) && !(Offset & (APAlign - 1));
|
2016-02-24 20:49:04 +08:00
|
|
|
}
|
2019-10-15 21:58:22 +08:00
|
|
|
return false;
|
2016-02-24 20:49:04 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/// Test if V is always a pointer to allocated and suitably aligned memory for
|
|
|
|
/// a simple load or store.
|
|
|
|
static bool isDereferenceableAndAlignedPointer(
|
2019-10-21 23:10:26 +08:00
|
|
|
const Value *V, Align Alignment, const APInt &Size, const DataLayout &DL,
|
2016-02-24 20:49:04 +08:00
|
|
|
const Instruction *CtxI, const DominatorTree *DT,
|
2016-07-03 07:47:27 +08:00
|
|
|
SmallPtrSetImpl<const Value *> &Visited) {
|
2016-08-31 11:22:32 +08:00
|
|
|
// Already visited? Bail out, we've likely hit unreachable code.
|
|
|
|
if (!Visited.insert(V).second)
|
|
|
|
return false;
|
|
|
|
|
2016-02-24 20:49:04 +08:00
|
|
|
// Note that it is not safe to speculate into a malloc'd region because
|
|
|
|
// malloc may return null.
|
|
|
|
|
Reduce dependence on pointee types when deducing dereferenceability
Summary:
Change some of the internal interfaces in Loads.cpp to keep track of the
number of bytes we're trying to prove dereferenceable using an explicit
`Size` parameter.
Before this, the `Size` parameter was implicitly inferred from the
pointee type of the pointer whose dereferenceability we were trying to
prove, causing us to be conservative around bitcasts. This was
unfortunate since bitcast instructions are no-ops and should never
break optimizations. With an explicit `Size` parameter, we're more
precise (as shown in the test cases), and the code is simpler.
We should eventually move towards a `DerefQuery` struct that groups
together a base pointer, an offset, a size and an alignment; but this
patch is a first step.
Reviewers: apilipenko, dblaikie, hfinkel, reames
Subscribers: mcrosier, llvm-commits
Differential Revision: http://reviews.llvm.org/D20764
llvm-svn: 271406
2016-06-02 00:47:45 +08:00
|
|
|
// bitcast instructions are no-ops as far as dereferenceability is concerned.
|
|
|
|
if (const BitCastOperator *BC = dyn_cast<BitCastOperator>(V))
|
2019-10-21 23:10:26 +08:00
|
|
|
return isDereferenceableAndAlignedPointer(BC->getOperand(0), Alignment,
|
|
|
|
Size, DL, CtxI, DT, Visited);
|
2016-02-24 20:49:04 +08:00
|
|
|
|
2016-06-02 08:52:53 +08:00
|
|
|
bool CheckForNonNull = false;
|
|
|
|
APInt KnownDerefBytes(Size.getBitWidth(),
|
|
|
|
V->getPointerDereferenceableBytes(DL, CheckForNonNull));
|
2019-08-27 07:57:27 +08:00
|
|
|
if (KnownDerefBytes.getBoolValue() && KnownDerefBytes.uge(Size))
|
|
|
|
if (!CheckForNonNull || isKnownNonZero(V, DL, 0, nullptr, CtxI, DT)) {
|
2019-08-27 12:52:35 +08:00
|
|
|
// As we recursed through GEPs to get here, we've incrementally checked
|
|
|
|
// that each step advanced by a multiple of the alignment. If our base is
|
|
|
|
// properly aligned, then the original offset accessed must also be.
|
2019-08-27 07:57:27 +08:00
|
|
|
Type *Ty = V->getType();
|
|
|
|
assert(Ty->isSized() && "must be sized");
|
|
|
|
APInt Offset(DL.getTypeStoreSizeInBits(Ty), 0);
|
2019-10-21 23:10:26 +08:00
|
|
|
return isAligned(V, Offset, Alignment, DL);
|
2019-08-27 07:57:27 +08:00
|
|
|
}
|
2016-02-24 20:49:04 +08:00
|
|
|
|
|
|
|
// For GEPs, determine if the indexing lands within the allocated object.
|
|
|
|
if (const GEPOperator *GEP = dyn_cast<GEPOperator>(V)) {
|
|
|
|
const Value *Base = GEP->getPointerOperand();
|
|
|
|
|
2018-02-14 14:58:08 +08:00
|
|
|
APInt Offset(DL.getIndexTypeSizeInBits(GEP->getType()), 0);
|
Reduce dependence on pointee types when deducing dereferenceability
Summary:
Change some of the internal interfaces in Loads.cpp to keep track of the
number of bytes we're trying to prove dereferenceable using an explicit
`Size` parameter.
Before this, the `Size` parameter was implicitly inferred from the
pointee type of the pointer whose dereferenceability we were trying to
prove, causing us to be conservative around bitcasts. This was
unfortunate since bitcast instructions are no-ops and should never
break optimizations. With an explicit `Size` parameter, we're more
precise (as shown in the test cases), and the code is simpler.
We should eventually move towards a `DerefQuery` struct that groups
together a base pointer, an offset, a size and an alignment; but this
patch is a first step.
Reviewers: apilipenko, dblaikie, hfinkel, reames
Subscribers: mcrosier, llvm-commits
Differential Revision: http://reviews.llvm.org/D20764
llvm-svn: 271406
2016-06-02 00:47:45 +08:00
|
|
|
if (!GEP->accumulateConstantOffset(DL, Offset) || Offset.isNegative() ||
|
2019-10-21 23:10:26 +08:00
|
|
|
!Offset.urem(APInt(Offset.getBitWidth(), Alignment.value()))
|
|
|
|
.isMinValue())
|
2016-02-24 20:49:04 +08:00
|
|
|
return false;
|
|
|
|
|
Reduce dependence on pointee types when deducing dereferenceability
Summary:
Change some of the internal interfaces in Loads.cpp to keep track of the
number of bytes we're trying to prove dereferenceable using an explicit
`Size` parameter.
Before this, the `Size` parameter was implicitly inferred from the
pointee type of the pointer whose dereferenceability we were trying to
prove, causing us to be conservative around bitcasts. This was
unfortunate since bitcast instructions are no-ops and should never
break optimizations. With an explicit `Size` parameter, we're more
precise (as shown in the test cases), and the code is simpler.
We should eventually move towards a `DerefQuery` struct that groups
together a base pointer, an offset, a size and an alignment; but this
patch is a first step.
Reviewers: apilipenko, dblaikie, hfinkel, reames
Subscribers: mcrosier, llvm-commits
Differential Revision: http://reviews.llvm.org/D20764
llvm-svn: 271406
2016-06-02 00:47:45 +08:00
|
|
|
// If the base pointer is dereferenceable for Offset+Size bytes, then the
|
|
|
|
// GEP (== Base + Offset) is dereferenceable for Size bytes. If the base
|
|
|
|
// pointer is aligned to Align bytes, and the Offset is divisible by Align
|
|
|
|
// then the GEP (== Base + Offset == k_0 * Align + k_1 * Align) is also
|
|
|
|
// aligned to Align bytes.
|
|
|
|
|
2016-10-28 23:32:28 +08:00
|
|
|
// Offset and Size may have different bit widths if we have visited an
|
|
|
|
// addrspacecast, so we can't do arithmetic directly on the APInt values.
|
|
|
|
return isDereferenceableAndAlignedPointer(
|
2019-10-21 23:10:26 +08:00
|
|
|
Base, Alignment, Offset + Size.sextOrTrunc(Offset.getBitWidth()), DL,
|
|
|
|
CtxI, DT, Visited);
|
2016-02-24 20:49:04 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// For gc.relocate, look through relocations
|
|
|
|
if (const GCRelocateInst *RelocateInst = dyn_cast<GCRelocateInst>(V))
|
|
|
|
return isDereferenceableAndAlignedPointer(
|
2019-10-21 23:10:26 +08:00
|
|
|
RelocateInst->getDerivedPtr(), Alignment, Size, DL, CtxI, DT, Visited);
|
2016-02-24 20:49:04 +08:00
|
|
|
|
|
|
|
if (const AddrSpaceCastInst *ASC = dyn_cast<AddrSpaceCastInst>(V))
|
2019-10-21 23:10:26 +08:00
|
|
|
return isDereferenceableAndAlignedPointer(ASC->getOperand(0), Alignment,
|
|
|
|
Size, DL, CtxI, DT, Visited);
|
2016-02-24 20:49:04 +08:00
|
|
|
|
2019-01-07 13:42:51 +08:00
|
|
|
if (const auto *Call = dyn_cast<CallBase>(V))
|
2019-08-15 20:13:02 +08:00
|
|
|
if (auto *RP = getArgumentAliasingToReturnedPointer(Call, true))
|
2019-10-21 23:10:26 +08:00
|
|
|
return isDereferenceableAndAlignedPointer(RP, Alignment, Size, DL, CtxI,
|
|
|
|
DT, Visited);
|
2018-05-23 17:16:44 +08:00
|
|
|
|
2016-02-24 20:49:04 +08:00
|
|
|
// If we don't know, assume the worst.
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2019-10-21 23:10:26 +08:00
|
|
|
bool llvm::isDereferenceableAndAlignedPointer(const Value *V, Align Alignment,
|
2017-06-24 09:35:13 +08:00
|
|
|
const APInt &Size,
|
|
|
|
const DataLayout &DL,
|
|
|
|
const Instruction *CtxI,
|
|
|
|
const DominatorTree *DT) {
|
2019-08-28 07:36:31 +08:00
|
|
|
// Note: At the moment, Size can be zero. This ends up being interpreted as
|
|
|
|
// a query of whether [Base, V] is dereferenceable and V is aligned (since
|
|
|
|
// that's what the implementation happened to do). It's unclear if this is
|
|
|
|
// the desired semantic, but at least SelectionDAG does exercise this case.
|
|
|
|
|
2017-06-24 09:35:13 +08:00
|
|
|
SmallPtrSet<const Value *, 32> Visited;
|
2019-10-21 23:10:26 +08:00
|
|
|
return ::isDereferenceableAndAlignedPointer(V, Alignment, Size, DL, CtxI, DT,
|
2017-06-24 09:35:13 +08:00
|
|
|
Visited);
|
|
|
|
}
|
|
|
|
|
2019-07-09 19:35:35 +08:00
|
|
|
bool llvm::isDereferenceableAndAlignedPointer(const Value *V, Type *Ty,
|
2019-10-21 23:10:26 +08:00
|
|
|
MaybeAlign MA,
|
2016-02-24 20:49:04 +08:00
|
|
|
const DataLayout &DL,
|
|
|
|
const Instruction *CtxI,
|
2016-07-03 07:47:27 +08:00
|
|
|
const DominatorTree *DT) {
|
2020-01-22 18:42:57 +08:00
|
|
|
// For unsized types or scalable vectors we don't know exactly how many bytes
|
|
|
|
// are dereferenced, so bail out.
|
|
|
|
if (!Ty->isSized() || (Ty->isVectorTy() && Ty->getVectorIsScalable()))
|
2019-10-21 23:10:26 +08:00
|
|
|
return false;
|
|
|
|
|
2016-02-24 20:49:04 +08:00
|
|
|
// When dereferenceability information is provided by a dereferenceable
|
|
|
|
// attribute, we know exactly how many bytes are dereferenceable. If we can
|
|
|
|
// determine the exact offset to the attributed variable, we can use that
|
|
|
|
// information here.
|
|
|
|
|
|
|
|
// Require ABI alignment for loads without alignment specification
|
2019-10-21 23:10:26 +08:00
|
|
|
const Align Alignment = DL.getValueOrABITypeAlignment(MA, Ty);
|
2019-12-13 17:55:45 +08:00
|
|
|
APInt AccessSize(DL.getPointerTypeSizeInBits(V->getType()),
|
2019-08-28 07:36:31 +08:00
|
|
|
DL.getTypeStoreSize(Ty));
|
2019-10-21 23:10:26 +08:00
|
|
|
return isDereferenceableAndAlignedPointer(V, Alignment, AccessSize, DL, CtxI,
|
|
|
|
DT);
|
2016-02-24 20:49:04 +08:00
|
|
|
}
|
|
|
|
|
2019-07-09 19:35:35 +08:00
|
|
|
bool llvm::isDereferenceablePointer(const Value *V, Type *Ty,
|
|
|
|
const DataLayout &DL,
|
2016-02-24 20:49:04 +08:00
|
|
|
const Instruction *CtxI,
|
2016-07-03 07:47:27 +08:00
|
|
|
const DominatorTree *DT) {
|
2019-10-21 23:10:26 +08:00
|
|
|
return isDereferenceableAndAlignedPointer(V, Ty, Align::None(), DL, CtxI, DT);
|
2016-02-24 20:49:04 +08:00
|
|
|
}
|
|
|
|
|
2018-05-01 23:54:18 +08:00
|
|
|
/// Test if A and B will obviously have the same value.
|
2014-10-19 07:31:55 +08:00
|
|
|
///
|
|
|
|
/// This includes recognizing that %t0 and %t1 will have the same
|
2010-05-29 00:19:17 +08:00
|
|
|
/// value in code like this:
|
2014-10-19 07:31:55 +08:00
|
|
|
/// \code
|
2010-05-29 00:19:17 +08:00
|
|
|
/// %t0 = getelementptr \@a, 0, 3
|
|
|
|
/// store i32 0, i32* %t0
|
|
|
|
/// %t1 = getelementptr \@a, 0, 3
|
|
|
|
/// %t2 = load i32* %t1
|
2014-10-19 07:31:55 +08:00
|
|
|
/// \endcode
|
2010-05-29 00:19:17 +08:00
|
|
|
///
|
|
|
|
static bool AreEquivalentAddressValues(const Value *A, const Value *B) {
|
|
|
|
// Test if the values are trivially equivalent.
|
2014-10-19 07:41:25 +08:00
|
|
|
if (A == B)
|
|
|
|
return true;
|
2011-06-04 01:15:37 +08:00
|
|
|
|
2010-05-29 00:19:17 +08:00
|
|
|
// Test if the values come from identical arithmetic instructions.
|
|
|
|
// Use isIdenticalToWhenDefined instead of isIdenticalTo because
|
|
|
|
// this function is only used when one address use dominates the
|
|
|
|
// other, which means that they'll always either have the same
|
|
|
|
// value or one of them will have an undefined value.
|
2014-10-19 07:41:25 +08:00
|
|
|
if (isa<BinaryOperator>(A) || isa<CastInst>(A) || isa<PHINode>(A) ||
|
|
|
|
isa<GetElementPtrInst>(A))
|
2010-05-29 00:19:17 +08:00
|
|
|
if (const Instruction *BI = dyn_cast<Instruction>(B))
|
|
|
|
if (cast<Instruction>(A)->isIdenticalToWhenDefined(BI))
|
|
|
|
return true;
|
2011-06-04 01:15:37 +08:00
|
|
|
|
2010-05-29 00:19:17 +08:00
|
|
|
// Otherwise they may not be equivalent.
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2019-09-11 05:33:53 +08:00
|
|
|
bool llvm::isDereferenceableAndAlignedInLoop(LoadInst *LI, Loop *L,
|
|
|
|
ScalarEvolution &SE,
|
|
|
|
DominatorTree &DT) {
|
|
|
|
auto &DL = LI->getModule()->getDataLayout();
|
|
|
|
Value *Ptr = LI->getPointerOperand();
|
2019-09-13 00:49:10 +08:00
|
|
|
|
|
|
|
APInt EltSize(DL.getIndexTypeSizeInBits(Ptr->getType()),
|
|
|
|
DL.getTypeStoreSize(LI->getType()));
|
2019-10-21 23:10:26 +08:00
|
|
|
const Align Alignment = DL.getValueOrABITypeAlignment(
|
|
|
|
MaybeAlign(LI->getAlignment()), LI->getType());
|
2019-09-13 00:49:10 +08:00
|
|
|
|
|
|
|
Instruction *HeaderFirstNonPHI = L->getHeader()->getFirstNonPHI();
|
|
|
|
|
|
|
|
// If given a uniform (i.e. non-varying) address, see if we can prove the
|
|
|
|
// access is safe within the loop w/o needing predication.
|
|
|
|
if (L->isLoopInvariant(Ptr))
|
2019-10-21 23:10:26 +08:00
|
|
|
return isDereferenceableAndAlignedPointer(Ptr, Alignment, EltSize, DL,
|
|
|
|
HeaderFirstNonPHI, &DT);
|
2019-09-13 00:49:10 +08:00
|
|
|
|
|
|
|
// Otherwise, check to see if we have a repeating access pattern where we can
|
|
|
|
// prove that all accesses are well aligned and dereferenceable.
|
2019-09-11 05:33:53 +08:00
|
|
|
auto *AddRec = dyn_cast<SCEVAddRecExpr>(SE.getSCEV(Ptr));
|
|
|
|
if (!AddRec || AddRec->getLoop() != L || !AddRec->isAffine())
|
|
|
|
return false;
|
|
|
|
auto* Step = dyn_cast<SCEVConstant>(AddRec->getStepRecurrence(SE));
|
|
|
|
if (!Step)
|
|
|
|
return false;
|
|
|
|
// TODO: generalize to access patterns which have gaps
|
2019-09-13 00:49:10 +08:00
|
|
|
if (Step->getAPInt() != EltSize)
|
2019-09-11 05:33:53 +08:00
|
|
|
return false;
|
|
|
|
|
|
|
|
// TODO: If the symbolic trip count has a small bound (max count), we might
|
|
|
|
// be able to prove safety.
|
|
|
|
auto TC = SE.getSmallConstantTripCount(L);
|
|
|
|
if (!TC)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
const APInt AccessSize = TC * EltSize;
|
|
|
|
|
|
|
|
auto *StartS = dyn_cast<SCEVUnknown>(AddRec->getStart());
|
|
|
|
if (!StartS)
|
|
|
|
return false;
|
|
|
|
assert(SE.isLoopInvariant(StartS, L) && "implied by addrec definition");
|
|
|
|
Value *Base = StartS->getValue();
|
|
|
|
|
|
|
|
// For the moment, restrict ourselves to the case where the access size is a
|
|
|
|
// multiple of the requested alignment and the base is aligned.
|
|
|
|
// TODO: generalize if a case found which warrants
|
2019-10-21 23:10:26 +08:00
|
|
|
if (EltSize.urem(Alignment.value()) != 0)
|
2019-09-11 05:33:53 +08:00
|
|
|
return false;
|
2019-10-21 23:10:26 +08:00
|
|
|
return isDereferenceableAndAlignedPointer(Base, Alignment, AccessSize, DL,
|
|
|
|
HeaderFirstNonPHI, &DT);
|
2019-09-11 05:33:53 +08:00
|
|
|
}
|
|
|
|
|
2018-05-01 23:54:18 +08:00
|
|
|
/// Check if executing a load of this pointer value cannot trap.
|
2014-10-19 07:46:17 +08:00
|
|
|
///
|
2016-04-27 19:00:48 +08:00
|
|
|
/// If DT and ScanFrom are specified this method performs context-sensitive
|
|
|
|
/// analysis and returns true if it is safe to load immediately before ScanFrom.
|
2016-02-11 21:42:59 +08:00
|
|
|
///
|
2014-10-19 07:46:17 +08:00
|
|
|
/// If it is not obviously safe to load from the specified pointer, we do
|
|
|
|
/// a quick local scan of the basic block containing \c ScanFrom, to determine
|
|
|
|
/// if the address is already accessed.
|
|
|
|
///
|
|
|
|
/// This uses the pointee type to determine how many bytes need to be safe to
|
|
|
|
/// load from the pointer.
|
2019-10-21 23:10:26 +08:00
|
|
|
bool llvm::isSafeToLoadUnconditionally(Value *V, MaybeAlign MA, APInt &Size,
|
2016-04-27 19:00:48 +08:00
|
|
|
const DataLayout &DL,
|
2016-02-11 21:42:59 +08:00
|
|
|
Instruction *ScanFrom,
|
2016-07-03 07:47:27 +08:00
|
|
|
const DominatorTree *DT) {
|
2015-06-25 20:18:43 +08:00
|
|
|
// Zero alignment means that the load has the ABI alignment for the target
|
2019-10-21 23:10:26 +08:00
|
|
|
const Align Alignment =
|
|
|
|
DL.getValueOrABITypeAlignment(MA, V->getType()->getPointerElementType());
|
2015-06-25 20:18:43 +08:00
|
|
|
|
2016-02-11 21:42:59 +08:00
|
|
|
// If DT is not specified we can't make context-sensitive query
|
|
|
|
const Instruction* CtxI = DT ? ScanFrom : nullptr;
|
2019-10-21 23:10:26 +08:00
|
|
|
if (isDereferenceableAndAlignedPointer(V, Alignment, Size, DL, CtxI, DT))
|
2016-01-17 20:35:29 +08:00
|
|
|
return true;
|
|
|
|
|
2019-08-28 03:34:43 +08:00
|
|
|
if (!ScanFrom)
|
2013-01-01 01:42:11 +08:00
|
|
|
return false;
|
2010-05-29 00:19:17 +08:00
|
|
|
|
2019-08-28 03:34:43 +08:00
|
|
|
if (Size.getBitWidth() > 64)
|
2016-04-27 19:00:48 +08:00
|
|
|
return false;
|
2019-08-28 03:34:43 +08:00
|
|
|
const uint64_t LoadSize = Size.getZExtValue();
|
2016-04-27 19:00:48 +08:00
|
|
|
|
2010-05-29 00:19:17 +08:00
|
|
|
// Otherwise, be a little bit aggressive by scanning the local block where we
|
|
|
|
// want to check to see if the pointer is already being loaded or stored
|
|
|
|
// from/to. If so, the previous load or store would have already trapped,
|
|
|
|
// so there is no harm doing an extra load (also, CSE will later eliminate
|
|
|
|
// the load entirely).
|
Analysis: Remove implicit ilist iterator conversions
Remove implicit ilist iterator conversions from LLVMAnalysis.
I came across something really scary in `llvm::isKnownNotFullPoison()`
which relied on `Instruction::getNextNode()` being completely broken
(not surprising, but scary nevertheless). This function is documented
(and coded to) return `nullptr` when it gets to the sentinel, but with
an `ilist_half_node` as a sentinel, the sentinel check looks into some
other memory and we don't recognize we've hit the end.
Rooting out these scary cases is the reason I'm removing the implicit
conversions before doing anything else with `ilist`; I'm not at all
surprised that clients rely on badness.
I found another scary case -- this time, not relying on badness, just
bad (but I guess getting lucky so far) -- in
`ObjectSizeOffsetEvaluator::compute_()`. Here, we save out the
insertion point, do some things, and then restore it. Previously, we
let the iterator auto-convert to `Instruction*`, and then set it back
using the `Instruction*` version:
Instruction *PrevInsertPoint = Builder.GetInsertPoint();
/* Logic that may change insert point */
if (PrevInsertPoint)
Builder.SetInsertPoint(PrevInsertPoint);
The check for `PrevInsertPoint` doesn't protect correctly against bad
accesses. If the insertion point has been set to the end of a basic
block (i.e., `SetInsertPoint(SomeBB)`), then `GetInsertPoint()` returns
an iterator pointing at the list sentinel. The version of
`SetInsertPoint()` that's getting called will then call
`PrevInsertPoint->getParent()`, which explodes horribly. The only
reason this hasn't blown up is that it's fairly unlikely the builder is
adding to the end of the block; usually, we're adding instructions
somewhere before the terminator.
llvm-svn: 249925
2015-10-10 08:53:03 +08:00
|
|
|
BasicBlock::iterator BBI = ScanFrom->getIterator(),
|
|
|
|
E = ScanFrom->getParent()->begin();
|
2010-05-29 00:19:17 +08:00
|
|
|
|
2014-10-20 08:24:14 +08:00
|
|
|
// We can at least always strip pointer casts even though we can't use the
|
|
|
|
// base here.
|
|
|
|
V = V->stripPointerCasts();
|
|
|
|
|
2010-05-29 00:19:17 +08:00
|
|
|
while (BBI != E) {
|
|
|
|
--BBI;
|
|
|
|
|
|
|
|
// If we see a free or a call which may write to memory (i.e. which might do
|
|
|
|
// a free) the pointer could be marked invalid.
|
|
|
|
if (isa<CallInst>(BBI) && BBI->mayWriteToMemory() &&
|
|
|
|
!isa<DbgInfoIntrinsic>(BBI))
|
|
|
|
return false;
|
|
|
|
|
2014-10-20 08:24:14 +08:00
|
|
|
Value *AccessedPtr;
|
2019-10-21 23:10:26 +08:00
|
|
|
MaybeAlign MaybeAccessedAlign;
|
2015-06-25 20:18:43 +08:00
|
|
|
if (LoadInst *LI = dyn_cast<LoadInst>(BBI)) {
|
2019-01-25 05:31:13 +08:00
|
|
|
// Ignore volatile loads. The execution of a volatile load cannot
|
|
|
|
// be used to prove an address is backed by regular memory; it can,
|
|
|
|
// for example, point to an MMIO register.
|
|
|
|
if (LI->isVolatile())
|
|
|
|
continue;
|
2014-10-20 08:24:14 +08:00
|
|
|
AccessedPtr = LI->getPointerOperand();
|
2019-10-21 23:10:26 +08:00
|
|
|
MaybeAccessedAlign = MaybeAlign(LI->getAlignment());
|
2015-06-25 20:18:43 +08:00
|
|
|
} else if (StoreInst *SI = dyn_cast<StoreInst>(BBI)) {
|
2019-01-25 05:31:13 +08:00
|
|
|
// Ignore volatile stores (see comment for loads).
|
|
|
|
if (SI->isVolatile())
|
|
|
|
continue;
|
2014-10-20 08:24:14 +08:00
|
|
|
AccessedPtr = SI->getPointerOperand();
|
2019-10-21 23:10:26 +08:00
|
|
|
MaybeAccessedAlign = MaybeAlign(SI->getAlignment());
|
2015-06-25 20:18:43 +08:00
|
|
|
} else
|
|
|
|
continue;
|
|
|
|
|
|
|
|
Type *AccessedTy = AccessedPtr->getType()->getPointerElementType();
|
2019-10-21 23:10:26 +08:00
|
|
|
|
|
|
|
const Align AccessedAlign =
|
|
|
|
DL.getValueOrABITypeAlignment(MaybeAccessedAlign, AccessedTy);
|
|
|
|
if (AccessedAlign < Alignment)
|
2014-10-20 08:24:14 +08:00
|
|
|
continue;
|
|
|
|
|
2015-03-10 10:37:25 +08:00
|
|
|
// Handle trivial cases.
|
2019-08-28 03:34:43 +08:00
|
|
|
if (AccessedPtr == V &&
|
|
|
|
LoadSize <= DL.getTypeStoreSize(AccessedTy))
|
2014-10-20 08:24:14 +08:00
|
|
|
return true;
|
|
|
|
|
|
|
|
if (AreEquivalentAddressValues(AccessedPtr->stripPointerCasts(), V) &&
|
2015-06-25 20:18:43 +08:00
|
|
|
LoadSize <= DL.getTypeStoreSize(AccessedTy))
|
2014-10-20 08:24:14 +08:00
|
|
|
return true;
|
2010-05-29 00:19:17 +08:00
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2019-10-21 23:10:26 +08:00
|
|
|
bool llvm::isSafeToLoadUnconditionally(Value *V, Type *Ty, MaybeAlign Alignment,
|
2019-07-09 19:35:35 +08:00
|
|
|
const DataLayout &DL,
|
|
|
|
Instruction *ScanFrom,
|
|
|
|
const DominatorTree *DT) {
|
|
|
|
APInt Size(DL.getIndexTypeSizeInBits(V->getType()), DL.getTypeStoreSize(Ty));
|
2019-10-21 23:10:26 +08:00
|
|
|
return isSafeToLoadUnconditionally(V, Alignment, Size, DL, ScanFrom, DT);
|
2019-07-09 19:35:35 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/// DefMaxInstsToScan - the default number of maximum instructions
|
2015-09-19 03:14:35 +08:00
|
|
|
/// to scan in the block, used by FindAvailableLoadedValue().
|
|
|
|
/// FindAvailableLoadedValue() was introduced in r60148, to improve jump
|
|
|
|
/// threading in part by eliminating partially redundant loads.
|
|
|
|
/// At that point, the value of MaxInstsToScan was already set to '6'
|
|
|
|
/// without documented explanation.
|
|
|
|
cl::opt<unsigned>
|
|
|
|
llvm::DefMaxInstsToScan("available-load-scan-limit", cl::init(6), cl::Hidden,
|
|
|
|
cl::desc("Use this to specify the default maximum number of instructions "
|
|
|
|
"to scan backward from a given instruction, when searching for "
|
|
|
|
"available loaded value"));
|
|
|
|
|
2016-08-08 12:10:22 +08:00
|
|
|
Value *llvm::FindAvailableLoadedValue(LoadInst *Load,
|
|
|
|
BasicBlock *ScanBB,
|
2010-05-29 00:19:17 +08:00
|
|
|
BasicBlock::iterator &ScanFrom,
|
|
|
|
unsigned MaxInstsToScan,
|
2017-03-19 23:27:52 +08:00
|
|
|
AliasAnalysis *AA, bool *IsLoad,
|
2017-02-02 23:12:34 +08:00
|
|
|
unsigned *NumScanedInst) {
|
2017-03-19 23:27:52 +08:00
|
|
|
// Don't CSE load that is volatile or anything stronger than unordered.
|
2016-07-09 06:15:08 +08:00
|
|
|
if (!Load->isUnordered())
|
|
|
|
return nullptr;
|
|
|
|
|
2017-03-19 23:27:52 +08:00
|
|
|
return FindAvailablePtrLoadStore(
|
|
|
|
Load->getPointerOperand(), Load->getType(), Load->isAtomic(), ScanBB,
|
|
|
|
ScanFrom, MaxInstsToScan, AA, IsLoad, NumScanedInst);
|
|
|
|
}
|
|
|
|
|
|
|
|
Value *llvm::FindAvailablePtrLoadStore(Value *Ptr, Type *AccessTy,
|
|
|
|
bool AtLeastAtomic, BasicBlock *ScanBB,
|
|
|
|
BasicBlock::iterator &ScanFrom,
|
|
|
|
unsigned MaxInstsToScan,
|
|
|
|
AliasAnalysis *AA, bool *IsLoadCSE,
|
|
|
|
unsigned *NumScanedInst) {
|
|
|
|
if (MaxInstsToScan == 0)
|
|
|
|
MaxInstsToScan = ~0U;
|
|
|
|
|
2015-03-05 02:43:29 +08:00
|
|
|
const DataLayout &DL = ScanBB->getModule()->getDataLayout();
|
2014-10-20 08:24:14 +08:00
|
|
|
Value *StrippedPtr = Ptr->stripPointerCasts();
|
2014-10-19 07:19:03 +08:00
|
|
|
|
2010-05-29 00:19:17 +08:00
|
|
|
while (ScanFrom != ScanBB->begin()) {
|
|
|
|
// We must ignore debug info directives when counting (otherwise they
|
|
|
|
// would affect codegen).
|
Analysis: Remove implicit ilist iterator conversions
Remove implicit ilist iterator conversions from LLVMAnalysis.
I came across something really scary in `llvm::isKnownNotFullPoison()`
which relied on `Instruction::getNextNode()` being completely broken
(not surprising, but scary nevertheless). This function is documented
(and coded to) return `nullptr` when it gets to the sentinel, but with
an `ilist_half_node` as a sentinel, the sentinel check looks into some
other memory and we don't recognize we've hit the end.
Rooting out these scary cases is the reason I'm removing the implicit
conversions before doing anything else with `ilist`; I'm not at all
surprised that clients rely on badness.
I found another scary case -- this time, not relying on badness, just
bad (but I guess getting lucky so far) -- in
`ObjectSizeOffsetEvaluator::compute_()`. Here, we save out the
insertion point, do some things, and then restore it. Previously, we
let the iterator auto-convert to `Instruction*`, and then set it back
using the `Instruction*` version:
Instruction *PrevInsertPoint = Builder.GetInsertPoint();
/* Logic that may change insert point */
if (PrevInsertPoint)
Builder.SetInsertPoint(PrevInsertPoint);
The check for `PrevInsertPoint` doesn't protect correctly against bad
accesses. If the insertion point has been set to the end of a basic
block (i.e., `SetInsertPoint(SomeBB)`), then `GetInsertPoint()` returns
an iterator pointing at the list sentinel. The version of
`SetInsertPoint()` that's getting called will then call
`PrevInsertPoint->getParent()`, which explodes horribly. The only
reason this hasn't blown up is that it's fairly unlikely the builder is
adding to the end of the block; usually, we're adding instructions
somewhere before the terminator.
llvm-svn: 249925
2015-10-10 08:53:03 +08:00
|
|
|
Instruction *Inst = &*--ScanFrom;
|
2010-05-29 00:19:17 +08:00
|
|
|
if (isa<DbgInfoIntrinsic>(Inst))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
// Restore ScanFrom to expected value in case next test succeeds
|
|
|
|
ScanFrom++;
|
2014-10-19 07:19:03 +08:00
|
|
|
|
2017-02-02 23:12:34 +08:00
|
|
|
if (NumScanedInst)
|
|
|
|
++(*NumScanedInst);
|
|
|
|
|
2010-05-29 00:19:17 +08:00
|
|
|
// Don't scan huge blocks.
|
2014-10-19 07:19:03 +08:00
|
|
|
if (MaxInstsToScan-- == 0)
|
|
|
|
return nullptr;
|
|
|
|
|
2010-05-29 00:19:17 +08:00
|
|
|
--ScanFrom;
|
|
|
|
// If this is a load of Ptr, the loaded value is available.
|
2011-08-16 05:56:39 +08:00
|
|
|
// (This is true even if the load is volatile or atomic, although
|
|
|
|
// those cases are unlikely.)
|
2016-06-25 02:42:58 +08:00
|
|
|
if (LoadInst *LI = dyn_cast<LoadInst>(Inst))
|
|
|
|
if (AreEquivalentAddressValues(
|
|
|
|
LI->getPointerOperand()->stripPointerCasts(), StrippedPtr) &&
|
2015-03-10 10:37:25 +08:00
|
|
|
CastInst::isBitOrNoopPointerCastable(LI->getType(), AccessTy, DL)) {
|
2016-04-22 00:51:08 +08:00
|
|
|
|
|
|
|
// We can value forward from an atomic to a non-atomic, but not the
|
|
|
|
// other way around.
|
2017-03-19 23:27:52 +08:00
|
|
|
if (LI->isAtomic() < AtLeastAtomic)
|
2016-04-22 00:51:08 +08:00
|
|
|
return nullptr;
|
|
|
|
|
2016-06-16 10:33:42 +08:00
|
|
|
if (IsLoadCSE)
|
|
|
|
*IsLoadCSE = true;
|
2010-05-29 00:19:17 +08:00
|
|
|
return LI;
|
2012-03-14 02:07:41 +08:00
|
|
|
}
|
2014-10-19 07:19:03 +08:00
|
|
|
|
2019-11-07 20:09:32 +08:00
|
|
|
// Try to get the store size for the type.
|
|
|
|
auto AccessSize = LocationSize::precise(DL.getTypeStoreSize(AccessTy));
|
|
|
|
|
2010-05-29 00:19:17 +08:00
|
|
|
if (StoreInst *SI = dyn_cast<StoreInst>(Inst)) {
|
2014-10-20 08:24:14 +08:00
|
|
|
Value *StorePtr = SI->getPointerOperand()->stripPointerCasts();
|
2010-05-29 00:19:17 +08:00
|
|
|
// If this is a store through Ptr, the value is available!
|
2011-08-16 05:56:39 +08:00
|
|
|
// (This is true even if the store is volatile or atomic, although
|
|
|
|
// those cases are unlikely.)
|
2014-10-20 08:24:14 +08:00
|
|
|
if (AreEquivalentAddressValues(StorePtr, StrippedPtr) &&
|
2014-11-25 16:20:27 +08:00
|
|
|
CastInst::isBitOrNoopPointerCastable(SI->getValueOperand()->getType(),
|
2015-03-10 10:37:25 +08:00
|
|
|
AccessTy, DL)) {
|
2016-04-22 00:51:08 +08:00
|
|
|
|
|
|
|
// We can value forward from an atomic to a non-atomic, but not the
|
|
|
|
// other way around.
|
2017-03-19 23:27:52 +08:00
|
|
|
if (SI->isAtomic() < AtLeastAtomic)
|
2016-04-22 00:51:08 +08:00
|
|
|
return nullptr;
|
|
|
|
|
2016-08-08 12:10:22 +08:00
|
|
|
if (IsLoadCSE)
|
|
|
|
*IsLoadCSE = false;
|
2010-05-29 00:19:17 +08:00
|
|
|
return SI->getOperand(0);
|
2012-03-14 02:07:41 +08:00
|
|
|
}
|
2014-10-19 07:19:03 +08:00
|
|
|
|
2014-10-20 18:03:01 +08:00
|
|
|
// If both StrippedPtr and StorePtr reach all the way to an alloca or
|
|
|
|
// global and they are different, ignore the store. This is a trivial form
|
|
|
|
// of alias analysis that is important for reg2mem'd code.
|
2014-10-20 08:24:14 +08:00
|
|
|
if ((isa<AllocaInst>(StrippedPtr) || isa<GlobalVariable>(StrippedPtr)) &&
|
2014-10-20 18:03:01 +08:00
|
|
|
(isa<AllocaInst>(StorePtr) || isa<GlobalVariable>(StorePtr)) &&
|
|
|
|
StrippedPtr != StorePtr)
|
2010-05-29 00:19:17 +08:00
|
|
|
continue;
|
2014-10-19 07:19:03 +08:00
|
|
|
|
2010-05-29 00:19:17 +08:00
|
|
|
// If we have alias analysis and it says the store won't modify the loaded
|
|
|
|
// value, ignore the store.
|
2017-12-06 04:12:23 +08:00
|
|
|
if (AA && !isModSet(AA->getModRefInfo(SI, StrippedPtr, AccessSize)))
|
2010-05-29 00:19:17 +08:00
|
|
|
continue;
|
2014-10-19 07:19:03 +08:00
|
|
|
|
2010-05-29 00:19:17 +08:00
|
|
|
// Otherwise the store that may or may not alias the pointer, bail out.
|
|
|
|
++ScanFrom;
|
2014-04-15 12:59:12 +08:00
|
|
|
return nullptr;
|
2010-05-29 00:19:17 +08:00
|
|
|
}
|
2014-10-19 07:19:03 +08:00
|
|
|
|
2010-05-29 00:19:17 +08:00
|
|
|
// If this is some other instruction that may clobber Ptr, bail out.
|
|
|
|
if (Inst->mayWriteToMemory()) {
|
|
|
|
// If alias analysis claims that it really won't modify the load,
|
|
|
|
// ignore it.
|
2017-12-06 04:12:23 +08:00
|
|
|
if (AA && !isModSet(AA->getModRefInfo(Inst, StrippedPtr, AccessSize)))
|
2010-05-29 00:19:17 +08:00
|
|
|
continue;
|
2014-10-19 07:19:03 +08:00
|
|
|
|
2010-05-29 00:19:17 +08:00
|
|
|
// May modify the pointer, bail out.
|
|
|
|
++ScanFrom;
|
2014-04-15 12:59:12 +08:00
|
|
|
return nullptr;
|
2010-05-29 00:19:17 +08:00
|
|
|
}
|
|
|
|
}
|
2014-10-19 07:19:03 +08:00
|
|
|
|
2010-05-29 00:19:17 +08:00
|
|
|
// Got to the start of the block, we didn't find it, but are done for this
|
|
|
|
// block.
|
2014-04-15 12:59:12 +08:00
|
|
|
return nullptr;
|
2010-05-29 00:19:17 +08:00
|
|
|
}
|