2010-04-09 02:47:09 +08:00
|
|
|
//===-- Lint.cpp - Check for common errors in LLVM IR ---------------------===//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// This pass statically checks for common and easily-identified constructs
|
|
|
|
// which produce undefined or likely unintended behavior in LLVM IR.
|
|
|
|
//
|
|
|
|
// It is not a guarantee of correctness, in two ways. First, it isn't
|
|
|
|
// comprehensive. There are checks which could be done statically which are
|
|
|
|
// not yet implemented. Some of these are indicated by TODO comments, but
|
|
|
|
// those aren't comprehensive either. Second, many conditions cannot be
|
|
|
|
// checked statically. This pass does no dynamic instrumentation, so it
|
|
|
|
// can't check for all possible problems.
|
2014-03-07 01:33:55 +08:00
|
|
|
//
|
2010-04-09 02:47:09 +08:00
|
|
|
// Another limitation is that it assumes all code will be executed. A store
|
|
|
|
// through a null pointer in a basic block which is never reached is harmless,
|
2010-07-06 23:21:57 +08:00
|
|
|
// but this pass will warn about it anyway. This is the main reason why most
|
|
|
|
// of these checks live here instead of in the Verifier pass.
|
2010-04-22 09:30:05 +08:00
|
|
|
//
|
2010-04-09 02:47:09 +08:00
|
|
|
// Optimization passes may make conditions that this pass checks for more or
|
|
|
|
// less obvious. If an optimization pass appears to be introducing a warning,
|
|
|
|
// it may be that the optimization pass is merely exposing an existing
|
|
|
|
// condition in the code.
|
2014-03-07 01:33:55 +08:00
|
|
|
//
|
2010-04-09 02:47:09 +08:00
|
|
|
// This code may be run before instcombine. In many cases, instcombine checks
|
|
|
|
// for the same kinds of things and turns instructions with undefined behavior
|
|
|
|
// into unreachable (or equivalent). Because of this, this pass makes some
|
|
|
|
// effort to look through bitcasts and so on.
|
2014-03-07 01:33:55 +08:00
|
|
|
//
|
2010-04-09 02:47:09 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2012-12-04 00:50:05 +08:00
|
|
|
#include "llvm/Analysis/Lint.h"
|
2016-08-13 08:50:41 +08:00
|
|
|
#include "llvm/ADT/APInt.h"
|
|
|
|
#include "llvm/ADT/ArrayRef.h"
|
|
|
|
#include "llvm/ADT/SmallPtrSet.h"
|
|
|
|
#include "llvm/ADT/Twine.h"
|
2010-04-09 02:47:09 +08:00
|
|
|
#include "llvm/Analysis/AliasAnalysis.h"
|
2016-12-19 16:22:17 +08:00
|
|
|
#include "llvm/Analysis/AssumptionCache.h"
|
2010-05-29 00:21:24 +08:00
|
|
|
#include "llvm/Analysis/ConstantFolding.h"
|
2012-12-04 00:50:05 +08:00
|
|
|
#include "llvm/Analysis/InstructionSimplify.h"
|
2010-05-29 00:21:24 +08:00
|
|
|
#include "llvm/Analysis/Loads.h"
|
2016-08-13 08:50:41 +08:00
|
|
|
#include "llvm/Analysis/MemoryLocation.h"
|
2012-12-04 00:50:05 +08:00
|
|
|
#include "llvm/Analysis/Passes.h"
|
2015-01-15 10:16:27 +08:00
|
|
|
#include "llvm/Analysis/TargetLibraryInfo.h"
|
2010-04-09 02:47:09 +08:00
|
|
|
#include "llvm/Analysis/ValueTracking.h"
|
2016-08-13 08:50:41 +08:00
|
|
|
#include "llvm/IR/Argument.h"
|
|
|
|
#include "llvm/IR/BasicBlock.h"
|
2014-03-04 19:01:28 +08:00
|
|
|
#include "llvm/IR/CallSite.h"
|
2016-08-13 08:50:41 +08:00
|
|
|
#include "llvm/IR/Constant.h"
|
|
|
|
#include "llvm/IR/Constants.h"
|
2013-01-02 19:36:10 +08:00
|
|
|
#include "llvm/IR/DataLayout.h"
|
2016-08-13 08:50:41 +08:00
|
|
|
#include "llvm/IR/DerivedTypes.h"
|
2014-01-13 17:26:24 +08:00
|
|
|
#include "llvm/IR/Dominators.h"
|
2013-01-02 19:36:10 +08:00
|
|
|
#include "llvm/IR/Function.h"
|
2016-08-13 08:50:41 +08:00
|
|
|
#include "llvm/IR/GlobalVariable.h"
|
2014-03-06 11:23:41 +08:00
|
|
|
#include "llvm/IR/InstVisitor.h"
|
2016-08-13 08:50:41 +08:00
|
|
|
#include "llvm/IR/InstrTypes.h"
|
|
|
|
#include "llvm/IR/Instruction.h"
|
|
|
|
#include "llvm/IR/Instructions.h"
|
2013-01-02 19:36:10 +08:00
|
|
|
#include "llvm/IR/IntrinsicInst.h"
|
2015-02-13 18:01:29 +08:00
|
|
|
#include "llvm/IR/LegacyPassManager.h"
|
2017-06-06 19:49:48 +08:00
|
|
|
#include "llvm/IR/Module.h"
|
2016-08-13 08:50:41 +08:00
|
|
|
#include "llvm/IR/Type.h"
|
|
|
|
#include "llvm/IR/Value.h"
|
2012-12-04 00:50:05 +08:00
|
|
|
#include "llvm/Pass.h"
|
2016-08-13 08:50:41 +08:00
|
|
|
#include "llvm/Support/Casting.h"
|
2010-04-09 02:47:09 +08:00
|
|
|
#include "llvm/Support/Debug.h"
|
2017-04-27 00:39:58 +08:00
|
|
|
#include "llvm/Support/KnownBits.h"
|
2016-08-13 08:50:41 +08:00
|
|
|
#include "llvm/Support/MathExtras.h"
|
2010-04-09 02:47:09 +08:00
|
|
|
#include "llvm/Support/raw_ostream.h"
|
2016-08-13 08:50:41 +08:00
|
|
|
#include <cassert>
|
|
|
|
#include <cstdint>
|
|
|
|
#include <iterator>
|
|
|
|
#include <string>
|
|
|
|
|
2010-04-09 02:47:09 +08:00
|
|
|
using namespace llvm;
|
|
|
|
|
|
|
|
namespace {
|
2010-05-01 03:05:00 +08:00
|
|
|
namespace MemRef {
|
2015-03-09 00:07:39 +08:00
|
|
|
static const unsigned Read = 1;
|
|
|
|
static const unsigned Write = 2;
|
|
|
|
static const unsigned Callee = 4;
|
|
|
|
static const unsigned Branchee = 8;
|
2016-08-13 08:50:41 +08:00
|
|
|
} // end namespace MemRef
|
2010-05-01 03:05:00 +08:00
|
|
|
|
2010-04-09 02:47:09 +08:00
|
|
|
class Lint : public FunctionPass, public InstVisitor<Lint> {
|
|
|
|
friend class InstVisitor<Lint>;
|
|
|
|
|
2010-04-09 09:39:53 +08:00
|
|
|
void visitFunction(Function &F);
|
|
|
|
|
2010-04-09 02:47:09 +08:00
|
|
|
void visitCallSite(CallSite CS);
|
2010-05-29 05:43:57 +08:00
|
|
|
void visitMemoryReference(Instruction &I, Value *Ptr,
|
2010-10-20 06:54:46 +08:00
|
|
|
uint64_t Size, unsigned Align,
|
2011-07-18 12:54:35 +08:00
|
|
|
Type *Ty, unsigned Flags);
|
2015-02-11 03:52:43 +08:00
|
|
|
void visitEHBeginCatch(IntrinsicInst *II);
|
|
|
|
void visitEHEndCatch(IntrinsicInst *II);
|
2010-04-09 02:47:09 +08:00
|
|
|
|
|
|
|
void visitCallInst(CallInst &I);
|
|
|
|
void visitInvokeInst(InvokeInst &I);
|
|
|
|
void visitReturnInst(ReturnInst &I);
|
|
|
|
void visitLoadInst(LoadInst &I);
|
|
|
|
void visitStoreInst(StoreInst &I);
|
2010-04-09 09:39:53 +08:00
|
|
|
void visitXor(BinaryOperator &I);
|
|
|
|
void visitSub(BinaryOperator &I);
|
2010-04-09 07:05:57 +08:00
|
|
|
void visitLShr(BinaryOperator &I);
|
|
|
|
void visitAShr(BinaryOperator &I);
|
|
|
|
void visitShl(BinaryOperator &I);
|
2010-04-09 02:47:09 +08:00
|
|
|
void visitSDiv(BinaryOperator &I);
|
|
|
|
void visitUDiv(BinaryOperator &I);
|
|
|
|
void visitSRem(BinaryOperator &I);
|
|
|
|
void visitURem(BinaryOperator &I);
|
|
|
|
void visitAllocaInst(AllocaInst &I);
|
|
|
|
void visitVAArgInst(VAArgInst &I);
|
|
|
|
void visitIndirectBrInst(IndirectBrInst &I);
|
2010-04-09 07:05:57 +08:00
|
|
|
void visitExtractElementInst(ExtractElementInst &I);
|
|
|
|
void visitInsertElementInst(InsertElementInst &I);
|
2010-04-09 09:39:53 +08:00
|
|
|
void visitUnreachableInst(UnreachableInst &I);
|
2010-04-09 02:47:09 +08:00
|
|
|
|
2015-08-06 10:05:46 +08:00
|
|
|
Value *findValue(Value *V, bool OffsetOk) const;
|
|
|
|
Value *findValueImpl(Value *V, bool OffsetOk,
|
2014-08-21 13:55:13 +08:00
|
|
|
SmallPtrSetImpl<Value *> &Visited) const;
|
2010-05-29 00:21:24 +08:00
|
|
|
|
2010-04-09 02:47:09 +08:00
|
|
|
public:
|
|
|
|
Module *Mod;
|
2015-08-06 10:05:46 +08:00
|
|
|
const DataLayout *DL;
|
2010-04-09 02:47:09 +08:00
|
|
|
AliasAnalysis *AA;
|
2016-12-19 16:22:17 +08:00
|
|
|
AssumptionCache *AC;
|
2010-05-29 00:21:24 +08:00
|
|
|
DominatorTree *DT;
|
2011-12-01 11:08:23 +08:00
|
|
|
TargetLibraryInfo *TLI;
|
2010-04-09 02:47:09 +08:00
|
|
|
|
2014-06-27 06:52:05 +08:00
|
|
|
std::string Messages;
|
|
|
|
raw_string_ostream MessagesStr;
|
2010-04-09 02:47:09 +08:00
|
|
|
|
|
|
|
static char ID; // Pass identification, replacement for typeid
|
2014-06-27 06:52:05 +08:00
|
|
|
Lint() : FunctionPass(ID), MessagesStr(Messages) {
|
2010-10-20 01:21:58 +08:00
|
|
|
initializeLintPass(*PassRegistry::getPassRegistry());
|
|
|
|
}
|
2010-04-09 02:47:09 +08:00
|
|
|
|
2014-03-05 15:30:04 +08:00
|
|
|
bool runOnFunction(Function &F) override;
|
2010-04-09 02:47:09 +08:00
|
|
|
|
2014-03-05 15:30:04 +08:00
|
|
|
void getAnalysisUsage(AnalysisUsage &AU) const override {
|
2010-04-09 02:47:09 +08:00
|
|
|
AU.setPreservesAll();
|
[PM/AA] Rebuild LLVM's alias analysis infrastructure in a way compatible
with the new pass manager, and no longer relying on analysis groups.
This builds essentially a ground-up new AA infrastructure stack for
LLVM. The core ideas are the same that are used throughout the new pass
manager: type erased polymorphism and direct composition. The design is
as follows:
- FunctionAAResults is a type-erasing alias analysis results aggregation
interface to walk a single query across a range of results from
different alias analyses. Currently this is function-specific as we
always assume that aliasing queries are *within* a function.
- AAResultBase is a CRTP utility providing stub implementations of
various parts of the alias analysis result concept, notably in several
cases in terms of other more general parts of the interface. This can
be used to implement only a narrow part of the interface rather than
the entire interface. This isn't really ideal, this logic should be
hoisted into FunctionAAResults as currently it will cause
a significant amount of redundant work, but it faithfully models the
behavior of the prior infrastructure.
- All the alias analysis passes are ported to be wrapper passes for the
legacy PM and new-style analysis passes for the new PM with a shared
result object. In some cases (most notably CFL), this is an extremely
naive approach that we should revisit when we can specialize for the
new pass manager.
- BasicAA has been restructured to reflect that it is much more
fundamentally a function analysis because it uses dominator trees and
loop info that need to be constructed for each function.
All of the references to getting alias analysis results have been
updated to use the new aggregation interface. All the preservation and
other pass management code has been updated accordingly.
The way the FunctionAAResultsWrapperPass works is to detect the
available alias analyses when run, and add them to the results object.
This means that we should be able to continue to respect when various
passes are added to the pipeline, for example adding CFL or adding TBAA
passes should just cause their results to be available and to get folded
into this. The exception to this rule is BasicAA which really needs to
be a function pass due to using dominator trees and loop info. As
a consequence, the FunctionAAResultsWrapperPass directly depends on
BasicAA and always includes it in the aggregation.
This has significant implications for preserving analyses. Generally,
most passes shouldn't bother preserving FunctionAAResultsWrapperPass
because rebuilding the results just updates the set of known AA passes.
The exception to this rule are LoopPass instances which need to preserve
all the function analyses that the loop pass manager will end up
needing. This means preserving both BasicAAWrapperPass and the
aggregating FunctionAAResultsWrapperPass.
Now, when preserving an alias analysis, you do so by directly preserving
that analysis. This is only necessary for non-immutable-pass-provided
alias analyses though, and there are only three of interest: BasicAA,
GlobalsAA (formerly GlobalsModRef), and SCEVAA. Usually BasicAA is
preserved when needed because it (like DominatorTree and LoopInfo) is
marked as a CFG-only pass. I've expanded GlobalsAA into the preserved
set everywhere we previously were preserving all of AliasAnalysis, and
I've added SCEVAA in the intersection of that with where we preserve
SCEV itself.
One significant challenge to all of this is that the CGSCC passes were
actually using the alias analysis implementations by taking advantage of
a pretty amazing set of loop holes in the old pass manager's analysis
management code which allowed analysis groups to slide through in many
cases. Moving away from analysis groups makes this problem much more
obvious. To fix it, I've leveraged the flexibility the design of the new
PM components provides to just directly construct the relevant alias
analyses for the relevant functions in the IPO passes that need them.
This is a bit hacky, but should go away with the new pass manager, and
is already in many ways cleaner than the prior state.
Another significant challenge is that various facilities of the old
alias analysis infrastructure just don't fit any more. The most
significant of these is the alias analysis 'counter' pass. That pass
relied on the ability to snoop on AA queries at different points in the
analysis group chain. Instead, I'm planning to build printing
functionality directly into the aggregation layer. I've not included
that in this patch merely to keep it smaller.
Note that all of this needs a nearly complete rewrite of the AA
documentation. I'm planning to do that, but I'd like to make sure the
new design settles, and to flesh out a bit more of what it looks like in
the new pass manager first.
Differential Revision: http://reviews.llvm.org/D12080
llvm-svn: 247167
2015-09-10 01:55:00 +08:00
|
|
|
AU.addRequired<AAResultsWrapperPass>();
|
2016-12-19 16:22:17 +08:00
|
|
|
AU.addRequired<AssumptionCacheTracker>();
|
2015-01-15 18:41:28 +08:00
|
|
|
AU.addRequired<TargetLibraryInfoWrapperPass>();
|
2014-01-13 21:07:17 +08:00
|
|
|
AU.addRequired<DominatorTreeWrapperPass>();
|
2010-04-09 02:47:09 +08:00
|
|
|
}
|
2014-03-05 15:30:04 +08:00
|
|
|
void print(raw_ostream &O, const Module *M) const override {}
|
2010-04-09 02:47:09 +08:00
|
|
|
|
2015-03-08 05:15:40 +08:00
|
|
|
void WriteValues(ArrayRef<const Value *> Vs) {
|
|
|
|
for (const Value *V : Vs) {
|
|
|
|
if (!V)
|
|
|
|
continue;
|
|
|
|
if (isa<Instruction>(V)) {
|
|
|
|
MessagesStr << *V << '\n';
|
|
|
|
} else {
|
|
|
|
V->printAsOperand(MessagesStr, true, Mod);
|
|
|
|
MessagesStr << '\n';
|
|
|
|
}
|
2010-04-09 02:47:09 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-03-17 01:49:03 +08:00
|
|
|
/// \brief A check failed, so printout out the condition and the message.
|
|
|
|
///
|
|
|
|
/// This provides a nice place to put a breakpoint if you want to see why
|
|
|
|
/// something is not correct.
|
2015-03-15 00:47:37 +08:00
|
|
|
void CheckFailed(const Twine &Message) { MessagesStr << Message << '\n'; }
|
|
|
|
|
2015-03-17 01:49:03 +08:00
|
|
|
/// \brief A check failed (with values to print).
|
|
|
|
///
|
|
|
|
/// This calls the Message-only version so that the above is easier to set
|
|
|
|
/// a breakpoint on.
|
2015-03-15 00:47:37 +08:00
|
|
|
template <typename T1, typename... Ts>
|
|
|
|
void CheckFailed(const Twine &Message, const T1 &V1, const Ts &...Vs) {
|
|
|
|
CheckFailed(Message);
|
|
|
|
WriteValues({V1, Vs...});
|
2010-04-09 02:47:09 +08:00
|
|
|
}
|
|
|
|
};
|
2016-08-13 08:50:41 +08:00
|
|
|
} // end anonymous namespace
|
2010-04-09 02:47:09 +08:00
|
|
|
|
|
|
|
char Lint::ID = 0;
|
2010-10-13 03:48:12 +08:00
|
|
|
INITIALIZE_PASS_BEGIN(Lint, "lint", "Statically lint-checks LLVM IR",
|
|
|
|
false, true)
|
2016-12-19 16:22:17 +08:00
|
|
|
INITIALIZE_PASS_DEPENDENCY(AssumptionCacheTracker)
|
2015-01-15 18:41:28 +08:00
|
|
|
INITIALIZE_PASS_DEPENDENCY(TargetLibraryInfoWrapperPass)
|
2014-01-13 21:07:17 +08:00
|
|
|
INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
|
[PM/AA] Rebuild LLVM's alias analysis infrastructure in a way compatible
with the new pass manager, and no longer relying on analysis groups.
This builds essentially a ground-up new AA infrastructure stack for
LLVM. The core ideas are the same that are used throughout the new pass
manager: type erased polymorphism and direct composition. The design is
as follows:
- FunctionAAResults is a type-erasing alias analysis results aggregation
interface to walk a single query across a range of results from
different alias analyses. Currently this is function-specific as we
always assume that aliasing queries are *within* a function.
- AAResultBase is a CRTP utility providing stub implementations of
various parts of the alias analysis result concept, notably in several
cases in terms of other more general parts of the interface. This can
be used to implement only a narrow part of the interface rather than
the entire interface. This isn't really ideal, this logic should be
hoisted into FunctionAAResults as currently it will cause
a significant amount of redundant work, but it faithfully models the
behavior of the prior infrastructure.
- All the alias analysis passes are ported to be wrapper passes for the
legacy PM and new-style analysis passes for the new PM with a shared
result object. In some cases (most notably CFL), this is an extremely
naive approach that we should revisit when we can specialize for the
new pass manager.
- BasicAA has been restructured to reflect that it is much more
fundamentally a function analysis because it uses dominator trees and
loop info that need to be constructed for each function.
All of the references to getting alias analysis results have been
updated to use the new aggregation interface. All the preservation and
other pass management code has been updated accordingly.
The way the FunctionAAResultsWrapperPass works is to detect the
available alias analyses when run, and add them to the results object.
This means that we should be able to continue to respect when various
passes are added to the pipeline, for example adding CFL or adding TBAA
passes should just cause their results to be available and to get folded
into this. The exception to this rule is BasicAA which really needs to
be a function pass due to using dominator trees and loop info. As
a consequence, the FunctionAAResultsWrapperPass directly depends on
BasicAA and always includes it in the aggregation.
This has significant implications for preserving analyses. Generally,
most passes shouldn't bother preserving FunctionAAResultsWrapperPass
because rebuilding the results just updates the set of known AA passes.
The exception to this rule are LoopPass instances which need to preserve
all the function analyses that the loop pass manager will end up
needing. This means preserving both BasicAAWrapperPass and the
aggregating FunctionAAResultsWrapperPass.
Now, when preserving an alias analysis, you do so by directly preserving
that analysis. This is only necessary for non-immutable-pass-provided
alias analyses though, and there are only three of interest: BasicAA,
GlobalsAA (formerly GlobalsModRef), and SCEVAA. Usually BasicAA is
preserved when needed because it (like DominatorTree and LoopInfo) is
marked as a CFG-only pass. I've expanded GlobalsAA into the preserved
set everywhere we previously were preserving all of AliasAnalysis, and
I've added SCEVAA in the intersection of that with where we preserve
SCEV itself.
One significant challenge to all of this is that the CGSCC passes were
actually using the alias analysis implementations by taking advantage of
a pretty amazing set of loop holes in the old pass manager's analysis
management code which allowed analysis groups to slide through in many
cases. Moving away from analysis groups makes this problem much more
obvious. To fix it, I've leveraged the flexibility the design of the new
PM components provides to just directly construct the relevant alias
analyses for the relevant functions in the IPO passes that need them.
This is a bit hacky, but should go away with the new pass manager, and
is already in many ways cleaner than the prior state.
Another significant challenge is that various facilities of the old
alias analysis infrastructure just don't fit any more. The most
significant of these is the alias analysis 'counter' pass. That pass
relied on the ability to snoop on AA queries at different points in the
analysis group chain. Instead, I'm planning to build printing
functionality directly into the aggregation layer. I've not included
that in this patch merely to keep it smaller.
Note that all of this needs a nearly complete rewrite of the AA
documentation. I'm planning to do that, but I'd like to make sure the
new design settles, and to flesh out a bit more of what it looks like in
the new pass manager first.
Differential Revision: http://reviews.llvm.org/D12080
llvm-svn: 247167
2015-09-10 01:55:00 +08:00
|
|
|
INITIALIZE_PASS_DEPENDENCY(AAResultsWrapperPass)
|
2010-10-13 03:48:12 +08:00
|
|
|
INITIALIZE_PASS_END(Lint, "lint", "Statically lint-checks LLVM IR",
|
|
|
|
false, true)
|
2010-04-09 02:47:09 +08:00
|
|
|
|
|
|
|
// Assert - We know that cond should be true, if not print an error message.
|
2015-03-08 05:15:40 +08:00
|
|
|
#define Assert(C, ...) \
|
2016-08-13 08:50:41 +08:00
|
|
|
do { if (!(C)) { CheckFailed(__VA_ARGS__); return; } } while (false)
|
2010-04-09 02:47:09 +08:00
|
|
|
|
|
|
|
// Lint::run - This is the main Analysis entry point for a
|
|
|
|
// function.
|
|
|
|
//
|
|
|
|
bool Lint::runOnFunction(Function &F) {
|
|
|
|
Mod = F.getParent();
|
2015-08-06 10:05:46 +08:00
|
|
|
DL = &F.getParent()->getDataLayout();
|
[PM/AA] Rebuild LLVM's alias analysis infrastructure in a way compatible
with the new pass manager, and no longer relying on analysis groups.
This builds essentially a ground-up new AA infrastructure stack for
LLVM. The core ideas are the same that are used throughout the new pass
manager: type erased polymorphism and direct composition. The design is
as follows:
- FunctionAAResults is a type-erasing alias analysis results aggregation
interface to walk a single query across a range of results from
different alias analyses. Currently this is function-specific as we
always assume that aliasing queries are *within* a function.
- AAResultBase is a CRTP utility providing stub implementations of
various parts of the alias analysis result concept, notably in several
cases in terms of other more general parts of the interface. This can
be used to implement only a narrow part of the interface rather than
the entire interface. This isn't really ideal, this logic should be
hoisted into FunctionAAResults as currently it will cause
a significant amount of redundant work, but it faithfully models the
behavior of the prior infrastructure.
- All the alias analysis passes are ported to be wrapper passes for the
legacy PM and new-style analysis passes for the new PM with a shared
result object. In some cases (most notably CFL), this is an extremely
naive approach that we should revisit when we can specialize for the
new pass manager.
- BasicAA has been restructured to reflect that it is much more
fundamentally a function analysis because it uses dominator trees and
loop info that need to be constructed for each function.
All of the references to getting alias analysis results have been
updated to use the new aggregation interface. All the preservation and
other pass management code has been updated accordingly.
The way the FunctionAAResultsWrapperPass works is to detect the
available alias analyses when run, and add them to the results object.
This means that we should be able to continue to respect when various
passes are added to the pipeline, for example adding CFL or adding TBAA
passes should just cause their results to be available and to get folded
into this. The exception to this rule is BasicAA which really needs to
be a function pass due to using dominator trees and loop info. As
a consequence, the FunctionAAResultsWrapperPass directly depends on
BasicAA and always includes it in the aggregation.
This has significant implications for preserving analyses. Generally,
most passes shouldn't bother preserving FunctionAAResultsWrapperPass
because rebuilding the results just updates the set of known AA passes.
The exception to this rule are LoopPass instances which need to preserve
all the function analyses that the loop pass manager will end up
needing. This means preserving both BasicAAWrapperPass and the
aggregating FunctionAAResultsWrapperPass.
Now, when preserving an alias analysis, you do so by directly preserving
that analysis. This is only necessary for non-immutable-pass-provided
alias analyses though, and there are only three of interest: BasicAA,
GlobalsAA (formerly GlobalsModRef), and SCEVAA. Usually BasicAA is
preserved when needed because it (like DominatorTree and LoopInfo) is
marked as a CFG-only pass. I've expanded GlobalsAA into the preserved
set everywhere we previously were preserving all of AliasAnalysis, and
I've added SCEVAA in the intersection of that with where we preserve
SCEV itself.
One significant challenge to all of this is that the CGSCC passes were
actually using the alias analysis implementations by taking advantage of
a pretty amazing set of loop holes in the old pass manager's analysis
management code which allowed analysis groups to slide through in many
cases. Moving away from analysis groups makes this problem much more
obvious. To fix it, I've leveraged the flexibility the design of the new
PM components provides to just directly construct the relevant alias
analyses for the relevant functions in the IPO passes that need them.
This is a bit hacky, but should go away with the new pass manager, and
is already in many ways cleaner than the prior state.
Another significant challenge is that various facilities of the old
alias analysis infrastructure just don't fit any more. The most
significant of these is the alias analysis 'counter' pass. That pass
relied on the ability to snoop on AA queries at different points in the
analysis group chain. Instead, I'm planning to build printing
functionality directly into the aggregation layer. I've not included
that in this patch merely to keep it smaller.
Note that all of this needs a nearly complete rewrite of the AA
documentation. I'm planning to do that, but I'd like to make sure the
new design settles, and to flesh out a bit more of what it looks like in
the new pass manager first.
Differential Revision: http://reviews.llvm.org/D12080
llvm-svn: 247167
2015-09-10 01:55:00 +08:00
|
|
|
AA = &getAnalysis<AAResultsWrapperPass>().getAAResults();
|
2016-12-19 16:22:17 +08:00
|
|
|
AC = &getAnalysis<AssumptionCacheTracker>().getAssumptionCache(F);
|
2014-01-13 21:07:17 +08:00
|
|
|
DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
|
2015-01-15 18:41:28 +08:00
|
|
|
TLI = &getAnalysis<TargetLibraryInfoWrapperPass>().getTLI();
|
2010-04-09 02:47:09 +08:00
|
|
|
visit(F);
|
|
|
|
dbgs() << MessagesStr.str();
|
2014-06-27 06:52:05 +08:00
|
|
|
Messages.clear();
|
2010-04-09 02:47:09 +08:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2010-04-09 09:39:53 +08:00
|
|
|
void Lint::visitFunction(Function &F) {
|
|
|
|
// This isn't undefined behavior, it's just a little unusual, and it's a
|
|
|
|
// fairly common mistake to neglect to name a function.
|
2015-03-08 05:15:40 +08:00
|
|
|
Assert(F.hasName() || F.hasLocalLinkage(),
|
|
|
|
"Unusual: Unnamed function with non-local linkage", &F);
|
2010-07-06 23:23:00 +08:00
|
|
|
|
|
|
|
// TODO: Check for irreducible control flow.
|
2010-04-09 02:47:09 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void Lint::visitCallSite(CallSite CS) {
|
|
|
|
Instruction &I = *CS.getInstruction();
|
|
|
|
Value *Callee = CS.getCalledValue();
|
|
|
|
|
2015-06-17 15:21:38 +08:00
|
|
|
visitMemoryReference(I, Callee, MemoryLocation::UnknownSize, 0, nullptr,
|
|
|
|
MemRef::Callee);
|
2010-04-09 02:47:09 +08:00
|
|
|
|
2015-08-06 10:05:46 +08:00
|
|
|
if (Function *F = dyn_cast<Function>(findValue(Callee,
|
2015-03-10 10:37:25 +08:00
|
|
|
/*OffsetOk=*/false))) {
|
2015-03-08 05:15:40 +08:00
|
|
|
Assert(CS.getCallingConv() == F->getCallingConv(),
|
|
|
|
"Undefined behavior: Caller and callee calling convention differ",
|
|
|
|
&I);
|
2010-04-09 02:47:09 +08:00
|
|
|
|
2011-07-18 12:54:35 +08:00
|
|
|
FunctionType *FT = F->getFunctionType();
|
2013-11-10 11:18:50 +08:00
|
|
|
unsigned NumActualArgs = CS.arg_size();
|
2010-04-09 02:47:09 +08:00
|
|
|
|
2015-03-08 05:15:40 +08:00
|
|
|
Assert(FT->isVarArg() ? FT->getNumParams() <= NumActualArgs
|
|
|
|
: FT->getNumParams() == NumActualArgs,
|
|
|
|
"Undefined behavior: Call argument count mismatches callee "
|
|
|
|
"argument count",
|
|
|
|
&I);
|
2010-04-09 02:47:09 +08:00
|
|
|
|
2015-03-08 05:15:40 +08:00
|
|
|
Assert(FT->getReturnType() == I.getType(),
|
|
|
|
"Undefined behavior: Call return type mismatches "
|
|
|
|
"callee return type",
|
|
|
|
&I);
|
2010-07-13 02:02:04 +08:00
|
|
|
|
2010-05-29 05:43:57 +08:00
|
|
|
// Check argument types (in case the callee was casted) and attributes.
|
2010-07-06 23:23:00 +08:00
|
|
|
// TODO: Verify that caller and callee attributes are compatible.
|
2010-05-29 05:43:57 +08:00
|
|
|
Function::arg_iterator PI = F->arg_begin(), PE = F->arg_end();
|
|
|
|
CallSite::arg_iterator AI = CS.arg_begin(), AE = CS.arg_end();
|
|
|
|
for (; AI != AE; ++AI) {
|
|
|
|
Value *Actual = *AI;
|
|
|
|
if (PI != PE) {
|
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
|
|
|
Argument *Formal = &*PI++;
|
2015-03-08 05:15:40 +08:00
|
|
|
Assert(Formal->getType() == Actual->getType(),
|
|
|
|
"Undefined behavior: Call argument type mismatches "
|
|
|
|
"callee parameter type",
|
|
|
|
&I);
|
2010-06-02 04:51:40 +08:00
|
|
|
|
2010-12-14 06:53:18 +08:00
|
|
|
// Check that noalias arguments don't alias other arguments. This is
|
|
|
|
// not fully precise because we don't know the sizes of the dereferenced
|
|
|
|
// memory regions.
|
2010-05-29 05:43:57 +08:00
|
|
|
if (Formal->hasNoAliasAttr() && Actual->getType()->isPointerTy())
|
2010-11-12 03:23:51 +08:00
|
|
|
for (CallSite::arg_iterator BI = CS.arg_begin(); BI != AE; ++BI)
|
2010-12-11 04:04:06 +08:00
|
|
|
if (AI != BI && (*BI)->getType()->isPointerTy()) {
|
2015-06-22 10:16:51 +08:00
|
|
|
AliasResult Result = AA->alias(*AI, *BI);
|
|
|
|
Assert(Result != MustAlias && Result != PartialAlias,
|
2015-03-08 05:15:40 +08:00
|
|
|
"Unusual: noalias argument aliases another argument", &I);
|
2010-12-11 04:04:06 +08:00
|
|
|
}
|
2010-06-02 04:51:40 +08:00
|
|
|
|
|
|
|
// Check that an sret argument points to valid memory.
|
2010-05-29 05:43:57 +08:00
|
|
|
if (Formal->hasStructRetAttr() && Actual->getType()->isPointerTy()) {
|
2011-07-18 12:54:35 +08:00
|
|
|
Type *Ty =
|
2010-05-29 05:43:57 +08:00
|
|
|
cast<PointerType>(Formal->getType())->getElementType();
|
2015-08-06 10:05:46 +08:00
|
|
|
visitMemoryReference(I, Actual, DL->getTypeStoreSize(Ty),
|
|
|
|
DL->getABITypeAlignment(Ty), Ty,
|
2015-03-10 10:37:25 +08:00
|
|
|
MemRef::Read | MemRef::Write);
|
2010-05-29 05:43:57 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2010-04-09 02:47:09 +08:00
|
|
|
}
|
|
|
|
|
2010-05-27 05:46:36 +08:00
|
|
|
if (CS.isCall() && cast<CallInst>(CS.getInstruction())->isTailCall())
|
|
|
|
for (CallSite::arg_iterator AI = CS.arg_begin(), AE = CS.arg_end();
|
|
|
|
AI != AE; ++AI) {
|
2015-08-06 10:05:46 +08:00
|
|
|
Value *Obj = findValue(*AI, /*OffsetOk=*/true);
|
2015-03-08 05:15:40 +08:00
|
|
|
Assert(!isa<AllocaInst>(Obj),
|
2015-03-10 10:37:25 +08:00
|
|
|
"Undefined behavior: Call with \"tail\" keyword references "
|
|
|
|
"alloca",
|
2015-03-08 05:15:40 +08:00
|
|
|
&I);
|
2010-05-27 05:46:36 +08:00
|
|
|
}
|
|
|
|
|
2010-04-09 02:47:09 +08:00
|
|
|
|
|
|
|
if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(&I))
|
|
|
|
switch (II->getIntrinsicID()) {
|
|
|
|
default: break;
|
|
|
|
|
|
|
|
// TODO: Check more intrinsics
|
|
|
|
|
|
|
|
case Intrinsic::memcpy: {
|
|
|
|
MemCpyInst *MCI = cast<MemCpyInst>(&I);
|
2010-05-29 05:43:57 +08:00
|
|
|
// TODO: If the size is known, use it.
|
2015-06-17 15:21:38 +08:00
|
|
|
visitMemoryReference(I, MCI->getDest(), MemoryLocation::UnknownSize,
|
2015-11-19 13:56:52 +08:00
|
|
|
MCI->getAlignment(), nullptr, MemRef::Write);
|
2015-06-17 15:21:38 +08:00
|
|
|
visitMemoryReference(I, MCI->getSource(), MemoryLocation::UnknownSize,
|
2015-11-19 13:56:52 +08:00
|
|
|
MCI->getAlignment(), nullptr, MemRef::Read);
|
2010-04-09 02:47:09 +08:00
|
|
|
|
2010-04-09 09:39:53 +08:00
|
|
|
// Check that the memcpy arguments don't overlap. The AliasAnalysis API
|
|
|
|
// isn't expressive enough for what we really want to do. Known partial
|
|
|
|
// overlap is not distinguished from the case where nothing is known.
|
2010-10-20 06:54:46 +08:00
|
|
|
uint64_t Size = 0;
|
2010-04-09 02:47:09 +08:00
|
|
|
if (const ConstantInt *Len =
|
2015-08-06 10:05:46 +08:00
|
|
|
dyn_cast<ConstantInt>(findValue(MCI->getLength(),
|
2015-03-10 10:37:25 +08:00
|
|
|
/*OffsetOk=*/false)))
|
2010-04-09 02:47:09 +08:00
|
|
|
if (Len->getValue().isIntN(32))
|
|
|
|
Size = Len->getValue().getZExtValue();
|
2015-03-08 05:15:40 +08:00
|
|
|
Assert(AA->alias(MCI->getSource(), Size, MCI->getDest(), Size) !=
|
2015-06-22 10:16:51 +08:00
|
|
|
MustAlias,
|
2015-03-08 05:15:40 +08:00
|
|
|
"Undefined behavior: memcpy source and destination overlap", &I);
|
2010-04-09 02:47:09 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case Intrinsic::memmove: {
|
|
|
|
MemMoveInst *MMI = cast<MemMoveInst>(&I);
|
2010-05-29 05:43:57 +08:00
|
|
|
// TODO: If the size is known, use it.
|
2015-06-17 15:21:38 +08:00
|
|
|
visitMemoryReference(I, MMI->getDest(), MemoryLocation::UnknownSize,
|
2015-11-19 13:56:52 +08:00
|
|
|
MMI->getAlignment(), nullptr, MemRef::Write);
|
2015-06-17 15:21:38 +08:00
|
|
|
visitMemoryReference(I, MMI->getSource(), MemoryLocation::UnknownSize,
|
2015-11-19 13:56:52 +08:00
|
|
|
MMI->getAlignment(), nullptr, MemRef::Read);
|
2010-04-09 02:47:09 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case Intrinsic::memset: {
|
|
|
|
MemSetInst *MSI = cast<MemSetInst>(&I);
|
2010-05-29 05:43:57 +08:00
|
|
|
// TODO: If the size is known, use it.
|
2015-06-17 15:21:38 +08:00
|
|
|
visitMemoryReference(I, MSI->getDest(), MemoryLocation::UnknownSize,
|
2015-11-19 13:56:52 +08:00
|
|
|
MSI->getAlignment(), nullptr, MemRef::Write);
|
2010-04-09 02:47:09 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case Intrinsic::vastart:
|
2015-03-08 05:15:40 +08:00
|
|
|
Assert(I.getParent()->getParent()->isVarArg(),
|
|
|
|
"Undefined behavior: va_start called in a non-varargs function",
|
|
|
|
&I);
|
2010-04-09 09:39:53 +08:00
|
|
|
|
2015-06-17 15:21:38 +08:00
|
|
|
visitMemoryReference(I, CS.getArgument(0), MemoryLocation::UnknownSize, 0,
|
|
|
|
nullptr, MemRef::Read | MemRef::Write);
|
2010-04-09 02:47:09 +08:00
|
|
|
break;
|
|
|
|
case Intrinsic::vacopy:
|
2015-06-17 15:21:38 +08:00
|
|
|
visitMemoryReference(I, CS.getArgument(0), MemoryLocation::UnknownSize, 0,
|
|
|
|
nullptr, MemRef::Write);
|
|
|
|
visitMemoryReference(I, CS.getArgument(1), MemoryLocation::UnknownSize, 0,
|
|
|
|
nullptr, MemRef::Read);
|
2010-04-09 02:47:09 +08:00
|
|
|
break;
|
|
|
|
case Intrinsic::vaend:
|
2015-06-17 15:21:38 +08:00
|
|
|
visitMemoryReference(I, CS.getArgument(0), MemoryLocation::UnknownSize, 0,
|
|
|
|
nullptr, MemRef::Read | MemRef::Write);
|
2010-04-09 02:47:09 +08:00
|
|
|
break;
|
2010-05-27 06:21:25 +08:00
|
|
|
|
|
|
|
case Intrinsic::stackrestore:
|
|
|
|
// Stackrestore doesn't read or write memory, but it sets the
|
|
|
|
// stack pointer, which the compiler may read from or write to
|
|
|
|
// at any time, so check it for both readability and writeability.
|
2015-06-17 15:21:38 +08:00
|
|
|
visitMemoryReference(I, CS.getArgument(0), MemoryLocation::UnknownSize, 0,
|
|
|
|
nullptr, MemRef::Read | MemRef::Write);
|
2010-05-27 06:21:25 +08:00
|
|
|
break;
|
2010-04-09 02:47:09 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Lint::visitCallInst(CallInst &I) {
|
|
|
|
return visitCallSite(&I);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Lint::visitInvokeInst(InvokeInst &I) {
|
|
|
|
return visitCallSite(&I);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Lint::visitReturnInst(ReturnInst &I) {
|
|
|
|
Function *F = I.getParent()->getParent();
|
2015-03-08 05:15:40 +08:00
|
|
|
Assert(!F->doesNotReturn(),
|
|
|
|
"Unusual: Return statement in function with noreturn attribute", &I);
|
2010-05-28 12:33:42 +08:00
|
|
|
|
|
|
|
if (Value *V = I.getReturnValue()) {
|
2015-08-06 10:05:46 +08:00
|
|
|
Value *Obj = findValue(V, /*OffsetOk=*/true);
|
2015-03-08 05:15:40 +08:00
|
|
|
Assert(!isa<AllocaInst>(Obj), "Unusual: Returning alloca value", &I);
|
2010-05-28 12:33:42 +08:00
|
|
|
}
|
2010-04-09 02:47:09 +08:00
|
|
|
}
|
|
|
|
|
2010-05-29 05:43:57 +08:00
|
|
|
// TODO: Check that the reference is in bounds.
|
2010-07-06 23:23:00 +08:00
|
|
|
// TODO: Check readnone/readonly function attributes.
|
2010-04-09 02:47:09 +08:00
|
|
|
void Lint::visitMemoryReference(Instruction &I,
|
2010-10-20 06:54:46 +08:00
|
|
|
Value *Ptr, uint64_t Size, unsigned Align,
|
2011-07-18 12:54:35 +08:00
|
|
|
Type *Ty, unsigned Flags) {
|
2010-05-29 05:43:57 +08:00
|
|
|
// If no memory is being referenced, it doesn't matter if the pointer
|
|
|
|
// is valid.
|
|
|
|
if (Size == 0)
|
|
|
|
return;
|
|
|
|
|
2015-08-06 10:05:46 +08:00
|
|
|
Value *UnderlyingObject = findValue(Ptr, /*OffsetOk=*/true);
|
2015-03-08 05:15:40 +08:00
|
|
|
Assert(!isa<ConstantPointerNull>(UnderlyingObject),
|
|
|
|
"Undefined behavior: Null pointer dereference", &I);
|
|
|
|
Assert(!isa<UndefValue>(UnderlyingObject),
|
|
|
|
"Undefined behavior: Undef pointer dereference", &I);
|
|
|
|
Assert(!isa<ConstantInt>(UnderlyingObject) ||
|
2017-07-07 02:39:47 +08:00
|
|
|
!cast<ConstantInt>(UnderlyingObject)->isMinusOne(),
|
2015-03-08 05:15:40 +08:00
|
|
|
"Unusual: All-ones pointer dereference", &I);
|
|
|
|
Assert(!isa<ConstantInt>(UnderlyingObject) ||
|
|
|
|
!cast<ConstantInt>(UnderlyingObject)->isOne(),
|
|
|
|
"Unusual: Address one pointer dereference", &I);
|
2010-04-09 02:47:09 +08:00
|
|
|
|
2010-05-01 03:05:00 +08:00
|
|
|
if (Flags & MemRef::Write) {
|
|
|
|
if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(UnderlyingObject))
|
2015-03-08 05:15:40 +08:00
|
|
|
Assert(!GV->isConstant(), "Undefined behavior: Write to read-only memory",
|
|
|
|
&I);
|
|
|
|
Assert(!isa<Function>(UnderlyingObject) &&
|
|
|
|
!isa<BlockAddress>(UnderlyingObject),
|
|
|
|
"Undefined behavior: Write to text section", &I);
|
2010-05-01 03:05:00 +08:00
|
|
|
}
|
|
|
|
if (Flags & MemRef::Read) {
|
2015-03-08 05:15:40 +08:00
|
|
|
Assert(!isa<Function>(UnderlyingObject), "Unusual: Load from function body",
|
|
|
|
&I);
|
|
|
|
Assert(!isa<BlockAddress>(UnderlyingObject),
|
|
|
|
"Undefined behavior: Load from block address", &I);
|
2010-05-01 03:05:00 +08:00
|
|
|
}
|
|
|
|
if (Flags & MemRef::Callee) {
|
2015-03-08 05:15:40 +08:00
|
|
|
Assert(!isa<BlockAddress>(UnderlyingObject),
|
|
|
|
"Undefined behavior: Call to block address", &I);
|
2010-05-01 03:05:00 +08:00
|
|
|
}
|
|
|
|
if (Flags & MemRef::Branchee) {
|
2015-03-08 05:15:40 +08:00
|
|
|
Assert(!isa<Constant>(UnderlyingObject) ||
|
|
|
|
isa<BlockAddress>(UnderlyingObject),
|
|
|
|
"Undefined behavior: Branch to non-blockaddress", &I);
|
2010-05-01 03:05:00 +08:00
|
|
|
}
|
|
|
|
|
2012-09-26 15:45:36 +08:00
|
|
|
// Check for buffer overflows and misalignment.
|
2013-01-31 10:00:45 +08:00
|
|
|
// Only handles memory references that read/write something simple like an
|
|
|
|
// alloca instruction or a global variable.
|
|
|
|
int64_t Offset = 0;
|
2015-08-06 10:05:46 +08:00
|
|
|
if (Value *Base = GetPointerBaseWithConstantOffset(Ptr, Offset, *DL)) {
|
2013-01-31 10:00:45 +08:00
|
|
|
// OK, so the access is to a constant offset from Ptr. Check that Ptr is
|
|
|
|
// something we can handle and if so extract the size of this base object
|
|
|
|
// along with its alignment.
|
2015-06-17 15:21:38 +08:00
|
|
|
uint64_t BaseSize = MemoryLocation::UnknownSize;
|
2013-01-31 10:00:45 +08:00
|
|
|
unsigned BaseAlign = 0;
|
|
|
|
|
|
|
|
if (AllocaInst *AI = dyn_cast<AllocaInst>(Base)) {
|
|
|
|
Type *ATy = AI->getAllocatedType();
|
2015-03-10 10:37:25 +08:00
|
|
|
if (!AI->isArrayAllocation() && ATy->isSized())
|
2015-08-06 10:05:46 +08:00
|
|
|
BaseSize = DL->getTypeAllocSize(ATy);
|
2013-01-31 10:00:45 +08:00
|
|
|
BaseAlign = AI->getAlignment();
|
2015-03-10 10:37:25 +08:00
|
|
|
if (BaseAlign == 0 && ATy->isSized())
|
2015-08-06 10:05:46 +08:00
|
|
|
BaseAlign = DL->getABITypeAlignment(ATy);
|
2013-01-31 10:00:45 +08:00
|
|
|
} else if (GlobalVariable *GV = dyn_cast<GlobalVariable>(Base)) {
|
|
|
|
// If the global may be defined differently in another compilation unit
|
|
|
|
// then don't warn about funky memory accesses.
|
|
|
|
if (GV->hasDefinitiveInitializer()) {
|
2016-01-17 04:30:46 +08:00
|
|
|
Type *GTy = GV->getValueType();
|
2015-03-10 10:37:25 +08:00
|
|
|
if (GTy->isSized())
|
2015-08-06 10:05:46 +08:00
|
|
|
BaseSize = DL->getTypeAllocSize(GTy);
|
2013-01-31 10:00:45 +08:00
|
|
|
BaseAlign = GV->getAlignment();
|
2015-03-10 10:37:25 +08:00
|
|
|
if (BaseAlign == 0 && GTy->isSized())
|
2015-08-06 10:05:46 +08:00
|
|
|
BaseAlign = DL->getABITypeAlignment(GTy);
|
2012-09-25 18:00:49 +08:00
|
|
|
}
|
2010-04-09 02:47:09 +08:00
|
|
|
}
|
2013-01-31 10:00:45 +08:00
|
|
|
|
|
|
|
// Accesses from before the start or after the end of the object are not
|
|
|
|
// defined.
|
2015-06-17 15:21:38 +08:00
|
|
|
Assert(Size == MemoryLocation::UnknownSize ||
|
|
|
|
BaseSize == MemoryLocation::UnknownSize ||
|
2015-03-08 05:15:40 +08:00
|
|
|
(Offset >= 0 && Offset + Size <= BaseSize),
|
|
|
|
"Undefined behavior: Buffer overflow", &I);
|
2013-01-31 10:00:45 +08:00
|
|
|
|
|
|
|
// Accesses that say that the memory is more aligned than it is are not
|
|
|
|
// defined.
|
2015-03-10 10:37:25 +08:00
|
|
|
if (Align == 0 && Ty && Ty->isSized())
|
2015-08-06 10:05:46 +08:00
|
|
|
Align = DL->getABITypeAlignment(Ty);
|
2015-03-08 05:15:40 +08:00
|
|
|
Assert(!BaseAlign || Align <= MinAlign(BaseAlign, Offset),
|
|
|
|
"Undefined behavior: Memory reference address is misaligned", &I);
|
2010-04-09 02:47:09 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Lint::visitLoadInst(LoadInst &I) {
|
2010-05-29 05:43:57 +08:00
|
|
|
visitMemoryReference(I, I.getPointerOperand(),
|
2015-08-06 10:05:46 +08:00
|
|
|
DL->getTypeStoreSize(I.getType()), I.getAlignment(),
|
2010-05-29 05:43:57 +08:00
|
|
|
I.getType(), MemRef::Read);
|
2010-04-09 02:47:09 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void Lint::visitStoreInst(StoreInst &I) {
|
2010-05-29 05:43:57 +08:00
|
|
|
visitMemoryReference(I, I.getPointerOperand(),
|
2015-08-06 10:05:46 +08:00
|
|
|
DL->getTypeStoreSize(I.getOperand(0)->getType()),
|
2010-05-29 05:43:57 +08:00
|
|
|
I.getAlignment(),
|
|
|
|
I.getOperand(0)->getType(), MemRef::Write);
|
2010-04-09 02:47:09 +08:00
|
|
|
}
|
|
|
|
|
2010-04-09 09:39:53 +08:00
|
|
|
void Lint::visitXor(BinaryOperator &I) {
|
2015-03-08 05:15:40 +08:00
|
|
|
Assert(!isa<UndefValue>(I.getOperand(0)) || !isa<UndefValue>(I.getOperand(1)),
|
|
|
|
"Undefined result: xor(undef, undef)", &I);
|
2010-04-09 09:39:53 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void Lint::visitSub(BinaryOperator &I) {
|
2015-03-08 05:15:40 +08:00
|
|
|
Assert(!isa<UndefValue>(I.getOperand(0)) || !isa<UndefValue>(I.getOperand(1)),
|
|
|
|
"Undefined result: sub(undef, undef)", &I);
|
2010-04-09 09:39:53 +08:00
|
|
|
}
|
|
|
|
|
2010-04-09 07:05:57 +08:00
|
|
|
void Lint::visitLShr(BinaryOperator &I) {
|
2015-08-06 10:05:46 +08:00
|
|
|
if (ConstantInt *CI = dyn_cast<ConstantInt>(findValue(I.getOperand(1),
|
|
|
|
/*OffsetOk=*/false)))
|
2015-03-08 05:15:40 +08:00
|
|
|
Assert(CI->getValue().ult(cast<IntegerType>(I.getType())->getBitWidth()),
|
|
|
|
"Undefined result: Shift count out of range", &I);
|
2010-04-09 07:05:57 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void Lint::visitAShr(BinaryOperator &I) {
|
2015-08-06 10:05:46 +08:00
|
|
|
if (ConstantInt *CI =
|
|
|
|
dyn_cast<ConstantInt>(findValue(I.getOperand(1), /*OffsetOk=*/false)))
|
2015-03-08 05:15:40 +08:00
|
|
|
Assert(CI->getValue().ult(cast<IntegerType>(I.getType())->getBitWidth()),
|
|
|
|
"Undefined result: Shift count out of range", &I);
|
2010-04-09 07:05:57 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void Lint::visitShl(BinaryOperator &I) {
|
2015-08-06 10:05:46 +08:00
|
|
|
if (ConstantInt *CI =
|
|
|
|
dyn_cast<ConstantInt>(findValue(I.getOperand(1), /*OffsetOk=*/false)))
|
2015-03-08 05:15:40 +08:00
|
|
|
Assert(CI->getValue().ult(cast<IntegerType>(I.getType())->getBitWidth()),
|
|
|
|
"Undefined result: Shift count out of range", &I);
|
2010-04-09 07:05:57 +08:00
|
|
|
}
|
|
|
|
|
2016-12-19 16:22:17 +08:00
|
|
|
static bool isZero(Value *V, const DataLayout &DL, DominatorTree *DT,
|
|
|
|
AssumptionCache *AC) {
|
2010-04-09 09:39:53 +08:00
|
|
|
// Assume undef could be zero.
|
2013-08-27 07:29:33 +08:00
|
|
|
if (isa<UndefValue>(V))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
VectorType *VecTy = dyn_cast<VectorType>(V->getType());
|
|
|
|
if (!VecTy) {
|
2017-05-25 00:53:07 +08:00
|
|
|
KnownBits Known = computeKnownBits(V, DL, 0, AC, dyn_cast<Instruction>(V), DT);
|
2017-05-06 01:36:09 +08:00
|
|
|
return Known.isZero();
|
2013-08-27 07:29:33 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// Per-component check doesn't work with zeroinitializer
|
|
|
|
Constant *C = dyn_cast<Constant>(V);
|
|
|
|
if (!C)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
if (C->isZeroValue())
|
|
|
|
return true;
|
|
|
|
|
|
|
|
// For a vector, KnownZero will only be true if all values are zero, so check
|
|
|
|
// this per component
|
|
|
|
for (unsigned I = 0, N = VecTy->getNumElements(); I != N; ++I) {
|
|
|
|
Constant *Elem = C->getAggregateElement(I);
|
|
|
|
if (isa<UndefValue>(Elem))
|
|
|
|
return true;
|
|
|
|
|
2017-05-25 00:53:07 +08:00
|
|
|
KnownBits Known = computeKnownBits(Elem, DL);
|
2017-05-06 01:36:09 +08:00
|
|
|
if (Known.isZero())
|
2013-08-27 07:29:33 +08:00
|
|
|
return true;
|
|
|
|
}
|
2010-04-09 09:39:53 +08:00
|
|
|
|
2013-08-27 07:29:33 +08:00
|
|
|
return false;
|
2010-04-09 02:47:09 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void Lint::visitSDiv(BinaryOperator &I) {
|
2016-12-19 16:22:17 +08:00
|
|
|
Assert(!isZero(I.getOperand(1), I.getModule()->getDataLayout(), DT, AC),
|
2015-03-08 05:15:40 +08:00
|
|
|
"Undefined behavior: Division by zero", &I);
|
2010-04-09 02:47:09 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void Lint::visitUDiv(BinaryOperator &I) {
|
2016-12-19 16:22:17 +08:00
|
|
|
Assert(!isZero(I.getOperand(1), I.getModule()->getDataLayout(), DT, AC),
|
2015-03-08 05:15:40 +08:00
|
|
|
"Undefined behavior: Division by zero", &I);
|
2010-04-09 02:47:09 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void Lint::visitSRem(BinaryOperator &I) {
|
2016-12-19 16:22:17 +08:00
|
|
|
Assert(!isZero(I.getOperand(1), I.getModule()->getDataLayout(), DT, AC),
|
2015-03-08 05:15:40 +08:00
|
|
|
"Undefined behavior: Division by zero", &I);
|
2010-04-09 02:47:09 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void Lint::visitURem(BinaryOperator &I) {
|
2016-12-19 16:22:17 +08:00
|
|
|
Assert(!isZero(I.getOperand(1), I.getModule()->getDataLayout(), DT, AC),
|
2015-03-08 05:15:40 +08:00
|
|
|
"Undefined behavior: Division by zero", &I);
|
2010-04-09 02:47:09 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void Lint::visitAllocaInst(AllocaInst &I) {
|
|
|
|
if (isa<ConstantInt>(I.getArraySize()))
|
|
|
|
// This isn't undefined behavior, it's just an obvious pessimization.
|
2015-03-08 05:15:40 +08:00
|
|
|
Assert(&I.getParent()->getParent()->getEntryBlock() == I.getParent(),
|
|
|
|
"Pessimization: Static alloca outside of entry block", &I);
|
2010-07-06 23:23:00 +08:00
|
|
|
|
|
|
|
// TODO: Check for an unusual size (MSB set?)
|
2010-04-09 02:47:09 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void Lint::visitVAArgInst(VAArgInst &I) {
|
2015-06-17 15:21:38 +08:00
|
|
|
visitMemoryReference(I, I.getOperand(0), MemoryLocation::UnknownSize, 0,
|
2014-04-15 12:59:12 +08:00
|
|
|
nullptr, MemRef::Read | MemRef::Write);
|
2010-04-09 02:47:09 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void Lint::visitIndirectBrInst(IndirectBrInst &I) {
|
2015-06-17 15:21:38 +08:00
|
|
|
visitMemoryReference(I, I.getAddress(), MemoryLocation::UnknownSize, 0,
|
2014-04-15 12:59:12 +08:00
|
|
|
nullptr, MemRef::Branchee);
|
2010-08-03 07:06:43 +08:00
|
|
|
|
2015-03-08 05:15:40 +08:00
|
|
|
Assert(I.getNumDestinations() != 0,
|
|
|
|
"Undefined behavior: indirectbr with no destinations", &I);
|
2010-04-09 02:47:09 +08:00
|
|
|
}
|
|
|
|
|
2010-04-09 07:05:57 +08:00
|
|
|
void Lint::visitExtractElementInst(ExtractElementInst &I) {
|
2015-08-06 10:05:46 +08:00
|
|
|
if (ConstantInt *CI = dyn_cast<ConstantInt>(findValue(I.getIndexOperand(),
|
|
|
|
/*OffsetOk=*/false)))
|
2015-03-08 05:15:40 +08:00
|
|
|
Assert(CI->getValue().ult(I.getVectorOperandType()->getNumElements()),
|
|
|
|
"Undefined result: extractelement index out of range", &I);
|
2010-04-09 07:05:57 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void Lint::visitInsertElementInst(InsertElementInst &I) {
|
2015-08-06 10:05:46 +08:00
|
|
|
if (ConstantInt *CI = dyn_cast<ConstantInt>(findValue(I.getOperand(2),
|
|
|
|
/*OffsetOk=*/false)))
|
2015-03-08 05:15:40 +08:00
|
|
|
Assert(CI->getValue().ult(I.getType()->getNumElements()),
|
|
|
|
"Undefined result: insertelement index out of range", &I);
|
2010-04-09 09:39:53 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void Lint::visitUnreachableInst(UnreachableInst &I) {
|
|
|
|
// This isn't undefined behavior, it's merely suspicious.
|
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
|
|
|
Assert(&I == &I.getParent()->front() ||
|
|
|
|
std::prev(I.getIterator())->mayHaveSideEffects(),
|
2015-03-08 05:15:40 +08:00
|
|
|
"Unusual: unreachable immediately preceded by instruction without "
|
|
|
|
"side effects",
|
|
|
|
&I);
|
2010-04-09 07:05:57 +08:00
|
|
|
}
|
|
|
|
|
2010-05-29 00:21:24 +08:00
|
|
|
/// findValue - Look through bitcasts and simple memory reference patterns
|
|
|
|
/// to identify an equivalent, but more informative, value. If OffsetOk
|
|
|
|
/// is true, look through getelementptrs with non-zero offsets too.
|
|
|
|
///
|
|
|
|
/// Most analysis passes don't require this logic, because instcombine
|
|
|
|
/// will simplify most of these kinds of things away. But it's a goal of
|
|
|
|
/// this Lint pass to be useful even on non-optimized IR.
|
2015-08-06 10:05:46 +08:00
|
|
|
Value *Lint::findValue(Value *V, bool OffsetOk) const {
|
2010-05-29 00:45:33 +08:00
|
|
|
SmallPtrSet<Value *, 4> Visited;
|
2015-08-06 10:05:46 +08:00
|
|
|
return findValueImpl(V, OffsetOk, Visited);
|
2010-05-29 00:45:33 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/// findValueImpl - Implementation helper for findValue.
|
2015-08-06 10:05:46 +08:00
|
|
|
Value *Lint::findValueImpl(Value *V, bool OffsetOk,
|
2014-08-21 13:55:13 +08:00
|
|
|
SmallPtrSetImpl<Value *> &Visited) const {
|
2010-05-29 00:45:33 +08:00
|
|
|
// Detect self-referential values.
|
2014-11-19 15:49:26 +08:00
|
|
|
if (!Visited.insert(V).second)
|
2010-05-29 00:45:33 +08:00
|
|
|
return UndefValue::get(V->getType());
|
|
|
|
|
2010-05-29 00:21:24 +08:00
|
|
|
// TODO: Look through sext or zext cast, when the result is known to
|
|
|
|
// be interpreted as signed or unsigned, respectively.
|
2010-05-29 05:43:57 +08:00
|
|
|
// TODO: Look through eliminable cast pairs.
|
2010-05-29 00:21:24 +08:00
|
|
|
// TODO: Look through calls with unique return values.
|
|
|
|
// TODO: Look through vector insert/extract/shuffle.
|
2015-08-06 10:05:46 +08:00
|
|
|
V = OffsetOk ? GetUnderlyingObject(V, *DL) : V->stripPointerCasts();
|
2010-05-29 00:21:24 +08:00
|
|
|
if (LoadInst *L = dyn_cast<LoadInst>(V)) {
|
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 = L->getIterator();
|
2010-05-29 00:21:24 +08:00
|
|
|
BasicBlock *BB = L->getParent();
|
2010-05-29 01:44:00 +08:00
|
|
|
SmallPtrSet<BasicBlock *, 4> VisitedBlocks;
|
2010-05-29 00:21:24 +08:00
|
|
|
for (;;) {
|
2014-11-19 15:49:26 +08:00
|
|
|
if (!VisitedBlocks.insert(BB).second)
|
|
|
|
break;
|
2015-09-19 03:14:35 +08:00
|
|
|
if (Value *U =
|
2016-01-22 09:51:51 +08:00
|
|
|
FindAvailableLoadedValue(L, BB, BBI, DefMaxInstsToScan, AA))
|
2015-08-06 10:05:46 +08:00
|
|
|
return findValueImpl(U, OffsetOk, Visited);
|
2010-05-29 01:44:00 +08:00
|
|
|
if (BBI != BB->begin()) break;
|
|
|
|
BB = BB->getUniquePredecessor();
|
2010-05-29 00:21:24 +08:00
|
|
|
if (!BB) break;
|
|
|
|
BBI = BB->end();
|
|
|
|
}
|
2010-05-29 05:43:57 +08:00
|
|
|
} else if (PHINode *PN = dyn_cast<PHINode>(V)) {
|
2010-11-17 12:30:22 +08:00
|
|
|
if (Value *W = PN->hasConstantValue())
|
2010-11-17 18:23:23 +08:00
|
|
|
if (W != V)
|
2015-08-06 10:05:46 +08:00
|
|
|
return findValueImpl(W, OffsetOk, Visited);
|
2010-05-29 00:21:24 +08:00
|
|
|
} else if (CastInst *CI = dyn_cast<CastInst>(V)) {
|
2015-08-06 10:05:46 +08:00
|
|
|
if (CI->isNoopCast(*DL))
|
|
|
|
return findValueImpl(CI->getOperand(0), OffsetOk, Visited);
|
2010-05-29 00:21:24 +08:00
|
|
|
} else if (ExtractValueInst *Ex = dyn_cast<ExtractValueInst>(V)) {
|
|
|
|
if (Value *W = FindInsertedValue(Ex->getAggregateOperand(),
|
2011-07-13 18:26:04 +08:00
|
|
|
Ex->getIndices()))
|
2010-05-29 00:21:24 +08:00
|
|
|
if (W != V)
|
2015-08-06 10:05:46 +08:00
|
|
|
return findValueImpl(W, OffsetOk, Visited);
|
2010-05-29 05:43:57 +08:00
|
|
|
} else if (ConstantExpr *CE = dyn_cast<ConstantExpr>(V)) {
|
|
|
|
// Same as above, but for ConstantExpr instead of Instruction.
|
|
|
|
if (Instruction::isCast(CE->getOpcode())) {
|
|
|
|
if (CastInst::isNoopCast(Instruction::CastOps(CE->getOpcode()),
|
2015-03-10 10:37:25 +08:00
|
|
|
CE->getOperand(0)->getType(), CE->getType(),
|
2015-08-06 10:05:46 +08:00
|
|
|
DL->getIntPtrType(V->getType())))
|
|
|
|
return findValueImpl(CE->getOperand(0), OffsetOk, Visited);
|
2010-05-29 05:43:57 +08:00
|
|
|
} else if (CE->getOpcode() == Instruction::ExtractValue) {
|
2011-04-13 23:22:40 +08:00
|
|
|
ArrayRef<unsigned> Indices = CE->getIndices();
|
2011-07-13 18:26:04 +08:00
|
|
|
if (Value *W = FindInsertedValue(CE->getOperand(0), Indices))
|
2010-05-29 05:43:57 +08:00
|
|
|
if (W != V)
|
2015-08-06 10:05:46 +08:00
|
|
|
return findValueImpl(W, OffsetOk, Visited);
|
2010-05-29 05:43:57 +08:00
|
|
|
}
|
2010-05-29 00:21:24 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// As a last resort, try SimplifyInstruction or constant folding.
|
|
|
|
if (Instruction *Inst = dyn_cast<Instruction>(V)) {
|
2017-04-29 03:55:38 +08:00
|
|
|
if (Value *W = SimplifyInstruction(Inst, {*DL, TLI, DT, AC}))
|
2015-08-06 10:05:46 +08:00
|
|
|
return findValueImpl(W, OffsetOk, Visited);
|
2016-07-29 11:27:26 +08:00
|
|
|
} else if (auto *C = dyn_cast<Constant>(V)) {
|
|
|
|
if (Value *W = ConstantFoldConstant(C, *DL, TLI))
|
|
|
|
if (W && W != V)
|
2015-08-06 10:05:46 +08:00
|
|
|
return findValueImpl(W, OffsetOk, Visited);
|
2010-05-29 00:21:24 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
return V;
|
|
|
|
}
|
|
|
|
|
2010-04-09 02:47:09 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Implement the public interfaces to this file...
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
FunctionPass *llvm::createLintPass() {
|
|
|
|
return new Lint();
|
|
|
|
}
|
|
|
|
|
|
|
|
/// lintFunction - Check a function for errors, printing messages on stderr.
|
|
|
|
///
|
|
|
|
void llvm::lintFunction(const Function &f) {
|
|
|
|
Function &F = const_cast<Function&>(f);
|
|
|
|
assert(!F.isDeclaration() && "Cannot lint external functions");
|
|
|
|
|
2015-02-13 18:01:29 +08:00
|
|
|
legacy::FunctionPassManager FPM(F.getParent());
|
2010-04-09 02:47:09 +08:00
|
|
|
Lint *V = new Lint();
|
|
|
|
FPM.add(V);
|
|
|
|
FPM.run(F);
|
|
|
|
}
|
|
|
|
|
|
|
|
/// lintModule - Check a module for errors, printing messages on stderr.
|
|
|
|
///
|
2010-05-27 06:28:53 +08:00
|
|
|
void llvm::lintModule(const Module &M) {
|
2015-02-13 18:01:29 +08:00
|
|
|
legacy::PassManager PM;
|
2010-04-09 02:47:09 +08:00
|
|
|
Lint *V = new Lint();
|
|
|
|
PM.add(V);
|
|
|
|
PM.run(const_cast<Module&>(M));
|
|
|
|
}
|