83 cl::desc(
"In the Lint pass, abort on errors."));
87static const unsigned Read = 1;
88static const unsigned Write = 2;
89static const unsigned Callee = 4;
90static const unsigned Branchee = 8;
121 Value *findValue(
Value *V,
bool OffsetOk)
const;
133 std::string Messages;
138 :
Mod(
Mod),
DL(
DL), AA(AA), AC(AC), DT(DT), TLI(TLI),
139 MessagesStr(Messages) {}
142 for (
const Value *V : Vs) {
145 if (isa<Instruction>(V)) {
146 MessagesStr << *
V <<
'\n';
148 V->printAsOperand(MessagesStr,
true,
Mod);
158 void CheckFailed(
const Twine &Message) { MessagesStr << Message <<
'\n'; }
164 template <
typename T1,
typename... Ts>
165 void CheckFailed(
const Twine &Message,
const T1 &V1,
const Ts &... Vs) {
166 CheckFailed(Message);
167 WriteValues({V1, Vs...});
173#define Check(C, ...) \
176 CheckFailed(__VA_ARGS__); \
184 Check(
F.hasName() ||
F.hasLocalLinkage(),
185 "Unusual: Unnamed function with non-local linkage", &
F);
194 nullptr, MemRef::Callee);
196 if (
Function *
F = dyn_cast<Function>(findValue(Callee,
198 Check(
I.getCallingConv() ==
F->getCallingConv(),
199 "Undefined behavior: Caller and callee calling convention differ",
203 unsigned NumActualArgs =
I.arg_size();
205 Check(FT->isVarArg() ? FT->getNumParams() <= NumActualArgs
206 : FT->getNumParams() == NumActualArgs,
207 "Undefined behavior: Call argument count mismatches callee "
211 Check(FT->getReturnType() ==
I.getType(),
212 "Undefined behavior: Call return type mismatches "
213 "callee return type",
219 auto AI =
I.arg_begin(), AE =
I.arg_end();
220 for (; AI != AE; ++AI) {
225 "Undefined behavior: Call argument type mismatches "
226 "callee parameter type",
235 for (
auto *BI =
I.arg_begin(); BI != AE; ++BI, ++ArgNo) {
245 if (
I.doesNotAccessMemory(ArgNo))
247 if (AI != BI && (*BI)->getType()->isPointerTy()) {
251 "Unusual: noalias argument aliases another argument", &
I);
261 visitMemoryReference(
I, Loc,
DL->getABITypeAlign(Ty), Ty,
262 MemRef::Read | MemRef::Write);
268 if (
const auto *CI = dyn_cast<CallInst>(&
I)) {
269 if (CI->isTailCall()) {
272 for (
Value *Arg :
I.args()) {
277 Value *Obj = findValue(Arg,
true);
278 Check(!isa<AllocaInst>(Obj),
279 "Undefined behavior: Call with \"tail\" keyword references "
287 switch (
II->getIntrinsicID()) {
293 case Intrinsic::memcpy:
294 case Intrinsic::memcpy_inline: {
306 dyn_cast<ConstantInt>(findValue(MCI->
getLength(),
308 if (
Len->getValue().isIntN(32))
312 "Undefined behavior: memcpy source and destination overlap", &
I);
315 case Intrinsic::memmove: {
323 case Intrinsic::memset: {
329 case Intrinsic::memset_inline: {
336 case Intrinsic::vastart:
339 std::nullopt,
nullptr, MemRef::Read | MemRef::Write);
341 case Intrinsic::vacopy:
343 std::nullopt,
nullptr, MemRef::Write);
345 std::nullopt,
nullptr, MemRef::Read);
347 case Intrinsic::vaend:
349 std::nullopt,
nullptr, MemRef::Read | MemRef::Write);
352 case Intrinsic::stackrestore:
357 std::nullopt,
nullptr, MemRef::Read | MemRef::Write);
359 case Intrinsic::get_active_lane_mask:
360 if (
auto *TripCount = dyn_cast<ConstantInt>(
I.getArgOperand(1)))
361 Check(!TripCount->isZero(),
362 "get_active_lane_mask: operand #2 "
363 "must be greater than 0",
371 Check(!
F->doesNotReturn(),
372 "Unusual: Return statement in function with noreturn attribute", &
I);
374 if (
Value *V =
I.getReturnValue()) {
375 Value *Obj = findValue(V,
true);
376 Check(!isa<AllocaInst>(Obj),
"Unusual: Returning alloca value", &
I);
392 "Undefined behavior: Null pointer dereference", &
I);
394 "Undefined behavior: Undef pointer dereference", &
I);
397 "Unusual: All-ones pointer dereference", &
I);
400 "Unusual: Address one pointer dereference", &
I);
402 if (Flags & MemRef::Write) {
404 Check(!GV->isConstant(),
"Undefined behavior: Write to read-only memory",
408 "Undefined behavior: Write to text section", &
I);
410 if (Flags & MemRef::Read) {
414 "Undefined behavior: Load from block address", &
I);
416 if (Flags & MemRef::Callee) {
418 "Undefined behavior: Call to block address", &
I);
420 if (Flags & MemRef::Branchee) {
423 "Undefined behavior: Branch to non-blockaddress", &
I);
438 Type *ATy = AI->getAllocatedType();
439 if (!AI->isArrayAllocation() && ATy->
isSized())
440 BaseSize =
DL->getTypeAllocSize(ATy);
441 BaseAlign = AI->getAlign();
445 if (GV->hasDefinitiveInitializer()) {
446 Type *GTy = GV->getValueType();
448 BaseSize =
DL->getTypeAllocSize(GTy);
449 BaseAlign = GV->getAlign();
450 if (!BaseAlign && GTy->
isSized())
451 BaseAlign =
DL->getABITypeAlign(GTy);
459 "Undefined behavior: Buffer overflow", &
I);
464 Align =
DL->getABITypeAlign(Ty);
465 if (BaseAlign &&
Align)
467 "Undefined behavior: Memory reference address is misaligned", &
I);
478 I.getOperand(0)->getType(), MemRef::Write);
482 Check(!isa<UndefValue>(
I.getOperand(0)) || !isa<UndefValue>(
I.getOperand(1)),
483 "Undefined result: xor(undef, undef)", &
I);
487 Check(!isa<UndefValue>(
I.getOperand(0)) || !isa<UndefValue>(
I.getOperand(1)),
488 "Undefined result: sub(undef, undef)", &
I);
492 if (
ConstantInt *CI = dyn_cast<ConstantInt>(findValue(
I.getOperand(1),
494 Check(CI->getValue().ult(cast<IntegerType>(
I.getType())->getBitWidth()),
495 "Undefined result: Shift count out of range", &
I);
500 dyn_cast<ConstantInt>(findValue(
I.getOperand(1),
false)))
501 Check(CI->getValue().ult(cast<IntegerType>(
I.getType())->getBitWidth()),
502 "Undefined result: Shift count out of range", &
I);
507 dyn_cast<ConstantInt>(findValue(
I.getOperand(1),
false)))
508 Check(CI->getValue().ult(cast<IntegerType>(
I.getType())->getBitWidth()),
509 "Undefined result: Shift count out of range", &
I);
515 if (isa<UndefValue>(V))
518 VectorType *VecTy = dyn_cast<VectorType>(V->getType());
530 if (
C->isZeroValue())
538 if (isa<UndefValue>(Elem))
551 "Undefined behavior: Division by zero", &
I);
556 "Undefined behavior: Division by zero", &
I);
561 "Undefined behavior: Division by zero", &
I);
566 "Undefined behavior: Division by zero", &
I);
570 if (isa<ConstantInt>(
I.getArraySize()))
572 Check(&
I.getParent()->getParent()->getEntryBlock() ==
I.getParent(),
573 "Pessimization: Static alloca outside of entry block", &
I);
580 MemRef::Read | MemRef::Write);
585 std::nullopt,
nullptr, MemRef::Branchee);
587 Check(
I.getNumDestinations() != 0,
588 "Undefined behavior: indirectbr with no destinations", &
I);
592 if (
ConstantInt *CI = dyn_cast<ConstantInt>(findValue(
I.getIndexOperand(),
596 cast<FixedVectorType>(
I.getVectorOperandType())->getNumElements()),
597 "Undefined result: extractelement index out of range", &
I);
601 if (
ConstantInt *CI = dyn_cast<ConstantInt>(findValue(
I.getOperand(2),
603 Check(CI->getValue().ult(
604 cast<FixedVectorType>(
I.getType())->getNumElements()),
605 "Undefined result: insertelement index out of range", &
I);
610 Check(&
I == &
I.getParent()->front() ||
611 std::prev(
I.getIterator())->mayHaveSideEffects(),
612 "Unusual: unreachable immediately preceded by instruction without "
624Value *Lint::findValue(
Value *V,
bool OffsetOk)
const {
626 return findValueImpl(V, OffsetOk, Visited);
630Value *Lint::findValueImpl(
Value *V,
bool OffsetOk,
633 if (!Visited.
insert(V).second)
642 if (
LoadInst *L = dyn_cast<LoadInst>(V)) {
648 if (!VisitedBlocks.
insert(BB).second)
652 return findValueImpl(U, OffsetOk, Visited);
653 if (BBI != BB->
begin())
660 }
else if (
PHINode *PN = dyn_cast<PHINode>(V)) {
661 if (
Value *W = PN->hasConstantValue())
662 return findValueImpl(W, OffsetOk, Visited);
663 }
else if (
CastInst *CI = dyn_cast<CastInst>(V)) {
664 if (CI->isNoopCast(*
DL))
665 return findValueImpl(CI->getOperand(0), OffsetOk, Visited);
670 return findValueImpl(W, OffsetOk, Visited);
671 }
else if (
ConstantExpr *CE = dyn_cast<ConstantExpr>(V)) {
675 CE->getOperand(0)->getType(),
CE->getType(),
677 return findValueImpl(
CE->getOperand(0), OffsetOk, Visited);
682 if (
Instruction *Inst = dyn_cast<Instruction>(V)) {
684 return findValueImpl(W, OffsetOk, Visited);
685 }
else if (
auto *
C = dyn_cast<Constant>(V)) {
688 return findValueImpl(W, OffsetOk, Visited);
695 auto *
Mod =
F.getParent();
696 auto *
DL = &
F.getDataLayout();
701 Lint L(
Mod,
DL, AA, AC, DT, TLI);
703 dbgs() << L.MessagesStr.str();
719 assert(!
F.isDeclaration() &&
"Cannot lint external functions");
739 if (!
F.isDeclaration())
This file implements a class to represent arbitrary precision integral constant values and operations...
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
This is the interface for LLVM's primary stateless and local alias analysis.
This file contains the declarations for the subclasses of Constant, which represent the different fla...
static bool isZero(Value *V, const DataLayout &DL, DominatorTree *DT, AssumptionCache *AC)
static const char LintAbortOnErrorArgName[]
static cl::opt< bool > LintAbortOnError(LintAbortOnErrorArgName, cl::init(false), cl::desc("In the Lint pass, abort on errors."))
This file provides utility analysis objects describing memory locations.
Module.h This file contains the declarations for the Module class.
uint64_t IntrinsicInst * II
FunctionAnalysisManager FAM
This header defines various interfaces for pass management in LLVM.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
static unsigned getNumElements(Type *Ty)
This is the interface for a metadata-based scoped no-alias analysis.
This file defines the SmallPtrSet class.
This is the interface for a metadata-based TBAA.
A manager for alias analyses.
void registerFunctionAnalysis()
Register a specific AA result.
AliasResult alias(const MemoryLocation &LocA, const MemoryLocation &LocB)
The main low level interface to the alias analysis implementation.
The possible results of an alias query.
@ PartialAlias
The two locations alias, but only due to a partial overlap.
@ MustAlias
The two locations precisely alias each other.
an instruction to allocate memory on the stack
A container for analyses that lazily runs them and caches their results.
bool registerPass(PassBuilderT &&PassBuilder)
Register an analysis pass with the manager.
PassT::Result & getResult(IRUnitT &IR, ExtraArgTs... ExtraArgs)
Get the result of an analysis pass for a given IR unit.
This class represents an incoming formal argument to a Function.
bool hasNoAliasAttr() const
Return true if this argument has the noalias attribute.
bool onlyReadsMemory() const
Return true if this argument has the readonly or readnone attribute.
Type * getParamStructRetType() const
If this is an sret argument, return its type.
bool hasStructRetAttr() const
Return true if this argument has the sret attribute.
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
A function analysis which provides an AssumptionCache.
A cache of @llvm.assume calls within a function.
bool hasParamAttr(unsigned ArgNo, Attribute::AttrKind Kind) const
Return true if the attribute exists for the given argument.
AttributeSet getAttributes(unsigned Index) const
The attributes for the specified index are returned.
Analysis pass providing a never-invalidated alias analysis result.
LLVM Basic Block Representation.
iterator begin()
Instruction iterator methods.
const BasicBlock * getUniquePredecessor() const
Return the predecessor of this block if it has a unique predecessor block.
InstListType::iterator iterator
Instruction iterators...
This class is a wrapper over an AAResults, and it is intended to be used only when there are no IR ch...
Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to callin...
This is the base class for all instructions that perform data casts.
static bool isNoopCast(Instruction::CastOps Opcode, Type *SrcTy, Type *DstTy, const DataLayout &DL)
A no-op cast is one that can be effected without changing any bits.
A constant value that is initialized with an expression using other constant values.
This is the shared class of boolean and integer constants.
This is an important base class in LLVM.
A parsed version of the target data layout string in and methods for querying it.
Analysis pass which computes a DominatorTree.
Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree.
Indirect Branch Instruction.
This instruction inserts a single (scalar) element into a VectorType value.
Base class for instruction visitors.
RetTy visitIndirectBrInst(IndirectBrInst &I)
RetTy visitExtractElementInst(ExtractElementInst &I)
RetTy visitCallBase(CallBase &I)
void visitFunction(Function &F)
RetTy visitUnreachableInst(UnreachableInst &I)
RetTy visitReturnInst(ReturnInst &I)
RetTy visitStoreInst(StoreInst &I)
RetTy visitInsertElementInst(InsertElementInst &I)
RetTy visitAllocaInst(AllocaInst &I)
RetTy visitLoadInst(LoadInst &I)
RetTy visitVAArgInst(VAArgInst &I)
A wrapper class for inspecting calls to intrinsic functions.
PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM)
An instruction for reading from memory.
static LocationSize precise(uint64_t Value)
TypeSize getValue() const
static constexpr LocationSize afterPointer()
Any location after the base pointer (but still within the underlying object).
This class wraps the llvm.memcpy intrinsic.
Value * getLength() const
Value * getDest() const
This is just like getRawDest, but it strips off any cast instructions (including addrspacecast) that ...
MaybeAlign getDestAlign() const
This class wraps the llvm.memmove intrinsic.
This class wraps the llvm.memset.inline intrinsic.
This class wraps the llvm.memset and llvm.memset.inline intrinsics.
MaybeAlign getSourceAlign() const
Value * getSource() const
This is just like getRawSource, but it strips off any cast instructions that feed it,...
Representation for a specific memory location.
static MemoryLocation get(const LoadInst *LI)
Return a location with information about the memory reference by the given instruction.
static MemoryLocation getForSource(const MemTransferInst *MTI)
Return a location representing the source of a memory transfer.
LocationSize Size
The maximum size of the location, in address-units, or UnknownSize if the size is not known.
static MemoryLocation getAfter(const Value *Ptr, const AAMDNodes &AATags=AAMDNodes())
Return a location that may access any location after Ptr, while remaining within the underlying objec...
const Value * Ptr
The address of the start of the location.
static MemoryLocation getForDest(const MemIntrinsic *MI)
Return a location representing the destination of a memory set or transfer.
static MemoryLocation getForArgument(const CallBase *Call, unsigned ArgIdx, const TargetLibraryInfo *TLI)
Return a location representing a particular argument of a call.
A Module instance is used to store all the information related to an LLVM module.
static PoisonValue * get(Type *T)
Static factory methods - Return an 'poison' object of the specified type.
A set of analyses that are preserved following a run of a transformation pass.
static PreservedAnalyses all()
Construct a special preserved set that preserves all passes.
Return a value (possibly void), from a function.
Analysis pass providing a never-invalidated alias analysis result.
A templated base class for SmallPtrSet which provides the typesafe interface that is common across al...
std::pair< iterator, bool > insert(PtrType Ptr)
Inserts Ptr if and only if there is no element in the container equal to Ptr.
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.
An instruction for storing to memory.
Analysis pass providing the TargetLibraryInfo.
Provides information about what library functions are available for the current target.
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Analysis pass providing a never-invalidated alias analysis result.
The instances of the Type class are immutable: once they are created, they are never changed.
bool isPointerTy() const
True if this is an instance of PointerType.
bool isSized(SmallPtrSetImpl< Type * > *Visited=nullptr) const
Return true if it makes sense to take the size of this type.
This function has undefined behavior.
This class represents the va_arg llvm instruction, which returns an argument of the specified type gi...
LLVM Value Representation.
Type * getType() const
All values are typed, get the type of this value.
A raw_ostream that writes to an std::string.
@ C
The default llvm calling convention, compatible with C.
@ CE
Windows NT (Windows on ARM)
initializer< Ty > init(const Ty &Val)
This is an optimization pass for GlobalISel generic memory operations.
Value * GetPointerBaseWithConstantOffset(Value *Ptr, int64_t &Offset, const DataLayout &DL, bool AllowNonInbounds=true)
Analyze the specified pointer to see if it can be expressed as a base pointer plus a constant offset.
const Value * getUnderlyingObject(const Value *V, unsigned MaxLookup=6)
This method strips off any GEP address adjustments, pointer casts or llvm.threadlocal....
Value * FindAvailableLoadedValue(LoadInst *Load, BasicBlock *ScanBB, BasicBlock::iterator &ScanFrom, unsigned MaxInstsToScan=DefMaxInstsToScan, BatchAAResults *AA=nullptr, bool *IsLoadCSE=nullptr, unsigned *NumScanedInst=nullptr)
Scan backwards to see if we have the value of the given load available locally within a small number ...
Value * simplifyInstruction(Instruction *I, const SimplifyQuery &Q)
See if we can compute a simplified version of this instruction.
Constant * ConstantFoldConstant(const Constant *C, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr)
ConstantFoldConstant - Fold the constant using the specified DataLayout.
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
void lintModule(const Module &M)
Lint a module.
cl::opt< unsigned > DefMaxInstsToScan
The default number of maximum instructions to scan in the block, used by FindAvailableLoadedValue().
@ Mod
The access may modify the value stored in memory.
void computeKnownBits(const Value *V, KnownBits &Known, const DataLayout &DL, unsigned Depth=0, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr, bool UseInstrInfo=true)
Determine which bits of V are known to be either zero or one and return them in the KnownZero/KnownOn...
Align commonAlignment(Align A, uint64_t Offset)
Returns the alignment that satisfies both alignments.
Value * FindInsertedValue(Value *V, ArrayRef< unsigned > idx_range, std::optional< BasicBlock::iterator > InsertBefore=std::nullopt)
Given an aggregate and an sequence of indices, see if the scalar value indexed is already around as a...
void lintFunction(const Function &F)
lintFunction - Check a function for errors, printing messages on stderr.
This struct is a compact representation of a valid (non-zero power of two) alignment.
bool isZero() const
Returns true if value is all zero.
This struct is a compact representation of a valid (power of two) or undefined (0) alignment.