This is an archive of the discontinued LLVM Phabricator instance.

Differential D8158

DataLayout is mandatory, update the API to reflect it with references.
ClosedPublic

Authored by mehdi_amini on Mar 8 2015, 7:40 PM.

Details

Reviewers
echristo
Summary

Now that the DataLayout is a mandatory part of the module, let's start
cleaning the codebase. This patch is a first attempt at doing that.

This patch is not exactly NFC as for instance some places were passing a
nullptr instead of the DataLayout, possibly just because there was a
default value on the DataLayout argument to many functions in the API.
Even though it is not purely NFC, there is no change in the validation.

I turned as many pointer to DataLayout to references, this helped figuring
out all the places where a nullptr could come up.

I had initially a local version of this patch broken into over 30 independant,
commits but some later commit were cleaning the API and touching part of the
code modified in the previous commits, so the intermediate steps are not very
clean. Here is the squashed result.

Diff Detail

Repository
rL LLVM

Event Timeline

mehdi_amini updated this revision to Diff 21469.Mar 8 2015, 7:40 PM
mehdi_amini retitled this revision from to DataLayout is mandatory, update the API to reflect it with references. .
mehdi_amini updated this object.
mehdi_amini edited the test plan for this revision. (Show Details)
mehdi_amini added a reviewer: echristo.
mehdi_amini set the repository for this revision to rL LLVM.
mehdi_amini added a subscriber: Unknown Object (MLST).
Herald added a subscriber: jholewinski. · View Herald TranscriptMar 8 2015, 7:40 PM
echristo accepted this revision.Mar 9 2015, 10:31 AM
echristo edited edge metadata.

Couple of comments, in general looks fine and anything else can be covered in post-commit etc based on answers.

You pass down the DataLayout in a few new places rather than keep it cached or look it up, any reason? (This is also one of the inline comments as I found it in a particular place, but rather than keep asking it's also a top level comment).

Thanks for the work! That was very long :)

-eric

lib/Analysis/Lint.cpp
178

Any reason not to leave it cached instead of passing it down?

lib/Analysis/LoopAccessAnalysis.cpp
292

Formatting. :)

This revision is now accepted and ready to land.Mar 9 2015, 10:31 AM
mehdi_amini added a comment.Mar 9 2015, 2:49 PM

Thanks for review, that was quick :)

lib/Analysis/Lint.cpp
178

In short: cannot rebind a reference and I wanted to get rid of the pointer.

It plays well with passes that initialize a separate transient object to do the processing, but not with passes that do their processing "in-place". Because passes object are not transient, they carry their state between runs, including a potential obsolete DL pointer.

Not sure if I was clear?

This was very case-by-case, and I may have get it wrong here and there (I mean wrong in the sense that a function argument could have been save by retrieving the DL differently, I don't think I broke correctness).

lib/Analysis/LoopAccessAnalysis.cpp
292

That was clang-format, it probably gets over 80 lines without the line break. I'll rephrase the comment to save what is needed to fit in the line.

mehdi_amini updated this revision to Diff 21534.Mar 9 2015, 5:46 PM
mehdi_amini edited edge metadata.
  • add a DataLayout parameter to getOrEnforceKnownAlignment() instead of using CtxI instruction to please clang (which does not have an instruction hanging around).
  • cleanup:
    • some includes were in header where they could have been in .cpp.
    • rename TD to DL everywhere for consistency (DataLayout was TargetData in the past apparently).
    • fixup all comments mentioning what to do in case of missing DataLayout
mehdi_amini closed this revision.Mar 9 2015, 7:42 PM

r231739/r231740

Revision Contents

PathSize
include/
llvm/
Analysis/
2 lines
30 lines
1 line
69 lines
1 line
3 lines
5 lines
17 lines
5 lines
8 lines
4 lines
10 lines
4 lines
44 lines
IR/
6 lines
13 lines
2 lines
Target/
3 lines
Transforms/
IPO/
2 lines
Utils/
32 lines
2 lines
23 lines
17 lines
7 lines
lib/
Analysis/
5 lines
50 lines
107 lines
22 lines
IPA/
10 lines
53 lines
7 lines
111 lines
94 lines
150 lines
20 lines
50 lines
2 lines
49 lines
42 lines
97 lines
107 lines
259 lines
CodeGen/
AsmPrinter/
5 lines
11 lines
8 lines
105 lines
SelectionDAG/
4 lines
7 lines
11 lines
7 lines
IR/
18 lines
35 lines
Target/
Mips/
15 lines
NVPTX/
4 lines
PowerPC/
2 lines
2 lines
2 lines
R600/
5 lines
4 lines
Transforms/
IPO/
31 lines
24 lines
19 lines
21 lines
53 lines
InstCombine/
88 lines
14 lines
64 lines
135 lines
48 lines
20 lines
99 lines
26 lines
5 lines
36 lines
25 lines
148 lines
4 lines
180 lines
Instrumentation/
52 lines
23 lines
18 lines
54 lines
55 lines
ObjCARC/
16 lines
5 lines
6 lines
10 lines
5 lines
28 lines
4 lines
Scalar/
7 lines
31 lines
3 lines
5 lines
57 lines
14 lines
130 lines
34 lines
9 lines
12 lines
77 lines
30 lines
10 lines
2 lines
27 lines
4 lines
6 lines
5 lines
3 lines
59 lines
2 lines
82 lines
189 lines
23 lines
56 lines
17 lines
4 lines
7 lines
Utils/
127 lines
30 lines
20 lines
22 lines
21 lines
6 lines
4 lines
4 lines
3 lines
264 lines
2 lines
176 lines
Vectorize/
24 lines
115 lines
94 lines
unittests/
IR/
2 lines
8 lines

Diff 21469

include/llvm/Analysis/AliasAnalysis.h

Context not available.
/// getDataLayout - Return a pointer to the current DataLayout object, or /// getDataLayout - Return a pointer to the current DataLayout object, or
/// null if no DataLayout object is available. /// null if no DataLayout object is available.
/// ///
const DataLayout *getDataLayout() const { return DL; }
/// getTargetLibraryInfo - Return a pointer to the current TargetLibraryInfo /// getTargetLibraryInfo - Return a pointer to the current TargetLibraryInfo
/// object, or null if no TargetLibraryInfo object is available. /// object, or null if no TargetLibraryInfo object is available.
/// ///
Context not available.

include/llvm/Analysis/ConstantFolding.h

Context not available.
/// Note that this fails if not all of the operands are constant. Otherwise, /// Note that this fails if not all of the operands are constant. Otherwise,
/// this function can only fail when attempting to fold instructions like loads /// this function can only fail when attempting to fold instructions like loads
/// and stores, which have no constant expression form. /// and stores, which have no constant expression form.
Constant *ConstantFoldInstruction(Instruction *I, Constant *ConstantFoldInstruction(Instruction *I, const DataLayout &DL,
const DataLayout *TD = nullptr, const TargetLibraryInfo *TLI = nullptr);
const TargetLibraryInfo *TLI = nullptr);
/// ConstantFoldConstantExpression - Attempt to fold the constant expression /// ConstantFoldConstantExpression - Attempt to fold the constant expression
/// using the specified DataLayout. If successful, the constant result is /// using the specified DataLayout. If successful, the constant result is
/// result is returned, if not, null is returned. /// result is returned, if not, null is returned.
Constant *ConstantFoldConstantExpression(const ConstantExpr *CE, Constant *
const DataLayout *TD = nullptr, ConstantFoldConstantExpression(const ConstantExpr *CE, const DataLayout &DL,
const TargetLibraryInfo *TLI =nullptr); const TargetLibraryInfo *TLI = nullptr);
/// ConstantFoldInstOperands - Attempt to constant fold an instruction with the /// ConstantFoldInstOperands - Attempt to constant fold an instruction with the
/// specified operands. If successful, the constant result is returned, if not, /// specified operands. If successful, the constant result is returned, if not,
Context not available.
/// fold instructions like loads and stores, which have no constant expression /// fold instructions like loads and stores, which have no constant expression
/// form. /// form.
/// ///
Constant *ConstantFoldInstOperands(unsigned Opcode, Type *DestTy, Constant *ConstantFoldInstOperands(unsigned Opcode, Type *DestTy,
ArrayRef<Constant *> Ops, ArrayRef<Constant *> Ops,
const DataLayout *TD = nullptr, const DataLayout &DL,
const TargetLibraryInfo *TLI = nullptr); const TargetLibraryInfo *TLI = nullptr);
/// ConstantFoldCompareInstOperands - Attempt to constant fold a compare /// ConstantFoldCompareInstOperands - Attempt to constant fold a compare
/// instruction (icmp/fcmp) with the specified operands. If it fails, it /// instruction (icmp/fcmp) with the specified operands. If it fails, it
/// returns a constant expression of the specified operands. /// returns a constant expression of the specified operands.
/// ///
Constant *ConstantFoldCompareInstOperands(unsigned Predicate, Constant *
Constant *LHS, Constant *RHS, ConstantFoldCompareInstOperands(unsigned Predicate, Constant *LHS,
const DataLayout *TD = nullptr, Constant *RHS, const DataLayout &DL,
const TargetLibraryInfo *TLI=nullptr); const TargetLibraryInfo *TLI = nullptr);
/// ConstantFoldInsertValueInstruction - Attempt to constant fold an insertvalue /// ConstantFoldInsertValueInstruction - Attempt to constant fold an insertvalue
/// instruction with the specified operands and indices. The constant result is /// instruction with the specified operands and indices. The constant result is
Context not available.
/// ConstantFoldLoadFromConstPtr - Return the value that a load from C would /// ConstantFoldLoadFromConstPtr - Return the value that a load from C would
/// produce if it is constant and determinable. If this is not determinable, /// produce if it is constant and determinable. If this is not determinable,
/// return null. /// return null.
Constant *ConstantFoldLoadFromConstPtr(Constant *C, Constant *ConstantFoldLoadFromConstPtr(Constant *C, const DataLayout &DL);
const DataLayout *TD = nullptr);
/// ConstantFoldLoadThroughGEPConstantExpr - Given a constant and a /// ConstantFoldLoadThroughGEPConstantExpr - Given a constant and a
/// getelementptr constantexpr, return the constant value being addressed by the /// getelementptr constantexpr, return the constant value being addressed by the
Context not available.

include/llvm/Analysis/IVUsers.h

Context not available.
LoopInfo *LI; LoopInfo *LI;
DominatorTree *DT; DominatorTree *DT;
ScalarEvolution *SE; ScalarEvolution *SE;
const DataLayout *DL;
SmallPtrSet<Instruction*,16> Processed; SmallPtrSet<Instruction*,16> Processed;
/// IVUses - A list of all tracked IV uses of induction variable expressions /// IVUses - A list of all tracked IV uses of induction variable expressions
Context not available.

include/llvm/Analysis/InstructionSimplify.h

Context not available.
/// SimplifyAddInst - Given operands for an Add, see if we can /// SimplifyAddInst - Given operands for an Add, see if we can
/// fold the result. If not, this returns null. /// fold the result. If not, this returns null.
Value *SimplifyAddInst(Value *LHS, Value *RHS, bool isNSW, bool isNUW, Value *SimplifyAddInst(Value *LHS, Value *RHS, bool isNSW, bool isNUW,
const DataLayout *TD = nullptr, const DataLayout &DL,
const TargetLibraryInfo *TLI = nullptr, const TargetLibraryInfo *TLI = nullptr,
const DominatorTree *DT = nullptr, const DominatorTree *DT = nullptr,
AssumptionCache *AC = nullptr, AssumptionCache *AC = nullptr,
Context not available.
/// SimplifySubInst - Given operands for a Sub, see if we can /// SimplifySubInst - Given operands for a Sub, see if we can
/// fold the result. If not, this returns null. /// fold the result. If not, this returns null.
Value *SimplifySubInst(Value *LHS, Value *RHS, bool isNSW, bool isNUW, Value *SimplifySubInst(Value *LHS, Value *RHS, bool isNSW, bool isNUW,
const DataLayout *TD = nullptr, const DataLayout &DL,
const TargetLibraryInfo *TLI = nullptr, const TargetLibraryInfo *TLI = nullptr,
const DominatorTree *DT = nullptr, const DominatorTree *DT = nullptr,
AssumptionCache *AC = nullptr, AssumptionCache *AC = nullptr,
Context not available.
/// Given operands for an FAdd, see if we can fold the result. If not, this /// Given operands for an FAdd, see if we can fold the result. If not, this
/// returns null. /// returns null.
Value *SimplifyFAddInst(Value *LHS, Value *RHS, FastMathFlags FMF, Value *SimplifyFAddInst(Value *LHS, Value *RHS, FastMathFlags FMF,
const DataLayout *TD = nullptr, const DataLayout &DL,
const TargetLibraryInfo *TLI = nullptr, const TargetLibraryInfo *TLI = nullptr,
const DominatorTree *DT = nullptr, const DominatorTree *DT = nullptr,
AssumptionCache *AC = nullptr, AssumptionCache *AC = nullptr,
Context not available.
/// Given operands for an FSub, see if we can fold the result. If not, this /// Given operands for an FSub, see if we can fold the result. If not, this
/// returns null. /// returns null.
Value *SimplifyFSubInst(Value *LHS, Value *RHS, FastMathFlags FMF, Value *SimplifyFSubInst(Value *LHS, Value *RHS, FastMathFlags FMF,
const DataLayout *TD = nullptr, const DataLayout &DL,
const TargetLibraryInfo *TLI = nullptr, const TargetLibraryInfo *TLI = nullptr,
const DominatorTree *DT = nullptr, const DominatorTree *DT = nullptr,
AssumptionCache *AC = nullptr, AssumptionCache *AC = nullptr,
Context not available.
/// Given operands for an FMul, see if we can fold the result. If not, this /// Given operands for an FMul, see if we can fold the result. If not, this
/// returns null. /// returns null.
Value *SimplifyFMulInst(Value *LHS, Value *RHS, FastMathFlags FMF, Value *SimplifyFMulInst(Value *LHS, Value *RHS, FastMathFlags FMF,
const DataLayout *TD = nullptr, const DataLayout &DL,
const TargetLibraryInfo *TLI = nullptr, const TargetLibraryInfo *TLI = nullptr,
const DominatorTree *DT = nullptr, const DominatorTree *DT = nullptr,
AssumptionCache *AC = nullptr, AssumptionCache *AC = nullptr,
Context not available.
/// SimplifyMulInst - Given operands for a Mul, see if we can /// SimplifyMulInst - Given operands for a Mul, see if we can
/// fold the result. If not, this returns null. /// fold the result. If not, this returns null.
Value *SimplifyMulInst(Value *LHS, Value *RHS, const DataLayout *TD = nullptr, Value *SimplifyMulInst(Value *LHS, Value *RHS, const DataLayout &DL,
const TargetLibraryInfo *TLI = nullptr, const TargetLibraryInfo *TLI = nullptr,
const DominatorTree *DT = nullptr, const DominatorTree *DT = nullptr,
AssumptionCache *AC = nullptr, AssumptionCache *AC = nullptr,
Context not available.
/// SimplifySDivInst - Given operands for an SDiv, see if we can /// SimplifySDivInst - Given operands for an SDiv, see if we can
/// fold the result. If not, this returns null. /// fold the result. If not, this returns null.
Value *SimplifySDivInst(Value *LHS, Value *RHS, Value *SimplifySDivInst(Value *LHS, Value *RHS, const DataLayout &DL,
const DataLayout *TD = nullptr,
const TargetLibraryInfo *TLI = nullptr, const TargetLibraryInfo *TLI = nullptr,
const DominatorTree *DT = nullptr, const DominatorTree *DT = nullptr,
AssumptionCache *AC = nullptr, AssumptionCache *AC = nullptr,
Context not available.
/// SimplifyUDivInst - Given operands for a UDiv, see if we can /// SimplifyUDivInst - Given operands for a UDiv, see if we can
/// fold the result. If not, this returns null. /// fold the result. If not, this returns null.
Value *SimplifyUDivInst(Value *LHS, Value *RHS, Value *SimplifyUDivInst(Value *LHS, Value *RHS, const DataLayout &DL,
const DataLayout *TD = nullptr,
const TargetLibraryInfo *TLI = nullptr, const TargetLibraryInfo *TLI = nullptr,
const DominatorTree *DT = nullptr, const DominatorTree *DT = nullptr,
AssumptionCache *AC = nullptr, AssumptionCache *AC = nullptr,
Context not available.
/// SimplifyFDivInst - Given operands for an FDiv, see if we can /// SimplifyFDivInst - Given operands for an FDiv, see if we can
/// fold the result. If not, this returns null. /// fold the result. If not, this returns null.
Value *SimplifyFDivInst(Value *LHS, Value *RHS, FastMathFlags FMF, Value *SimplifyFDivInst(Value *LHS, Value *RHS, FastMathFlags FMF,
const DataLayout *TD = nullptr, const DataLayout &DL,
const TargetLibraryInfo *TLI = nullptr, const TargetLibraryInfo *TLI = nullptr,
const DominatorTree *DT = nullptr, const DominatorTree *DT = nullptr,
AssumptionCache *AC = nullptr, AssumptionCache *AC = nullptr,
Context not available.
/// SimplifySRemInst - Given operands for an SRem, see if we can /// SimplifySRemInst - Given operands for an SRem, see if we can
/// fold the result. If not, this returns null. /// fold the result. If not, this returns null.
Value *SimplifySRemInst(Value *LHS, Value *RHS, Value *SimplifySRemInst(Value *LHS, Value *RHS, const DataLayout &DL,
const DataLayout *TD = nullptr,
const TargetLibraryInfo *TLI = nullptr, const TargetLibraryInfo *TLI = nullptr,
const DominatorTree *DT = nullptr, const DominatorTree *DT = nullptr,
AssumptionCache *AC = nullptr, AssumptionCache *AC = nullptr,
Context not available.
/// SimplifyURemInst - Given operands for a URem, see if we can /// SimplifyURemInst - Given operands for a URem, see if we can
/// fold the result. If not, this returns null. /// fold the result. If not, this returns null.
Value *SimplifyURemInst(Value *LHS, Value *RHS, Value *SimplifyURemInst(Value *LHS, Value *RHS, const DataLayout &DL,
const DataLayout *TD = nullptr,
const TargetLibraryInfo *TLI = nullptr, const TargetLibraryInfo *TLI = nullptr,
const DominatorTree *DT = nullptr, const DominatorTree *DT = nullptr,
AssumptionCache *AC = nullptr, AssumptionCache *AC = nullptr,
Context not available.
/// SimplifyFRemInst - Given operands for an FRem, see if we can /// SimplifyFRemInst - Given operands for an FRem, see if we can
/// fold the result. If not, this returns null. /// fold the result. If not, this returns null.
Value *SimplifyFRemInst(Value *LHS, Value *RHS, FastMathFlags FMF, Value *SimplifyFRemInst(Value *LHS, Value *RHS, FastMathFlags FMF,
const DataLayout *TD = nullptr, const DataLayout &DL,
const TargetLibraryInfo *TLI = nullptr, const TargetLibraryInfo *TLI = nullptr,
const DominatorTree *DT = nullptr, const DominatorTree *DT = nullptr,
AssumptionCache *AC = nullptr, AssumptionCache *AC = nullptr,
Context not available.
/// SimplifyShlInst - Given operands for a Shl, see if we can /// SimplifyShlInst - Given operands for a Shl, see if we can
/// fold the result. If not, this returns null. /// fold the result. If not, this returns null.
Value *SimplifyShlInst(Value *Op0, Value *Op1, bool isNSW, bool isNUW, Value *SimplifyShlInst(Value *Op0, Value *Op1, bool isNSW, bool isNUW,
const DataLayout *TD = nullptr, const DataLayout &DL,
const TargetLibraryInfo *TLI = nullptr, const TargetLibraryInfo *TLI = nullptr,
const DominatorTree *DT = nullptr, const DominatorTree *DT = nullptr,
AssumptionCache *AC = nullptr, AssumptionCache *AC = nullptr,
Context not available.
/// SimplifyLShrInst - Given operands for a LShr, see if we can /// SimplifyLShrInst - Given operands for a LShr, see if we can
/// fold the result. If not, this returns null. /// fold the result. If not, this returns null.
Value *SimplifyLShrInst(Value *Op0, Value *Op1, bool isExact, Value *SimplifyLShrInst(Value *Op0, Value *Op1, bool isExact,
const DataLayout *TD = nullptr, const DataLayout &DL,
const TargetLibraryInfo *TLI = nullptr, const TargetLibraryInfo *TLI = nullptr,
const DominatorTree *DT = nullptr, const DominatorTree *DT = nullptr,
AssumptionCache *AC = nullptr, AssumptionCache *AC = nullptr,
Context not available.
/// SimplifyAShrInst - Given operands for a AShr, see if we can /// SimplifyAShrInst - Given operands for a AShr, see if we can
/// fold the result. If not, this returns null. /// fold the result. If not, this returns null.
Value *SimplifyAShrInst(Value *Op0, Value *Op1, bool isExact, Value *SimplifyAShrInst(Value *Op0, Value *Op1, bool isExact,
const DataLayout *TD = nullptr, const DataLayout &DL,
const TargetLibraryInfo *TLI = nullptr, const TargetLibraryInfo *TLI = nullptr,
const DominatorTree *DT = nullptr, const DominatorTree *DT = nullptr,
AssumptionCache *AC = nullptr, AssumptionCache *AC = nullptr,
Context not available.
/// SimplifyAndInst - Given operands for an And, see if we can /// SimplifyAndInst - Given operands for an And, see if we can
/// fold the result. If not, this returns null. /// fold the result. If not, this returns null.
Value *SimplifyAndInst(Value *LHS, Value *RHS, const DataLayout *TD = nullptr, Value *SimplifyAndInst(Value *LHS, Value *RHS, const DataLayout &DL,
const TargetLibraryInfo *TLI = nullptr, const TargetLibraryInfo *TLI = nullptr,
const DominatorTree *DT = nullptr, const DominatorTree *DT = nullptr,
AssumptionCache *AC = nullptr, AssumptionCache *AC = nullptr,
Context not available.
/// SimplifyOrInst - Given operands for an Or, see if we can /// SimplifyOrInst - Given operands for an Or, see if we can
/// fold the result. If not, this returns null. /// fold the result. If not, this returns null.
Value *SimplifyOrInst(Value *LHS, Value *RHS, const DataLayout *TD = nullptr, Value *SimplifyOrInst(Value *LHS, Value *RHS, const DataLayout &DL,
const TargetLibraryInfo *TLI = nullptr, const TargetLibraryInfo *TLI = nullptr,
const DominatorTree *DT = nullptr, const DominatorTree *DT = nullptr,
AssumptionCache *AC = nullptr, AssumptionCache *AC = nullptr,
Context not available.
/// SimplifyXorInst - Given operands for a Xor, see if we can /// SimplifyXorInst - Given operands for a Xor, see if we can
/// fold the result. If not, this returns null. /// fold the result. If not, this returns null.
Value *SimplifyXorInst(Value *LHS, Value *RHS, const DataLayout *TD = nullptr, Value *SimplifyXorInst(Value *LHS, Value *RHS, const DataLayout &DL,
const TargetLibraryInfo *TLI = nullptr, const TargetLibraryInfo *TLI = nullptr,
const DominatorTree *DT = nullptr, const DominatorTree *DT = nullptr,
AssumptionCache *AC = nullptr, AssumptionCache *AC = nullptr,
Context not available.
/// SimplifyICmpInst - Given operands for an ICmpInst, see if we can /// SimplifyICmpInst - Given operands for an ICmpInst, see if we can
/// fold the result. If not, this returns null. /// fold the result. If not, this returns null.
Value *SimplifyICmpInst(unsigned Predicate, Value *LHS, Value *RHS, Value *SimplifyICmpInst(unsigned Predicate, Value *LHS, Value *RHS,
const DataLayout *TD = nullptr, const DataLayout &DL,
const TargetLibraryInfo *TLI = nullptr, const TargetLibraryInfo *TLI = nullptr,
const DominatorTree *DT = nullptr, const DominatorTree *DT = nullptr,
AssumptionCache *AC = nullptr, AssumptionCache *AC = nullptr,
Context not available.
/// SimplifyFCmpInst - Given operands for an FCmpInst, see if we can /// SimplifyFCmpInst - Given operands for an FCmpInst, see if we can
/// fold the result. If not, this returns null. /// fold the result. If not, this returns null.
Value *SimplifyFCmpInst(unsigned Predicate, Value *LHS, Value *RHS, Value *SimplifyFCmpInst(unsigned Predicate, Value *LHS, Value *RHS,
const DataLayout *TD = nullptr, const DataLayout &DL,
const TargetLibraryInfo *TLI = nullptr, const TargetLibraryInfo *TLI = nullptr,
const DominatorTree *DT = nullptr, const DominatorTree *DT = nullptr,
AssumptionCache *AC = nullptr, AssumptionCache *AC = nullptr,
Context not available.
/// SimplifySelectInst - Given operands for a SelectInst, see if we can fold /// SimplifySelectInst - Given operands for a SelectInst, see if we can fold
/// the result. If not, this returns null. /// the result. If not, this returns null.
Value *SimplifySelectInst(Value *Cond, Value *TrueVal, Value *FalseVal, Value *SimplifySelectInst(Value *Cond, Value *TrueVal, Value *FalseVal,
const DataLayout *TD = nullptr, const DataLayout &DL,
const TargetLibraryInfo *TLI = nullptr, const TargetLibraryInfo *TLI = nullptr,
const DominatorTree *DT = nullptr, const DominatorTree *DT = nullptr,
AssumptionCache *AC = nullptr, AssumptionCache *AC = nullptr,
Context not available.
/// SimplifyGEPInst - Given operands for an GetElementPtrInst, see if we can /// SimplifyGEPInst - Given operands for an GetElementPtrInst, see if we can
/// fold the result. If not, this returns null. /// fold the result. If not, this returns null.
Value *SimplifyGEPInst(ArrayRef<Value *> Ops, const DataLayout *TD = nullptr, Value *SimplifyGEPInst(ArrayRef<Value *> Ops, const DataLayout &DL,
const TargetLibraryInfo *TLI = nullptr, const TargetLibraryInfo *TLI = nullptr,
const DominatorTree *DT = nullptr, const DominatorTree *DT = nullptr,
AssumptionCache *AC = nullptr, AssumptionCache *AC = nullptr,
Context not available.
/// SimplifyInsertValueInst - Given operands for an InsertValueInst, see if we /// SimplifyInsertValueInst - Given operands for an InsertValueInst, see if we
/// can fold the result. If not, this returns null. /// can fold the result. If not, this returns null.
Value *SimplifyInsertValueInst(Value *Agg, Value *Val, Value *SimplifyInsertValueInst(Value *Agg, Value *Val,
ArrayRef<unsigned> Idxs, ArrayRef<unsigned> Idxs, const DataLayout &DL,
const DataLayout *TD = nullptr,
const TargetLibraryInfo *TLI = nullptr, const TargetLibraryInfo *TLI = nullptr,
const DominatorTree *DT = nullptr, const DominatorTree *DT = nullptr,
AssumptionCache *AC = nullptr, AssumptionCache *AC = nullptr,
Context not available.
/// SimplifyTruncInst - Given operands for an TruncInst, see if we can fold /// SimplifyTruncInst - Given operands for an TruncInst, see if we can fold
/// the result. If not, this returns null. /// the result. If not, this returns null.
Value *SimplifyTruncInst(Value *Op, Type *Ty, const DataLayout *TD = nullptr, Value *SimplifyTruncInst(Value *Op, Type *Ty, const DataLayout &DL,
const TargetLibraryInfo *TLI = nullptr, const TargetLibraryInfo *TLI = nullptr,
const DominatorTree *DT = nullptr, const DominatorTree *DT = nullptr,
AssumptionCache *AC = nullptr, AssumptionCache *AC = nullptr,
Context not available.
/// SimplifyCmpInst - Given operands for a CmpInst, see if we can /// SimplifyCmpInst - Given operands for a CmpInst, see if we can
/// fold the result. If not, this returns null. /// fold the result. If not, this returns null.
Value *SimplifyCmpInst(unsigned Predicate, Value *LHS, Value *RHS, Value *SimplifyCmpInst(unsigned Predicate, Value *LHS, Value *RHS,
const DataLayout *TD = nullptr, const DataLayout &DL,
const TargetLibraryInfo *TLI = nullptr, const TargetLibraryInfo *TLI = nullptr,
const DominatorTree *DT = nullptr, const DominatorTree *DT = nullptr,
AssumptionCache *AC = nullptr, AssumptionCache *AC = nullptr,
Context not available.
/// SimplifyBinOp - Given operands for a BinaryOperator, see if we can /// SimplifyBinOp - Given operands for a BinaryOperator, see if we can
/// fold the result. If not, this returns null. /// fold the result. If not, this returns null.
Value *SimplifyBinOp(unsigned Opcode, Value *LHS, Value *RHS, Value *SimplifyBinOp(unsigned Opcode, Value *LHS, Value *RHS,
const DataLayout *TD = nullptr, const DataLayout &DL,
const TargetLibraryInfo *TLI = nullptr, const TargetLibraryInfo *TLI = nullptr,
const DominatorTree *DT = nullptr, const DominatorTree *DT = nullptr,
AssumptionCache *AC = nullptr, AssumptionCache *AC = nullptr,
Context not available.
/// In contrast to SimplifyBinOp, try to use FastMathFlag when folding the /// In contrast to SimplifyBinOp, try to use FastMathFlag when folding the
/// result. In case we don't need FastMathFlags, simply fall to SimplifyBinOp. /// result. In case we don't need FastMathFlags, simply fall to SimplifyBinOp.
Value *SimplifyFPBinOp(unsigned Opcode, Value *LHS, Value *RHS, Value *SimplifyFPBinOp(unsigned Opcode, Value *LHS, Value *RHS,
const FastMathFlags &FMF, const FastMathFlags &FMF, const DataLayout &DL,
const DataLayout *TD = nullptr,
const TargetLibraryInfo *TLI = nullptr, const TargetLibraryInfo *TLI = nullptr,
const DominatorTree *DT = nullptr, const DominatorTree *DT = nullptr,
AssumptionCache *AC = nullptr, AssumptionCache *AC = nullptr,
Context not available.
/// ///
/// If this call could not be simplified returns null. /// If this call could not be simplified returns null.
Value *SimplifyCall(Value *V, User::op_iterator ArgBegin, Value *SimplifyCall(Value *V, User::op_iterator ArgBegin,
User::op_iterator ArgEnd, const DataLayout *TD = nullptr, User::op_iterator ArgEnd, const DataLayout &DL,
const TargetLibraryInfo *TLI = nullptr, const TargetLibraryInfo *TLI = nullptr,
const DominatorTree *DT = nullptr, const DominatorTree *DT = nullptr,
AssumptionCache *AC = nullptr, AssumptionCache *AC = nullptr,
Context not available.
/// result. /// result.
/// ///
/// If this call could not be simplified returns null. /// If this call could not be simplified returns null.
Value *SimplifyCall(Value *V, ArrayRef<Value *> Args, Value *SimplifyCall(Value *V, ArrayRef<Value *> Args, const DataLayout &DL,
const DataLayout *TD = nullptr,
const TargetLibraryInfo *TLI = nullptr, const TargetLibraryInfo *TLI = nullptr,
const DominatorTree *DT = nullptr, const DominatorTree *DT = nullptr,
AssumptionCache *AC = nullptr, AssumptionCache *AC = nullptr,
Context not available.
/// SimplifyInstruction - See if we can compute a simplified version of this /// SimplifyInstruction - See if we can compute a simplified version of this
/// instruction. If not, this returns null. /// instruction. If not, this returns null.
Value *SimplifyInstruction(Instruction *I, const DataLayout *TD = nullptr, Value *SimplifyInstruction(Instruction *I, const DataLayout &DL,
const TargetLibraryInfo *TLI = nullptr, const TargetLibraryInfo *TLI = nullptr,
const DominatorTree *DT = nullptr, const DominatorTree *DT = nullptr,
AssumptionCache *AC = nullptr); AssumptionCache *AC = nullptr);
Context not available.
/// ///
/// The function returns true if any simplifications were performed. /// The function returns true if any simplifications were performed.
bool replaceAndRecursivelySimplify(Instruction *I, Value *SimpleV, bool replaceAndRecursivelySimplify(Instruction *I, Value *SimpleV,
const DataLayout *TD = nullptr,
const TargetLibraryInfo *TLI = nullptr, const TargetLibraryInfo *TLI = nullptr,
const DominatorTree *DT = nullptr, const DominatorTree *DT = nullptr,
AssumptionCache *AC = nullptr); AssumptionCache *AC = nullptr);
Context not available.
/// of the users impacted. It returns true if any simplifications were /// of the users impacted. It returns true if any simplifications were
/// performed. /// performed.
bool recursivelySimplifyInstruction(Instruction *I, bool recursivelySimplifyInstruction(Instruction *I,
const DataLayout *TD = nullptr,
const TargetLibraryInfo *TLI = nullptr, const TargetLibraryInfo *TLI = nullptr,
const DominatorTree *DT = nullptr, const DominatorTree *DT = nullptr,
AssumptionCache *AC = nullptr); AssumptionCache *AC = nullptr);
Context not available.

include/llvm/Analysis/LazyValueInfo.h

Context not available.
/// This pass computes, caches, and vends lazy value constraint information. /// This pass computes, caches, and vends lazy value constraint information.
class LazyValueInfo : public FunctionPass { class LazyValueInfo : public FunctionPass {
AssumptionCache *AC; AssumptionCache *AC;
const DataLayout *DL;
class TargetLibraryInfo *TLI; class TargetLibraryInfo *TLI;
DominatorTree *DT; DominatorTree *DT;
void *PImpl; void *PImpl;
Context not available.

include/llvm/Analysis/Loads.h

Context not available.
/// specified pointer, we do a quick local scan of the basic block containing /// specified pointer, we do a quick local scan of the basic block containing
/// ScanFrom, to determine if the address is already accessed. /// ScanFrom, to determine if the address is already accessed.
bool isSafeToLoadUnconditionally(Value *V, Instruction *ScanFrom, bool isSafeToLoadUnconditionally(Value *V, Instruction *ScanFrom,
unsigned Align, unsigned Align);
const DataLayout *TD = nullptr);
/// FindAvailableLoadedValue - Scan the ScanBB block backwards (starting at /// FindAvailableLoadedValue - Scan the ScanBB block backwards (starting at
/// the instruction before ScanFrom) checking to see if we have the value at /// the instruction before ScanFrom) checking to see if we have the value at
Context not available.

include/llvm/Analysis/LoopAccessAnalysis.h

Context not available.
SmallVector<unsigned, 2> AliasSetId; SmallVector<unsigned, 2> AliasSetId;
}; };
LoopAccessInfo(Loop *L, ScalarEvolution *SE, const DataLayout *DL, LoopAccessInfo(Loop *L, ScalarEvolution *SE, const DataLayout &DL,
const TargetLibraryInfo *TLI, AliasAnalysis *AA, const TargetLibraryInfo *TLI, AliasAnalysis *AA,
DominatorTree *DT, const ValueToValueMap &Strides); DominatorTree *DT, const ValueToValueMap &Strides);
Context not available.
RuntimePointerCheck PtrRtCheck; RuntimePointerCheck PtrRtCheck;
Loop *TheLoop; Loop *TheLoop;
ScalarEvolution *SE; ScalarEvolution *SE;
const DataLayout *DL; const DataLayout &DL;
const TargetLibraryInfo *TLI; const TargetLibraryInfo *TLI;
AliasAnalysis *AA; AliasAnalysis *AA;
DominatorTree *DT; DominatorTree *DT;
Context not available.
// The used analysis passes. // The used analysis passes.
ScalarEvolution *SE; ScalarEvolution *SE;
const DataLayout *DL;
const TargetLibraryInfo *TLI; const TargetLibraryInfo *TLI;
AliasAnalysis *AA; AliasAnalysis *AA;
DominatorTree *DT; DominatorTree *DT;
Context not available.

include/llvm/Analysis/MemoryBuiltins.h

Context not available.
/// isArrayMalloc - Returns the corresponding CallInst if the instruction /// isArrayMalloc - Returns the corresponding CallInst if the instruction
/// is a call to malloc whose array size can be determined and the array size /// is a call to malloc whose array size can be determined and the array size
/// is not constant 1. Otherwise, return NULL. /// is not constant 1. Otherwise, return NULL.
const CallInst *isArrayMalloc(const Value *I, const DataLayout *DL, const CallInst *isArrayMalloc(const Value *I, const DataLayout &DL,
const TargetLibraryInfo *TLI); const TargetLibraryInfo *TLI);
/// getMallocType - Returns the PointerType resulting from the malloc call. /// getMallocType - Returns the PointerType resulting from the malloc call.
Context not available.
/// then return that multiple. For non-array mallocs, the multiple is /// then return that multiple. For non-array mallocs, the multiple is
/// constant 1. Otherwise, return NULL for mallocs whose array size cannot be /// constant 1. Otherwise, return NULL for mallocs whose array size cannot be
/// determined. /// determined.
Value *getMallocArraySize(CallInst *CI, const DataLayout *DL, Value *getMallocArraySize(CallInst *CI, const DataLayout &DL,
const TargetLibraryInfo *TLI, const TargetLibraryInfo *TLI,
bool LookThroughSExt = false); bool LookThroughSExt = false);
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// calloc Call Utility Functions. // calloc Call Utility Functions.
// //
Context not available.
/// underlying object pointed to by Ptr. /// underlying object pointed to by Ptr.
/// If RoundToAlign is true, then Size is rounded up to the aligment of allocas, /// If RoundToAlign is true, then Size is rounded up to the aligment of allocas,
/// byval arguments, and global variables. /// byval arguments, and global variables.
bool getObjectSize(const Value *Ptr, uint64_t &Size, const DataLayout *DL, bool getObjectSize(const Value *Ptr, uint64_t &Size, const DataLayout &DL,
const TargetLibraryInfo *TLI, bool RoundToAlign = false); const TargetLibraryInfo *TLI, bool RoundToAlign = false);
typedef std::pair<APInt, APInt> SizeOffsetType; typedef std::pair<APInt, APInt> SizeOffsetType;
/// \brief Evaluate the size and offset of an object pointed to by a Value* /// \brief Evaluate the size and offset of an object pointed to by a Value*
Context not available.
class ObjectSizeOffsetVisitor class ObjectSizeOffsetVisitor
: public InstVisitor<ObjectSizeOffsetVisitor, SizeOffsetType> { : public InstVisitor<ObjectSizeOffsetVisitor, SizeOffsetType> {
const DataLayout *DL; const DataLayout &DL;
const TargetLibraryInfo *TLI; const TargetLibraryInfo *TLI;
bool RoundToAlign; bool RoundToAlign;
unsigned IntTyBits; unsigned IntTyBits;
Context not available.
} }
public: public:
ObjectSizeOffsetVisitor(const DataLayout *DL, const TargetLibraryInfo *TLI, ObjectSizeOffsetVisitor(const DataLayout &DL, const TargetLibraryInfo *TLI,
LLVMContext &Context, bool RoundToAlign = false); LLVMContext &Context, bool RoundToAlign = false);
SizeOffsetType compute(Value *V); SizeOffsetType compute(Value *V);
Context not available.
typedef DenseMap<const Value*, WeakEvalType> CacheMapTy; typedef DenseMap<const Value*, WeakEvalType> CacheMapTy;
typedef SmallPtrSet<const Value*, 8> PtrSetTy; typedef SmallPtrSet<const Value*, 8> PtrSetTy;
const DataLayout *DL; const DataLayout &DL;
const TargetLibraryInfo *TLI; const TargetLibraryInfo *TLI;
LLVMContext &Context; LLVMContext &Context;
BuilderTy Builder; BuilderTy Builder;
Context not available.
SizeOffsetEvalType compute_(Value *V); SizeOffsetEvalType compute_(Value *V);
public: public:
ObjectSizeOffsetEvaluator(const DataLayout *DL, const TargetLibraryInfo *TLI, ObjectSizeOffsetEvaluator(const DataLayout &DL, const TargetLibraryInfo *TLI,
LLVMContext &Context, bool RoundToAlign = false); LLVMContext &Context, bool RoundToAlign = false);
SizeOffsetEvalType compute(Value *V); SizeOffsetEvalType compute(Value *V);
Context not available.

include/llvm/Analysis/MemoryDependenceAnalysis.h

Context not available.
class CallSite; class CallSite;
class AliasAnalysis; class AliasAnalysis;
class AssumptionCache; class AssumptionCache;
class DataLayout;
class MemoryDependenceAnalysis; class MemoryDependenceAnalysis;
class PredIteratorCache; class PredIteratorCache;
class DominatorTree; class DominatorTree;
Context not available.
/// Current AA implementation, just a cache. /// Current AA implementation, just a cache.
AliasAnalysis *AA; AliasAnalysis *AA;
const DataLayout *DL;
DominatorTree *DT; DominatorTree *DT;
AssumptionCache *AC; AssumptionCache *AC;
std::unique_ptr<PredIteratorCache> PredCache; std::unique_ptr<PredIteratorCache> PredCache;
Context not available.
static unsigned getLoadLoadClobberFullWidthSize(const Value *MemLocBase, static unsigned getLoadLoadClobberFullWidthSize(const Value *MemLocBase,
int64_t MemLocOffs, int64_t MemLocOffs,
unsigned MemLocSize, unsigned MemLocSize,
const LoadInst *LI, const LoadInst *LI);
const DataLayout &DL);
private: private:
MemDepResult getCallSiteDependencyFrom(CallSite C, bool isReadOnlyCall, MemDepResult getCallSiteDependencyFrom(CallSite C, bool isReadOnlyCall,
Context not available.

include/llvm/Analysis/PHITransAddr.h

Context not available.
class PHITransAddr { class PHITransAddr {
/// Addr - The actual address we're analyzing. /// Addr - The actual address we're analyzing.
Value *Addr; Value *Addr;
/// The DataLayout we are playing with if known, otherwise null. /// The DataLayout we are playing with.
const DataLayout *DL; const DataLayout &DL;
/// TLI - The target library info if known, otherwise null. /// TLI - The target library info if known, otherwise null.
const TargetLibraryInfo *TLI; const TargetLibraryInfo *TLI;
Context not available.
/// InstInputs - The inputs for our symbolic address. /// InstInputs - The inputs for our symbolic address.
SmallVector<Instruction*, 4> InstInputs; SmallVector<Instruction*, 4> InstInputs;
public: public:
PHITransAddr(Value *addr, const DataLayout *DL, AssumptionCache *AC) PHITransAddr(Value *addr, const DataLayout &DL, AssumptionCache *AC)
: Addr(addr), DL(DL), TLI(nullptr), AC(AC) { : Addr(addr), DL(DL), TLI(nullptr), AC(AC) {
// If the address is an instruction, the whole thing is considered an input. // If the address is an instruction, the whole thing is considered an input.
if (Instruction *I = dyn_cast<Instruction>(Addr)) if (Instruction *I = dyn_cast<Instruction>(Addr))
Context not available.

include/llvm/Analysis/ScalarEvolution.h

Context not available.
/// ///
LoopInfo *LI; LoopInfo *LI;
/// The DataLayout information for the target we are targeting.
///
const DataLayout *DL;
/// TLI - The target library information for the target we are targeting. /// TLI - The target library information for the target we are targeting.
/// ///
TargetLibraryInfo *TLI; TargetLibraryInfo *TLI;
Context not available.

include/llvm/Analysis/ScalarEvolutionExpander.h

Context not available.
/// memory. /// memory.
class SCEVExpander : public SCEVVisitor<SCEVExpander, Value*> { class SCEVExpander : public SCEVVisitor<SCEVExpander, Value*> {
ScalarEvolution &SE; ScalarEvolution &SE;
const DataLayout &DL;
// New instructions receive a name to identifies them with the current pass. // New instructions receive a name to identifies them with the current pass.
const char* IVName; const char* IVName;
Context not available.
public: public:
/// SCEVExpander - Construct a SCEVExpander in "canonical" mode. /// SCEVExpander - Construct a SCEVExpander in "canonical" mode.
explicit SCEVExpander(ScalarEvolution &se, const char *name) explicit SCEVExpander(ScalarEvolution &se, const DataLayout &DL,
: SE(se), IVName(name), IVIncInsertLoop(nullptr), IVIncInsertPos(nullptr), const char *name)
CanonicalMode(true), LSRMode(false), : SE(se), DL(DL), IVName(name), IVIncInsertLoop(nullptr),
Builder(se.getContext(), TargetFolder(se.DL)) { IVIncInsertPos(nullptr), CanonicalMode(true), LSRMode(false),
Builder(se.getContext(), TargetFolder(DL)) {
#ifndef NDEBUG #ifndef NDEBUG
DebugType = ""; DebugType = "";
#endif #endif
Context not available.

include/llvm/Analysis/TargetFolder.h

Context not available.
/// TargetFolder - Create constants with target dependent folding. /// TargetFolder - Create constants with target dependent folding.
class TargetFolder { class TargetFolder {
const DataLayout *DL; const DataLayout &DL;
/// Fold - Fold the constant using target specific information. /// Fold - Fold the constant using target specific information.
Constant *Fold(Constant *C) const { Constant *Fold(Constant *C) const {
Context not available.
} }
public: public:
explicit TargetFolder(const DataLayout *DL) : DL(DL) {} explicit TargetFolder(const DataLayout &DL) : DL(DL) {}
//===--------------------------------------------------------------------===// //===--------------------------------------------------------------------===//
// Binary Operators // Binary Operators
Context not available.

include/llvm/Analysis/ValueTracking.h

Context not available.
/// same width as the vector element, and the bit is set only if it is true /// same width as the vector element, and the bit is set only if it is true
/// for all of the elements in the vector. /// for all of the elements in the vector.
void computeKnownBits(Value *V, APInt &KnownZero, APInt &KnownOne, void computeKnownBits(Value *V, APInt &KnownZero, APInt &KnownOne,
const DataLayout *TD = nullptr, unsigned Depth = 0, const DataLayout &TD, unsigned Depth = 0,
AssumptionCache *AC = nullptr, AssumptionCache *AC = nullptr,
const Instruction *CxtI = nullptr, const Instruction *CxtI = nullptr,
const DominatorTree *DT = nullptr); const DominatorTree *DT = nullptr);
Context not available.
/// ComputeSignBit - Determine whether the sign bit is known to be zero or /// ComputeSignBit - Determine whether the sign bit is known to be zero or
/// one. Convenience wrapper around computeKnownBits. /// one. Convenience wrapper around computeKnownBits.
void ComputeSignBit(Value *V, bool &KnownZero, bool &KnownOne, void ComputeSignBit(Value *V, bool &KnownZero, bool &KnownOne,
const DataLayout *TD = nullptr, unsigned Depth = 0, const DataLayout &TD, unsigned Depth = 0,
AssumptionCache *AC = nullptr, AssumptionCache *AC = nullptr,
const Instruction *CxtI = nullptr, const Instruction *CxtI = nullptr,
const DominatorTree *DT = nullptr); const DominatorTree *DT = nullptr);
Context not available.
/// element is known to be a power of two when defined. Supports values with /// element is known to be a power of two when defined. Supports values with
/// integer or pointer type and vectors of integers. If 'OrZero' is set then /// integer or pointer type and vectors of integers. If 'OrZero' is set then
/// returns true if the given value is either a power of two or zero. /// returns true if the given value is either a power of two or zero.
bool isKnownToBeAPowerOfTwo(Value *V, bool OrZero = false, unsigned Depth = 0, bool isKnownToBeAPowerOfTwo(Value *V, const DataLayout &DL,
bool OrZero = false, unsigned Depth = 0,
AssumptionCache *AC = nullptr, AssumptionCache *AC = nullptr,
const Instruction *CxtI = nullptr, const Instruction *CxtI = nullptr,
const DominatorTree *DT = nullptr); const DominatorTree *DT = nullptr);
Context not available.
/// when defined. For vectors return true if every element is known to be /// when defined. For vectors return true if every element is known to be
/// non-zero when defined. Supports values with integer or pointer type and /// non-zero when defined. Supports values with integer or pointer type and
/// vectors of integers. /// vectors of integers.
bool isKnownNonZero(Value *V, const DataLayout *TD = nullptr, bool isKnownNonZero(Value *V, const DataLayout &TD, unsigned Depth = 0,
unsigned Depth = 0, AssumptionCache *AC = nullptr, AssumptionCache *AC = nullptr,
const Instruction *CxtI = nullptr, const Instruction *CxtI = nullptr,
const DominatorTree *DT = nullptr); const DominatorTree *DT = nullptr);
Context not available.
/// where V is a vector, the mask, known zero, and known one values are the /// where V is a vector, the mask, known zero, and known one values are the
/// same width as the vector element, and the bit is set only if it is true /// same width as the vector element, and the bit is set only if it is true
/// for all of the elements in the vector. /// for all of the elements in the vector.
bool MaskedValueIsZero(Value *V, const APInt &Mask, bool MaskedValueIsZero(Value *V, const APInt &Mask, const DataLayout &TD,
const DataLayout *TD = nullptr, unsigned Depth = 0, unsigned Depth = 0, AssumptionCache *AC = nullptr,
AssumptionCache *AC = nullptr,
const Instruction *CxtI = nullptr, const Instruction *CxtI = nullptr,
const DominatorTree *DT = nullptr); const DominatorTree *DT = nullptr);
Context not available.
/// ///
/// 'Op' must have a scalar integer type. /// 'Op' must have a scalar integer type.
/// ///
unsigned ComputeNumSignBits(Value *Op, const DataLayout *TD = nullptr, unsigned ComputeNumSignBits(Value *Op, const DataLayout &TD,
unsigned Depth = 0, AssumptionCache *AC = nullptr, unsigned Depth = 0, AssumptionCache *AC = nullptr,
const Instruction *CxtI = nullptr, const Instruction *CxtI = nullptr,
const DominatorTree *DT = nullptr); const DominatorTree *DT = nullptr);
Context not available.
/// it can be expressed as a base pointer plus a constant offset. Return the /// it can be expressed as a base pointer plus a constant offset. Return the
/// base and offset to the caller. /// base and offset to the caller.
Value *GetPointerBaseWithConstantOffset(Value *Ptr, int64_t &Offset, Value *GetPointerBaseWithConstantOffset(Value *Ptr, int64_t &Offset,
const DataLayout *TD); const DataLayout &TD);
static inline const Value * static inline const Value *
GetPointerBaseWithConstantOffset(const Value *Ptr, int64_t &Offset, GetPointerBaseWithConstantOffset(const Value *Ptr, int64_t &Offset,
const DataLayout *TD) { const DataLayout &TD) {
return GetPointerBaseWithConstantOffset(const_cast<Value*>(Ptr), Offset,TD); return GetPointerBaseWithConstantOffset(const_cast<Value*>(Ptr), Offset,TD);
} }
Context not available.
/// being addressed. Note that the returned value has pointer type if the /// being addressed. Note that the returned value has pointer type if the
/// specified value does. If the MaxLookup value is non-zero, it limits the /// specified value does. If the MaxLookup value is non-zero, it limits the
/// number of instructions to be stripped off. /// number of instructions to be stripped off.
Value *GetUnderlyingObject(Value *V, const DataLayout *TD = nullptr, Value *GetUnderlyingObject(Value *V, const DataLayout &TD,
unsigned MaxLookup = 6); unsigned MaxLookup = 6);
static inline const Value * static inline const Value *GetUnderlyingObject(const Value *V,
GetUnderlyingObject(const Value *V, const DataLayout *TD = nullptr, const DataLayout &TD,
unsigned MaxLookup = 6) { unsigned MaxLookup = 6) {
return GetUnderlyingObject(const_cast<Value *>(V), TD, MaxLookup); return GetUnderlyingObject(const_cast<Value *>(V), TD, MaxLookup);
} }
/// GetUnderlyingObjects - This method is similar to GetUnderlyingObject /// GetUnderlyingObjects - This method is similar to GetUnderlyingObject
/// except that it can look through phi and select instructions and return /// except that it can look through phi and select instructions and return
/// multiple objects. /// multiple objects.
void GetUnderlyingObjects(Value *V, void GetUnderlyingObjects(Value *V, SmallVectorImpl<Value *> &Objects,
SmallVectorImpl<Value *> &Objects, const DataLayout &TD, unsigned MaxLookup = 6);
const DataLayout *TD = nullptr,
unsigned MaxLookup = 6);
/// onlyUsedByLifetimeMarkers - Return true if the only users of this pointer /// onlyUsedByLifetimeMarkers - Return true if the only users of this pointer
/// are lifetime markers. /// are lifetime markers.
Context not available.
/// the correct dominance relationships for the operands and users hold. /// the correct dominance relationships for the operands and users hold.
/// However, this method can return true for instructions that read memory; /// However, this method can return true for instructions that read memory;
/// for such instructions, moving them may change the resulting value. /// for such instructions, moving them may change the resulting value.
bool isSafeToSpeculativelyExecute(const Value *V, bool isSafeToSpeculativelyExecute(const Value *V);
const DataLayout *TD = nullptr);
/// isKnownNonNull - Return true if this pointer couldn't possibly be null by /// isKnownNonNull - Return true if this pointer couldn't possibly be null by
/// its definition. This returns true for allocas, non-extern-weak globals /// its definition. This returns true for allocas, non-extern-weak globals
Context not available.
/// assume intrinsic, I, at the point in the control-flow identified by the /// assume intrinsic, I, at the point in the control-flow identified by the
/// context instruction, CxtI. /// context instruction, CxtI.
bool isValidAssumeForContext(const Instruction *I, const Instruction *CxtI, bool isValidAssumeForContext(const Instruction *I, const Instruction *CxtI,
const DataLayout *DL = nullptr,
const DominatorTree *DT = nullptr); const DominatorTree *DT = nullptr);
enum class OverflowResult { AlwaysOverflows, MayOverflow, NeverOverflows }; enum class OverflowResult { AlwaysOverflows, MayOverflow, NeverOverflows };
OverflowResult computeOverflowForUnsignedMul(Value *LHS, Value *RHS, OverflowResult computeOverflowForUnsignedMul(Value *LHS, Value *RHS,
const DataLayout *DL, const DataLayout &DL,
AssumptionCache *AC, AssumptionCache *AC,
const Instruction *CxtI, const Instruction *CxtI,
const DominatorTree *DT); const DominatorTree *DT);
OverflowResult computeOverflowForUnsignedAdd(Value *LHS, Value *RHS, OverflowResult computeOverflowForUnsignedAdd(Value *LHS, Value *RHS,
const DataLayout *DL, const DataLayout &DL,
AssumptionCache *AC, AssumptionCache *AC,
const Instruction *CxtI, const Instruction *CxtI,
const DominatorTree *DT); const DominatorTree *DT);
Context not available.

include/llvm/IR/IRBuilder.h

Context not available.
} }
/// \brief Fetch the type representing a pointer to an integer value. /// \brief Fetch the type representing a pointer to an integer value.
IntegerType* getIntPtrTy(const DataLayout *DL, unsigned AddrSpace = 0) { IntegerType *getIntPtrTy(const DataLayout &DL, unsigned AddrSpace = 0) {
return DL->getIntPtrType(Context, AddrSpace); return DL.getIntPtrType(Context, AddrSpace);
} }
//===--------------------------------------------------------------------===// //===--------------------------------------------------------------------===//
Context not available.
"trying to create an alignment assumption on a non-pointer?"); "trying to create an alignment assumption on a non-pointer?");
PointerType *PtrTy = cast<PointerType>(PtrValue->getType()); PointerType *PtrTy = cast<PointerType>(PtrValue->getType());
Type *IntPtrTy = getIntPtrTy(&DL, PtrTy->getAddressSpace()); Type *IntPtrTy = getIntPtrTy(DL, PtrTy->getAddressSpace());
Value *PtrIntValue = CreatePtrToInt(PtrValue, IntPtrTy, "ptrint"); Value *PtrIntValue = CreatePtrToInt(PtrValue, IntPtrTy, "ptrint");
Value *Mask = ConstantInt::get(IntPtrTy, Value *Mask = ConstantInt::get(IntPtrTy,
Context not available.

include/llvm/IR/InstrTypes.h

Context not available.
/// This ensures that any pointer<->integer cast has enough bits in the /// This ensures that any pointer<->integer cast has enough bits in the
/// integer and any other cast is a bitcast. /// integer and any other cast is a bitcast.
static bool isBitOrNoopPointerCastable( static bool isBitOrNoopPointerCastable(
Type *SrcTy, ///< The Type from which the value should be cast. Type *SrcTy, ///< The Type from which the value should be cast.
Type *DestTy, ///< The Type to which the value should be cast. Type *DestTy, ///< The Type to which the value should be cast.
const DataLayout *Layout = 0 ///< Optional DataLayout. const DataLayout &DL);
);
/// Returns the opcode necessary to cast Val into Ty using usual casting /// Returns the opcode necessary to cast Val into Ty using usual casting
/// rules. /// rules.
Context not available.
) const; ) const;
/// @brief Determine if this cast is a no-op cast. /// @brief Determine if this cast is a no-op cast.
bool isNoopCast( bool
const DataLayout *DL ///< DataLayout to get the Int Ptr type from. isNoopCast(const DataLayout &DL ///< DataLayout to get the Int Ptr type from.
) const; ) const;
/// Determine how a pair of casts can be eliminated, if they can be at all. /// Determine how a pair of casts can be eliminated, if they can be at all.
/// This is a helper function for both CastInst and ConstantExpr. /// This is a helper function for both CastInst and ConstantExpr.
Context not available.

include/llvm/IR/Value.h

Context not available.
/// ///
/// Test if this value is always a pointer to allocated and suitably aligned /// Test if this value is always a pointer to allocated and suitably aligned
/// memory for a simple load or store. /// memory for a simple load or store.
bool isDereferenceablePointer(const DataLayout *DL = nullptr) const; bool isDereferenceablePointer(const DataLayout &DL) const;
/// \brief Translate PHI node to its predecessor from the given basic block. /// \brief Translate PHI node to its predecessor from the given basic block.
/// ///
Context not available.

include/llvm/Target/TargetLowering.h

Context not available.
public: public:
const TargetMachine &getTargetMachine() const { return TM; } const TargetMachine &getTargetMachine() const { return TM; }
const DataLayout *getDataLayout() const { return DL; } const DataLayout *getDataLayout() const { return TM.getDataLayout(); }
bool isBigEndian() const { return !IsLittleEndian; } bool isBigEndian() const { return !IsLittleEndian; }
bool isLittleEndian() const { return IsLittleEndian; } bool isLittleEndian() const { return IsLittleEndian; }
Context not available.
private: private:
const TargetMachine &TM; const TargetMachine &TM;
const DataLayout *DL;
/// True if this is a little endian target. /// True if this is a little endian target.
bool IsLittleEndian; bool IsLittleEndian;
Context not available.

include/llvm/Transforms/IPO/LowerBitSets.h

Context not available.
bool containsGlobalOffset(uint64_t Offset) const; bool containsGlobalOffset(uint64_t Offset) const;
bool containsValue(const DataLayout *DL, bool containsValue(const DataLayout &DL,
const DenseMap<GlobalVariable *, uint64_t> &GlobalLayout, const DenseMap<GlobalVariable *, uint64_t> &GlobalLayout,
Value *V, uint64_t COffset = 0) const; Value *V, uint64_t COffset = 0) const;
}; };
Context not available.

include/llvm/Transforms/Utils/BuildLibCalls.h

Context not available.
/// EmitStrLen - Emit a call to the strlen function to the builder, for the /// EmitStrLen - Emit a call to the strlen function to the builder, for the
/// specified pointer. Ptr is required to be some pointer type, and the /// specified pointer. Ptr is required to be some pointer type, and the
/// return value has 'intptr_t' type. /// return value has 'intptr_t' type.
Value *EmitStrLen(Value *Ptr, IRBuilder<> &B, const DataLayout *TD, Value *EmitStrLen(Value *Ptr, IRBuilder<> &B, const DataLayout &DL,
const TargetLibraryInfo *TLI); const TargetLibraryInfo *TLI);
/// EmitStrNLen - Emit a call to the strnlen function to the builder, for the /// EmitStrNLen - Emit a call to the strnlen function to the builder, for the
/// specified pointer. Ptr is required to be some pointer type, MaxLen must /// specified pointer. Ptr is required to be some pointer type, MaxLen must
/// be of size_t type, and the return value has 'intptr_t' type. /// be of size_t type, and the return value has 'intptr_t' type.
Value *EmitStrNLen(Value *Ptr, Value *MaxLen, IRBuilder<> &B, Value *EmitStrNLen(Value *Ptr, Value *MaxLen, IRBuilder<> &B,
const DataLayout *TD, const TargetLibraryInfo *TLI); const DataLayout &DL, const TargetLibraryInfo *TLI);
/// EmitStrChr - Emit a call to the strchr function to the builder, for the /// EmitStrChr - Emit a call to the strchr function to the builder, for the
/// specified pointer and character. Ptr is required to be some pointer type, /// specified pointer and character. Ptr is required to be some pointer type,
/// and the return value has 'i8*' type. /// and the return value has 'i8*' type.
Value *EmitStrChr(Value *Ptr, char C, IRBuilder<> &B, const DataLayout *TD, Value *EmitStrChr(Value *Ptr, char C, IRBuilder<> &B,
const TargetLibraryInfo *TLI); const TargetLibraryInfo *TLI);
/// EmitStrNCmp - Emit a call to the strncmp function to the builder. /// EmitStrNCmp - Emit a call to the strncmp function to the builder.
Value *EmitStrNCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilder<> &B, Value *EmitStrNCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilder<> &B,
const DataLayout *TD, const TargetLibraryInfo *TLI); const DataLayout &DL, const TargetLibraryInfo *TLI);
/// EmitStrCpy - Emit a call to the strcpy function to the builder, for the /// EmitStrCpy - Emit a call to the strcpy function to the builder, for the
/// specified pointer arguments. /// specified pointer arguments.
Value *EmitStrCpy(Value *Dst, Value *Src, IRBuilder<> &B, Value *EmitStrCpy(Value *Dst, Value *Src, IRBuilder<> &B,
const DataLayout *TD, const TargetLibraryInfo *TLI, const TargetLibraryInfo *TLI, StringRef Name = "strcpy");
StringRef Name = "strcpy");
/// EmitStrNCpy - Emit a call to the strncpy function to the builder, for the /// EmitStrNCpy - Emit a call to the strncpy function to the builder, for the
/// specified pointer arguments and length. /// specified pointer arguments and length.
Value *EmitStrNCpy(Value *Dst, Value *Src, Value *Len, IRBuilder<> &B, Value *EmitStrNCpy(Value *Dst, Value *Src, Value *Len, IRBuilder<> &B,
const DataLayout *TD, const TargetLibraryInfo *TLI, const TargetLibraryInfo *TLI, StringRef Name = "strncpy");
StringRef Name = "strncpy");
/// EmitMemCpyChk - Emit a call to the __memcpy_chk function to the builder. /// EmitMemCpyChk - Emit a call to the __memcpy_chk function to the builder.
/// This expects that the Len and ObjSize have type 'intptr_t' and Dst/Src /// This expects that the Len and ObjSize have type 'intptr_t' and Dst/Src
/// are pointers. /// are pointers.
Value *EmitMemCpyChk(Value *Dst, Value *Src, Value *Len, Value *ObjSize, Value *EmitMemCpyChk(Value *Dst, Value *Src, Value *Len, Value *ObjSize,
IRBuilder<> &B, const DataLayout *TD, IRBuilder<> &B, const DataLayout &DL,
const TargetLibraryInfo *TLI); const TargetLibraryInfo *TLI);
/// EmitMemChr - Emit a call to the memchr function. This assumes that Ptr is /// EmitMemChr - Emit a call to the memchr function. This assumes that Ptr is
/// a pointer, Val is an i32 value, and Len is an 'intptr_t' value. /// a pointer, Val is an i32 value, and Len is an 'intptr_t' value.
Value *EmitMemChr(Value *Ptr, Value *Val, Value *Len, IRBuilder<> &B, Value *EmitMemChr(Value *Ptr, Value *Val, Value *Len, IRBuilder<> &B,
const DataLayout *TD, const TargetLibraryInfo *TLI); const DataLayout &DL, const TargetLibraryInfo *TLI);
/// EmitMemCmp - Emit a call to the memcmp function. /// EmitMemCmp - Emit a call to the memcmp function.
Value *EmitMemCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilder<> &B, Value *EmitMemCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilder<> &B,
const DataLayout *TD, const TargetLibraryInfo *TLI); const DataLayout &DL, const TargetLibraryInfo *TLI);
/// EmitUnaryFloatFnCall - Emit a call to the unary function named 'Name' /// EmitUnaryFloatFnCall - Emit a call to the unary function named 'Name'
/// (e.g. 'floor'). This function is known to take a single of type matching /// (e.g. 'floor'). This function is known to take a single of type matching
Context not available.
/// EmitPutChar - Emit a call to the putchar function. This assumes that Char /// EmitPutChar - Emit a call to the putchar function. This assumes that Char
/// is an integer. /// is an integer.
Value *EmitPutChar(Value *Char, IRBuilder<> &B, const DataLayout *TD, Value *EmitPutChar(Value *Char, IRBuilder<> &B, const TargetLibraryInfo *TLI);
const TargetLibraryInfo *TLI);
/// EmitPutS - Emit a call to the puts function. This assumes that Str is /// EmitPutS - Emit a call to the puts function. This assumes that Str is
/// some pointer. /// some pointer.
Value *EmitPutS(Value *Str, IRBuilder<> &B, const DataLayout *TD, Value *EmitPutS(Value *Str, IRBuilder<> &B, const TargetLibraryInfo *TLI);
const TargetLibraryInfo *TLI);
/// EmitFPutC - Emit a call to the fputc function. This assumes that Char is /// EmitFPutC - Emit a call to the fputc function. This assumes that Char is
/// an i32, and File is a pointer to FILE. /// an i32, and File is a pointer to FILE.
Value *EmitFPutC(Value *Char, Value *File, IRBuilder<> &B, Value *EmitFPutC(Value *Char, Value *File, IRBuilder<> &B,
const DataLayout *TD, const TargetLibraryInfo *TLI); const TargetLibraryInfo *TLI);
/// EmitFPutS - Emit a call to the puts function. Str is required to be a /// EmitFPutS - Emit a call to the puts function. Str is required to be a
/// pointer and File is a pointer to FILE. /// pointer and File is a pointer to FILE.
Value *EmitFPutS(Value *Str, Value *File, IRBuilder<> &B, const DataLayout *TD, Value *EmitFPutS(Value *Str, Value *File, IRBuilder<> &B,
const TargetLibraryInfo *TLI); const TargetLibraryInfo *TLI);
/// EmitFWrite - Emit a call to the fwrite function. This assumes that Ptr is /// EmitFWrite - Emit a call to the fwrite function. This assumes that Ptr is
/// a pointer, Size is an 'intptr_t', and File is a pointer to FILE. /// a pointer, Size is an 'intptr_t', and File is a pointer to FILE.
Value *EmitFWrite(Value *Ptr, Value *Size, Value *File, IRBuilder<> &B, Value *EmitFWrite(Value *Ptr, Value *Size, Value *File, IRBuilder<> &B,
const DataLayout *TD, const TargetLibraryInfo *TLI); const DataLayout &DL, const TargetLibraryInfo *TLI);
} }
#endif #endif
Context not available.

include/llvm/Transforms/Utils/Cloning.h

Context not available.
SmallVectorImpl<ReturnInst*> &Returns, SmallVectorImpl<ReturnInst*> &Returns,
const char *NameSuffix = "", const char *NameSuffix = "",
ClonedCodeInfo *CodeInfo = nullptr, ClonedCodeInfo *CodeInfo = nullptr,
const DataLayout *DL = nullptr,
CloningDirector *Director = nullptr); CloningDirector *Director = nullptr);
Context not available.
SmallVectorImpl<ReturnInst*> &Returns, SmallVectorImpl<ReturnInst*> &Returns,
const char *NameSuffix = "", const char *NameSuffix = "",
ClonedCodeInfo *CodeInfo = nullptr, ClonedCodeInfo *CodeInfo = nullptr,
const DataLayout *DL = nullptr,
Instruction *TheCall = nullptr); Instruction *TheCall = nullptr);
/// InlineFunctionInfo - This class captures the data input to the /// InlineFunctionInfo - This class captures the data input to the
Context not available.

include/llvm/Transforms/Utils/Local.h

Context not available.
#include "llvm/IR/IRBuilder.h" #include "llvm/IR/IRBuilder.h"
#include "llvm/IR/Operator.h" #include "llvm/IR/Operator.h"
// FIXME
#include "llvm/IR/Module.h"
namespace llvm { namespace llvm {
class User; class User;
Context not available.
/// ///
/// This returns true if it changed the code, note that it can delete /// This returns true if it changed the code, note that it can delete
/// instructions in other blocks as well in this block. /// instructions in other blocks as well in this block.
bool SimplifyInstructionsInBlock(BasicBlock *BB, const DataLayout *TD = nullptr, bool SimplifyInstructionsInBlock(BasicBlock *BB,
const TargetLibraryInfo *TLI = nullptr); const TargetLibraryInfo *TLI = nullptr);
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
Context not available.
/// ///
/// .. and delete the predecessor corresponding to the '1', this will attempt to /// .. and delete the predecessor corresponding to the '1', this will attempt to
/// recursively fold the 'and' to 0. /// recursively fold the 'and' to 0.
void RemovePredecessorAndSimplify(BasicBlock *BB, BasicBlock *Pred, void RemovePredecessorAndSimplify(BasicBlock *BB, BasicBlock *Pred);
DataLayout *TD = nullptr);
/// MergeBasicBlockIntoOnlyPred - BB is a block with one predecessor and its /// MergeBasicBlockIntoOnlyPred - BB is a block with one predecessor and its
/// predecessor is known to have one successor (BB!). Eliminate the edge /// predecessor is known to have one successor (BB!). Eliminate the edge
Context not available.
/// the basic block that was pointed to. /// the basic block that was pointed to.
/// ///
bool SimplifyCFG(BasicBlock *BB, const TargetTransformInfo &TTI, bool SimplifyCFG(BasicBlock *BB, const TargetTransformInfo &TTI,
unsigned BonusInstThreshold, const DataLayout *TD = nullptr, unsigned BonusInstThreshold, AssumptionCache *AC = nullptr);
AssumptionCache *AC = nullptr);
/// FlatternCFG - This function is used to flatten a CFG. For /// FlatternCFG - This function is used to flatten a CFG. For
/// example, it uses parallel-and and parallel-or mode to collapse /// example, it uses parallel-and and parallel-or mode to collapse
Context not available.
/// and if a predecessor branches to us and one of our successors, fold the /// and if a predecessor branches to us and one of our successors, fold the
/// setcc into the predecessor and use logical operations to pick the right /// setcc into the predecessor and use logical operations to pick the right
/// destination. /// destination.
bool FoldBranchToCommonDest(BranchInst *BI, const DataLayout *DL = nullptr, bool FoldBranchToCommonDest(BranchInst *BI, unsigned BonusInstThreshold = 1);
unsigned BonusInstThreshold = 1);
/// DemoteRegToStack - This function takes a virtual register computed by an /// DemoteRegToStack - This function takes a virtual register computed by an
/// Instruction and replaces it with a slot in the stack frame, allocated via /// Instruction and replaces it with a slot in the stack frame, allocated via
Context not available.
/// and it is more than the alignment of the ultimate object, see if we can /// and it is more than the alignment of the ultimate object, see if we can
/// increase the alignment of the ultimate object, making this check succeed. /// increase the alignment of the ultimate object, making this check succeed.
unsigned getOrEnforceKnownAlignment(Value *V, unsigned PrefAlign, unsigned getOrEnforceKnownAlignment(Value *V, unsigned PrefAlign,
const DataLayout *TD = nullptr, const Instruction &CxtI,
AssumptionCache *AC = nullptr, AssumptionCache *AC = nullptr,
const Instruction *CxtI = nullptr,
const DominatorTree *DT = nullptr); const DominatorTree *DT = nullptr);
/// getKnownAlignment - Try to infer an alignment for the specified pointer. /// getKnownAlignment - Try to infer an alignment for the specified pointer.
static inline unsigned getKnownAlignment(Value *V, static inline unsigned getKnownAlignment(Value *V, const Instruction &CxtI,
const DataLayout *TD = nullptr,
AssumptionCache *AC = nullptr, AssumptionCache *AC = nullptr,
const Instruction *CxtI = nullptr,
const DominatorTree *DT = nullptr) { const DominatorTree *DT = nullptr) {
return getOrEnforceKnownAlignment(V, 0, TD, AC, CxtI, DT); return getOrEnforceKnownAlignment(V, 0, CxtI, AC, DT);
} }
/// EmitGEPOffset - Given a getelementptr instruction/constantexpr, emit the /// EmitGEPOffset - Given a getelementptr instruction/constantexpr, emit the
Context not available.

include/llvm/Transforms/Utils/LoopUtils.h

Context not available.
/// passed into it. /// passed into it.
bool simplifyLoop(Loop *L, DominatorTree *DT, LoopInfo *LI, Pass *PP, bool simplifyLoop(Loop *L, DominatorTree *DT, LoopInfo *LI, Pass *PP,
AliasAnalysis *AA = nullptr, ScalarEvolution *SE = nullptr, AliasAnalysis *AA = nullptr, ScalarEvolution *SE = nullptr,
const DataLayout *DL = nullptr,
AssumptionCache *AC = nullptr); AssumptionCache *AC = nullptr);
/// \brief Put loop into LCSSA form. /// \brief Put loop into LCSSA form.
Context not available.
/// dominated by the specified block, and that are in the current loop) in /// dominated by the specified block, and that are in the current loop) in
/// reverse depth first order w.r.t the DominatorTree. This allows us to visit /// reverse depth first order w.r.t the DominatorTree. This allows us to visit
/// uses before definitions, allowing us to sink a loop body in one pass without /// uses before definitions, allowing us to sink a loop body in one pass without
/// iteration. Takes DomTreeNode, AliasAnalysis, LoopInfo, DominatorTree, /// iteration. Takes DomTreeNode, AliasAnalysis, LoopInfo, DominatorTree,
/// DataLayout, TargetLibraryInfo, Loop, AliasSet information for all /// DataLayout, TargetLibraryInfo, Loop, AliasSet information for all
/// instructions of the loop and loop safety information as arguments. /// instructions of the loop and loop safety information as arguments.
/// It returns changed status. /// It returns changed status.
bool sinkRegion(DomTreeNode *, AliasAnalysis *, LoopInfo *, DominatorTree *, bool sinkRegion(DomTreeNode *, AliasAnalysis *, LoopInfo *, DominatorTree *,
const DataLayout *, TargetLibraryInfo *, Loop *, TargetLibraryInfo *, Loop *, AliasSetTracker *,
AliasSetTracker *, LICMSafetyInfo *); LICMSafetyInfo *);
/// \brief Walk the specified region of the CFG (defined by all blocks /// \brief Walk the specified region of the CFG (defined by all blocks
/// dominated by the specified block, and that are in the current loop) in depth /// dominated by the specified block, and that are in the current loop) in depth
Context not available.
/// TargetLibraryInfo, Loop, AliasSet information for all instructions of the /// TargetLibraryInfo, Loop, AliasSet information for all instructions of the
/// loop and loop safety information as arguments. It returns changed status. /// loop and loop safety information as arguments. It returns changed status.
bool hoistRegion(DomTreeNode *, AliasAnalysis *, LoopInfo *, DominatorTree *, bool hoistRegion(DomTreeNode *, AliasAnalysis *, LoopInfo *, DominatorTree *,
const DataLayout *, TargetLibraryInfo *, Loop *, TargetLibraryInfo *, Loop *, AliasSetTracker *,
AliasSetTracker *, LICMSafetyInfo *); LICMSafetyInfo *);
/// \brief Try to promote memory values to scalars by sinking stores out of /// \brief Try to promote memory values to scalars by sinking stores out of
/// the loop and moving loads to before the loop. We do this by looping over /// the loop and moving loads to before the loop. We do this by looping over
Context not available.

include/llvm/Transforms/Utils/SimplifyLibCalls.h

Context not available.
/// is unknown) by passing true for OnlyLowerUnknownSize. /// is unknown) by passing true for OnlyLowerUnknownSize.
class FortifiedLibCallSimplifier { class FortifiedLibCallSimplifier {
private: private:
const DataLayout *DL;
const TargetLibraryInfo *TLI; const TargetLibraryInfo *TLI;
bool OnlyLowerUnknownSize; bool OnlyLowerUnknownSize;
public: public:
FortifiedLibCallSimplifier(const DataLayout *DL, const TargetLibraryInfo *TLI, FortifiedLibCallSimplifier(const TargetLibraryInfo *TLI,
bool OnlyLowerUnknownSize = false); bool OnlyLowerUnknownSize = false);
/// \brief Take the given call instruction and return a more /// \brief Take the given call instruction and return a more
Context not available.
class LibCallSimplifier { class LibCallSimplifier {
private: private:
FortifiedLibCallSimplifier FortifiedSimplifier; FortifiedLibCallSimplifier FortifiedSimplifier;
const DataLayout *DL; const DataLayout &DL;
const TargetLibraryInfo *TLI; const TargetLibraryInfo *TLI;
bool UnsafeFPShrink; bool UnsafeFPShrink;
function_ref<void(Instruction *, Value *)> Replacer; function_ref<void(Instruction *, Value *)> Replacer;
Context not available.
void replaceAllUsesWith(Instruction *I, Value *With); void replaceAllUsesWith(Instruction *I, Value *With);
public: public:
LibCallSimplifier(const DataLayout *TD, const TargetLibraryInfo *TLI, LibCallSimplifier(const DataLayout &DL, const TargetLibraryInfo *TLI,
function_ref<void(Instruction *, Value *)> Replacer = function_ref<void(Instruction *, Value *)> Replacer =
&replaceAllUsesWithDefault); &replaceAllUsesWithDefault);
Context not available.

lib/Analysis/AliasAnalysis.cpp

Context not available.
AliasAnalysis::callCapturesBefore(const Instruction *I, AliasAnalysis::callCapturesBefore(const Instruction *I,
const AliasAnalysis::Location &MemLoc, const AliasAnalysis::Location &MemLoc,
DominatorTree *DT) { DominatorTree *DT) {
if (!DT || !DL) return AliasAnalysis::ModRef; if (!DT)
return AliasAnalysis::ModRef;
const Value *Object = GetUnderlyingObject(MemLoc.Ptr, DL); const Value *Object = GetUnderlyingObject(MemLoc.Ptr, *DL);
if (!isIdentifiedObject(Object) || isa<GlobalValue>(Object) || if (!isIdentifiedObject(Object) || isa<GlobalValue>(Object) ||
isa<Constant>(Object)) isa<Constant>(Object))
return AliasAnalysis::ModRef; return AliasAnalysis::ModRef;
Context not available.

lib/Analysis/BasicAliasAnalysis.cpp

Context not available.
const TargetLibraryInfo &TLI, const TargetLibraryInfo &TLI,
bool RoundToAlign = false) { bool RoundToAlign = false) {
uint64_t Size; uint64_t Size;
if (getObjectSize(V, Size, &DL, &TLI, RoundToAlign)) if (getObjectSize(V, Size, DL, &TLI, RoundToAlign))
return Size; return Size;
return AliasAnalysis::UnknownSize; return AliasAnalysis::UnknownSize;
} }
Context not available.
case Instruction::Or: case Instruction::Or:
// X|C == X+C if all the bits in C are unset in X. Otherwise we can't // X|C == X+C if all the bits in C are unset in X. Otherwise we can't
// analyze it. // analyze it.
if (!MaskedValueIsZero(BOp->getOperand(0), RHSC->getValue(), &DL, 0, AC, if (!MaskedValueIsZero(BOp->getOperand(0), RHSC->getValue(), DL, 0, AC,
BOp, DT)) BOp, DT))
break; break;
// FALL THROUGH. // FALL THROUGH.
Context not available.
static const Value * static const Value *
DecomposeGEPExpression(const Value *V, int64_t &BaseOffs, DecomposeGEPExpression(const Value *V, int64_t &BaseOffs,
SmallVectorImpl<VariableGEPIndex> &VarIndices, SmallVectorImpl<VariableGEPIndex> &VarIndices,
bool &MaxLookupReached, const DataLayout *DL, bool &MaxLookupReached, const DataLayout &DL,
AssumptionCache *AC, DominatorTree *DT) { AssumptionCache *AC, DominatorTree *DT) {
// Limit recursion depth to limit compile time in crazy cases. // Limit recursion depth to limit compile time in crazy cases.
unsigned MaxLookup = MaxLookupSearchDepth; unsigned MaxLookup = MaxLookupSearchDepth;
Context not available.
if (!GEPOp->getOperand(0)->getType()->getPointerElementType()->isSized()) if (!GEPOp->getOperand(0)->getType()->getPointerElementType()->isSized())
return V; return V;
// If we are lacking DataLayout information, we can't compute the offets of
// elements computed by GEPs. However, we can handle bitcast equivalent
// GEPs.
if (!DL) {
if (!GEPOp->hasAllZeroIndices())
return V;
V = GEPOp->getOperand(0);
continue;
}
unsigned AS = GEPOp->getPointerAddressSpace(); unsigned AS = GEPOp->getPointerAddressSpace();
// Walk the indices of the GEP, accumulating them into BaseOff/VarIndices. // Walk the indices of the GEP, accumulating them into BaseOff/VarIndices.
gep_type_iterator GTI = gep_type_begin(GEPOp); gep_type_iterator GTI = gep_type_begin(GEPOp);
Context not available.
unsigned FieldNo = cast<ConstantInt>(Index)->getZExtValue(); unsigned FieldNo = cast<ConstantInt>(Index)->getZExtValue();
if (FieldNo == 0) continue; if (FieldNo == 0) continue;
BaseOffs += DL->getStructLayout(STy)->getElementOffset(FieldNo); BaseOffs += DL.getStructLayout(STy)->getElementOffset(FieldNo);
continue; continue;
} }
// For an array/pointer, add the element offset, explicitly scaled. // For an array/pointer, add the element offset, explicitly scaled.
if (ConstantInt *CIdx = dyn_cast<ConstantInt>(Index)) { if (ConstantInt *CIdx = dyn_cast<ConstantInt>(Index)) {
if (CIdx->isZero()) continue; if (CIdx->isZero()) continue;
BaseOffs += DL->getTypeAllocSize(*GTI)*CIdx->getSExtValue(); BaseOffs += DL.getTypeAllocSize(*GTI) * CIdx->getSExtValue();
continue; continue;
} }
uint64_t Scale = DL->getTypeAllocSize(*GTI); uint64_t Scale = DL.getTypeAllocSize(*GTI);
ExtensionKind Extension = EK_NotExtended; ExtensionKind Extension = EK_NotExtended;
// If the integer type is smaller than the pointer size, it is implicitly // If the integer type is smaller than the pointer size, it is implicitly
// sign extended to pointer size. // sign extended to pointer size.
unsigned Width = Index->getType()->getIntegerBitWidth(); unsigned Width = Index->getType()->getIntegerBitWidth();
if (DL->getPointerSizeInBits(AS) > Width) if (DL.getPointerSizeInBits(AS) > Width)
Extension = EK_SignExt; Extension = EK_SignExt;
// Use GetLinearExpression to decompose the index into a C1*V+C2 form. // Use GetLinearExpression to decompose the index into a C1*V+C2 form.
APInt IndexScale(Width, 0), IndexOffset(Width, 0); APInt IndexScale(Width, 0), IndexOffset(Width, 0);
Index = GetLinearExpression(Index, IndexScale, IndexOffset, Extension, Index = GetLinearExpression(Index, IndexScale, IndexOffset, Extension, DL,
*DL, 0, AC, DT); 0, AC, DT);
// The GEP index scale ("Scale") scales C1*V+C2, yielding (C1*V+C2)*Scale. // The GEP index scale ("Scale") scales C1*V+C2, yielding (C1*V+C2)*Scale.
// This gives us an aggregate computation of (C1*Scale)*V + C2*Scale. // This gives us an aggregate computation of (C1*Scale)*V + C2*Scale.
Context not available.
// Make sure that we have a scale that makes sense for this target's // Make sure that we have a scale that makes sense for this target's
// pointer size. // pointer size.
if (unsigned ShiftBits = 64 - DL->getPointerSizeInBits(AS)) { if (unsigned ShiftBits = 64 - DL.getPointerSizeInBits(AS)) {
Scale <<= ShiftBits; Scale <<= ShiftBits;
Scale = (int64_t)Scale >> ShiftBits; Scale = (int64_t)Scale >> ShiftBits;
} }
Context not available.
SmallVector<const Value *, 16> Worklist; SmallVector<const Value *, 16> Worklist;
Worklist.push_back(Loc.Ptr); Worklist.push_back(Loc.Ptr);
do { do {
const Value *V = GetUnderlyingObject(Worklist.pop_back_val(), DL); const Value *V = GetUnderlyingObject(Worklist.pop_back_val(), *DL);
if (!Visited.insert(V).second) { if (!Visited.insert(V).second) {
Visited.clear(); Visited.clear();
return AliasAnalysis::pointsToConstantMemory(Loc, OrLocal); return AliasAnalysis::pointsToConstantMemory(Loc, OrLocal);
Context not available.
assert(notDifferentParent(CS.getInstruction(), Loc.Ptr) && assert(notDifferentParent(CS.getInstruction(), Loc.Ptr) &&
"AliasAnalysis query involving multiple functions!"); "AliasAnalysis query involving multiple functions!");
const Value *Object = GetUnderlyingObject(Loc.Ptr, DL); const Value *Object = GetUnderlyingObject(Loc.Ptr, *DL);
// If this is a tail call and Loc.Ptr points to a stack location, we know that // If this is a tail call and Loc.Ptr points to a stack location, we know that
// the tail call cannot access or modify the local stack. // the tail call cannot access or modify the local stack.
Context not available.
SmallVector<VariableGEPIndex, 4> GEP2VariableIndices; SmallVector<VariableGEPIndex, 4> GEP2VariableIndices;
const Value *GEP2BasePtr = const Value *GEP2BasePtr =
DecomposeGEPExpression(GEP2, GEP2BaseOffset, GEP2VariableIndices, DecomposeGEPExpression(GEP2, GEP2BaseOffset, GEP2VariableIndices,
GEP2MaxLookupReached, DL, AC2, DT); GEP2MaxLookupReached, *DL, AC2, DT);
const Value *GEP1BasePtr = const Value *GEP1BasePtr =
DecomposeGEPExpression(GEP1, GEP1BaseOffset, GEP1VariableIndices, DecomposeGEPExpression(GEP1, GEP1BaseOffset, GEP1VariableIndices,
GEP1MaxLookupReached, DL, AC1, DT); GEP1MaxLookupReached, *DL, AC1, DT);
// DecomposeGEPExpression and GetUnderlyingObject should return the // DecomposeGEPExpression and GetUnderlyingObject should return the
// same result except when DecomposeGEPExpression has no DataLayout. // same result except when DecomposeGEPExpression has no DataLayout.
if (GEP1BasePtr != UnderlyingV1 || GEP2BasePtr != UnderlyingV2) { if (GEP1BasePtr != UnderlyingV1 || GEP2BasePtr != UnderlyingV2) {
Context not available.
// about the relation of the resulting pointer. // about the relation of the resulting pointer.
const Value *GEP1BasePtr = const Value *GEP1BasePtr =
DecomposeGEPExpression(GEP1, GEP1BaseOffset, GEP1VariableIndices, DecomposeGEPExpression(GEP1, GEP1BaseOffset, GEP1VariableIndices,
GEP1MaxLookupReached, DL, AC1, DT); GEP1MaxLookupReached, *DL, AC1, DT);
int64_t GEP2BaseOffset; int64_t GEP2BaseOffset;
bool GEP2MaxLookupReached; bool GEP2MaxLookupReached;
SmallVector<VariableGEPIndex, 4> GEP2VariableIndices; SmallVector<VariableGEPIndex, 4> GEP2VariableIndices;
const Value *GEP2BasePtr = const Value *GEP2BasePtr =
DecomposeGEPExpression(GEP2, GEP2BaseOffset, GEP2VariableIndices, DecomposeGEPExpression(GEP2, GEP2BaseOffset, GEP2VariableIndices,
GEP2MaxLookupReached, DL, AC2, DT); GEP2MaxLookupReached, *DL, AC2, DT);
// DecomposeGEPExpression and GetUnderlyingObject should return the // DecomposeGEPExpression and GetUnderlyingObject should return the
// same result except when DecomposeGEPExpression has no DataLayout. // same result except when DecomposeGEPExpression has no DataLayout.
Context not available.
const Value *GEP1BasePtr = const Value *GEP1BasePtr =
DecomposeGEPExpression(GEP1, GEP1BaseOffset, GEP1VariableIndices, DecomposeGEPExpression(GEP1, GEP1BaseOffset, GEP1VariableIndices,
GEP1MaxLookupReached, DL, AC1, DT); GEP1MaxLookupReached, *DL, AC1, DT);
// DecomposeGEPExpression and GetUnderlyingObject should return the // DecomposeGEPExpression and GetUnderlyingObject should return the
// same result except when DecomposeGEPExpression has no DataLayout. // same result except when DecomposeGEPExpression has no DataLayout.
Context not available.
const Value *V = GEP1VariableIndices[i].V; const Value *V = GEP1VariableIndices[i].V;
bool SignKnownZero, SignKnownOne; bool SignKnownZero, SignKnownOne;
ComputeSignBit(const_cast<Value *>(V), SignKnownZero, SignKnownOne, DL, ComputeSignBit(const_cast<Value *>(V), SignKnownZero, SignKnownOne, *DL,
0, AC1, nullptr, DT); 0, AC1, nullptr, DT);
// Zero-extension widens the variable, and so forces the sign // Zero-extension widens the variable, and so forces the sign
Context not available.
return NoAlias; // Scalars cannot alias each other return NoAlias; // Scalars cannot alias each other
// Figure out what objects these things are pointing to if we can. // Figure out what objects these things are pointing to if we can.
const Value *O1 = GetUnderlyingObject(V1, DL, MaxLookupSearchDepth); const Value *O1 = GetUnderlyingObject(V1, *DL, MaxLookupSearchDepth);
const Value *O2 = GetUnderlyingObject(V2, DL, MaxLookupSearchDepth); const Value *O2 = GetUnderlyingObject(V2, *DL, MaxLookupSearchDepth);
// Null values in the default address space don't point to any object, so they // Null values in the default address space don't point to any object, so they
// don't alias any other pointer. // don't alias any other pointer.
Context not available.

lib/Analysis/ConstantFolding.cpp

Context not available.
} }
static Constant *ConstantFoldLoadThroughBitcast(ConstantExpr *CE, static Constant *ConstantFoldLoadThroughBitcast(ConstantExpr *CE,
const DataLayout *DL) { const DataLayout &DL) {
if (!DL)
return nullptr;
auto *DestPtrTy = dyn_cast<PointerType>(CE->getType()); auto *DestPtrTy = dyn_cast<PointerType>(CE->getType());
if (!DestPtrTy) if (!DestPtrTy)
return nullptr; return nullptr;
Context not available.
// If the type sizes are the same and a cast is legal, just directly // If the type sizes are the same and a cast is legal, just directly
// cast the constant. // cast the constant.
if (DL->getTypeSizeInBits(DestTy) == DL->getTypeSizeInBits(SrcTy)) { if (DL.getTypeSizeInBits(DestTy) == DL.getTypeSizeInBits(SrcTy)) {
Instruction::CastOps Cast = Instruction::BitCast; Instruction::CastOps Cast = Instruction::BitCast;
// If we are going from a pointer to int or vice versa, we spell the cast // If we are going from a pointer to int or vice versa, we spell the cast
// differently. // differently.
Context not available.
/// Return the value that a load from C would produce if it is constant and /// Return the value that a load from C would produce if it is constant and
/// determinable. If this is not determinable, return null. /// determinable. If this is not determinable, return null.
Constant *llvm::ConstantFoldLoadFromConstPtr(Constant *C, Constant *llvm::ConstantFoldLoadFromConstPtr(Constant *C,
const DataLayout *TD) { const DataLayout &TD) {
// First, try the easy cases: // First, try the easy cases:
if (GlobalVariable *GV = dyn_cast<GlobalVariable>(C)) if (GlobalVariable *GV = dyn_cast<GlobalVariable>(C))
if (GV->isConstant() && GV->hasDefinitiveInitializer()) if (GV->isConstant() && GV->hasDefinitiveInitializer())
Context not available.
// Instead of loading constant c string, use corresponding integer value // Instead of loading constant c string, use corresponding integer value
// directly if string length is small enough. // directly if string length is small enough.
StringRef Str; StringRef Str;
if (TD && getConstantStringInfo(CE, Str) && !Str.empty()) { if (getConstantStringInfo(CE, Str) && !Str.empty()) {
unsigned StrLen = Str.size(); unsigned StrLen = Str.size();
Type *Ty = cast<PointerType>(CE->getType())->getElementType(); Type *Ty = cast<PointerType>(CE->getType())->getElementType();
unsigned NumBits = Ty->getPrimitiveSizeInBits(); unsigned NumBits = Ty->getPrimitiveSizeInBits();
Context not available.
(isa<IntegerType>(Ty) || Ty->isFloatingPointTy())) { (isa<IntegerType>(Ty) || Ty->isFloatingPointTy())) {
APInt StrVal(NumBits, 0); APInt StrVal(NumBits, 0);
APInt SingleChar(NumBits, 0); APInt SingleChar(NumBits, 0);
if (TD->isLittleEndian()) { if (TD.isLittleEndian()) {
for (signed i = StrLen-1; i >= 0; i--) { for (signed i = StrLen-1; i >= 0; i--) {
SingleChar = (uint64_t) Str[i] & UCHAR_MAX; SingleChar = (uint64_t) Str[i] & UCHAR_MAX;
StrVal = (StrVal << 8) | SingleChar; StrVal = (StrVal << 8) | SingleChar;
Context not available.
} }
// Try hard to fold loads from bitcasted strange and non-type-safe things. // Try hard to fold loads from bitcasted strange and non-type-safe things.
if (TD) return FoldReinterpretLoadFromConstPtr(CE, TD);
return FoldReinterpretLoadFromConstPtr(CE, *TD);
return nullptr;
} }
static Constant *ConstantFoldLoadInst(const LoadInst *LI, const DataLayout *TD){ static Constant *ConstantFoldLoadInst(const LoadInst *LI,
const DataLayout &TD) {
if (LI->isVolatile()) return nullptr; if (LI->isVolatile()) return nullptr;
if (Constant *C = dyn_cast<Constant>(LI->getOperand(0))) if (Constant *C = dyn_cast<Constant>(LI->getOperand(0)))
Context not available.
/// these together. If target data info is available, it is provided as DL, /// these together. If target data info is available, it is provided as DL,
/// otherwise DL is null. /// otherwise DL is null.
static Constant *SymbolicallyEvaluateBinop(unsigned Opc, Constant *Op0, static Constant *SymbolicallyEvaluateBinop(unsigned Opc, Constant *Op0,
Constant *Op1, const DataLayout *DL){ Constant *Op1,
const DataLayout &DL) {
// SROA // SROA
// Fold (and 0xffffffff00000000, (shl x, 32)) -> shl. // Fold (and 0xffffffff00000000, (shl x, 32)) -> shl.
// Fold (lshr (or X, Y), 32) -> (lshr [X/Y], 32) if one doesn't contribute // Fold (lshr (or X, Y), 32) -> (lshr [X/Y], 32) if one doesn't contribute
// bits. // bits.
if (Opc == Instruction::And) {
if (Opc == Instruction::And && DL) { unsigned BitWidth = DL.getTypeSizeInBits(Op0->getType()->getScalarType());
unsigned BitWidth = DL->getTypeSizeInBits(Op0->getType()->getScalarType());
APInt KnownZero0(BitWidth, 0), KnownOne0(BitWidth, 0); APInt KnownZero0(BitWidth, 0), KnownOne0(BitWidth, 0);
APInt KnownZero1(BitWidth, 0), KnownOne1(BitWidth, 0); APInt KnownZero1(BitWidth, 0), KnownOne1(BitWidth, 0);
computeKnownBits(Op0, KnownZero0, KnownOne0, DL); computeKnownBits(Op0, KnownZero0, KnownOne0, DL);
Context not available.
// If the constant expr is something like &A[123] - &A[4].f, fold this into a // If the constant expr is something like &A[123] - &A[4].f, fold this into a
// constant. This happens frequently when iterating over a global array. // constant. This happens frequently when iterating over a global array.
if (Opc == Instruction::Sub && DL) { if (Opc == Instruction::Sub) {
GlobalValue *GV1, *GV2; GlobalValue *GV1, *GV2;
APInt Offs1, Offs2; APInt Offs1, Offs2;
if (IsConstantOffsetFromGlobal(Op0, GV1, Offs1, *DL)) if (IsConstantOffsetFromGlobal(Op0, GV1, Offs1, DL))
if (IsConstantOffsetFromGlobal(Op1, GV2, Offs2, *DL) && if (IsConstantOffsetFromGlobal(Op1, GV2, Offs2, DL) && GV1 == GV2) {
GV1 == GV2) { unsigned OpSize = DL.getTypeSizeInBits(Op0->getType());
unsigned OpSize = DL->getTypeSizeInBits(Op0->getType());
// (&GV+C1) - (&GV+C2) -> C1-C2, pointer arithmetic cannot overflow. // (&GV+C1) - (&GV+C2) -> C1-C2, pointer arithmetic cannot overflow.
// PtrToInt may change the bitwidth so we have convert to the right size // PtrToInt may change the bitwidth so we have convert to the right size
Context not available.
/// If array indices are not pointer-sized integers, explicitly cast them so /// If array indices are not pointer-sized integers, explicitly cast them so
/// that they aren't implicitly casted by the getelementptr. /// that they aren't implicitly casted by the getelementptr.
static Constant *CastGEPIndices(ArrayRef<Constant *> Ops, static Constant *CastGEPIndices(ArrayRef<Constant *> Ops, Type *ResultTy,
Type *ResultTy, const DataLayout *TD, const DataLayout &TD,
const TargetLibraryInfo *TLI) { const TargetLibraryInfo *TLI) {
if (!TD) Type *IntPtrTy = TD.getIntPtrType(ResultTy);
return nullptr;
Type *IntPtrTy = TD->getIntPtrType(ResultTy);
bool Any = false; bool Any = false;
SmallVector<Constant*, 32> NewIdxs; SmallVector<Constant*, 32> NewIdxs;
Context not available.
/// If we can symbolically evaluate the GEP constant expression, do so. /// If we can symbolically evaluate the GEP constant expression, do so.
static Constant *SymbolicallyEvaluateGEP(ArrayRef<Constant *> Ops, static Constant *SymbolicallyEvaluateGEP(ArrayRef<Constant *> Ops,
Type *ResultTy, const DataLayout *TD, Type *ResultTy, const DataLayout &TD,
const TargetLibraryInfo *TLI) { const TargetLibraryInfo *TLI) {
Constant *Ptr = Ops[0]; Constant *Ptr = Ops[0];
if (!TD || !Ptr->getType()->getPointerElementType()->isSized() || if (!Ptr->getType()->getPointerElementType()->isSized() ||
!Ptr->getType()->isPointerTy()) !Ptr->getType()->isPointerTy())
return nullptr; return nullptr;
Type *IntPtrTy = TD->getIntPtrType(Ptr->getType()); Type *IntPtrTy = TD.getIntPtrType(Ptr->getType());
Type *ResultElementTy = ResultTy->getPointerElementType(); Type *ResultElementTy = ResultTy->getPointerElementType();
// If this is a constant expr gep that is effectively computing an // If this is a constant expr gep that is effectively computing an
Context not available.
return nullptr; return nullptr;
} }
unsigned BitWidth = TD->getTypeSizeInBits(IntPtrTy); unsigned BitWidth = TD.getTypeSizeInBits(IntPtrTy);
APInt Offset = APInt Offset =
APInt(BitWidth, TD->getIndexedOffset(Ptr->getType(), APInt(BitWidth,
makeArrayRef((Value *const*) TD.getIndexedOffset(
Ops.data() + 1, Ptr->getType(),
Ops.size() - 1))); makeArrayRef((Value * const *)Ops.data() + 1, Ops.size() - 1)));
Ptr = StripPtrCastKeepAS(Ptr); Ptr = StripPtrCastKeepAS(Ptr);
// If this is a GEP of a GEP, fold it all into a single GEP. // If this is a GEP of a GEP, fold it all into a single GEP.
Context not available.
break; break;
Ptr = cast<Constant>(GEP->getOperand(0)); Ptr = cast<Constant>(GEP->getOperand(0));
Offset += APInt(BitWidth, Offset += APInt(BitWidth, TD.getIndexedOffset(Ptr->getType(), NestedOps));
TD->getIndexedOffset(Ptr->getType(), NestedOps));
Ptr = StripPtrCastKeepAS(Ptr); Ptr = StripPtrCastKeepAS(Ptr);
} }
Context not available.
} }
// Determine which element of the array the offset points into. // Determine which element of the array the offset points into.
APInt ElemSize(BitWidth, TD->getTypeAllocSize(ATy->getElementType())); APInt ElemSize(BitWidth, TD.getTypeAllocSize(ATy->getElementType()));
if (ElemSize == 0) if (ElemSize == 0)
// The element size is 0. This may be [0 x Ty]*, so just use a zero // The element size is 0. This may be [0 x Ty]*, so just use a zero
// index for this level and proceed to the next level to see if it can // index for this level and proceed to the next level to see if it can
Context not available.
// can't re-form this GEP in a regular form, so bail out. The pointer // can't re-form this GEP in a regular form, so bail out. The pointer
// operand likely went through casts that are necessary to make the GEP // operand likely went through casts that are necessary to make the GEP
// sensible. // sensible.
const StructLayout &SL = *TD->getStructLayout(STy); const StructLayout &SL = *TD.getStructLayout(STy);
if (Offset.uge(SL.getSizeInBytes())) if (Offset.uge(SL.getSizeInBytes()))
break; break;
Context not available.
// If we ended up indexing a member with a type that doesn't match // If we ended up indexing a member with a type that doesn't match
// the type of what the original indices indexed, add a cast. // the type of what the original indices indexed, add a cast.
if (Ty != ResultElementTy) if (Ty != ResultElementTy)
C = FoldBitCast(C, ResultTy, *TD); C = FoldBitCast(C, ResultTy, TD);
return C; return C;
} }
Context not available.
/// Note that this fails if not all of the operands are constant. Otherwise, /// Note that this fails if not all of the operands are constant. Otherwise,
/// this function can only fail when attempting to fold instructions like loads /// this function can only fail when attempting to fold instructions like loads
/// and stores, which have no constant expression form. /// and stores, which have no constant expression form.
Constant *llvm::ConstantFoldInstruction(Instruction *I, Constant *llvm::ConstantFoldInstruction(Instruction *I, const DataLayout &TD,
const DataLayout *TD,
const TargetLibraryInfo *TLI) { const TargetLibraryInfo *TLI) {
// Handle PHI nodes quickly here... // Handle PHI nodes quickly here...
if (PHINode *PN = dyn_cast<PHINode>(I)) { if (PHINode *PN = dyn_cast<PHINode>(I)) {
Context not available.
} }
static Constant * static Constant *
ConstantFoldConstantExpressionImpl(const ConstantExpr *CE, const DataLayout *TD, ConstantFoldConstantExpressionImpl(const ConstantExpr *CE, const DataLayout &TD,
const TargetLibraryInfo *TLI, const TargetLibraryInfo *TLI,
SmallPtrSetImpl<ConstantExpr *> &FoldedOps) { SmallPtrSetImpl<ConstantExpr *> &FoldedOps) {
SmallVector<Constant *, 8> Ops; SmallVector<Constant *, 8> Ops;
Context not available.
/// using the specified DataLayout. If successful, the constant result is /// using the specified DataLayout. If successful, the constant result is
/// result is returned, if not, null is returned. /// result is returned, if not, null is returned.
Constant *llvm::ConstantFoldConstantExpression(const ConstantExpr *CE, Constant *llvm::ConstantFoldConstantExpression(const ConstantExpr *CE,
const DataLayout *TD, const DataLayout &TD,
const TargetLibraryInfo *TLI) { const TargetLibraryInfo *TLI) {
SmallPtrSet<ConstantExpr *, 4> FoldedOps; SmallPtrSet<ConstantExpr *, 4> FoldedOps;
return ConstantFoldConstantExpressionImpl(CE, TD, TLI, FoldedOps); return ConstantFoldConstantExpressionImpl(CE, TD, TLI, FoldedOps);
Context not available.
/// ///
Constant *llvm::ConstantFoldInstOperands(unsigned Opcode, Type *DestTy, Constant *llvm::ConstantFoldInstOperands(unsigned Opcode, Type *DestTy,
ArrayRef<Constant *> Ops, ArrayRef<Constant *> Ops,
const DataLayout *TD, const DataLayout &TD,
const TargetLibraryInfo *TLI) { const TargetLibraryInfo *TLI) {
// Handle easy binops first. // Handle easy binops first.
if (Instruction::isBinaryOp(Opcode)) { if (Instruction::isBinaryOp(Opcode)) {
Context not available.
// If the input is a inttoptr, eliminate the pair. This requires knowing // If the input is a inttoptr, eliminate the pair. This requires knowing
// the width of a pointer, so it can't be done in ConstantExpr::getCast. // the width of a pointer, so it can't be done in ConstantExpr::getCast.
if (ConstantExpr *CE = dyn_cast<ConstantExpr>(Ops[0])) { if (ConstantExpr *CE = dyn_cast<ConstantExpr>(Ops[0])) {
if (TD && CE->getOpcode() == Instruction::IntToPtr) { if (CE->getOpcode() == Instruction::IntToPtr) {
Constant *Input = CE->getOperand(0); Constant *Input = CE->getOperand(0);
unsigned InWidth = Input->getType()->getScalarSizeInBits(); unsigned InWidth = Input->getType()->getScalarSizeInBits();
unsigned PtrWidth = TD->getPointerTypeSizeInBits(CE->getType()); unsigned PtrWidth = TD.getPointerTypeSizeInBits(CE->getType());
if (PtrWidth < InWidth) { if (PtrWidth < InWidth) {
Constant *Mask = Constant *Mask =
ConstantInt::get(CE->getContext(), ConstantInt::get(CE->getContext(),
Context not available.
// This requires knowing the width of a pointer, so it can't be done in // This requires knowing the width of a pointer, so it can't be done in
// ConstantExpr::getCast. // ConstantExpr::getCast.
if (ConstantExpr *CE = dyn_cast<ConstantExpr>(Ops[0])) { if (ConstantExpr *CE = dyn_cast<ConstantExpr>(Ops[0])) {
if (TD && CE->getOpcode() == Instruction::PtrToInt) { if (CE->getOpcode() == Instruction::PtrToInt) {
Constant *SrcPtr = CE->getOperand(0); Constant *SrcPtr = CE->getOperand(0);
unsigned SrcPtrSize = TD->getPointerTypeSizeInBits(SrcPtr->getType()); unsigned SrcPtrSize = TD.getPointerTypeSizeInBits(SrcPtr->getType());
unsigned MidIntSize = CE->getType()->getScalarSizeInBits(); unsigned MidIntSize = CE->getType()->getScalarSizeInBits();
if (MidIntSize >= SrcPtrSize) { if (MidIntSize >= SrcPtrSize) {
unsigned SrcAS = SrcPtr->getType()->getPointerAddressSpace(); unsigned SrcAS = SrcPtr->getType()->getPointerAddressSpace();
if (SrcAS == DestTy->getPointerAddressSpace()) if (SrcAS == DestTy->getPointerAddressSpace())
return FoldBitCast(CE->getOperand(0), DestTy, *TD); return FoldBitCast(CE->getOperand(0), DestTy, TD);
} }
} }
} }
Context not available.
case Instruction::AddrSpaceCast: case Instruction::AddrSpaceCast:
return ConstantExpr::getCast(Opcode, Ops[0], DestTy); return ConstantExpr::getCast(Opcode, Ops[0], DestTy);
case Instruction::BitCast: case Instruction::BitCast:
if (TD) return FoldBitCast(Ops[0], DestTy, TD);
return FoldBitCast(Ops[0], DestTy, *TD);
return ConstantExpr::getBitCast(Ops[0], DestTy);
case Instruction::Select: case Instruction::Select:
return ConstantExpr::getSelect(Ops[0], Ops[1], Ops[2]); return ConstantExpr::getSelect(Ops[0], Ops[1], Ops[2]);
case Instruction::ExtractElement: case Instruction::ExtractElement:
Context not available.
/// returns a constant expression of the specified operands. /// returns a constant expression of the specified operands.
Constant *llvm::ConstantFoldCompareInstOperands(unsigned Predicate, Constant *llvm::ConstantFoldCompareInstOperands(unsigned Predicate,
Constant *Ops0, Constant *Ops1, Constant *Ops0, Constant *Ops1,
const DataLayout *TD, const DataLayout &TD,
const TargetLibraryInfo *TLI) { const TargetLibraryInfo *TLI) {
// fold: icmp (inttoptr x), null -> icmp x, 0 // fold: icmp (inttoptr x), null -> icmp x, 0
// fold: icmp (ptrtoint x), 0 -> icmp x, null // fold: icmp (ptrtoint x), 0 -> icmp x, null
Context not available.
// ConstantExpr::getCompare cannot do this, because it doesn't have TD // ConstantExpr::getCompare cannot do this, because it doesn't have TD
// around to know if bit truncation is happening. // around to know if bit truncation is happening.
if (ConstantExpr *CE0 = dyn_cast<ConstantExpr>(Ops0)) { if (ConstantExpr *CE0 = dyn_cast<ConstantExpr>(Ops0)) {
if (TD && Ops1->isNullValue()) { if (Ops1->isNullValue()) {
if (CE0->getOpcode() == Instruction::IntToPtr) { if (CE0->getOpcode() == Instruction::IntToPtr) {
Type *IntPtrTy = TD->getIntPtrType(CE0->getType()); Type *IntPtrTy = TD.getIntPtrType(CE0->getType());
// Convert the integer value to the right size to ensure we get the // Convert the integer value to the right size to ensure we get the
// proper extension or truncation. // proper extension or truncation.
Constant *C = ConstantExpr::getIntegerCast(CE0->getOperand(0), Constant *C = ConstantExpr::getIntegerCast(CE0->getOperand(0),
Context not available.
// Only do this transformation if the int is intptrty in size, otherwise // Only do this transformation if the int is intptrty in size, otherwise
// there is a truncation or extension that we aren't modeling. // there is a truncation or extension that we aren't modeling.
if (CE0->getOpcode() == Instruction::PtrToInt) { if (CE0->getOpcode() == Instruction::PtrToInt) {
Type *IntPtrTy = TD->getIntPtrType(CE0->getOperand(0)->getType()); Type *IntPtrTy = TD.getIntPtrType(CE0->getOperand(0)->getType());
if (CE0->getType() == IntPtrTy) { if (CE0->getType() == IntPtrTy) {
Constant *C = CE0->getOperand(0); Constant *C = CE0->getOperand(0);
Constant *Null = Constant::getNullValue(C->getType()); Constant *Null = Constant::getNullValue(C->getType());
Context not available.
} }
if (ConstantExpr *CE1 = dyn_cast<ConstantExpr>(Ops1)) { if (ConstantExpr *CE1 = dyn_cast<ConstantExpr>(Ops1)) {
if (TD && CE0->getOpcode() == CE1->getOpcode()) { if (CE0->getOpcode() == CE1->getOpcode()) {
if (CE0->getOpcode() == Instruction::IntToPtr) { if (CE0->getOpcode() == Instruction::IntToPtr) {
Type *IntPtrTy = TD->getIntPtrType(CE0->getType()); Type *IntPtrTy = TD.getIntPtrType(CE0->getType());
// Convert the integer value to the right size to ensure we get the // Convert the integer value to the right size to ensure we get the
// proper extension or truncation. // proper extension or truncation.
Context not available.
// Only do this transformation if the int is intptrty in size, otherwise // Only do this transformation if the int is intptrty in size, otherwise
// there is a truncation or extension that we aren't modeling. // there is a truncation or extension that we aren't modeling.
if (CE0->getOpcode() == Instruction::PtrToInt) { if (CE0->getOpcode() == Instruction::PtrToInt) {
Type *IntPtrTy = TD->getIntPtrType(CE0->getOperand(0)->getType()); Type *IntPtrTy = TD.getIntPtrType(CE0->getOperand(0)->getType());
if (CE0->getType() == IntPtrTy && if (CE0->getType() == IntPtrTy &&
CE0->getOperand(0)->getType() == CE1->getOperand(0)->getType()) { CE0->getOperand(0)->getType() == CE1->getOperand(0)->getType()) {
return ConstantFoldCompareInstOperands(Predicate, return ConstantFoldCompareInstOperands(Predicate,
Context not available.

lib/Analysis/DependenceAnalysis.cpp

Context not available.
#include "llvm/Analysis/ScalarEvolutionExpressions.h" #include "llvm/Analysis/ScalarEvolutionExpressions.h"
#include "llvm/Analysis/ValueTracking.h" #include "llvm/Analysis/ValueTracking.h"
#include "llvm/IR/InstIterator.h" #include "llvm/IR/InstIterator.h"
#include "llvm/IR/Module.h"
#include "llvm/IR/Operator.h" #include "llvm/IR/Operator.h"
#include "llvm/Support/CommandLine.h" #include "llvm/Support/CommandLine.h"
#include "llvm/Support/Debug.h" #include "llvm/Support/Debug.h"
Context not available.
OS << "!\n"; OS << "!\n";
} }
static AliasAnalysis::AliasResult underlyingObjectsAlias(AliasAnalysis *AA,
const DataLayout &DL,
static const Value *A,
AliasAnalysis::AliasResult underlyingObjectsAlias(AliasAnalysis *AA, const Value *B) {
const Value *A, const Value *AObj = GetUnderlyingObject(A, DL);
const Value *B) { const Value *BObj = GetUnderlyingObject(B, DL);
const Value *AObj = GetUnderlyingObject(A);
const Value *BObj = GetUnderlyingObject(B);
return AA->alias(AObj, AA->getTypeStoreSize(AObj->getType()), return AA->alias(AObj, AA->getTypeStoreSize(AObj->getType()),
BObj, AA->getTypeStoreSize(BObj->getType())); BObj, AA->getTypeStoreSize(BObj->getType()));
} }
Context not available.
Value *SrcPtr = getPointerOperand(Src); Value *SrcPtr = getPointerOperand(Src);
Value *DstPtr = getPointerOperand(Dst); Value *DstPtr = getPointerOperand(Dst);
switch (underlyingObjectsAlias(AA, DstPtr, SrcPtr)) { switch (underlyingObjectsAlias(AA, F->getParent()->getDataLayout(), DstPtr,
SrcPtr)) {
case AliasAnalysis::MayAlias: case AliasAnalysis::MayAlias:
case AliasAnalysis::PartialAlias: case AliasAnalysis::PartialAlias:
// cannot analyse objects if we don't understand their aliasing. // cannot analyse objects if we don't understand their aliasing.
Context not available.
assert(isLoadOrStore(Dst)); assert(isLoadOrStore(Dst));
Value *SrcPtr = getPointerOperand(Src); Value *SrcPtr = getPointerOperand(Src);
Value *DstPtr = getPointerOperand(Dst); Value *DstPtr = getPointerOperand(Dst);
assert(underlyingObjectsAlias(AA, DstPtr, SrcPtr) == assert(underlyingObjectsAlias(AA, F->getParent()->getDataLayout(), DstPtr,
AliasAnalysis::MustAlias); SrcPtr) == AliasAnalysis::MustAlias);
// establish loop nesting levels // establish loop nesting levels
establishNestingLevels(Src, Dst); establishNestingLevels(Src, Dst);
Context not available.

lib/Analysis/IPA/GlobalsModRef.cpp

Context not available.
continue; continue;
// Check the value being stored. // Check the value being stored.
Value *Ptr = GetUnderlyingObject(SI->getOperand(0)); Value *Ptr = GetUnderlyingObject(SI->getOperand(0),
GV->getParent()->getDataLayout());
if (!isAllocLikeFn(Ptr, TLI)) if (!isAllocLikeFn(Ptr, TLI))
return false; // Too hard to analyze. return false; // Too hard to analyze.
Context not available.
GlobalsModRef::alias(const Location &LocA, GlobalsModRef::alias(const Location &LocA,
const Location &LocB) { const Location &LocB) {
// Get the base object these pointers point to. // Get the base object these pointers point to.
const Value *UV1 = GetUnderlyingObject(LocA.Ptr); const Value *UV1 = GetUnderlyingObject(LocA.Ptr, *DL);
const Value *UV2 = GetUnderlyingObject(LocB.Ptr); const Value *UV2 = GetUnderlyingObject(LocB.Ptr, *DL);
// If either of the underlying values is a global, they may be non-addr-taken // If either of the underlying values is a global, they may be non-addr-taken
// globals, which we can answer queries about. // globals, which we can answer queries about.
Context not available.
// If we are asking for mod/ref info of a direct call with a pointer to a // If we are asking for mod/ref info of a direct call with a pointer to a
// global we are tracking, return information if we have it. // global we are tracking, return information if we have it.
const DataLayout &DL = CS.getCaller()->getParent()->getDataLayout();
if (const GlobalValue *GV = if (const GlobalValue *GV =
dyn_cast<GlobalValue>(GetUnderlyingObject(Loc.Ptr))) dyn_cast<GlobalValue>(GetUnderlyingObject(Loc.Ptr, DL)))
if (GV->hasLocalLinkage()) if (GV->hasLocalLinkage())
if (const Function *F = CS.getCalledFunction()) if (const Function *F = CS.getCalledFunction())
if (NonAddressTakenGlobals.count(GV)) if (NonAddressTakenGlobals.count(GV))
Context not available.

lib/Analysis/IPA/InlineCost.cpp

Context not available.
typedef InstVisitor<CallAnalyzer, bool> Base; typedef InstVisitor<CallAnalyzer, bool> Base;
friend class InstVisitor<CallAnalyzer, bool>; friend class InstVisitor<CallAnalyzer, bool>;
// DataLayout if available, or null.
const DataLayout *const DL;
/// The TargetTransformInfo available for this compilation. /// The TargetTransformInfo available for this compilation.
const TargetTransformInfo &TTI; const TargetTransformInfo &TTI;
Context not available.
bool visitUnreachableInst(UnreachableInst &I); bool visitUnreachableInst(UnreachableInst &I);
public: public:
CallAnalyzer(const DataLayout *DL, const TargetTransformInfo &TTI, CallAnalyzer(const TargetTransformInfo &TTI, AssumptionCacheTracker *ACT,
AssumptionCacheTracker *ACT, Function &Callee, int Threshold) Function &Callee, int Threshold)
: DL(DL), TTI(TTI), ACT(ACT), F(Callee), Threshold(Threshold), Cost(0), : TTI(TTI), ACT(ACT), F(Callee), Threshold(Threshold), Cost(0),
IsCallerRecursive(false), IsRecursiveCall(false), IsCallerRecursive(false), IsRecursiveCall(false),
ExposesReturnsTwice(false), HasDynamicAlloca(false), ExposesReturnsTwice(false), HasDynamicAlloca(false),
ContainsNoDuplicateCall(false), HasReturn(false), HasIndirectBr(false), ContainsNoDuplicateCall(false), HasReturn(false), HasIndirectBr(false),
Context not available.
/// Returns false if unable to compute the offset for any reason. Respects any /// Returns false if unable to compute the offset for any reason. Respects any
/// simplified values known during the analysis of this callsite. /// simplified values known during the analysis of this callsite.
bool CallAnalyzer::accumulateGEPOffset(GEPOperator &GEP, APInt &Offset) { bool CallAnalyzer::accumulateGEPOffset(GEPOperator &GEP, APInt &Offset) {
if (!DL) const DataLayout &DL = F.getParent()->getDataLayout();
return false; unsigned IntPtrWidth = DL.getPointerSizeInBits();
unsigned IntPtrWidth = DL->getPointerSizeInBits();
assert(IntPtrWidth == Offset.getBitWidth()); assert(IntPtrWidth == Offset.getBitWidth());
for (gep_type_iterator GTI = gep_type_begin(GEP), GTE = gep_type_end(GEP); for (gep_type_iterator GTI = gep_type_begin(GEP), GTE = gep_type_end(GEP);
Context not available.
// Handle a struct index, which adds its field offset to the pointer. // Handle a struct index, which adds its field offset to the pointer.
if (StructType *STy = dyn_cast<StructType>(*GTI)) { if (StructType *STy = dyn_cast<StructType>(*GTI)) {
unsigned ElementIdx = OpC->getZExtValue(); unsigned ElementIdx = OpC->getZExtValue();
const StructLayout *SL = DL->getStructLayout(STy); const StructLayout *SL = DL.getStructLayout(STy);
Offset += APInt(IntPtrWidth, SL->getElementOffset(ElementIdx)); Offset += APInt(IntPtrWidth, SL->getElementOffset(ElementIdx));
continue; continue;
} }
APInt TypeSize(IntPtrWidth, DL->getTypeAllocSize(GTI.getIndexedType())); APInt TypeSize(IntPtrWidth, DL.getTypeAllocSize(GTI.getIndexedType()));
Offset += OpC->getValue().sextOrTrunc(IntPtrWidth) * TypeSize; Offset += OpC->getValue().sextOrTrunc(IntPtrWidth) * TypeSize;
} }
return true; return true;
Context not available.
// Accumulate the allocated size. // Accumulate the allocated size.
if (I.isStaticAlloca()) { if (I.isStaticAlloca()) {
const DataLayout &DL = F.getParent()->getDataLayout();
Type *Ty = I.getAllocatedType(); Type *Ty = I.getAllocatedType();
AllocatedSize += (DL ? DL->getTypeAllocSize(Ty) : AllocatedSize += DL.getTypeAllocSize(Ty);
Ty->getPrimitiveSizeInBits());
} }
// We will happily inline static alloca instructions. // We will happily inline static alloca instructions.
Context not available.
// Try to fold GEPs of constant-offset call site argument pointers. This // Try to fold GEPs of constant-offset call site argument pointers. This
// requires target data and inbounds GEPs. // requires target data and inbounds GEPs.
if (DL && I.isInBounds()) { if (I.isInBounds()) {
// Check if we have a base + offset for the pointer. // Check if we have a base + offset for the pointer.
Value *Ptr = I.getPointerOperand(); Value *Ptr = I.getPointerOperand();
std::pair<Value *, APInt> BaseAndOffset = ConstantOffsetPtrs.lookup(Ptr); std::pair<Value *, APInt> BaseAndOffset = ConstantOffsetPtrs.lookup(Ptr);
Context not available.
// Track base/offset pairs when converted to a plain integer provided the // Track base/offset pairs when converted to a plain integer provided the
// integer is large enough to represent the pointer. // integer is large enough to represent the pointer.
unsigned IntegerSize = I.getType()->getScalarSizeInBits(); unsigned IntegerSize = I.getType()->getScalarSizeInBits();
const DataLayout &DL = I.getModule()->getDataLayout(); const DataLayout &DL = F.getParent()->getDataLayout();
if (IntegerSize >= DL.getPointerSizeInBits()) { if (IntegerSize >= DL.getPointerSizeInBits()) {
std::pair<Value *, APInt> BaseAndOffset std::pair<Value *, APInt> BaseAndOffset
= ConstantOffsetPtrs.lookup(I.getOperand(0)); = ConstantOffsetPtrs.lookup(I.getOperand(0));
Context not available.
// modifications provided the integer is not too large. // modifications provided the integer is not too large.
Value *Op = I.getOperand(0); Value *Op = I.getOperand(0);
unsigned IntegerSize = Op->getType()->getScalarSizeInBits(); unsigned IntegerSize = Op->getType()->getScalarSizeInBits();
const DataLayout &DL = I.getModule()->getDataLayout(); const DataLayout &DL = F.getParent()->getDataLayout();
if (IntegerSize <= DL.getPointerSizeInBits()) { if (IntegerSize <= DL.getPointerSizeInBits()) {
std::pair<Value *, APInt> BaseAndOffset = ConstantOffsetPtrs.lookup(Op); std::pair<Value *, APInt> BaseAndOffset = ConstantOffsetPtrs.lookup(Op);
if (BaseAndOffset.first) if (BaseAndOffset.first)
Context not available.
Constant *COp = dyn_cast<Constant>(Operand); Constant *COp = dyn_cast<Constant>(Operand);
if (!COp) if (!COp)
COp = SimplifiedValues.lookup(Operand); COp = SimplifiedValues.lookup(Operand);
if (COp) if (COp) {
const DataLayout &DL = F.getParent()->getDataLayout();
if (Constant *C = ConstantFoldInstOperands(I.getOpcode(), I.getType(), if (Constant *C = ConstantFoldInstOperands(I.getOpcode(), I.getType(),
COp, DL)) { COp, DL)) {
SimplifiedValues[&I] = C; SimplifiedValues[&I] = C;
return true; return true;
} }
}
// Disable any SROA on the argument to arbitrary unary operators. // Disable any SROA on the argument to arbitrary unary operators.
disableSROA(Operand); disableSROA(Operand);
Context not available.
bool CallAnalyzer::visitBinaryOperator(BinaryOperator &I) { bool CallAnalyzer::visitBinaryOperator(BinaryOperator &I) {
Value *LHS = I.getOperand(0), *RHS = I.getOperand(1); Value *LHS = I.getOperand(0), *RHS = I.getOperand(1);
const DataLayout &DL = F.getParent()->getDataLayout();
if (!isa<Constant>(LHS)) if (!isa<Constant>(LHS))
if (Constant *SimpleLHS = SimplifiedValues.lookup(LHS)) if (Constant *SimpleLHS = SimplifiedValues.lookup(LHS))
LHS = SimpleLHS; LHS = SimpleLHS;
Context not available.
// during devirtualization and so we want to give it a hefty bonus for // during devirtualization and so we want to give it a hefty bonus for
// inlining, but cap that bonus in the event that inlining wouldn't pan // inlining, but cap that bonus in the event that inlining wouldn't pan
// out. Pretend to inline the function, with a custom threshold. // out. Pretend to inline the function, with a custom threshold.
CallAnalyzer CA(DL, TTI, ACT, *F, InlineConstants::IndirectCallThreshold); CallAnalyzer CA(TTI, ACT, *F, InlineConstants::IndirectCallThreshold);
if (CA.analyzeCall(CS)) { if (CA.analyzeCall(CS)) {
// We were able to inline the indirect call! Subtract the cost from the // We were able to inline the indirect call! Subtract the cost from the
// bonus we want to apply, but don't go below zero. // bonus we want to apply, but don't go below zero.
Context not available.
/// returns 0 if V is not a pointer, and returns the constant '0' if there are /// returns 0 if V is not a pointer, and returns the constant '0' if there are
/// no constant offsets applied. /// no constant offsets applied.
ConstantInt *CallAnalyzer::stripAndComputeInBoundsConstantOffsets(Value *&V) { ConstantInt *CallAnalyzer::stripAndComputeInBoundsConstantOffsets(Value *&V) {
if (!DL || !V->getType()->isPointerTy()) if (!V->getType()->isPointerTy())
return nullptr; return nullptr;
unsigned IntPtrWidth = DL->getPointerSizeInBits(); const DataLayout &DL = F.getParent()->getDataLayout();
unsigned IntPtrWidth = DL.getPointerSizeInBits();
APInt Offset = APInt::getNullValue(IntPtrWidth); APInt Offset = APInt::getNullValue(IntPtrWidth);
// Even though we don't look through PHI nodes, we could be called on an // Even though we don't look through PHI nodes, we could be called on an
Context not available.
assert(V->getType()->isPointerTy() && "Unexpected operand type!"); assert(V->getType()->isPointerTy() && "Unexpected operand type!");
} while (Visited.insert(V).second); } while (Visited.insert(V).second);
Type *IntPtrTy = DL->getIntPtrType(V->getContext()); Type *IntPtrTy = DL.getIntPtrType(V->getContext());
return cast<ConstantInt>(ConstantInt::get(IntPtrTy, Offset)); return cast<ConstantInt>(ConstantInt::get(IntPtrTy, Offset));
} }
Context not available.
assert(NumVectorInstructions == 0); assert(NumVectorInstructions == 0);
FiftyPercentVectorBonus = Threshold; FiftyPercentVectorBonus = Threshold;
TenPercentVectorBonus = Threshold / 2; TenPercentVectorBonus = Threshold / 2;
const DataLayout &DL = F.getParent()->getDataLayout();
// Give out bonuses per argument, as the instructions setting them up will // Give out bonuses per argument, as the instructions setting them up will
// be gone after inlining. // be gone after inlining.
for (unsigned I = 0, E = CS.arg_size(); I != E; ++I) { for (unsigned I = 0, E = CS.arg_size(); I != E; ++I) {
if (DL && CS.isByValArgument(I)) { if (CS.isByValArgument(I)) {
// We approximate the number of loads and stores needed by dividing the // We approximate the number of loads and stores needed by dividing the
// size of the byval type by the target's pointer size. // size of the byval type by the target's pointer size.
PointerType *PTy = cast<PointerType>(CS.getArgument(I)->getType()); PointerType *PTy = cast<PointerType>(CS.getArgument(I)->getType());
unsigned TypeSize = DL->getTypeSizeInBits(PTy->getElementType()); unsigned TypeSize = DL.getTypeSizeInBits(PTy->getElementType());
unsigned PointerSize = DL->getPointerSizeInBits(); unsigned PointerSize = DL.getPointerSizeInBits();
// Ceiling division. // Ceiling division.
unsigned NumStores = (TypeSize + PointerSize - 1) / PointerSize; unsigned NumStores = (TypeSize + PointerSize - 1) / PointerSize;
Context not available.
DEBUG(llvm::dbgs() << " Analyzing call of " << Callee->getName() DEBUG(llvm::dbgs() << " Analyzing call of " << Callee->getName()
<< "...\n"); << "...\n");
CallAnalyzer CA(&Callee->getParent()->getDataLayout(), TTIWP->getTTI(*Callee), CallAnalyzer CA(TTIWP->getTTI(*Callee), ACT, *Callee, Threshold);
ACT, *Callee, Threshold);
bool ShouldInline = CA.analyzeCall(CS); bool ShouldInline = CA.analyzeCall(CS);
DEBUG(CA.dump()); DEBUG(CA.dump());
Context not available.

lib/Analysis/IVUsers.cpp

Context not available.
/// return true. Otherwise, return false. /// return true. Otherwise, return false.
bool IVUsers::AddUsersImpl(Instruction *I, bool IVUsers::AddUsersImpl(Instruction *I,
SmallPtrSetImpl<Loop*> &SimpleLoopNests) { SmallPtrSetImpl<Loop*> &SimpleLoopNests) {
const DataLayout &DL = I->getModule()->getDataLayout();
// Add this IV user to the Processed set before returning false to ensure that // Add this IV user to the Processed set before returning false to ensure that
// all IV users are members of the set. See IVUsers::isIVUserOrOperand. // all IV users are members of the set. See IVUsers::isIVUserOrOperand.
if (!Processed.insert(I).second) if (!Processed.insert(I).second)
Context not available.
// IVUsers is used by LSR which assumes that all SCEV expressions are safe to // IVUsers is used by LSR which assumes that all SCEV expressions are safe to
// pass to SCEVExpander. Expressions are not safe to expand if they represent // pass to SCEVExpander. Expressions are not safe to expand if they represent
// operations that are not safe to speculate, namely integer division. // operations that are not safe to speculate, namely integer division.
if (!isa<PHINode>(I) && !isSafeToSpeculativelyExecute(I, DL)) if (!isa<PHINode>(I) && !isSafeToSpeculativelyExecute(I))
return false; return false;
// LSR is not APInt clean, do not touch integers bigger than 64-bits. // LSR is not APInt clean, do not touch integers bigger than 64-bits.
// Also avoid creating IVs of non-native types. For example, we don't want a // Also avoid creating IVs of non-native types. For example, we don't want a
// 64-bit IV in 32-bit code just because the loop has one 64-bit cast. // 64-bit IV in 32-bit code just because the loop has one 64-bit cast.
uint64_t Width = SE->getTypeSizeInBits(I->getType()); uint64_t Width = SE->getTypeSizeInBits(I->getType());
if (Width > 64 || (DL && !DL->isLegalInteger(Width))) if (Width > 64 || !DL.isLegalInteger(Width))
return false; return false;
// Get the symbolic expression for this instruction. // Get the symbolic expression for this instruction.
Context not available.
LI = &getAnalysis<LoopInfoWrapperPass>().getLoopInfo(); LI = &getAnalysis<LoopInfoWrapperPass>().getLoopInfo();
DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree(); DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
SE = &getAnalysis<ScalarEvolution>(); SE = &getAnalysis<ScalarEvolution>();
DL = &L->getHeader()->getModule()->getDataLayout();
// Find all uses of induction variables in this loop, and categorize // Find all uses of induction variables in this loop, and categorize
// them by stride. Start by finding all of the PHI nodes in the header for // them by stride. Start by finding all of the PHI nodes in the header for
Context not available.

lib/Analysis/InstructionSimplify.cpp

Context not available.
namespace { namespace {
struct Query { struct Query {
const DataLayout *DL; const DataLayout &DL;
const TargetLibraryInfo *TLI; const TargetLibraryInfo *TLI;
const DominatorTree *DT; const DominatorTree *DT;
AssumptionCache *AC; AssumptionCache *AC;
const Instruction *CxtI; const Instruction *CxtI;
Query(const DataLayout *DL, const TargetLibraryInfo *tli, Query(const DataLayout &DL, const TargetLibraryInfo *tli,
const DominatorTree *dt, AssumptionCache *ac = nullptr, const DominatorTree *dt, AssumptionCache *ac = nullptr,
const Instruction *cxti = nullptr) const Instruction *cxti = nullptr)
: DL(DL), TLI(tli), DT(dt), AC(ac), CxtI(cxti) {} : DL(DL), TLI(tli), DT(dt), AC(ac), CxtI(cxti) {}
Context not available.
} }
Value *llvm::SimplifyAddInst(Value *Op0, Value *Op1, bool isNSW, bool isNUW, Value *llvm::SimplifyAddInst(Value *Op0, Value *Op1, bool isNSW, bool isNUW,
const DataLayout *DL, const TargetLibraryInfo *TLI, const DataLayout &DL, const TargetLibraryInfo *TLI,
const DominatorTree *DT, AssumptionCache *AC, const DominatorTree *DT, AssumptionCache *AC,
const Instruction *CxtI) { const Instruction *CxtI) {
return ::SimplifyAddInst(Op0, Op1, isNSW, isNUW, Query(DL, TLI, DT, AC, CxtI), return ::SimplifyAddInst(Op0, Op1, isNSW, isNUW, Query(DL, TLI, DT, AC, CxtI),
Context not available.
/// This is very similar to GetPointerBaseWithConstantOffset except it doesn't /// This is very similar to GetPointerBaseWithConstantOffset except it doesn't
/// follow non-inbounds geps. This allows it to remain usable for icmp ult/etc. /// follow non-inbounds geps. This allows it to remain usable for icmp ult/etc.
/// folding. /// folding.
static Constant *stripAndComputeConstantOffsets(const DataLayout *DL, static Constant *stripAndComputeConstantOffsets(const DataLayout &DL, Value *&V,
Value *&V,
bool AllowNonInbounds = false) { bool AllowNonInbounds = false) {
assert(V->getType()->getScalarType()->isPointerTy()); assert(V->getType()->getScalarType()->isPointerTy());
// Without DataLayout, just be conservative for now. Theoretically, more could Type *IntPtrTy = DL.getIntPtrType(V->getType())->getScalarType();
// be done in this case.
if (!DL)
return ConstantInt::get(IntegerType::get(V->getContext(), 64), 0);
Type *IntPtrTy = DL->getIntPtrType(V->getType())->getScalarType();
APInt Offset = APInt::getNullValue(IntPtrTy->getIntegerBitWidth()); APInt Offset = APInt::getNullValue(IntPtrTy->getIntegerBitWidth());
// Even though we don't look through PHI nodes, we could be called on an // Even though we don't look through PHI nodes, we could be called on an
Context not available.
do { do {
if (GEPOperator *GEP = dyn_cast<GEPOperator>(V)) { if (GEPOperator *GEP = dyn_cast<GEPOperator>(V)) {
if ((!AllowNonInbounds && !GEP->isInBounds()) || if ((!AllowNonInbounds && !GEP->isInBounds()) ||
!GEP->accumulateConstantOffset(*DL, Offset)) !GEP->accumulateConstantOffset(DL, Offset))
break; break;
V = GEP->getPointerOperand(); V = GEP->getPointerOperand();
} else if (Operator::getOpcode(V) == Instruction::BitCast) { } else if (Operator::getOpcode(V) == Instruction::BitCast) {
Context not available.
/// \brief Compute the constant difference between two pointer values. /// \brief Compute the constant difference between two pointer values.
/// If the difference is not a constant, returns zero. /// If the difference is not a constant, returns zero.
static Constant *computePointerDifference(const DataLayout *DL, static Constant *computePointerDifference(const DataLayout &DL, Value *LHS,
Value *LHS, Value *RHS) { Value *RHS) {
Constant *LHSOffset = stripAndComputeConstantOffsets(DL, LHS); Constant *LHSOffset = stripAndComputeConstantOffsets(DL, LHS);
Constant *RHSOffset = stripAndComputeConstantOffsets(DL, RHS); Constant *RHSOffset = stripAndComputeConstantOffsets(DL, RHS);
Context not available.
} }
Value *llvm::SimplifySubInst(Value *Op0, Value *Op1, bool isNSW, bool isNUW, Value *llvm::SimplifySubInst(Value *Op0, Value *Op1, bool isNSW, bool isNUW,
const DataLayout *DL, const TargetLibraryInfo *TLI, const DataLayout &DL, const TargetLibraryInfo *TLI,
const DominatorTree *DT, AssumptionCache *AC, const DominatorTree *DT, AssumptionCache *AC,
const Instruction *CxtI) { const Instruction *CxtI) {
return ::SimplifySubInst(Op0, Op1, isNSW, isNUW, Query(DL, TLI, DT, AC, CxtI), return ::SimplifySubInst(Op0, Op1, isNSW, isNUW, Query(DL, TLI, DT, AC, CxtI),
Context not available.
} }
Value *llvm::SimplifyFAddInst(Value *Op0, Value *Op1, FastMathFlags FMF, Value *llvm::SimplifyFAddInst(Value *Op0, Value *Op1, FastMathFlags FMF,
const DataLayout *DL, const DataLayout &DL,
const TargetLibraryInfo *TLI, const TargetLibraryInfo *TLI,
const DominatorTree *DT, AssumptionCache *AC, const DominatorTree *DT, AssumptionCache *AC,
const Instruction *CxtI) { const Instruction *CxtI) {
Context not available.
} }
Value *llvm::SimplifyFSubInst(Value *Op0, Value *Op1, FastMathFlags FMF, Value *llvm::SimplifyFSubInst(Value *Op0, Value *Op1, FastMathFlags FMF,
const DataLayout *DL, const DataLayout &DL,
const TargetLibraryInfo *TLI, const TargetLibraryInfo *TLI,
const DominatorTree *DT, AssumptionCache *AC, const DominatorTree *DT, AssumptionCache *AC,
const Instruction *CxtI) { const Instruction *CxtI) {
Context not available.
} }
Value *llvm::SimplifyFMulInst(Value *Op0, Value *Op1, FastMathFlags FMF, Value *llvm::SimplifyFMulInst(Value *Op0, Value *Op1, FastMathFlags FMF,
const DataLayout *DL, const DataLayout &DL,
const TargetLibraryInfo *TLI, const TargetLibraryInfo *TLI,
const DominatorTree *DT, AssumptionCache *AC, const DominatorTree *DT, AssumptionCache *AC,
const Instruction *CxtI) { const Instruction *CxtI) {
Context not available.
RecursionLimit); RecursionLimit);
} }
Value *llvm::SimplifyMulInst(Value *Op0, Value *Op1, const DataLayout *DL, Value *llvm::SimplifyMulInst(Value *Op0, Value *Op1, const DataLayout &DL,
const TargetLibraryInfo *TLI, const TargetLibraryInfo *TLI,
const DominatorTree *DT, AssumptionCache *AC, const DominatorTree *DT, AssumptionCache *AC,
const Instruction *CxtI) { const Instruction *CxtI) {
Context not available.
return nullptr; return nullptr;
} }
Value *llvm::SimplifySDivInst(Value *Op0, Value *Op1, const DataLayout *DL, Value *llvm::SimplifySDivInst(Value *Op0, Value *Op1, const DataLayout &DL,
const TargetLibraryInfo *TLI, const TargetLibraryInfo *TLI,
const DominatorTree *DT, AssumptionCache *AC, const DominatorTree *DT, AssumptionCache *AC,
const Instruction *CxtI) { const Instruction *CxtI) {
Context not available.
return nullptr; return nullptr;
} }
Value *llvm::SimplifyUDivInst(Value *Op0, Value *Op1, const DataLayout *DL, Value *llvm::SimplifyUDivInst(Value *Op0, Value *Op1, const DataLayout &DL,
const TargetLibraryInfo *TLI, const TargetLibraryInfo *TLI,
const DominatorTree *DT, AssumptionCache *AC, const DominatorTree *DT, AssumptionCache *AC,
const Instruction *CxtI) { const Instruction *CxtI) {
Context not available.
} }
Value *llvm::SimplifyFDivInst(Value *Op0, Value *Op1, FastMathFlags FMF, Value *llvm::SimplifyFDivInst(Value *Op0, Value *Op1, FastMathFlags FMF,
const DataLayout *DL, const DataLayout &DL,
const TargetLibraryInfo *TLI, const TargetLibraryInfo *TLI,
const DominatorTree *DT, AssumptionCache *AC, const DominatorTree *DT, AssumptionCache *AC,
const Instruction *CxtI) { const Instruction *CxtI) {
Context not available.
return nullptr; return nullptr;
} }
Value *llvm::SimplifySRemInst(Value *Op0, Value *Op1, const DataLayout *DL, Value *llvm::SimplifySRemInst(Value *Op0, Value *Op1, const DataLayout &DL,
const TargetLibraryInfo *TLI, const TargetLibraryInfo *TLI,
const DominatorTree *DT, AssumptionCache *AC, const DominatorTree *DT, AssumptionCache *AC,
const Instruction *CxtI) { const Instruction *CxtI) {
Context not available.
return nullptr; return nullptr;
} }
Value *llvm::SimplifyURemInst(Value *Op0, Value *Op1, const DataLayout *DL, Value *llvm::SimplifyURemInst(Value *Op0, Value *Op1, const DataLayout &DL,
const TargetLibraryInfo *TLI, const TargetLibraryInfo *TLI,
const DominatorTree *DT, AssumptionCache *AC, const DominatorTree *DT, AssumptionCache *AC,
const Instruction *CxtI) { const Instruction *CxtI) {
Context not available.
} }
Value *llvm::SimplifyFRemInst(Value *Op0, Value *Op1, FastMathFlags FMF, Value *llvm::SimplifyFRemInst(Value *Op0, Value *Op1, FastMathFlags FMF,
const DataLayout *DL, const DataLayout &DL,
const TargetLibraryInfo *TLI, const TargetLibraryInfo *TLI,
const DominatorTree *DT, AssumptionCache *AC, const DominatorTree *DT, AssumptionCache *AC,
const Instruction *CxtI) { const Instruction *CxtI) {
Context not available.
} }
Value *llvm::SimplifyShlInst(Value *Op0, Value *Op1, bool isNSW, bool isNUW, Value *llvm::SimplifyShlInst(Value *Op0, Value *Op1, bool isNSW, bool isNUW,
const DataLayout *DL, const TargetLibraryInfo *TLI, const DataLayout &DL, const TargetLibraryInfo *TLI,
const DominatorTree *DT, AssumptionCache *AC, const DominatorTree *DT, AssumptionCache *AC,
const Instruction *CxtI) { const Instruction *CxtI) {
return ::SimplifyShlInst(Op0, Op1, isNSW, isNUW, Query(DL, TLI, DT, AC, CxtI), return ::SimplifyShlInst(Op0, Op1, isNSW, isNUW, Query(DL, TLI, DT, AC, CxtI),
Context not available.
} }
Value *llvm::SimplifyLShrInst(Value *Op0, Value *Op1, bool isExact, Value *llvm::SimplifyLShrInst(Value *Op0, Value *Op1, bool isExact,
const DataLayout *DL, const DataLayout &DL,
const TargetLibraryInfo *TLI, const TargetLibraryInfo *TLI,
const DominatorTree *DT, AssumptionCache *AC, const DominatorTree *DT, AssumptionCache *AC,
const Instruction *CxtI) { const Instruction *CxtI) {
Context not available.
} }
Value *llvm::SimplifyAShrInst(Value *Op0, Value *Op1, bool isExact, Value *llvm::SimplifyAShrInst(Value *Op0, Value *Op1, bool isExact,
const DataLayout *DL, const DataLayout &DL,
const TargetLibraryInfo *TLI, const TargetLibraryInfo *TLI,
const DominatorTree *DT, AssumptionCache *AC, const DominatorTree *DT, AssumptionCache *AC,
const Instruction *CxtI) { const Instruction *CxtI) {
Context not available.
// A & (-A) = A if A is a power of two or zero. // A & (-A) = A if A is a power of two or zero.
if (match(Op0, m_Neg(m_Specific(Op1))) || if (match(Op0, m_Neg(m_Specific(Op1))) ||
match(Op1, m_Neg(m_Specific(Op0)))) { match(Op1, m_Neg(m_Specific(Op0)))) {
if (isKnownToBeAPowerOfTwo(Op0, /*OrZero*/ true, 0, Q.AC, Q.CxtI, Q.DT)) if (isKnownToBeAPowerOfTwo(Op0, Q.DL, /*OrZero*/ true, 0, Q.AC, Q.CxtI,
Q.DT))
return Op0; return Op0;
if (isKnownToBeAPowerOfTwo(Op1, /*OrZero*/ true, 0, Q.AC, Q.CxtI, Q.DT)) if (isKnownToBeAPowerOfTwo(Op1, Q.DL, /*OrZero*/ true, 0, Q.AC, Q.CxtI,
Q.DT))
return Op1; return Op1;
} }
Context not available.
return nullptr; return nullptr;
} }
Value *llvm::SimplifyAndInst(Value *Op0, Value *Op1, const DataLayout *DL, Value *llvm::SimplifyAndInst(Value *Op0, Value *Op1, const DataLayout &DL,
const TargetLibraryInfo *TLI, const TargetLibraryInfo *TLI,
const DominatorTree *DT, AssumptionCache *AC, const DominatorTree *DT, AssumptionCache *AC,
const Instruction *CxtI) { const Instruction *CxtI) {
Context not available.
return nullptr; return nullptr;
} }
Value *llvm::SimplifyOrInst(Value *Op0, Value *Op1, const DataLayout *DL, Value *llvm::SimplifyOrInst(Value *Op0, Value *Op1, const DataLayout &DL,
const TargetLibraryInfo *TLI, const TargetLibraryInfo *TLI,
const DominatorTree *DT, AssumptionCache *AC, const DominatorTree *DT, AssumptionCache *AC,
const Instruction *CxtI) { const Instruction *CxtI) {
Context not available.
return nullptr; return nullptr;
} }
Value *llvm::SimplifyXorInst(Value *Op0, Value *Op1, const DataLayout *DL, Value *llvm::SimplifyXorInst(Value *Op0, Value *Op1, const DataLayout &DL,
const TargetLibraryInfo *TLI, const TargetLibraryInfo *TLI,
const DominatorTree *DT, AssumptionCache *AC, const DominatorTree *DT, AssumptionCache *AC,
const Instruction *CxtI) { const Instruction *CxtI) {
Context not available.
// If the C and C++ standards are ever made sufficiently restrictive in this // If the C and C++ standards are ever made sufficiently restrictive in this
// area, it may be possible to update LLVM's semantics accordingly and reinstate // area, it may be possible to update LLVM's semantics accordingly and reinstate
// this optimization. // this optimization.
static Constant *computePointerICmp(const DataLayout *DL, static Constant *computePointerICmp(const DataLayout &DL,
const TargetLibraryInfo *TLI, const TargetLibraryInfo *TLI,
CmpInst::Predicate Pred, CmpInst::Predicate Pred, Value *LHS,
Value *LHS, Value *RHS) { Value *RHS) {
// First, skip past any trivial no-ops. // First, skip past any trivial no-ops.
LHS = LHS->stripPointerCasts(); LHS = LHS->stripPointerCasts();
RHS = RHS->stripPointerCasts(); RHS = RHS->stripPointerCasts();
Context not available.
// Turn icmp (ptrtoint x), (ptrtoint/constant) into a compare of the input // Turn icmp (ptrtoint x), (ptrtoint/constant) into a compare of the input
// if the integer type is the same size as the pointer type. // if the integer type is the same size as the pointer type.
if (MaxRecurse && Q.DL && isa<PtrToIntInst>(LI) && if (MaxRecurse && isa<PtrToIntInst>(LI) &&
Q.DL->getTypeSizeInBits(SrcTy) == DstTy->getPrimitiveSizeInBits()) { Q.DL.getTypeSizeInBits(SrcTy) == DstTy->getPrimitiveSizeInBits()) {
if (Constant *RHSC = dyn_cast<Constant>(RHS)) { if (Constant *RHSC = dyn_cast<Constant>(RHS)) {
// Transfer the cast to the constant. // Transfer the cast to the constant.
if (Value *V = SimplifyICmpInst(Pred, SrcOp, if (Value *V = SimplifyICmpInst(Pred, SrcOp,
Context not available.
} }
Value *llvm::SimplifyICmpInst(unsigned Predicate, Value *LHS, Value *RHS, Value *llvm::SimplifyICmpInst(unsigned Predicate, Value *LHS, Value *RHS,
const DataLayout *DL, const DataLayout &DL,
const TargetLibraryInfo *TLI, const TargetLibraryInfo *TLI,
const DominatorTree *DT, AssumptionCache *AC, const DominatorTree *DT, AssumptionCache *AC,
Instruction *CxtI) { Instruction *CxtI) {
Context not available.
} }
Value *llvm::SimplifyFCmpInst(unsigned Predicate, Value *LHS, Value *RHS, Value *llvm::SimplifyFCmpInst(unsigned Predicate, Value *LHS, Value *RHS,
const DataLayout *DL, const DataLayout &DL,
const TargetLibraryInfo *TLI, const TargetLibraryInfo *TLI,
const DominatorTree *DT, AssumptionCache *AC, const DominatorTree *DT, AssumptionCache *AC,
const Instruction *CxtI) { const Instruction *CxtI) {
Context not available.
} }
Value *llvm::SimplifySelectInst(Value *Cond, Value *TrueVal, Value *FalseVal, Value *llvm::SimplifySelectInst(Value *Cond, Value *TrueVal, Value *FalseVal,
const DataLayout *DL, const DataLayout &DL,
const TargetLibraryInfo *TLI, const TargetLibraryInfo *TLI,
const DominatorTree *DT, AssumptionCache *AC, const DominatorTree *DT, AssumptionCache *AC,
const Instruction *CxtI) { const Instruction *CxtI) {
Context not available.
return Ops[0]; return Ops[0];
Type *Ty = PtrTy->getElementType(); Type *Ty = PtrTy->getElementType();
if (Q.DL && Ty->isSized()) { if (Ty->isSized()) {
Value *P; Value *P;
uint64_t C; uint64_t C;
uint64_t TyAllocSize = Q.DL->getTypeAllocSize(Ty); uint64_t TyAllocSize = Q.DL.getTypeAllocSize(Ty);
// getelementptr P, N -> P if P points to a type of zero size. // getelementptr P, N -> P if P points to a type of zero size.
if (TyAllocSize == 0) if (TyAllocSize == 0)
return Ops[0]; return Ops[0];
Context not available.
// The following transforms are only safe if the ptrtoint cast // The following transforms are only safe if the ptrtoint cast
// doesn't truncate the pointers. // doesn't truncate the pointers.
if (Ops[1]->getType()->getScalarSizeInBits() == if (Ops[1]->getType()->getScalarSizeInBits() ==
Q.DL->getPointerSizeInBits(AS)) { Q.DL.getPointerSizeInBits(AS)) {
auto PtrToIntOrZero = [GEPTy](Value *P) -> Value * { auto PtrToIntOrZero = [GEPTy](Value *P) -> Value * {
if (match(P, m_Zero())) if (match(P, m_Zero()))
return Constant::getNullValue(GEPTy); return Constant::getNullValue(GEPTy);
Context not available.
return ConstantExpr::getGetElementPtr(cast<Constant>(Ops[0]), Ops.slice(1)); return ConstantExpr::getGetElementPtr(cast<Constant>(Ops[0]), Ops.slice(1));
} }
Value *llvm::SimplifyGEPInst(ArrayRef<Value *> Ops, const DataLayout *DL, Value *llvm::SimplifyGEPInst(ArrayRef<Value *> Ops, const DataLayout &DL,
const TargetLibraryInfo *TLI, const TargetLibraryInfo *TLI,
const DominatorTree *DT, AssumptionCache *AC, const DominatorTree *DT, AssumptionCache *AC,
const Instruction *CxtI) { const Instruction *CxtI) {
Context not available.
} }
Value *llvm::SimplifyInsertValueInst( Value *llvm::SimplifyInsertValueInst(
Value *Agg, Value *Val, ArrayRef<unsigned> Idxs, const DataLayout *DL, Value *Agg, Value *Val, ArrayRef<unsigned> Idxs, const DataLayout &DL,
const TargetLibraryInfo *TLI, const DominatorTree *DT, AssumptionCache *AC, const TargetLibraryInfo *TLI, const DominatorTree *DT, AssumptionCache *AC,
const Instruction *CxtI) { const Instruction *CxtI) {
return ::SimplifyInsertValueInst(Agg, Val, Idxs, Query(DL, TLI, DT, AC, CxtI), return ::SimplifyInsertValueInst(Agg, Val, Idxs, Query(DL, TLI, DT, AC, CxtI),
Context not available.
return nullptr; return nullptr;
} }
Value *llvm::SimplifyTruncInst(Value *Op, Type *Ty, const DataLayout *DL, Value *llvm::SimplifyTruncInst(Value *Op, Type *Ty, const DataLayout &DL,
const TargetLibraryInfo *TLI, const TargetLibraryInfo *TLI,
const DominatorTree *DT, AssumptionCache *AC, const DominatorTree *DT, AssumptionCache *AC,
const Instruction *CxtI) { const Instruction *CxtI) {
Context not available.
} }
Value *llvm::SimplifyBinOp(unsigned Opcode, Value *LHS, Value *RHS, Value *llvm::SimplifyBinOp(unsigned Opcode, Value *LHS, Value *RHS,
const DataLayout *DL, const TargetLibraryInfo *TLI, const DataLayout &DL, const TargetLibraryInfo *TLI,
const DominatorTree *DT, AssumptionCache *AC, const DominatorTree *DT, AssumptionCache *AC,
const Instruction *CxtI) { const Instruction *CxtI) {
return ::SimplifyBinOp(Opcode, LHS, RHS, Query(DL, TLI, DT, AC, CxtI), return ::SimplifyBinOp(Opcode, LHS, RHS, Query(DL, TLI, DT, AC, CxtI),
Context not available.
} }
Value *llvm::SimplifyFPBinOp(unsigned Opcode, Value *LHS, Value *RHS, Value *llvm::SimplifyFPBinOp(unsigned Opcode, Value *LHS, Value *RHS,
const FastMathFlags &FMF, const DataLayout *DL, const FastMathFlags &FMF, const DataLayout &DL,
const TargetLibraryInfo *TLI, const TargetLibraryInfo *TLI,
const DominatorTree *DT, AssumptionCache *AC, const DominatorTree *DT, AssumptionCache *AC,
const Instruction *CxtI) { const Instruction *CxtI) {
Context not available.
} }
Value *llvm::SimplifyCmpInst(unsigned Predicate, Value *LHS, Value *RHS, Value *llvm::SimplifyCmpInst(unsigned Predicate, Value *LHS, Value *RHS,
const DataLayout *DL, const TargetLibraryInfo *TLI, const DataLayout &DL, const TargetLibraryInfo *TLI,
const DominatorTree *DT, AssumptionCache *AC, const DominatorTree *DT, AssumptionCache *AC,
const Instruction *CxtI) { const Instruction *CxtI) {
return ::SimplifyCmpInst(Predicate, LHS, RHS, Query(DL, TLI, DT, AC, CxtI), return ::SimplifyCmpInst(Predicate, LHS, RHS, Query(DL, TLI, DT, AC, CxtI),
Context not available.
} }
Value *llvm::SimplifyCall(Value *V, User::op_iterator ArgBegin, Value *llvm::SimplifyCall(Value *V, User::op_iterator ArgBegin,
User::op_iterator ArgEnd, const DataLayout *DL, User::op_iterator ArgEnd, const DataLayout &DL,
const TargetLibraryInfo *TLI, const DominatorTree *DT, const TargetLibraryInfo *TLI, const DominatorTree *DT,
AssumptionCache *AC, const Instruction *CxtI) { AssumptionCache *AC, const Instruction *CxtI) {
return ::SimplifyCall(V, ArgBegin, ArgEnd, Query(DL, TLI, DT, AC, CxtI), return ::SimplifyCall(V, ArgBegin, ArgEnd, Query(DL, TLI, DT, AC, CxtI),
Context not available.
} }
Value *llvm::SimplifyCall(Value *V, ArrayRef<Value *> Args, Value *llvm::SimplifyCall(Value *V, ArrayRef<Value *> Args,
const DataLayout *DL, const TargetLibraryInfo *TLI, const DataLayout &DL, const TargetLibraryInfo *TLI,
const DominatorTree *DT, AssumptionCache *AC, const DominatorTree *DT, AssumptionCache *AC,
const Instruction *CxtI) { const Instruction *CxtI) {
return ::SimplifyCall(V, Args.begin(), Args.end(), return ::SimplifyCall(V, Args.begin(), Args.end(),
Context not available.
/// SimplifyInstruction - See if we can compute a simplified version of this /// SimplifyInstruction - See if we can compute a simplified version of this
/// instruction. If not, this returns null. /// instruction. If not, this returns null.
Value *llvm::SimplifyInstruction(Instruction *I, const DataLayout *DL, Value *llvm::SimplifyInstruction(Instruction *I, const DataLayout &DL,
const TargetLibraryInfo *TLI, const TargetLibraryInfo *TLI,
const DominatorTree *DT, AssumptionCache *AC) { const DominatorTree *DT, AssumptionCache *AC) {
Value *Result; Value *Result;
Context not available.
/// This routine returns 'true' only when *it* simplifies something. The passed /// This routine returns 'true' only when *it* simplifies something. The passed
/// in simplified value does not count toward this. /// in simplified value does not count toward this.
static bool replaceAndRecursivelySimplifyImpl(Instruction *I, Value *SimpleV, static bool replaceAndRecursivelySimplifyImpl(Instruction *I, Value *SimpleV,
const DataLayout *DL,
const TargetLibraryInfo *TLI, const TargetLibraryInfo *TLI,
const DominatorTree *DT, const DominatorTree *DT,
AssumptionCache *AC) { AssumptionCache *AC) {
bool Simplified = false; bool Simplified = false;
SmallSetVector<Instruction *, 8> Worklist; SmallSetVector<Instruction *, 8> Worklist;
const DataLayout &DL = I->getModule()->getDataLayout();
// If we have an explicit value to collapse to, do that round of the // If we have an explicit value to collapse to, do that round of the
// simplification loop by hand initially. // simplification loop by hand initially.
Context not available.
return Simplified; return Simplified;
} }
bool llvm::recursivelySimplifyInstruction(Instruction *I, const DataLayout *DL, bool llvm::recursivelySimplifyInstruction(Instruction *I,
const TargetLibraryInfo *TLI, const TargetLibraryInfo *TLI,
const DominatorTree *DT, const DominatorTree *DT,
AssumptionCache *AC) { AssumptionCache *AC) {
return replaceAndRecursivelySimplifyImpl(I, nullptr, DL, TLI, DT, AC); return replaceAndRecursivelySimplifyImpl(I, nullptr, TLI, DT, AC);
} }
bool llvm::replaceAndRecursivelySimplify(Instruction *I, Value *SimpleV, bool llvm::replaceAndRecursivelySimplify(Instruction *I, Value *SimpleV,
const DataLayout *DL,
const TargetLibraryInfo *TLI, const TargetLibraryInfo *TLI,
const DominatorTree *DT, const DominatorTree *DT,
AssumptionCache *AC) { AssumptionCache *AC) {
assert(I != SimpleV && "replaceAndRecursivelySimplify(X,X) is not valid!"); assert(I != SimpleV && "replaceAndRecursivelySimplify(X,X) is not valid!");
assert(SimpleV && "Must provide a simplified value."); assert(SimpleV && "Must provide a simplified value.");
return replaceAndRecursivelySimplifyImpl(I, SimpleV, DL, TLI, DT, AC); return replaceAndRecursivelySimplifyImpl(I, SimpleV, TLI, DT, AC);
} }
Context not available.

lib/Analysis/LazyValueInfo.cpp

Context not available.
/// Merge the specified lattice value into this one, updating this /// Merge the specified lattice value into this one, updating this
/// one and returning true if anything changed. /// one and returning true if anything changed.
bool mergeIn(const LVILatticeVal &RHS) { bool mergeIn(const LVILatticeVal &RHS, const DataLayout &DL) {
if (RHS.isUndefined() || isOverdefined()) return false; if (RHS.isUndefined() || isOverdefined()) return false;
if (RHS.isOverdefined()) return markOverdefined(); if (RHS.isOverdefined()) return markOverdefined();
Context not available.
// Unless we can prove that the two Constants are different, we must // Unless we can prove that the two Constants are different, we must
// move to overdefined. // move to overdefined.
// FIXME: use DataLayout/TargetLibraryInfo for smarter constant folding. // FIXME: use DataLayout/TargetLibraryInfo for smarter constant folding.
if (ConstantInt *Res = dyn_cast<ConstantInt>( if (ConstantInt *Res =
ConstantFoldCompareInstOperands(CmpInst::ICMP_NE, dyn_cast<ConstantInt>(ConstantFoldCompareInstOperands(
getConstant(), CmpInst::ICMP_NE, getConstant(), RHS.getNotConstant(), DL)))
RHS.getNotConstant())))
if (Res->isOne()) if (Res->isOne())
return markNotConstant(RHS.getNotConstant()); return markNotConstant(RHS.getNotConstant());
Context not available.
// Unless we can prove that the two Constants are different, we must // Unless we can prove that the two Constants are different, we must
// move to overdefined. // move to overdefined.
// FIXME: use DataLayout/TargetLibraryInfo for smarter constant folding. // FIXME: use DataLayout/TargetLibraryInfo for smarter constant folding.
if (ConstantInt *Res = dyn_cast<ConstantInt>( if (ConstantInt *Res =
ConstantFoldCompareInstOperands(CmpInst::ICMP_NE, dyn_cast<ConstantInt>(ConstantFoldCompareInstOperands(
getNotConstant(), CmpInst::ICMP_NE, getNotConstant(), RHS.getConstant(), DL)))
RHS.getConstant())))
if (Res->isOne()) if (Res->isOne())
return false; return false;
Context not available.
/// A pointer to the cache of @llvm.assume calls. /// A pointer to the cache of @llvm.assume calls.
AssumptionCache *AC; AssumptionCache *AC;
/// An optional DL pointer. /// A mandatory DataLayout
const DataLayout *DL; const DataLayout &DL; /// An optional DT pointer.
/// An optional DT pointer.
DominatorTree *DT; DominatorTree *DT;
friend struct LVIValueHandle; friend struct LVIValueHandle;
Context not available.
OverDefinedCache.clear(); OverDefinedCache.clear();
} }
LazyValueInfoCache(AssumptionCache *AC, const DataLayout *DL = nullptr, LazyValueInfoCache(AssumptionCache *AC, const DataLayout &DL,
DominatorTree *DT = nullptr) DominatorTree *DT = nullptr)
: AC(AC), DL(DL), DT(DT) {} : AC(AC), DL(DL), DT(DT) {}
}; };
Context not available.
static bool InstructionDereferencesPointer(Instruction *I, Value *Ptr) { static bool InstructionDereferencesPointer(Instruction *I, Value *Ptr) {
if (LoadInst *L = dyn_cast<LoadInst>(I)) { if (LoadInst *L = dyn_cast<LoadInst>(I)) {
return L->getPointerAddressSpace() == 0 && return L->getPointerAddressSpace() == 0 &&
GetUnderlyingObject(L->getPointerOperand()) == Ptr; GetUnderlyingObject(L->getPointerOperand(),
L->getModule()->getDataLayout()) == Ptr;
} }
if (StoreInst *S = dyn_cast<StoreInst>(I)) { if (StoreInst *S = dyn_cast<StoreInst>(I)) {
return S->getPointerAddressSpace() == 0 && return S->getPointerAddressSpace() == 0 &&
GetUnderlyingObject(S->getPointerOperand()) == Ptr; GetUnderlyingObject(S->getPointerOperand(),
S->getModule()->getDataLayout()) == Ptr;
} }
if (MemIntrinsic *MI = dyn_cast<MemIntrinsic>(I)) { if (MemIntrinsic *MI = dyn_cast<MemIntrinsic>(I)) {
if (MI->isVolatile()) return false; if (MI->isVolatile()) return false;
Context not available.
if (!Len || Len->isZero()) return false; if (!Len || Len->isZero()) return false;
if (MI->getDestAddressSpace() == 0) if (MI->getDestAddressSpace() == 0)
if (GetUnderlyingObject(MI->getRawDest()) == Ptr) if (GetUnderlyingObject(MI->getRawDest(),
MI->getModule()->getDataLayout()) == Ptr)
return true; return true;
if (MemTransferInst *MTI = dyn_cast<MemTransferInst>(MI)) if (MemTransferInst *MTI = dyn_cast<MemTransferInst>(MI))
if (MTI->getSourceAddressSpace() == 0) if (MTI->getSourceAddressSpace() == 0)
if (GetUnderlyingObject(MTI->getRawSource()) == Ptr) if (GetUnderlyingObject(MTI->getRawSource(),
MTI->getModule()->getDataLayout()) == Ptr)
return true; return true;
} }
return false; return false;
Context not available.
if (isKnownNonNull(Val)) { if (isKnownNonNull(Val)) {
NotNull = true; NotNull = true;
} else { } else {
Value *UnderlyingVal = GetUnderlyingObject(Val); const DataLayout &DL = BB->getModule()->getDataLayout();
Value *UnderlyingVal = GetUnderlyingObject(Val, DL);
// If 'GetUnderlyingObject' didn't converge, skip it. It won't converge // If 'GetUnderlyingObject' didn't converge, skip it. It won't converge
// inside InstructionDereferencesPointer either. // inside InstructionDereferencesPointer either.
if (UnderlyingVal == GetUnderlyingObject(UnderlyingVal, nullptr, 1)) { if (UnderlyingVal == GetUnderlyingObject(UnderlyingVal, DL, 1)) {
for (Instruction &I : *BB) { for (Instruction &I : *BB) {
if (InstructionDereferencesPointer(&I, UnderlyingVal)) { if (InstructionDereferencesPointer(&I, UnderlyingVal)) {
NotNull = true; NotNull = true;
Context not available.
if (EdgesMissing) if (EdgesMissing)
continue; continue;
Result.mergeIn(EdgeResult); Result.mergeIn(EdgeResult, DL);
// If we hit overdefined, exit early. The BlockVals entry is already set // If we hit overdefined, exit early. The BlockVals entry is already set
// to overdefined. // to overdefined.
Context not available.
if (EdgesMissing) if (EdgesMissing)
continue; continue;
Result.mergeIn(EdgeResult); Result.mergeIn(EdgeResult, DL);
// If we hit overdefined, exit early. The BlockVals entry is already set // If we hit overdefined, exit early. The BlockVals entry is already set
// to overdefined. // to overdefined.
Context not available.
if (!AssumeVH) if (!AssumeVH)
continue; continue;
auto *I = cast<CallInst>(AssumeVH); auto *I = cast<CallInst>(AssumeVH);
if (!isValidAssumeForContext(I, BBI, DL, DT)) if (!isValidAssumeForContext(I, BBI, DT))
continue; continue;
Value *C = I->getArgOperand(0); Value *C = I->getArgOperand(0);
Context not available.
if (BBLV.isOverdefined()) if (BBLV.isOverdefined())
BBLV = Result; BBLV = Result;
else else
BBLV.mergeIn(Result); BBLV.mergeIn(Result, DL);
} }
} }
} }
Context not available.
/// This lazily constructs the LazyValueInfoCache. /// This lazily constructs the LazyValueInfoCache.
static LazyValueInfoCache &getCache(void *&PImpl, AssumptionCache *AC, static LazyValueInfoCache &getCache(void *&PImpl, AssumptionCache *AC,
const DataLayout *DL = nullptr, const DataLayout *DL,
DominatorTree *DT = nullptr) { DominatorTree *DT = nullptr) {
if (!PImpl) if (!PImpl) {
PImpl = new LazyValueInfoCache(AC, DL, DT); assert(DL && "getCache() called with a null DataLayout");
PImpl = new LazyValueInfoCache(AC, *DL, DT);
}
return *static_cast<LazyValueInfoCache*>(PImpl); return *static_cast<LazyValueInfoCache*>(PImpl);
} }
bool LazyValueInfo::runOnFunction(Function &F) { bool LazyValueInfo::runOnFunction(Function &F) {
AC = &getAnalysis<AssumptionCacheTracker>().getAssumptionCache(F); AC = &getAnalysis<AssumptionCacheTracker>().getAssumptionCache(F);
const DataLayout &DL = F.getParent()->getDataLayout();
DominatorTreeWrapperPass *DTWP = DominatorTreeWrapperPass *DTWP =
getAnalysisIfAvailable<DominatorTreeWrapperPass>(); getAnalysisIfAvailable<DominatorTreeWrapperPass>();
DT = DTWP ? &DTWP->getDomTree() : nullptr; DT = DTWP ? &DTWP->getDomTree() : nullptr;
DL = &F.getParent()->getDataLayout();
TLI = &getAnalysis<TargetLibraryInfoWrapperPass>().getTLI(); TLI = &getAnalysis<TargetLibraryInfoWrapperPass>().getTLI();
if (PImpl) if (PImpl)
getCache(PImpl, AC, DL, DT).clear(); getCache(PImpl, AC, &DL, DT).clear();
// Fully lazy. // Fully lazy.
return false; return false;
Context not available.
void LazyValueInfo::releaseMemory() { void LazyValueInfo::releaseMemory() {
// If the cache was allocated, free it. // If the cache was allocated, free it.
if (PImpl) { if (PImpl) {
delete &getCache(PImpl, AC); delete &getCache(PImpl, AC, nullptr);
PImpl = nullptr; PImpl = nullptr;
} }
} }
Constant *LazyValueInfo::getConstant(Value *V, BasicBlock *BB, Constant *LazyValueInfo::getConstant(Value *V, BasicBlock *BB,
Instruction *CxtI) { Instruction *CxtI) {
const DataLayout &DL = BB->getModule()->getDataLayout();
LVILatticeVal Result = LVILatticeVal Result =
getCache(PImpl, AC, DL, DT).getValueInBlock(V, BB, CxtI); getCache(PImpl, AC, &DL, DT).getValueInBlock(V, BB, CxtI);
if (Result.isConstant()) if (Result.isConstant())
return Result.getConstant(); return Result.getConstant();
Context not available.
Constant *LazyValueInfo::getConstantOnEdge(Value *V, BasicBlock *FromBB, Constant *LazyValueInfo::getConstantOnEdge(Value *V, BasicBlock *FromBB,
BasicBlock *ToBB, BasicBlock *ToBB,
Instruction *CxtI) { Instruction *CxtI) {
const DataLayout &DL = FromBB->getModule()->getDataLayout();
LVILatticeVal Result = LVILatticeVal Result =
getCache(PImpl, AC, DL, DT).getValueOnEdge(V, FromBB, ToBB, CxtI); getCache(PImpl, AC, &DL, DT).getValueOnEdge(V, FromBB, ToBB, CxtI);
if (Result.isConstant()) if (Result.isConstant())
return Result.getConstant(); return Result.getConstant();
Context not available.
return nullptr; return nullptr;
} }
static LazyValueInfo::Tristate static LazyValueInfo::Tristate getPredicateResult(unsigned Pred, Constant *C,
getPredicateResult(unsigned Pred, Constant *C, LVILatticeVal &Result, LVILatticeVal &Result,
const DataLayout *DL, TargetLibraryInfo *TLI) { const DataLayout &DL,
TargetLibraryInfo *TLI) {
// If we know the value is a constant, evaluate the conditional. // If we know the value is a constant, evaluate the conditional.
Constant *Res = nullptr; Constant *Res = nullptr;
Context not available.
LazyValueInfo::getPredicateOnEdge(unsigned Pred, Value *V, Constant *C, LazyValueInfo::getPredicateOnEdge(unsigned Pred, Value *V, Constant *C,
BasicBlock *FromBB, BasicBlock *ToBB, BasicBlock *FromBB, BasicBlock *ToBB,
Instruction *CxtI) { Instruction *CxtI) {
const DataLayout &DL = FromBB->getModule()->getDataLayout();
LVILatticeVal Result = LVILatticeVal Result =
getCache(PImpl, AC, DL, DT).getValueOnEdge(V, FromBB, ToBB, CxtI); getCache(PImpl, AC, &DL, DT).getValueOnEdge(V, FromBB, ToBB, CxtI);
return getPredicateResult(Pred, C, Result, DL, TLI); return getPredicateResult(Pred, C, Result, DL, TLI);
} }
Context not available.
LazyValueInfo::Tristate LazyValueInfo::Tristate
LazyValueInfo::getPredicateAt(unsigned Pred, Value *V, Constant *C, LazyValueInfo::getPredicateAt(unsigned Pred, Value *V, Constant *C,
Instruction *CxtI) { Instruction *CxtI) {
LVILatticeVal Result = getCache(PImpl, AC, DL, DT).getValueAt(V, CxtI); const DataLayout &DL = CxtI->getModule()->getDataLayout();
LVILatticeVal Result = getCache(PImpl, AC, &DL, DT).getValueAt(V, CxtI);
return getPredicateResult(Pred, C, Result, DL, TLI); return getPredicateResult(Pred, C, Result, DL, TLI);
} }
void LazyValueInfo::threadEdge(BasicBlock *PredBB, BasicBlock *OldSucc, void LazyValueInfo::threadEdge(BasicBlock *PredBB, BasicBlock *OldSucc,
BasicBlock *NewSucc) { BasicBlock *NewSucc) {
if (PImpl) if (PImpl) {
getCache(PImpl, AC, DL, DT).threadEdge(PredBB, OldSucc, NewSucc); const DataLayout &DL = PredBB->getModule()->getDataLayout();
getCache(PImpl, AC, &DL, DT).threadEdge(PredBB, OldSucc, NewSucc);
}
} }
void LazyValueInfo::eraseBlock(BasicBlock *BB) { void LazyValueInfo::eraseBlock(BasicBlock *BB) {
if (PImpl) if (PImpl) {
getCache(PImpl, AC, DL, DT).eraseBlock(BB); const DataLayout &DL = BB->getModule()->getDataLayout();
getCache(PImpl, AC, &DL, DT).eraseBlock(BB);
}
} }
Context not available.

lib/Analysis/Lint.cpp

Context not available.
void visitInsertElementInst(InsertElementInst &I); void visitInsertElementInst(InsertElementInst &I);
void visitUnreachableInst(UnreachableInst &I); void visitUnreachableInst(UnreachableInst &I);
Value *findValue(Value *V, bool OffsetOk) const; Value *findValue(Value *V, const DataLayout &DL, bool OffsetOk) const;
Value *findValueImpl(Value *V, bool OffsetOk, Value *findValueImpl(Value *V, const DataLayout &DL, bool OffsetOk,
SmallPtrSetImpl<Value *> &Visited) const; SmallPtrSetImpl<Value *> &Visited) const;
public: public:
Context not available.
AliasAnalysis *AA; AliasAnalysis *AA;
AssumptionCache *AC; AssumptionCache *AC;
DominatorTree *DT; DominatorTree *DT;
const DataLayout *DL;
TargetLibraryInfo *TLI; TargetLibraryInfo *TLI;
std::string Messages; std::string Messages;
Context not available.
AA = &getAnalysis<AliasAnalysis>(); AA = &getAnalysis<AliasAnalysis>();
AC = &getAnalysis<AssumptionCacheTracker>().getAssumptionCache(F); AC = &getAnalysis<AssumptionCacheTracker>().getAssumptionCache(F);
DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree(); DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
DL = &F.getParent()->getDataLayout();
echristoUnsubmitted
Not Done
ReplyInline Actions

Any reason not to leave it cached instead of passing it down?

echristo: Any reason not to leave it cached instead of passing it down?
mehdi_aminiAuthorUnsubmitted
Not Done
ReplyInline Actions

In short: cannot rebind a reference and I wanted to get rid of the pointer.

It plays well with passes that initialize a separate transient object to do the processing, but not with passes that do their processing "in-place". Because passes object are not transient, they carry their state between runs, including a potential obsolete DL pointer.

Not sure if I was clear?

This was very case-by-case, and I may have get it wrong here and there (I mean wrong in the sense that a function argument could have been save by retrieving the DL differently, I don't think I broke correctness).

mehdi_amini: In short: cannot rebind a reference and I wanted to get rid of the pointer. It plays well…
TLI = &getAnalysis<TargetLibraryInfoWrapperPass>().getTLI(); TLI = &getAnalysis<TargetLibraryInfoWrapperPass>().getTLI();
visit(F); visit(F);
dbgs() << MessagesStr.str(); dbgs() << MessagesStr.str();
Context not available.
void Lint::visitCallSite(CallSite CS) { void Lint::visitCallSite(CallSite CS) {
Instruction &I = *CS.getInstruction(); Instruction &I = *CS.getInstruction();
Value *Callee = CS.getCalledValue(); Value *Callee = CS.getCalledValue();
const DataLayout &DL = CS->getModule()->getDataLayout();
visitMemoryReference(I, Callee, AliasAnalysis::UnknownSize, visitMemoryReference(I, Callee, AliasAnalysis::UnknownSize,
0, nullptr, MemRef::Callee); 0, nullptr, MemRef::Callee);
if (Function *F = dyn_cast<Function>(findValue(Callee, /*OffsetOk=*/false))) { if (Function *F = dyn_cast<Function>(findValue(Callee, DL,
/*OffsetOk=*/false))) {
Assert(CS.getCallingConv() == F->getCallingConv(), Assert(CS.getCallingConv() == F->getCallingConv(),
"Undefined behavior: Caller and callee calling convention differ", "Undefined behavior: Caller and callee calling convention differ",
&I); &I);
FunctionType *FT = F->getFunctionType(); FunctionType *FT = F->getFunctionType();
unsigned NumActualArgs = CS.arg_size(); unsigned NumActualArgs = CS.arg_size();
Context not available.
Type *Ty = Type *Ty =
cast<PointerType>(Formal->getType())->getElementType(); cast<PointerType>(Formal->getType())->getElementType();
visitMemoryReference(I, Actual, AA->getTypeStoreSize(Ty), visitMemoryReference(I, Actual, AA->getTypeStoreSize(Ty),
DL ? DL->getABITypeAlignment(Ty) : 0, DL.getABITypeAlignment(Ty), Ty,
Ty, MemRef::Read | MemRef::Write); MemRef::Read | MemRef::Write);
} }
} }
} }
Context not available.
if (CS.isCall() && cast<CallInst>(CS.getInstruction())->isTailCall()) if (CS.isCall() && cast<CallInst>(CS.getInstruction())->isTailCall())
for (CallSite::arg_iterator AI = CS.arg_begin(), AE = CS.arg_end(); for (CallSite::arg_iterator AI = CS.arg_begin(), AE = CS.arg_end();
AI != AE; ++AI) { AI != AE; ++AI) {
Value *Obj = findValue(*AI, /*OffsetOk=*/true); Value *Obj = findValue(*AI, DL, /*OffsetOk=*/true);
Assert(!isa<AllocaInst>(Obj), Assert(!isa<AllocaInst>(Obj),
"Undefined behavior: Call with \"tail\" keyword references alloca", "Undefined behavior: Call with \"tail\" keyword references "
&I); "alloca", &I);
} }
Context not available.
// overlap is not distinguished from the case where nothing is known. // overlap is not distinguished from the case where nothing is known.
uint64_t Size = 0; uint64_t Size = 0;
if (const ConstantInt *Len = if (const ConstantInt *Len =
dyn_cast<ConstantInt>(findValue(MCI->getLength(), dyn_cast<ConstantInt>(findValue(MCI->getLength(), DL,
/*OffsetOk=*/false))) /*OffsetOk=*/false)))
if (Len->getValue().isIntN(32)) if (Len->getValue().isIntN(32))
Size = Len->getValue().getZExtValue(); Size = Len->getValue().getZExtValue();
Assert(AA->alias(MCI->getSource(), Size, MCI->getDest(), Size) != Assert(AA->alias(MCI->getSource(), Size, MCI->getDest(), Size) !=
Context not available.
"Unusual: Return statement in function with noreturn attribute", &I); "Unusual: Return statement in function with noreturn attribute", &I);
if (Value *V = I.getReturnValue()) { if (Value *V = I.getReturnValue()) {
Value *Obj = findValue(V, /*OffsetOk=*/true); Value *Obj =
findValue(V, F->getParent()->getDataLayout(), /*OffsetOk=*/true);
Assert(!isa<AllocaInst>(Obj), "Unusual: Returning alloca value", &I); Assert(!isa<AllocaInst>(Obj), "Unusual: Returning alloca value", &I);
} }
} }
Context not available.
if (Size == 0) if (Size == 0)
return; return;
Value *UnderlyingObject = findValue(Ptr, /*OffsetOk=*/true); Value *UnderlyingObject =
findValue(Ptr, I.getModule()->getDataLayout(), /*OffsetOk=*/true);
Assert(!isa<ConstantPointerNull>(UnderlyingObject), Assert(!isa<ConstantPointerNull>(UnderlyingObject),
"Undefined behavior: Null pointer dereference", &I); "Undefined behavior: Null pointer dereference", &I);
Assert(!isa<UndefValue>(UnderlyingObject), Assert(!isa<UndefValue>(UnderlyingObject),
"Undefined behavior: Undef pointer dereference", &I); "Undefined behavior: Undef pointer dereference", &I);
Assert(!isa<ConstantInt>(UnderlyingObject) || Assert(!isa<ConstantInt>(UnderlyingObject) ||
!cast<ConstantInt>(UnderlyingObject)->isAllOnesValue(), !cast<ConstantInt>(UnderlyingObject)->isAllOnesValue(),
"Unusual: All-ones pointer dereference", &I); "Unusual: All-ones pointer dereference", &I);
Assert(!isa<ConstantInt>(UnderlyingObject) || Assert(!isa<ConstantInt>(UnderlyingObject) ||
!cast<ConstantInt>(UnderlyingObject)->isOne(), !cast<ConstantInt>(UnderlyingObject)->isOne(),
"Unusual: Address one pointer dereference", &I); "Unusual: Address one pointer dereference", &I);
if (Flags & MemRef::Write) { if (Flags & MemRef::Write) {
if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(UnderlyingObject)) if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(UnderlyingObject))
Context not available.
// Check for buffer overflows and misalignment. // Check for buffer overflows and misalignment.
// Only handles memory references that read/write something simple like an // Only handles memory references that read/write something simple like an
// alloca instruction or a global variable. // alloca instruction or a global variable.
auto &DL = I.getModule()->getDataLayout();
int64_t Offset = 0; int64_t Offset = 0;
if (Value *Base = GetPointerBaseWithConstantOffset(Ptr, Offset, DL)) { if (Value *Base = GetPointerBaseWithConstantOffset(Ptr, Offset, DL)) {
// OK, so the access is to a constant offset from Ptr. Check that Ptr is // OK, so the access is to a constant offset from Ptr. Check that Ptr is
Context not available.
if (AllocaInst *AI = dyn_cast<AllocaInst>(Base)) { if (AllocaInst *AI = dyn_cast<AllocaInst>(Base)) {
Type *ATy = AI->getAllocatedType(); Type *ATy = AI->getAllocatedType();
if (DL && !AI->isArrayAllocation() && ATy->isSized()) if (!AI->isArrayAllocation() && ATy->isSized())
BaseSize = DL->getTypeAllocSize(ATy); BaseSize = DL.getTypeAllocSize(ATy);
BaseAlign = AI->getAlignment(); BaseAlign = AI->getAlignment();
if (DL && BaseAlign == 0 && ATy->isSized()) if (BaseAlign == 0 && ATy->isSized())
BaseAlign = DL->getABITypeAlignment(ATy); BaseAlign = DL.getABITypeAlignment(ATy);
} else if (GlobalVariable *GV = dyn_cast<GlobalVariable>(Base)) { } else if (GlobalVariable *GV = dyn_cast<GlobalVariable>(Base)) {
// If the global may be defined differently in another compilation unit // If the global may be defined differently in another compilation unit
// then don't warn about funky memory accesses. // then don't warn about funky memory accesses.
if (GV->hasDefinitiveInitializer()) { if (GV->hasDefinitiveInitializer()) {
Type *GTy = GV->getType()->getElementType(); Type *GTy = GV->getType()->getElementType();
if (DL && GTy->isSized()) if (GTy->isSized())
BaseSize = DL->getTypeAllocSize(GTy); BaseSize = DL.getTypeAllocSize(GTy);
BaseAlign = GV->getAlignment(); BaseAlign = GV->getAlignment();
if (DL && BaseAlign == 0 && GTy->isSized()) if (BaseAlign == 0 && GTy->isSized())
BaseAlign = DL->getABITypeAlignment(GTy); BaseAlign = DL.getABITypeAlignment(GTy);
} }
} }
Context not available.
// Accesses that say that the memory is more aligned than it is are not // Accesses that say that the memory is more aligned than it is are not
// defined. // defined.
if (DL && Align == 0 && Ty && Ty->isSized()) if (Align == 0 && Ty && Ty->isSized())
Align = DL->getABITypeAlignment(Ty); Align = DL.getABITypeAlignment(Ty);
Assert(!BaseAlign || Align <= MinAlign(BaseAlign, Offset), Assert(!BaseAlign || Align <= MinAlign(BaseAlign, Offset),
"Undefined behavior: Memory reference address is misaligned", &I); "Undefined behavior: Memory reference address is misaligned", &I);
} }
} }
Context not available.
} }
void Lint::visitLShr(BinaryOperator &I) { void Lint::visitLShr(BinaryOperator &I) {
if (ConstantInt *CI = if (ConstantInt *CI = dyn_cast<ConstantInt>(
dyn_cast<ConstantInt>(findValue(I.getOperand(1), /*OffsetOk=*/false))) findValue(I.getOperand(1), I.getModule()->getDataLayout(),
/*OffsetOk=*/false)))
Assert(CI->getValue().ult(cast<IntegerType>(I.getType())->getBitWidth()), Assert(CI->getValue().ult(cast<IntegerType>(I.getType())->getBitWidth()),
"Undefined result: Shift count out of range", &I); "Undefined result: Shift count out of range", &I);
} }
void Lint::visitAShr(BinaryOperator &I) { void Lint::visitAShr(BinaryOperator &I) {
if (ConstantInt *CI = if (ConstantInt *CI = dyn_cast<ConstantInt>(findValue(
dyn_cast<ConstantInt>(findValue(I.getOperand(1), /*OffsetOk=*/false))) I.getOperand(1), I.getModule()->getDataLayout(), /*OffsetOk=*/false)))
Assert(CI->getValue().ult(cast<IntegerType>(I.getType())->getBitWidth()), Assert(CI->getValue().ult(cast<IntegerType>(I.getType())->getBitWidth()),
"Undefined result: Shift count out of range", &I); "Undefined result: Shift count out of range", &I);
} }
void Lint::visitShl(BinaryOperator &I) { void Lint::visitShl(BinaryOperator &I) {
if (ConstantInt *CI = if (ConstantInt *CI = dyn_cast<ConstantInt>(findValue(
dyn_cast<ConstantInt>(findValue(I.getOperand(1), /*OffsetOk=*/false))) I.getOperand(1), I.getModule()->getDataLayout(), /*OffsetOk=*/false)))
Assert(CI->getValue().ult(cast<IntegerType>(I.getType())->getBitWidth()), Assert(CI->getValue().ult(cast<IntegerType>(I.getType())->getBitWidth()),
"Undefined result: Shift count out of range", &I); "Undefined result: Shift count out of range", &I);
} }
static bool static bool
Context not available.
II); II);
} }
static bool isZero(Value *V, const DataLayout *DL, DominatorTree *DT, static bool isZero(Value *V, const DataLayout &DL, DominatorTree *DT,
AssumptionCache *AC) { AssumptionCache *AC) {
// Assume undef could be zero. // Assume undef could be zero.
if (isa<UndefValue>(V)) if (isa<UndefValue>(V))
Context not available.
} }
void Lint::visitSDiv(BinaryOperator &I) { void Lint::visitSDiv(BinaryOperator &I) {
Assert(!isZero(I.getOperand(1), DL, DT, AC), Assert(!isZero(I.getOperand(1), I.getModule()->getDataLayout(), DT, AC),
"Undefined behavior: Division by zero", &I); "Undefined behavior: Division by zero", &I);
} }
void Lint::visitUDiv(BinaryOperator &I) { void Lint::visitUDiv(BinaryOperator &I) {
Assert(!isZero(I.getOperand(1), DL, DT, AC), Assert(!isZero(I.getOperand(1), I.getModule()->getDataLayout(), DT, AC),
"Undefined behavior: Division by zero", &I); "Undefined behavior: Division by zero", &I);
} }
void Lint::visitSRem(BinaryOperator &I) { void Lint::visitSRem(BinaryOperator &I) {
Assert(!isZero(I.getOperand(1), DL, DT, AC), Assert(!isZero(I.getOperand(1), I.getModule()->getDataLayout(), DT, AC),
"Undefined behavior: Division by zero", &I); "Undefined behavior: Division by zero", &I);
} }
void Lint::visitURem(BinaryOperator &I) { void Lint::visitURem(BinaryOperator &I) {
Assert(!isZero(I.getOperand(1), DL, DT, AC), Assert(!isZero(I.getOperand(1), I.getModule()->getDataLayout(), DT, AC),
"Undefined behavior: Division by zero", &I); "Undefined behavior: Division by zero", &I);
} }
void Lint::visitAllocaInst(AllocaInst &I) { void Lint::visitAllocaInst(AllocaInst &I) {
Context not available.
} }
void Lint::visitExtractElementInst(ExtractElementInst &I) { void Lint::visitExtractElementInst(ExtractElementInst &I) {
if (ConstantInt *CI = if (ConstantInt *CI = dyn_cast<ConstantInt>(
dyn_cast<ConstantInt>(findValue(I.getIndexOperand(), findValue(I.getIndexOperand(), I.getModule()->getDataLayout(),
/*OffsetOk=*/false))) /*OffsetOk=*/false)))
Assert(CI->getValue().ult(I.getVectorOperandType()->getNumElements()), Assert(CI->getValue().ult(I.getVectorOperandType()->getNumElements()),
"Undefined result: extractelement index out of range", &I); "Undefined result: extractelement index out of range", &I);
} }
void Lint::visitInsertElementInst(InsertElementInst &I) { void Lint::visitInsertElementInst(InsertElementInst &I) {
if (ConstantInt *CI = if (ConstantInt *CI = dyn_cast<ConstantInt>(
dyn_cast<ConstantInt>(findValue(I.getOperand(2), findValue(I.getOperand(2), I.getModule()->getDataLayout(),
/*OffsetOk=*/false))) /*OffsetOk=*/false)))
Assert(CI->getValue().ult(I.getType()->getNumElements()), Assert(CI->getValue().ult(I.getType()->getNumElements()),
"Undefined result: insertelement index out of range", &I); "Undefined result: insertelement index out of range", &I);
} }
void Lint::visitUnreachableInst(UnreachableInst &I) { void Lint::visitUnreachableInst(UnreachableInst &I) {
Context not available.
/// Most analysis passes don't require this logic, because instcombine /// 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 /// 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. /// this Lint pass to be useful even on non-optimized IR.
Value *Lint::findValue(Value *V, bool OffsetOk) const { Value *Lint::findValue(Value *V, const DataLayout &DL, bool OffsetOk) const {
SmallPtrSet<Value *, 4> Visited; SmallPtrSet<Value *, 4> Visited;
return findValueImpl(V, OffsetOk, Visited); return findValueImpl(V, DL, OffsetOk, Visited);
} }
/// findValueImpl - Implementation helper for findValue. /// findValueImpl - Implementation helper for findValue.
Value *Lint::findValueImpl(Value *V, bool OffsetOk, Value *Lint::findValueImpl(Value *V, const DataLayout &DL, bool OffsetOk,
SmallPtrSetImpl<Value *> &Visited) const { SmallPtrSetImpl<Value *> &Visited) const {
// Detect self-referential values. // Detect self-referential values.
if (!Visited.insert(V).second) if (!Visited.insert(V).second)
Context not available.
break; break;
if (Value *U = FindAvailableLoadedValue(L->getPointerOperand(), if (Value *U = FindAvailableLoadedValue(L->getPointerOperand(),
BB, BBI, 6, AA)) BB, BBI, 6, AA))
return findValueImpl(U, OffsetOk, Visited); return findValueImpl(U, DL, OffsetOk, Visited);
if (BBI != BB->begin()) break; if (BBI != BB->begin()) break;
BB = BB->getUniquePredecessor(); BB = BB->getUniquePredecessor();
if (!BB) break; if (!BB) break;
Context not available.
} else if (PHINode *PN = dyn_cast<PHINode>(V)) { } else if (PHINode *PN = dyn_cast<PHINode>(V)) {
if (Value *W = PN->hasConstantValue()) if (Value *W = PN->hasConstantValue())
if (W != V) if (W != V)
return findValueImpl(W, OffsetOk, Visited); return findValueImpl(W, DL, OffsetOk, Visited);
} else if (CastInst *CI = dyn_cast<CastInst>(V)) { } else if (CastInst *CI = dyn_cast<CastInst>(V)) {
if (CI->isNoopCast(DL)) if (CI->isNoopCast(DL))
return findValueImpl(CI->getOperand(0), OffsetOk, Visited); return findValueImpl(CI->getOperand(0), DL, OffsetOk, Visited);
} else if (ExtractValueInst *Ex = dyn_cast<ExtractValueInst>(V)) { } else if (ExtractValueInst *Ex = dyn_cast<ExtractValueInst>(V)) {
if (Value *W = FindInsertedValue(Ex->getAggregateOperand(), if (Value *W = FindInsertedValue(Ex->getAggregateOperand(),
Ex->getIndices())) Ex->getIndices()))
if (W != V) if (W != V)
return findValueImpl(W, OffsetOk, Visited); return findValueImpl(W, DL, OffsetOk, Visited);
} else if (ConstantExpr *CE = dyn_cast<ConstantExpr>(V)) { } else if (ConstantExpr *CE = dyn_cast<ConstantExpr>(V)) {
// Same as above, but for ConstantExpr instead of Instruction. // Same as above, but for ConstantExpr instead of Instruction.
if (Instruction::isCast(CE->getOpcode())) { if (Instruction::isCast(CE->getOpcode())) {
if (CastInst::isNoopCast(Instruction::CastOps(CE->getOpcode()), if (CastInst::isNoopCast(Instruction::CastOps(CE->getOpcode()),
CE->getOperand(0)->getType(), CE->getOperand(0)->getType(), CE->getType(),
CE->getType(), DL.getIntPtrType(V->getType())))
DL ? DL->getIntPtrType(V->getType()) : return findValueImpl(CE->getOperand(0), DL, OffsetOk, Visited);
Type::getInt64Ty(V->getContext())))
return findValueImpl(CE->getOperand(0), OffsetOk, Visited);
} else if (CE->getOpcode() == Instruction::ExtractValue) { } else if (CE->getOpcode() == Instruction::ExtractValue) {
ArrayRef<unsigned> Indices = CE->getIndices(); ArrayRef<unsigned> Indices = CE->getIndices();
if (Value *W = FindInsertedValue(CE->getOperand(0), Indices)) if (Value *W = FindInsertedValue(CE->getOperand(0), Indices))
if (W != V) if (W != V)
return findValueImpl(W, OffsetOk, Visited); return findValueImpl(W, DL, OffsetOk, Visited);
} }
} }
// As a last resort, try SimplifyInstruction or constant folding. // As a last resort, try SimplifyInstruction or constant folding.
if (Instruction *Inst = dyn_cast<Instruction>(V)) { if (Instruction *Inst = dyn_cast<Instruction>(V)) {
if (Value *W = SimplifyInstruction(Inst, DL, TLI, DT, AC)) if (Value *W = SimplifyInstruction(Inst, DL, TLI, DT, AC))
return findValueImpl(W, OffsetOk, Visited); return findValueImpl(W, DL, OffsetOk, Visited);
} else if (ConstantExpr *CE = dyn_cast<ConstantExpr>(V)) { } else if (ConstantExpr *CE = dyn_cast<ConstantExpr>(V)) {
if (Value *W = ConstantFoldConstantExpression(CE, DL, TLI)) if (Value *W = ConstantFoldConstantExpression(CE, DL, TLI))
if (W != V) if (W != V)
return findValueImpl(W, OffsetOk, Visited); return findValueImpl(W, DL, OffsetOk, Visited);
} }
return V; return V;
Context not available.

lib/Analysis/Loads.cpp

Context not available.
/// This uses the pointee type to determine how many bytes need to be safe to /// This uses the pointee type to determine how many bytes need to be safe to
/// load from the pointer. /// load from the pointer.
bool llvm::isSafeToLoadUnconditionally(Value *V, Instruction *ScanFrom, bool llvm::isSafeToLoadUnconditionally(Value *V, Instruction *ScanFrom,
unsigned Align, const DataLayout *DL) { unsigned Align) {
const DataLayout &DL = ScanFrom->getModule()->getDataLayout();
int64_t ByteOffset = 0; int64_t ByteOffset = 0;
Value *Base = V; Value *Base = V;
Base = GetPointerBaseWithConstantOffset(V, ByteOffset, DL); Base = GetPointerBaseWithConstantOffset(V, ByteOffset, DL);
Context not available.
} }
PointerType *AddrTy = cast<PointerType>(V->getType()); PointerType *AddrTy = cast<PointerType>(V->getType());
uint64_t LoadSize = DL ? DL->getTypeStoreSize(AddrTy->getElementType()) : 0; uint64_t LoadSize = DL.getTypeStoreSize(AddrTy->getElementType());
// If we found a base allocated type from either an alloca or global variable, // If we found a base allocated type from either an alloca or global variable,
// try to see if we are definitively within the allocated region. We need to // try to see if we are definitively within the allocated region. We need to
// know the size of the base type and the loaded type to do anything in this // know the size of the base type and the loaded type to do anything in this
// case, so only try this when we have the DataLayout available. // case, so only try this when we have the DataLayout available.
if (BaseType && BaseType->isSized() && DL) { if (BaseType && BaseType->isSized()) {
if (BaseAlign == 0) if (BaseAlign == 0)
BaseAlign = DL->getPrefTypeAlignment(BaseType); BaseAlign = DL.getPrefTypeAlignment(BaseType);
if (Align <= BaseAlign) { if (Align <= BaseAlign) {
// Check if the load is within the bounds of the underlying object. // Check if the load is within the bounds of the underlying object.
if (ByteOffset + LoadSize <= DL->getTypeAllocSize(BaseType) && if (ByteOffset + LoadSize <= DL.getTypeAllocSize(BaseType) &&
(Align == 0 || (ByteOffset % Align) == 0)) (Align == 0 || (ByteOffset % Align) == 0))
return true; return true;
} }
Context not available.
if (AccessedPtr == V) if (AccessedPtr == V)
return true; return true;
if (!DL)
continue;
auto *AccessedTy = cast<PointerType>(AccessedPtr->getType()); auto *AccessedTy = cast<PointerType>(AccessedPtr->getType());
if (AreEquivalentAddressValues(AccessedPtr->stripPointerCasts(), V) && if (AreEquivalentAddressValues(AccessedPtr->stripPointerCasts(), V) &&
LoadSize <= DL->getTypeStoreSize(AccessedTy->getElementType())) LoadSize <= DL.getTypeStoreSize(AccessedTy->getElementType()))
return true; return true;
} }
return false; return false;
Context not available.
if (LoadInst *LI = dyn_cast<LoadInst>(Inst)) if (LoadInst *LI = dyn_cast<LoadInst>(Inst))
if (AreEquivalentAddressValues( if (AreEquivalentAddressValues(
LI->getPointerOperand()->stripPointerCasts(), StrippedPtr) && LI->getPointerOperand()->stripPointerCasts(), StrippedPtr) &&
CastInst::isBitOrNoopPointerCastable(LI->getType(), AccessTy, &DL)) { CastInst::isBitOrNoopPointerCastable(LI->getType(), AccessTy, DL)) {
if (AATags) if (AATags)
LI->getAAMetadata(*AATags); LI->getAAMetadata(*AATags);
return LI; return LI;
Context not available.
// those cases are unlikely.) // those cases are unlikely.)
if (AreEquivalentAddressValues(StorePtr, StrippedPtr) && if (AreEquivalentAddressValues(StorePtr, StrippedPtr) &&
CastInst::isBitOrNoopPointerCastable(SI->getValueOperand()->getType(), CastInst::isBitOrNoopPointerCastable(SI->getValueOperand()->getType(),
AccessTy, &DL)) { AccessTy, DL)) {
if (AATags) if (AATags)
SI->getAAMetadata(*AATags); SI->getAAMetadata(*AATags);
return SI->getOperand(0); return SI->getOperand(0);
Context not available.

lib/Analysis/LoopAccessAnalysis.cpp

Context not available.
/// \brief Set of potential dependent memory accesses. /// \brief Set of potential dependent memory accesses.
typedef EquivalenceClasses<MemAccessInfo> DepCandidates; typedef EquivalenceClasses<MemAccessInfo> DepCandidates;
AccessAnalysis(const DataLayout *Dl, AliasAnalysis *AA, DepCandidates &DA) : AccessAnalysis(const DataLayout &Dl, AliasAnalysis *AA, DepCandidates &DA)
DL(Dl), AST(*AA), DepCands(DA), IsRTCheckNeeded(false) {} : DL(Dl), AST(*AA), DepCands(DA), IsRTCheckNeeded(false) {}
/// \brief Register a load and whether it is only read from. /// \brief Register a load and whether it is only read from.
void addLoad(AliasAnalysis::Location &Loc, bool IsReadOnly) { void addLoad(AliasAnalysis::Location &Loc, bool IsReadOnly) {
Context not available.
/// Set of all accesses. /// Set of all accesses.
PtrAccessSet Accesses; PtrAccessSet Accesses;
const DataLayout &DL;
/// Set of accesses that need a further dependence check. /// Set of accesses that need a further dependence check.
MemAccessInfoSet CheckDeps; MemAccessInfoSet CheckDeps;
/// Set of pointers that are read only. /// Set of pointers that are read only.
SmallPtrSet<Value*, 16> ReadOnlyPtr; SmallPtrSet<Value*, 16> ReadOnlyPtr;
const DataLayout *DL;
/// An alias set tracker to partition the access set by underlying object and /// An alias set tracker to partition the access set by underlying object and
//intrinsic property (such as TBAA metadata). //intrinsic property (such as TBAA metadata).
AliasSetTracker AST; AliasSetTracker AST;
Context not available.
/// \brief Check the stride of the pointer and ensure that it does not wrap in /// \brief Check the stride of the pointer and ensure that it does not wrap in
/// the address space. /// the address space.
static int isStridedPtr(ScalarEvolution *SE, const DataLayout *DL, Value *Ptr, static int isStridedPtr(ScalarEvolution *SE, Value *Ptr, const Loop *Lp,
const Loop *Lp, const ValueToValueMap &StridesMap); const ValueToValueMap &StridesMap);
bool AccessAnalysis::canCheckPtrAtRT( bool AccessAnalysis::canCheckPtrAtRT(
LoopAccessInfo::RuntimePointerCheck &RtCheck, unsigned &NumComparisons, LoopAccessInfo::RuntimePointerCheck &RtCheck, unsigned &NumComparisons,
Context not available.
++NumReadPtrChecks; ++NumReadPtrChecks;
if (hasComputableBounds(SE, StridesMap, Ptr) && if (hasComputableBounds(SE, StridesMap, Ptr) &&
// When we run after a failing dependency check we have to make sure we // When we run after a failing dependency check we have to make sure
echristoUnsubmitted
Not Done
ReplyInline Actions

Formatting. :)

echristo: Formatting. :)
mehdi_aminiAuthorUnsubmitted
Not Done
ReplyInline Actions

That was clang-format, it probably gets over 80 lines without the line break. I'll rephrase the comment to save what is needed to fit in the line.

mehdi_amini: That was clang-format, it probably gets over 80 lines without the line break. I'll rephrase the…
// we
// don't have wrapping pointers. // don't have wrapping pointers.
(!ShouldCheckStride || (!ShouldCheckStride ||
isStridedPtr(SE, DL, Ptr, TheLoop, StridesMap) == 1)) { isStridedPtr(SE, Ptr, TheLoop, StridesMap) == 1)) {
// The id of the dependence set. // The id of the dependence set.
unsigned DepId; unsigned DepId;
Context not available.
typedef PointerIntPair<Value *, 1, bool> MemAccessInfo; typedef PointerIntPair<Value *, 1, bool> MemAccessInfo;
typedef SmallPtrSet<MemAccessInfo, 8> MemAccessInfoSet; typedef SmallPtrSet<MemAccessInfo, 8> MemAccessInfoSet;
MemoryDepChecker(ScalarEvolution *Se, const DataLayout *Dl, const Loop *L) MemoryDepChecker(ScalarEvolution *Se, const Loop *L)
: SE(Se), DL(Dl), InnermostLoop(L), AccessIdx(0), : SE(Se), InnermostLoop(L), AccessIdx(0),
ShouldRetryWithRuntimeCheck(false) {} ShouldRetryWithRuntimeCheck(false) {}
/// \brief Register the location (instructions are given increasing numbers) /// \brief Register the location (instructions are given increasing numbers)
Context not available.
private: private:
ScalarEvolution *SE; ScalarEvolution *SE;
const DataLayout *DL;
const Loop *InnermostLoop; const Loop *InnermostLoop;
/// \brief Maps access locations (ptr, read/write) to program order. /// \brief Maps access locations (ptr, read/write) to program order.
Context not available.
} }
/// \brief Check whether the access through \p Ptr has a constant stride. /// \brief Check whether the access through \p Ptr has a constant stride.
static int isStridedPtr(ScalarEvolution *SE, const DataLayout *DL, Value *Ptr, static int isStridedPtr(ScalarEvolution *SE, Value *Ptr, const Loop *Lp,
const Loop *Lp, const ValueToValueMap &StridesMap) { const ValueToValueMap &StridesMap) {
const Type *Ty = Ptr->getType(); const Type *Ty = Ptr->getType();
assert(Ty->isPointerTy() && "Unexpected non-ptr"); assert(Ty->isPointerTy() && "Unexpected non-ptr");
Context not available.
return 0; return 0;
} }
int64_t Size = DL->getTypeAllocSize(PtrTy->getElementType()); auto &DL = Lp->getHeader()->getModule()->getDataLayout();
int64_t Size = DL.getTypeAllocSize(PtrTy->getElementType());
const APInt &APStepVal = C->getValue()->getValue(); const APInt &APStepVal = C->getValue()->getValue();
// Huge step value - give up. // Huge step value - give up.
Context not available.
const SCEV *AScev = replaceSymbolicStrideSCEV(SE, Strides, APtr); const SCEV *AScev = replaceSymbolicStrideSCEV(SE, Strides, APtr);
const SCEV *BScev = replaceSymbolicStrideSCEV(SE, Strides, BPtr); const SCEV *BScev = replaceSymbolicStrideSCEV(SE, Strides, BPtr);
int StrideAPtr = isStridedPtr(SE, DL, APtr, InnermostLoop, Strides); int StrideAPtr = isStridedPtr(SE, APtr, InnermostLoop, Strides);
int StrideBPtr = isStridedPtr(SE, DL, BPtr, InnermostLoop, Strides); int StrideBPtr = isStridedPtr(SE, BPtr, InnermostLoop, Strides);
const SCEV *Src = AScev; const SCEV *Src = AScev;
const SCEV *Sink = BScev; const SCEV *Sink = BScev;
Context not available.
Type *ATy = APtr->getType()->getPointerElementType(); Type *ATy = APtr->getType()->getPointerElementType();
Type *BTy = BPtr->getType()->getPointerElementType(); Type *BTy = BPtr->getType()->getPointerElementType();
unsigned TypeByteSize = DL->getTypeAllocSize(ATy); auto &DL = InnermostLoop->getHeader()->getModule()->getDataLayout();
unsigned TypeByteSize = DL.getTypeAllocSize(ATy);
// Negative distances are not plausible dependencies. // Negative distances are not plausible dependencies.
const APInt &Val = C->getValue()->getValue(); const APInt &Val = C->getValue()->getValue();
Context not available.
PtrRtCheck.Need = false; PtrRtCheck.Need = false;
const bool IsAnnotatedParallel = TheLoop->isAnnotatedParallel(); const bool IsAnnotatedParallel = TheLoop->isAnnotatedParallel();
MemoryDepChecker DepChecker(SE, DL, TheLoop); MemoryDepChecker DepChecker(SE, TheLoop);
// For each block. // For each block.
for (Loop::block_iterator bb = TheLoop->block_begin(), for (Loop::block_iterator bb = TheLoop->block_begin(),
Context not available.
} }
AccessAnalysis::DepCandidates DependentAccesses; AccessAnalysis::DepCandidates DependentAccesses;
AccessAnalysis Accesses(DL, AA, DependentAccesses); AccessAnalysis Accesses(TheLoop->getHeader()->getModule()->getDataLayout(),
AA, DependentAccesses);
// Holds the analyzed pointers. We don't want to call GetUnderlyingObjects // Holds the analyzed pointers. We don't want to call GetUnderlyingObjects
// multiple times on the same object. If the ptr is accessed twice, once // multiple times on the same object. If the ptr is accessed twice, once
Context not available.
// read a few words, modify, and write a few words, and some of the // read a few words, modify, and write a few words, and some of the
// words may be written to the same address. // words may be written to the same address.
bool IsReadOnlyPtr = false; bool IsReadOnlyPtr = false;
if (Seen.insert(Ptr).second || if (Seen.insert(Ptr).second || !isStridedPtr(SE, Ptr, TheLoop, Strides)) {
!isStridedPtr(SE, DL, Ptr, TheLoop, Strides)) {
++NumReads; ++NumReads;
IsReadOnlyPtr = true; IsReadOnlyPtr = true;
} }
Context not available.
SmallVector<TrackingVH<Value> , 2> Ends; SmallVector<TrackingVH<Value> , 2> Ends;
LLVMContext &Ctx = Loc->getContext(); LLVMContext &Ctx = Loc->getContext();
SCEVExpander Exp(*SE, "induction"); SCEVExpander Exp(*SE, DL, "induction");
Instruction *FirstInst = nullptr; Instruction *FirstInst = nullptr;
for (unsigned i = 0; i < NumPointers; ++i) { for (unsigned i = 0; i < NumPointers; ++i) {
Context not available.
} }
LoopAccessInfo::LoopAccessInfo(Loop *L, ScalarEvolution *SE, LoopAccessInfo::LoopAccessInfo(Loop *L, ScalarEvolution *SE,
const DataLayout *DL, const DataLayout &DL,
const TargetLibraryInfo *TLI, AliasAnalysis *AA, const TargetLibraryInfo *TLI, AliasAnalysis *AA,
DominatorTree *DT, DominatorTree *DT,
const ValueToValueMap &Strides) const ValueToValueMap &Strides)
Context not available.
#endif #endif
if (!LAI) { if (!LAI) {
const DataLayout &DL = L->getHeader()->getModule()->getDataLayout();
LAI = llvm::make_unique<LoopAccessInfo>(L, SE, DL, TLI, AA, DT, Strides); LAI = llvm::make_unique<LoopAccessInfo>(L, SE, DL, TLI, AA, DT, Strides);
#ifndef NDEBUG #ifndef NDEBUG
LAI->NumSymbolicStrides = Strides.size(); LAI->NumSymbolicStrides = Strides.size();
Context not available.
bool LoopAccessAnalysis::runOnFunction(Function &F) { bool LoopAccessAnalysis::runOnFunction(Function &F) {
SE = &getAnalysis<ScalarEvolution>(); SE = &getAnalysis<ScalarEvolution>();
DL = &F.getParent()->getDataLayout();
auto *TLIP = getAnalysisIfAvailable<TargetLibraryInfoWrapperPass>(); auto *TLIP = getAnalysisIfAvailable<TargetLibraryInfoWrapperPass>();
TLI = TLIP ? &TLIP->getTLI() : nullptr; TLI = TLIP ? &TLIP->getTLI() : nullptr;
AA = &getAnalysis<AliasAnalysis>(); AA = &getAnalysis<AliasAnalysis>();
Context not available.

lib/Analysis/MemDerefPrinter.cpp

Context not available.
for (auto &I: inst_range(F)) { for (auto &I: inst_range(F)) {
if (LoadInst *LI = dyn_cast<LoadInst>(&I)) { if (LoadInst *LI = dyn_cast<LoadInst>(&I)) {
Value *PO = LI->getPointerOperand(); Value *PO = LI->getPointerOperand();
if (PO->isDereferenceablePointer(&DL)) if (PO->isDereferenceablePointer(DL))
Vec.push_back(PO); Vec.push_back(PO);
} }
} }
Context not available.

lib/Analysis/MemoryBuiltins.cpp

Context not available.
return isMallocLikeFn(I, TLI) ? dyn_cast<CallInst>(I) : nullptr; return isMallocLikeFn(I, TLI) ? dyn_cast<CallInst>(I) : nullptr;
} }
static Value *computeArraySize(const CallInst *CI, const DataLayout *DL, static Value *computeArraySize(const CallInst *CI, const DataLayout &DL,
const TargetLibraryInfo *TLI, const TargetLibraryInfo *TLI,
bool LookThroughSExt = false) { bool LookThroughSExt = false) {
if (!CI) if (!CI)
Context not available.
// The size of the malloc's result type must be known to determine array size. // The size of the malloc's result type must be known to determine array size.
Type *T = getMallocAllocatedType(CI, TLI); Type *T = getMallocAllocatedType(CI, TLI);
if (!T || !T->isSized() || !DL) if (!T || !T->isSized())
return nullptr; return nullptr;
unsigned ElementSize = DL->getTypeAllocSize(T); unsigned ElementSize = DL.getTypeAllocSize(T);
if (StructType *ST = dyn_cast<StructType>(T)) if (StructType *ST = dyn_cast<StructType>(T))
ElementSize = DL->getStructLayout(ST)->getSizeInBytes(); ElementSize = DL.getStructLayout(ST)->getSizeInBytes();
// If malloc call's arg can be determined to be a multiple of ElementSize, // If malloc call's arg can be determined to be a multiple of ElementSize,
// return the multiple. Otherwise, return NULL. // return the multiple. Otherwise, return NULL.
Context not available.
/// isArrayMalloc - Returns the corresponding CallInst if the instruction /// isArrayMalloc - Returns the corresponding CallInst if the instruction
/// is a call to malloc whose array size can be determined and the array size /// is a call to malloc whose array size can be determined and the array size
/// is not constant 1. Otherwise, return NULL. /// is not constant 1. Otherwise, return NULL.
const CallInst *llvm::isArrayMalloc(const Value *I, const CallInst *llvm::isArrayMalloc(const Value *I, const DataLayout &DL,
const DataLayout *DL,
const TargetLibraryInfo *TLI) { const TargetLibraryInfo *TLI) {
const CallInst *CI = extractMallocCall(I, TLI); const CallInst *CI = extractMallocCall(I, TLI);
Value *ArraySize = computeArraySize(CI, DL, TLI); Value *ArraySize = computeArraySize(CI, DL, TLI);
Context not available.
/// then return that multiple. For non-array mallocs, the multiple is /// then return that multiple. For non-array mallocs, the multiple is
/// constant 1. Otherwise, return NULL for mallocs whose array size cannot be /// constant 1. Otherwise, return NULL for mallocs whose array size cannot be
/// determined. /// determined.
Value *llvm::getMallocArraySize(CallInst *CI, const DataLayout *DL, Value *llvm::getMallocArraySize(CallInst *CI, const DataLayout &DL,
const TargetLibraryInfo *TLI, const TargetLibraryInfo *TLI,
bool LookThroughSExt) { bool LookThroughSExt) {
assert(isMallocLikeFn(CI, TLI) && "getMallocArraySize and not malloc call"); assert(isMallocLikeFn(CI, TLI) && "getMallocArraySize and not malloc call");
Context not available.
/// object size in Size if successful, and false otherwise. /// object size in Size if successful, and false otherwise.
/// If RoundToAlign is true, then Size is rounded up to the aligment of allocas, /// If RoundToAlign is true, then Size is rounded up to the aligment of allocas,
/// byval arguments, and global variables. /// byval arguments, and global variables.
bool llvm::getObjectSize(const Value *Ptr, uint64_t &Size, const DataLayout *DL, bool llvm::getObjectSize(const Value *Ptr, uint64_t &Size, const DataLayout &DL,
const TargetLibraryInfo *TLI, bool RoundToAlign) { const TargetLibraryInfo *TLI, bool RoundToAlign) {
if (!DL)
return false;
ObjectSizeOffsetVisitor Visitor(DL, TLI, Ptr->getContext(), RoundToAlign); ObjectSizeOffsetVisitor Visitor(DL, TLI, Ptr->getContext(), RoundToAlign);
SizeOffsetType Data = Visitor.compute(const_cast<Value*>(Ptr)); SizeOffsetType Data = Visitor.compute(const_cast<Value*>(Ptr));
if (!Visitor.bothKnown(Data)) if (!Visitor.bothKnown(Data))
Context not available.
return Size; return Size;
} }
ObjectSizeOffsetVisitor::ObjectSizeOffsetVisitor(const DataLayout *DL, ObjectSizeOffsetVisitor::ObjectSizeOffsetVisitor(const DataLayout &DL,
const TargetLibraryInfo *TLI, const TargetLibraryInfo *TLI,
LLVMContext &Context, LLVMContext &Context,
bool RoundToAlign) bool RoundToAlign)
: DL(DL), TLI(TLI), RoundToAlign(RoundToAlign) { : DL(DL), TLI(TLI), RoundToAlign(RoundToAlign) {
// Pointer size must be rechecked for each object visited since it could have // Pointer size must be rechecked for each object visited since it could have
// a different address space. // a different address space.
} }
SizeOffsetType ObjectSizeOffsetVisitor::compute(Value *V) { SizeOffsetType ObjectSizeOffsetVisitor::compute(Value *V) {
IntTyBits = DL->getPointerTypeSizeInBits(V->getType()); IntTyBits = DL.getPointerTypeSizeInBits(V->getType());
Zero = APInt::getNullValue(IntTyBits); Zero = APInt::getNullValue(IntTyBits);
V = V->stripPointerCasts(); V = V->stripPointerCasts();
Context not available.
if (!I.getAllocatedType()->isSized()) if (!I.getAllocatedType()->isSized())
return unknown(); return unknown();
APInt Size(IntTyBits, DL->getTypeAllocSize(I.getAllocatedType())); APInt Size(IntTyBits, DL.getTypeAllocSize(I.getAllocatedType()));
if (!I.isArrayAllocation()) if (!I.isArrayAllocation())
return std::make_pair(align(Size, I.getAlignment()), Zero); return std::make_pair(align(Size, I.getAlignment()), Zero);
Context not available.
return unknown(); return unknown();
} }
PointerType *PT = cast<PointerType>(A.getType()); PointerType *PT = cast<PointerType>(A.getType());
APInt Size(IntTyBits, DL->getTypeAllocSize(PT->getElementType())); APInt Size(IntTyBits, DL.getTypeAllocSize(PT->getElementType()));
return std::make_pair(align(Size, A.getParamAlignment()), Zero); return std::make_pair(align(Size, A.getParamAlignment()), Zero);
} }
Context not available.
SizeOffsetType ObjectSizeOffsetVisitor::visitGEPOperator(GEPOperator &GEP) { SizeOffsetType ObjectSizeOffsetVisitor::visitGEPOperator(GEPOperator &GEP) {
SizeOffsetType PtrData = compute(GEP.getPointerOperand()); SizeOffsetType PtrData = compute(GEP.getPointerOperand());
APInt Offset(IntTyBits, 0); APInt Offset(IntTyBits, 0);
if (!bothKnown(PtrData) || !GEP.accumulateConstantOffset(*DL, Offset)) if (!bothKnown(PtrData) || !GEP.accumulateConstantOffset(DL, Offset))
return unknown(); return unknown();
return std::make_pair(PtrData.first, PtrData.second + Offset); return std::make_pair(PtrData.first, PtrData.second + Offset);
Context not available.
if (!GV.hasDefinitiveInitializer()) if (!GV.hasDefinitiveInitializer())
return unknown(); return unknown();
APInt Size(IntTyBits, DL->getTypeAllocSize(GV.getType()->getElementType())); APInt Size(IntTyBits, DL.getTypeAllocSize(GV.getType()->getElementType()));
return std::make_pair(align(Size, GV.getAlignment()), Zero); return std::make_pair(align(Size, GV.getAlignment()), Zero);
} }
Context not available.
return unknown(); return unknown();
} }
ObjectSizeOffsetEvaluator::ObjectSizeOffsetEvaluator(const DataLayout *DL, ObjectSizeOffsetEvaluator::ObjectSizeOffsetEvaluator(
const TargetLibraryInfo *TLI, const DataLayout &DL, const TargetLibraryInfo *TLI, LLVMContext &Context,
LLVMContext &Context, bool RoundToAlign)
bool RoundToAlign) : DL(DL), TLI(TLI), Context(Context), Builder(Context, TargetFolder(DL)),
: DL(DL), TLI(TLI), Context(Context), Builder(Context, TargetFolder(DL)), RoundToAlign(RoundToAlign) {
RoundToAlign(RoundToAlign) {
// IntTy and Zero must be set for each compute() since the address space may // IntTy and Zero must be set for each compute() since the address space may
// be different for later objects. // be different for later objects.
} }
SizeOffsetEvalType ObjectSizeOffsetEvaluator::compute(Value *V) { SizeOffsetEvalType ObjectSizeOffsetEvaluator::compute(Value *V) {
// XXX - Are vectors of pointers possible here? // XXX - Are vectors of pointers possible here?
IntTy = cast<IntegerType>(DL->getIntPtrType(V->getType())); IntTy = cast<IntegerType>(DL.getIntPtrType(V->getType()));
Zero = ConstantInt::get(IntTy, 0); Zero = ConstantInt::get(IntTy, 0);
SizeOffsetEvalType Result = compute_(V); SizeOffsetEvalType Result = compute_(V);
Context not available.
assert(I.isArrayAllocation()); assert(I.isArrayAllocation());
Value *ArraySize = I.getArraySize(); Value *ArraySize = I.getArraySize();
Value *Size = ConstantInt::get(ArraySize->getType(), Value *Size = ConstantInt::get(ArraySize->getType(),
DL->getTypeAllocSize(I.getAllocatedType())); DL.getTypeAllocSize(I.getAllocatedType()));
Size = Builder.CreateMul(Size, ArraySize); Size = Builder.CreateMul(Size, ArraySize);
return std::make_pair(Size, Zero); return std::make_pair(Size, Zero);
} }
Context not available.
if (!bothKnown(PtrData)) if (!bothKnown(PtrData))
return unknown(); return unknown();
Value *Offset = EmitGEPOffset(&Builder, *DL, &GEP, /*NoAssumptions=*/true); Value *Offset = EmitGEPOffset(&Builder, DL, &GEP, /*NoAssumptions=*/true);
Offset = Builder.CreateAdd(PtrData.second, Offset); Offset = Builder.CreateAdd(PtrData.second, Offset);
return std::make_pair(PtrData.first, Offset); return std::make_pair(PtrData.first, Offset);
} }
Context not available.

lib/Analysis/MemoryDependenceAnalysis.cpp

Context not available.
bool MemoryDependenceAnalysis::runOnFunction(Function &F) { bool MemoryDependenceAnalysis::runOnFunction(Function &F) {
AA = &getAnalysis<AliasAnalysis>(); AA = &getAnalysis<AliasAnalysis>();
AC = &getAnalysis<AssumptionCacheTracker>().getAssumptionCache(F); AC = &getAnalysis<AssumptionCacheTracker>().getAssumptionCache(F);
DL = &F.getParent()->getDataLayout();
DominatorTreeWrapperPass *DTWP = DominatorTreeWrapperPass *DTWP =
getAnalysisIfAvailable<DominatorTreeWrapperPass>(); getAnalysisIfAvailable<DominatorTreeWrapperPass>();
DT = DTWP ? &DTWP->getDomTree() : nullptr; DT = DTWP ? &DTWP->getDomTree() : nullptr;
Context not available.
/// ///
/// MemLocBase, MemLocOffset are lazily computed here the first time the /// MemLocBase, MemLocOffset are lazily computed here the first time the
/// base/offs of memloc is needed. /// base/offs of memloc is needed.
static bool static bool isLoadLoadClobberIfExtendedToFullWidth(
isLoadLoadClobberIfExtendedToFullWidth(const AliasAnalysis::Location &MemLoc, const AliasAnalysis::Location &MemLoc, const Value *&MemLocBase,
const Value *&MemLocBase, int64_t &MemLocOffs, const LoadInst *LI) {
int64_t &MemLocOffs, const DataLayout &DL = LI->getModule()->getDataLayout();
const LoadInst *LI,
const DataLayout *DL) {
// If we have no target data, we can't do this.
if (!DL) return false;
// If we haven't already computed the base/offset of MemLoc, do so now. // If we haven't already computed the base/offset of MemLoc, do so now.
if (!MemLocBase) if (!MemLocBase)
MemLocBase = GetPointerBaseWithConstantOffset(MemLoc.Ptr, MemLocOffs, DL); MemLocBase = GetPointerBaseWithConstantOffset(MemLoc.Ptr, MemLocOffs, DL);
unsigned Size = MemoryDependenceAnalysis:: unsigned Size = MemoryDependenceAnalysis::getLoadLoadClobberFullWidthSize(
getLoadLoadClobberFullWidthSize(MemLocBase, MemLocOffs, MemLoc.Size, MemLocBase, MemLocOffs, MemLoc.Size, LI);
LI, *DL);
return Size != 0; return Size != 0;
} }
Context not available.
/// 2) safe for the target, and 3) would provide the specified memory /// 2) safe for the target, and 3) would provide the specified memory
/// location value, then this function returns the size in bytes of the /// location value, then this function returns the size in bytes of the
/// load width to use. If not, this returns zero. /// load width to use. If not, this returns zero.
unsigned MemoryDependenceAnalysis:: unsigned MemoryDependenceAnalysis::getLoadLoadClobberFullWidthSize(
getLoadLoadClobberFullWidthSize(const Value *MemLocBase, int64_t MemLocOffs, const Value *MemLocBase, int64_t MemLocOffs, unsigned MemLocSize,
unsigned MemLocSize, const LoadInst *LI, const LoadInst *LI) {
const DataLayout &DL) {
// We can only extend simple integer loads. // We can only extend simple integer loads.
if (!isa<IntegerType>(LI->getType()) || !LI->isSimple()) return 0; if (!isa<IntegerType>(LI->getType()) || !LI->isSimple()) return 0;
Context not available.
if (LI->getParent()->getParent()->hasFnAttribute(Attribute::SanitizeThread)) if (LI->getParent()->getParent()->hasFnAttribute(Attribute::SanitizeThread))
return 0; return 0;
const DataLayout &DL = LI->getModule()->getDataLayout();
// Get the base of this load. // Get the base of this load.
int64_t LIOffs = 0; int64_t LIOffs = 0;
const Value *LIBase = const Value *LIBase =
GetPointerBaseWithConstantOffset(LI->getPointerOperand(), LIOffs, &DL); GetPointerBaseWithConstantOffset(LI->getPointerOperand(), LIOffs, DL);
// If the two pointers are not based on the same pointer, we can't tell that // If the two pointers are not based on the same pointer, we can't tell that
// they are related. // they are related.
Context not available.
isInvariantLoad = true; isInvariantLoad = true;
} }
const DataLayout &DL = BB->getModule()->getDataLayout();
// Walk backwards through the basic block, looking for dependencies. // Walk backwards through the basic block, looking for dependencies.
while (ScanIt != BB->begin()) { while (ScanIt != BB->begin()) {
Instruction *Inst = --ScanIt; Instruction *Inst = --ScanIt;
Context not available.
// location is 1 byte at P+1). If so, return it as a load/load // location is 1 byte at P+1). If so, return it as a load/load
// clobber result, allowing the client to decide to widen the load if // clobber result, allowing the client to decide to widen the load if
// it wants to. // it wants to.
if (IntegerType *ITy = dyn_cast<IntegerType>(LI->getType())) if (IntegerType *ITy = dyn_cast<IntegerType>(LI->getType())) {
if (LI->getAlignment()*8 > ITy->getPrimitiveSizeInBits() && if (LI->getAlignment() * 8 > ITy->getPrimitiveSizeInBits() &&
isLoadLoadClobberIfExtendedToFullWidth(MemLoc, MemLocBase, isLoadLoadClobberIfExtendedToFullWidth(MemLoc, MemLocBase,
MemLocOffset, LI, DL)) MemLocOffset, LI))
return MemDepResult::getClobber(Inst); return MemDepResult::getClobber(Inst);
}
continue; continue;
} }
Context not available.
const_cast<Value *>(Loc.Ptr))); const_cast<Value *>(Loc.Ptr)));
return; return;
} }
const DataLayout &DL = FromBB->getModule()->getDataLayout();
PHITransAddr Address(const_cast<Value *>(Loc.Ptr), DL, AC); PHITransAddr Address(const_cast<Value *>(Loc.Ptr), DL, AC);
// This is the set of blocks we've inspected, and the pointer we consider in // This is the set of blocks we've inspected, and the pointer we consider in
Context not available.

lib/Analysis/ScalarEvolution.cpp

Context not available.
} }
const SCEV *ScalarEvolution::getSizeOfExpr(Type *IntTy, Type *AllocTy) { const SCEV *ScalarEvolution::getSizeOfExpr(Type *IntTy, Type *AllocTy) {
// If we have DataLayout, we can bypass creating a target-independent // We can bypass creating a target-independent
// constant expression and then folding it back into a ConstantInt. // constant expression and then folding it back into a ConstantInt.
// This is just a compile-time optimization. // This is just a compile-time optimization.
if (DL) return getConstant(IntTy,
return getConstant(IntTy, DL->getTypeAllocSize(AllocTy)); F->getParent()->getDataLayout().getTypeAllocSize(AllocTy));
Constant *C = ConstantExpr::getSizeOf(AllocTy);
if (ConstantExpr *CE = dyn_cast<ConstantExpr>(C))
if (Constant *Folded = ConstantFoldConstantExpression(CE, DL, TLI))
C = Folded;
Type *Ty = getEffectiveSCEVType(PointerType::getUnqual(AllocTy));
assert(Ty == IntTy && "Effective SCEV type doesn't match");
return getTruncateOrZeroExtend(getSCEV(C), Ty);
} }
const SCEV *ScalarEvolution::getOffsetOfExpr(Type *IntTy, const SCEV *ScalarEvolution::getOffsetOfExpr(Type *IntTy,
StructType *STy, StructType *STy,
unsigned FieldNo) { unsigned FieldNo) {
// If we have DataLayout, we can bypass creating a target-independent // We can bypass creating a target-independent
// constant expression and then folding it back into a ConstantInt. // constant expression and then folding it back into a ConstantInt.
// This is just a compile-time optimization. // This is just a compile-time optimization.
if (DL) { return getConstant(
return getConstant(IntTy, IntTy,
DL->getStructLayout(STy)->getElementOffset(FieldNo)); F->getParent()->getDataLayout().getStructLayout(STy)->getElementOffset(
} FieldNo));
Constant *C = ConstantExpr::getOffsetOf(STy, FieldNo);
if (ConstantExpr *CE = dyn_cast<ConstantExpr>(C))
if (Constant *Folded = ConstantFoldConstantExpression(CE, DL, TLI))
C = Folded;
Type *Ty = getEffectiveSCEVType(PointerType::getUnqual(STy));
return getTruncateOrZeroExtend(getSCEV(C), Ty);
} }
const SCEV *ScalarEvolution::getUnknown(Value *V) { const SCEV *ScalarEvolution::getUnknown(Value *V) {
Context not available.
/// for which isSCEVable must return true. /// for which isSCEVable must return true.
uint64_t ScalarEvolution::getTypeSizeInBits(Type *Ty) const { uint64_t ScalarEvolution::getTypeSizeInBits(Type *Ty) const {
assert(isSCEVable(Ty) && "Type is not SCEVable!"); assert(isSCEVable(Ty) && "Type is not SCEVable!");
return F->getParent()->getDataLayout().getTypeSizeInBits(Ty);
// If we have a DataLayout, use it!
if (DL)
return DL->getTypeSizeInBits(Ty);
// Integer types have fixed sizes.
if (Ty->isIntegerTy())
return Ty->getPrimitiveSizeInBits();
// The only other support type is pointer. Without DataLayout, conservatively
// assume pointers are 64-bit.
assert(Ty->isPointerTy() && "isSCEVable permitted a non-SCEVable type!");
return 64;
} }
/// getEffectiveSCEVType - Return a type with the same bitwidth as /// getEffectiveSCEVType - Return a type with the same bitwidth as
Context not available.
// The only other support type is pointer. // The only other support type is pointer.
assert(Ty->isPointerTy() && "Unexpected non-pointer non-integer type!"); assert(Ty->isPointerTy() && "Unexpected non-pointer non-integer type!");
return F->getParent()->getDataLayout().getIntPtrType(Ty);
if (DL)
return DL->getIntPtrType(Ty);
// Without DataLayout, conservatively assume pointers are 64-bit.
return Type::getInt64Ty(getContext());
} }
const SCEV *ScalarEvolution::getCouldNotCompute() { const SCEV *ScalarEvolution::getCouldNotCompute() {
Context not available.
// PHI's incoming blocks are in a different loop, in which case doing so // PHI's incoming blocks are in a different loop, in which case doing so
// risks breaking LCSSA form. Instcombine would normally zap these, but // risks breaking LCSSA form. Instcombine would normally zap these, but
// it doesn't have DominatorTree information, so it may miss cases. // it doesn't have DominatorTree information, so it may miss cases.
if (Value *V = SimplifyInstruction(PN, DL, TLI, DT, AC)) if (Value *V =
SimplifyInstruction(PN, F->getParent()->getDataLayout(), TLI, DT, AC))
if (LI->replacementPreservesLCSSAForm(PN, V)) if (LI->replacementPreservesLCSSAForm(PN, V))
return getSCEV(V); return getSCEV(V);
Context not available.
// For a SCEVUnknown, ask ValueTracking. // For a SCEVUnknown, ask ValueTracking.
unsigned BitWidth = getTypeSizeInBits(U->getType()); unsigned BitWidth = getTypeSizeInBits(U->getType());
APInt Zeros(BitWidth, 0), Ones(BitWidth, 0); APInt Zeros(BitWidth, 0), Ones(BitWidth, 0);
computeKnownBits(U->getValue(), Zeros, Ones, DL, 0, AC, nullptr, DT); computeKnownBits(U->getValue(), Zeros, Ones,
F->getParent()->getDataLayout(), 0, AC, nullptr, DT);
return Zeros.countTrailingOnes(); return Zeros.countTrailingOnes();
} }
Context not available.
// For a SCEVUnknown, ask ValueTracking. // For a SCEVUnknown, ask ValueTracking.
APInt Zeros(BitWidth, 0), Ones(BitWidth, 0); APInt Zeros(BitWidth, 0), Ones(BitWidth, 0);
computeKnownBits(U->getValue(), Zeros, Ones, DL, 0, AC, nullptr, DT); computeKnownBits(U->getValue(), Zeros, Ones,
F->getParent()->getDataLayout(), 0, AC, nullptr, DT);
if (Ones == ~Zeros + 1) if (Ones == ~Zeros + 1)
return setUnsignedRange(U, ConservativeResult); return setUnsignedRange(U, ConservativeResult);
return setUnsignedRange(U, return setUnsignedRange(U,
Context not available.
if (MDRange.hasValue()) if (MDRange.hasValue())
ConservativeResult = ConservativeResult.intersectWith(MDRange.getValue()); ConservativeResult = ConservativeResult.intersectWith(MDRange.getValue());
// For a SCEVUnknown, ask ValueTracking. unsigned NS = ComputeNumSignBits(
if (!U->getValue()->getType()->isIntegerTy() && !DL) U->getValue(), F->getParent()->getDataLayout(), 0, AC, nullptr, DT);
return setSignedRange(U, ConservativeResult);
unsigned NS = ComputeNumSignBits(U->getValue(), DL, 0, AC, nullptr, DT);
if (NS <= 1) if (NS <= 1)
return setSignedRange(U, ConservativeResult); return setSignedRange(U, ConservativeResult);
return setSignedRange(U, ConservativeResult.intersectWith( return setSignedRange(U, ConservativeResult.intersectWith(
Context not available.
unsigned TZ = A.countTrailingZeros(); unsigned TZ = A.countTrailingZeros();
unsigned BitWidth = A.getBitWidth(); unsigned BitWidth = A.getBitWidth();
APInt KnownZero(BitWidth, 0), KnownOne(BitWidth, 0); APInt KnownZero(BitWidth, 0), KnownOne(BitWidth, 0);
computeKnownBits(U->getOperand(0), KnownZero, KnownOne, DL, 0, AC, computeKnownBits(U->getOperand(0), KnownZero, KnownOne,
nullptr, DT); F->getParent()->getDataLayout(), 0, AC, nullptr, DT);
APInt EffectiveMask = APInt EffectiveMask =
APInt::getLowBitsSet(BitWidth, BitWidth - LZ - TZ).shl(TZ); APInt::getLowBitsSet(BitWidth, BitWidth - LZ - TZ).shl(TZ);
Context not available.
/// reason, return null. /// reason, return null.
static Constant *EvaluateExpression(Value *V, const Loop *L, static Constant *EvaluateExpression(Value *V, const Loop *L,
DenseMap<Instruction *, Constant *> &Vals, DenseMap<Instruction *, Constant *> &Vals,
const DataLayout *DL, const DataLayout &DL,
const TargetLibraryInfo *TLI) { const TargetLibraryInfo *TLI) {
// Convenient constant check, but redundant for recursive calls. // Convenient constant check, but redundant for recursive calls.
if (Constant *C = dyn_cast<Constant>(V)) return C; if (Constant *C = dyn_cast<Constant>(V)) return C;
Context not available.
unsigned NumIterations = BEs.getZExtValue(); // must be in range unsigned NumIterations = BEs.getZExtValue(); // must be in range
unsigned IterationNum = 0; unsigned IterationNum = 0;
const DataLayout &DL = F->getParent()->getDataLayout();
for (; ; ++IterationNum) { for (; ; ++IterationNum) {
if (IterationNum == NumIterations) if (IterationNum == NumIterations)
return RetVal = CurrentIterVals[PN]; // Got exit value! return RetVal = CurrentIterVals[PN]; // Got exit value!
Context not available.
// Compute the value of the PHIs for the next iteration. // Compute the value of the PHIs for the next iteration.
// EvaluateExpression adds non-phi values to the CurrentIterVals map. // EvaluateExpression adds non-phi values to the CurrentIterVals map.
DenseMap<Instruction *, Constant *> NextIterVals; DenseMap<Instruction *, Constant *> NextIterVals;
Constant *NextPHI = EvaluateExpression(BEValue, L, CurrentIterVals, DL, Constant *NextPHI =
TLI); EvaluateExpression(BEValue, L, CurrentIterVals, DL, TLI);
if (!NextPHI) if (!NextPHI)
return nullptr; // Couldn't evaluate! return nullptr; // Couldn't evaluate!
NextIterVals[PN] = NextPHI; NextIterVals[PN] = NextPHI;
Context not available.
// Okay, we find a PHI node that defines the trip count of this loop. Execute // Okay, we find a PHI node that defines the trip count of this loop. Execute
// the loop symbolically to determine when the condition gets a value of // the loop symbolically to determine when the condition gets a value of
// "ExitWhen". // "ExitWhen".
unsigned MaxIterations = MaxBruteForceIterations; // Limit analysis. unsigned MaxIterations = MaxBruteForceIterations; // Limit analysis.
const DataLayout &DL = F->getParent()->getDataLayout();
for (unsigned IterationNum = 0; IterationNum != MaxIterations;++IterationNum){ for (unsigned IterationNum = 0; IterationNum != MaxIterations;++IterationNum){
ConstantInt *CondVal = ConstantInt *CondVal = dyn_cast_or_null<ConstantInt>(
dyn_cast_or_null<ConstantInt>(EvaluateExpression(Cond, L, CurrentIterVals, EvaluateExpression(Cond, L, CurrentIterVals, DL, TLI));
DL, TLI));
// Couldn't symbolically evaluate. // Couldn't symbolically evaluate.
if (!CondVal) return getCouldNotCompute(); if (!CondVal) return getCouldNotCompute();
Context not available.
// Check to see if getSCEVAtScope actually made an improvement. // Check to see if getSCEVAtScope actually made an improvement.
if (MadeImprovement) { if (MadeImprovement) {
Constant *C = nullptr; Constant *C = nullptr;
const DataLayout &DL = F->getParent()->getDataLayout();
if (const CmpInst *CI = dyn_cast<CmpInst>(I)) if (const CmpInst *CI = dyn_cast<CmpInst>(I))
C = ConstantFoldCompareInstOperands(CI->getPredicate(), C = ConstantFoldCompareInstOperands(CI->getPredicate(), Operands[0],
Operands[0], Operands[1], DL, Operands[1], DL, TLI);
TLI);
else if (const LoadInst *LI = dyn_cast<LoadInst>(I)) { else if (const LoadInst *LI = dyn_cast<LoadInst>(I)) {
if (!LI->isVolatile()) if (!LI->isVolatile())
C = ConstantFoldLoadFromConstPtr(Operands[0], DL); C = ConstantFoldLoadFromConstPtr(Operands[0], DL);
} else } else
C = ConstantFoldInstOperands(I->getOpcode(), I->getType(), C = ConstantFoldInstOperands(I->getOpcode(), I->getType(), Operands,
Operands, DL, TLI); DL, TLI);
if (!C) return V; if (!C) return V;
return getSCEV(C); return getSCEV(C);
} }
Context not available.
this->F = &F; this->F = &F;
AC = &getAnalysis<AssumptionCacheTracker>().getAssumptionCache(F); AC = &getAnalysis<AssumptionCacheTracker>().getAssumptionCache(F);
LI = &getAnalysis<LoopInfoWrapperPass>().getLoopInfo(); LI = &getAnalysis<LoopInfoWrapperPass>().getLoopInfo();
DL = &F.getParent()->getDataLayout();
TLI = &getAnalysis<TargetLibraryInfoWrapperPass>().getTLI(); TLI = &getAnalysis<TargetLibraryInfoWrapperPass>().getTLI();
DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree(); DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
return false; return false;
Context not available.

lib/Analysis/ScalarEvolutionExpander.cpp

Context not available.
/// TODO: When ScalarEvolution gets a SCEVSDivExpr, this can be made /// TODO: When ScalarEvolution gets a SCEVSDivExpr, this can be made
/// unnecessary; in its place, just signed-divide Ops[i] by the scale and /// unnecessary; in its place, just signed-divide Ops[i] by the scale and
/// check to see if the divide was folded. /// check to see if the divide was folded.
static bool FactorOutConstant(const SCEV *&S, static bool FactorOutConstant(const SCEV *&S, const SCEV *&Remainder,
const SCEV *&Remainder, const SCEV *Factor, ScalarEvolution &SE,
const SCEV *Factor, const DataLayout &DL) {
ScalarEvolution &SE,
const DataLayout *DL) {
// Everything is divisible by one. // Everything is divisible by one.
if (Factor->isOne()) if (Factor->isOne())
return true; return true;
Context not available.
// In a Mul, check if there is a constant operand which is a multiple // In a Mul, check if there is a constant operand which is a multiple
// of the given factor. // of the given factor.
if (const SCEVMulExpr *M = dyn_cast<SCEVMulExpr>(S)) { if (const SCEVMulExpr *M = dyn_cast<SCEVMulExpr>(S)) {
if (DL) { // With DataLayout, the size is known. Check if there is a constant
// With DataLayout, the size is known. Check if there is a constant // operand which is a multiple of the given factor. If so, we can
// operand which is a multiple of the given factor. If so, we can // factor it.
// factor it. const SCEVConstant *FC = cast<SCEVConstant>(Factor);
const SCEVConstant *FC = cast<SCEVConstant>(Factor); if (const SCEVConstant *C = dyn_cast<SCEVConstant>(M->getOperand(0)))
if (const SCEVConstant *C = dyn_cast<SCEVConstant>(M->getOperand(0))) if (!C->getValue()->getValue().srem(FC->getValue()->getValue())) {
if (!C->getValue()->getValue().srem(FC->getValue()->getValue())) { SmallVector<const SCEV *, 4> NewMulOps(M->op_begin(), M->op_end());
SmallVector<const SCEV *, 4> NewMulOps(M->op_begin(), M->op_end()); NewMulOps[0] = SE.getConstant(
NewMulOps[0] = C->getValue()->getValue().sdiv(FC->getValue()->getValue()));
SE.getConstant(C->getValue()->getValue().sdiv( S = SE.getMulExpr(NewMulOps);
FC->getValue()->getValue())); return true;
S = SE.getMulExpr(NewMulOps);
return true;
}
} else {
// Without DataLayout, check if Factor can be factored out of any of the
// Mul's operands. If so, we can just remove it.
for (unsigned i = 0, e = M->getNumOperands(); i != e; ++i) {
const SCEV *SOp = M->getOperand(i);
const SCEV *Remainder = SE.getConstant(SOp->getType(), 0);
if (FactorOutConstant(SOp, Remainder, Factor, SE, DL) &&
Remainder->isZero()) {
SmallVector<const SCEV *, 4> NewMulOps(M->op_begin(), M->op_end());
NewMulOps[i] = SOp;
S = SE.getMulExpr(NewMulOps);
return true;
}
} }
}
} }
// In an AddRec, check if both start and step are divisible. // In an AddRec, check if both start and step are divisible.
Context not available.
// without the other. // without the other.
SplitAddRecs(Ops, Ty, SE); SplitAddRecs(Ops, Ty, SE);
Type *IntPtrTy = SE.DL Type *IntPtrTy = DL.getIntPtrType(PTy);
? SE.DL->getIntPtrType(PTy)
: Type::getInt64Ty(PTy->getContext());
// Descend down the pointer's type and attempt to convert the other // Descend down the pointer's type and attempt to convert the other
// operands into GEP indices, at each level. The first index in a GEP // operands into GEP indices, at each level. The first index in a GEP
Context not available.
for (unsigned i = 0, e = Ops.size(); i != e; ++i) { for (unsigned i = 0, e = Ops.size(); i != e; ++i) {
const SCEV *Op = Ops[i]; const SCEV *Op = Ops[i];
const SCEV *Remainder = SE.getConstant(Ty, 0); const SCEV *Remainder = SE.getConstant(Ty, 0);
if (FactorOutConstant(Op, Remainder, ElSize, SE, SE.DL)) { if (FactorOutConstant(Op, Remainder, ElSize, SE, DL)) {
// Op now has ElSize factored out. // Op now has ElSize factored out.
ScaledOps.push_back(Op); ScaledOps.push_back(Op);
if (!Remainder->isZero()) if (!Remainder->isZero())
Context not available.
bool FoundFieldNo = false; bool FoundFieldNo = false;
// An empty struct has no fields. // An empty struct has no fields.
if (STy->getNumElements() == 0) break; if (STy->getNumElements() == 0) break;
if (SE.DL) { // With DataLayout, field offsets are known. See if a constant offset
// With DataLayout, field offsets are known. See if a constant offset // falls within any of the struct fields.
// falls within any of the struct fields. if (Ops.empty())
if (Ops.empty()) break; break;
if (const SCEVConstant *C = dyn_cast<SCEVConstant>(Ops[0])) if (const SCEVConstant *C = dyn_cast<SCEVConstant>(Ops[0]))
if (SE.getTypeSizeInBits(C->getType()) <= 64) { if (SE.getTypeSizeInBits(C->getType()) <= 64) {
const StructLayout &SL = *SE.DL->getStructLayout(STy); const StructLayout &SL = *DL.getStructLayout(STy);
uint64_t FullOffset = C->getValue()->getZExtValue(); uint64_t FullOffset = C->getValue()->getZExtValue();
if (FullOffset < SL.getSizeInBytes()) { if (FullOffset < SL.getSizeInBytes()) {
unsigned ElIdx = SL.getElementContainingOffset(FullOffset); unsigned ElIdx = SL.getElementContainingOffset(FullOffset);
GepIndices.push_back( GepIndices.push_back(
ConstantInt::get(Type::getInt32Ty(Ty->getContext()), ElIdx)); ConstantInt::get(Type::getInt32Ty(Ty->getContext()), ElIdx));
ElTy = STy->getTypeAtIndex(ElIdx); ElTy = STy->getTypeAtIndex(ElIdx);
Ops[0] = Ops[0] =
SE.getConstant(Ty, FullOffset - SL.getElementOffset(ElIdx)); SE.getConstant(Ty, FullOffset - SL.getElementOffset(ElIdx));
AnyNonZeroIndices = true; AnyNonZeroIndices = true;
FoundFieldNo = true; FoundFieldNo = true;
}
}
} else {
// Without DataLayout, just check for an offsetof expression of the
// appropriate struct type.
for (unsigned i = 0, e = Ops.size(); i != e; ++i)
if (const SCEVUnknown *U = dyn_cast<SCEVUnknown>(Ops[i])) {
Type *CTy;
Constant *FieldNo;
if (U->isOffsetOf(CTy, FieldNo) && CTy == STy) {
GepIndices.push_back(FieldNo);
ElTy =
STy->getTypeAtIndex(cast<ConstantInt>(FieldNo)->getZExtValue());
Ops[i] = SE.getConstant(Ty, 0);
AnyNonZeroIndices = true;
FoundFieldNo = true;
break;
}
} }
} }
// If no struct field offsets were found, tentatively assume that // If no struct field offsets were found, tentatively assume that
// field zero was selected (since the zero offset would obviously // field zero was selected (since the zero offset would obviously
// be folded away). // be folded away).
Context not available.
// Fold constant phis. They may be congruent to other constant phis and // Fold constant phis. They may be congruent to other constant phis and
// would confuse the logic below that expects proper IVs. // would confuse the logic below that expects proper IVs.
if (Value *V = SimplifyInstruction(Phi, SE.DL, SE.TLI, SE.DT, SE.AC)) { if (Value *V = SimplifyInstruction(Phi, DL, SE.TLI, SE.DT, SE.AC)) {
Phi->replaceAllUsesWith(V); Phi->replaceAllUsesWith(V);
DeadInsts.push_back(Phi); DeadInsts.push_back(Phi);
++NumElim; ++NumElim;
Context not available.

lib/Analysis/ValueTracking.cpp

Context not available.
/// Returns the bitwidth of the given scalar or pointer type (if unknown returns /// Returns the bitwidth of the given scalar or pointer type (if unknown returns
/// 0). For vector types, returns the element type's bitwidth. /// 0). For vector types, returns the element type's bitwidth.
static unsigned getBitWidth(Type *Ty, const DataLayout *TD) { static unsigned getBitWidth(Type *Ty, const DataLayout &TD) {
if (unsigned BitWidth = Ty->getScalarSizeInBits()) if (unsigned BitWidth = Ty->getScalarSizeInBits())
return BitWidth; return BitWidth;
return TD ? TD->getPointerTypeSizeInBits(Ty) : 0; return TD.getPointerTypeSizeInBits(Ty);
} }
// Many of these functions have internal versions that take an assumption // Many of these functions have internal versions that take an assumption
Context not available.
} }
static void computeKnownBits(Value *V, APInt &KnownZero, APInt &KnownOne, static void computeKnownBits(Value *V, APInt &KnownZero, APInt &KnownOne,
const DataLayout *TD, unsigned Depth, const DataLayout &TD, unsigned Depth,
const Query &Q); const Query &Q);
void llvm::computeKnownBits(Value *V, APInt &KnownZero, APInt &KnownOne, void llvm::computeKnownBits(Value *V, APInt &KnownZero, APInt &KnownOne,
const DataLayout *TD, unsigned Depth, const DataLayout &TD, unsigned Depth,
AssumptionCache *AC, const Instruction *CxtI, AssumptionCache *AC, const Instruction *CxtI,
const DominatorTree *DT) { const DominatorTree *DT) {
::computeKnownBits(V, KnownZero, KnownOne, TD, Depth, ::computeKnownBits(V, KnownZero, KnownOne, TD, Depth,
Context not available.
} }
static void ComputeSignBit(Value *V, bool &KnownZero, bool &KnownOne, static void ComputeSignBit(Value *V, bool &KnownZero, bool &KnownOne,
const DataLayout *TD, unsigned Depth, const DataLayout &TD, unsigned Depth,
const Query &Q); const Query &Q);
void llvm::ComputeSignBit(Value *V, bool &KnownZero, bool &KnownOne, void llvm::ComputeSignBit(Value *V, bool &KnownZero, bool &KnownOne,
const DataLayout *TD, unsigned Depth, const DataLayout &TD, unsigned Depth,
AssumptionCache *AC, const Instruction *CxtI, AssumptionCache *AC, const Instruction *CxtI,
const DominatorTree *DT) { const DominatorTree *DT) {
::ComputeSignBit(V, KnownZero, KnownOne, TD, Depth, ::ComputeSignBit(V, KnownZero, KnownOne, TD, Depth,
Context not available.
} }
static bool isKnownToBeAPowerOfTwo(Value *V, bool OrZero, unsigned Depth, static bool isKnownToBeAPowerOfTwo(Value *V, bool OrZero, unsigned Depth,
const Query &Q); const Query &Q, const DataLayout &DL);
bool llvm::isKnownToBeAPowerOfTwo(Value *V, bool OrZero, unsigned Depth, bool llvm::isKnownToBeAPowerOfTwo(Value *V, const DataLayout &DL, bool OrZero,
AssumptionCache *AC, const Instruction *CxtI, unsigned Depth, AssumptionCache *AC,
const Instruction *CxtI,
const DominatorTree *DT) { const DominatorTree *DT) {
return ::isKnownToBeAPowerOfTwo(V, OrZero, Depth, return ::isKnownToBeAPowerOfTwo(V, OrZero, Depth,
Query(AC, safeCxtI(V, CxtI), DT)); Query(AC, safeCxtI(V, CxtI), DT), DL);
} }
static bool isKnownNonZero(Value *V, const DataLayout *TD, unsigned Depth, static bool isKnownNonZero(Value *V, const DataLayout &TD, unsigned Depth,
const Query &Q); const Query &Q);
bool llvm::isKnownNonZero(Value *V, const DataLayout *TD, unsigned Depth, bool llvm::isKnownNonZero(Value *V, const DataLayout &TD, unsigned Depth,
AssumptionCache *AC, const Instruction *CxtI, AssumptionCache *AC, const Instruction *CxtI,
const DominatorTree *DT) { const DominatorTree *DT) {
return ::isKnownNonZero(V, TD, Depth, Query(AC, safeCxtI(V, CxtI), DT)); return ::isKnownNonZero(V, TD, Depth, Query(AC, safeCxtI(V, CxtI), DT));
} }
static bool MaskedValueIsZero(Value *V, const APInt &Mask, static bool MaskedValueIsZero(Value *V, const APInt &Mask, const DataLayout &TD,
const DataLayout *TD, unsigned Depth, unsigned Depth, const Query &Q);
const Query &Q);
bool llvm::MaskedValueIsZero(Value *V, const APInt &Mask, const DataLayout *TD, bool llvm::MaskedValueIsZero(Value *V, const APInt &Mask, const DataLayout &TD,
unsigned Depth, AssumptionCache *AC, unsigned Depth, AssumptionCache *AC,
const Instruction *CxtI, const DominatorTree *DT) { const Instruction *CxtI, const DominatorTree *DT) {
return ::MaskedValueIsZero(V, Mask, TD, Depth, return ::MaskedValueIsZero(V, Mask, TD, Depth,
Query(AC, safeCxtI(V, CxtI), DT)); Query(AC, safeCxtI(V, CxtI), DT));
} }
static unsigned ComputeNumSignBits(Value *V, const DataLayout *TD, static unsigned ComputeNumSignBits(Value *V, const DataLayout &TD,
unsigned Depth, const Query &Q); unsigned Depth, const Query &Q);
unsigned llvm::ComputeNumSignBits(Value *V, const DataLayout *TD, unsigned llvm::ComputeNumSignBits(Value *V, const DataLayout &TD,
unsigned Depth, AssumptionCache *AC, unsigned Depth, AssumptionCache *AC,
const Instruction *CxtI, const Instruction *CxtI,
const DominatorTree *DT) { const DominatorTree *DT) {
Context not available.
static void computeKnownBitsAddSub(bool Add, Value *Op0, Value *Op1, bool NSW, static void computeKnownBitsAddSub(bool Add, Value *Op0, Value *Op1, bool NSW,
APInt &KnownZero, APInt &KnownOne, APInt &KnownZero, APInt &KnownOne,
APInt &KnownZero2, APInt &KnownOne2, APInt &KnownZero2, APInt &KnownOne2,
const DataLayout *TD, unsigned Depth, const DataLayout &TD, unsigned Depth,
const Query &Q) { const Query &Q) {
if (!Add) { if (!Add) {
if (ConstantInt *CLHS = dyn_cast<ConstantInt>(Op0)) { if (ConstantInt *CLHS = dyn_cast<ConstantInt>(Op0)) {
Context not available.
static void computeKnownBitsMul(Value *Op0, Value *Op1, bool NSW, static void computeKnownBitsMul(Value *Op0, Value *Op1, bool NSW,
APInt &KnownZero, APInt &KnownOne, APInt &KnownZero, APInt &KnownOne,
APInt &KnownZero2, APInt &KnownOne2, APInt &KnownZero2, APInt &KnownOne2,
const DataLayout *TD, unsigned Depth, const DataLayout &TD, unsigned Depth,
const Query &Q) { const Query &Q) {
unsigned BitWidth = KnownZero.getBitWidth(); unsigned BitWidth = KnownZero.getBitWidth();
computeKnownBits(Op1, KnownZero, KnownOne, TD, Depth+1, Q); computeKnownBits(Op1, KnownZero, KnownOne, TD, Depth+1, Q);
Context not available.
return false; return false;
} }
static bool isValidAssumeForContext(Value *V, const Query &Q, static bool isValidAssumeForContext(Value *V, const Query &Q) {
const DataLayout *DL) {
Instruction *Inv = cast<Instruction>(V); Instruction *Inv = cast<Instruction>(V);
// There are two restrictions on the use of an assume: // There are two restrictions on the use of an assume:
Context not available.
for (BasicBlock::const_iterator I = for (BasicBlock::const_iterator I =
std::next(BasicBlock::const_iterator(Q.CxtI)), std::next(BasicBlock::const_iterator(Q.CxtI)),
IE(Inv); I != IE; ++I) IE(Inv); I != IE; ++I)
if (!isSafeToSpeculativelyExecute(I, DL) && if (!isSafeToSpeculativelyExecute(I) && !isAssumeLikeIntrinsic(I))
!isAssumeLikeIntrinsic(I))
return false; return false;
return !isEphemeralValueOf(Inv, Q.CxtI); return !isEphemeralValueOf(Inv, Q.CxtI);
Context not available.
for (BasicBlock::const_iterator I = for (BasicBlock::const_iterator I =
std::next(BasicBlock::const_iterator(Q.CxtI)), std::next(BasicBlock::const_iterator(Q.CxtI)),
IE(Inv); I != IE; ++I) IE(Inv); I != IE; ++I)
if (!isSafeToSpeculativelyExecute(I, DL) && if (!isSafeToSpeculativelyExecute(I) && !isAssumeLikeIntrinsic(I))
!isAssumeLikeIntrinsic(I))
return false; return false;
return !isEphemeralValueOf(Inv, Q.CxtI); return !isEphemeralValueOf(Inv, Q.CxtI);
Context not available.
bool llvm::isValidAssumeForContext(const Instruction *I, bool llvm::isValidAssumeForContext(const Instruction *I,
const Instruction *CxtI, const Instruction *CxtI,
const DataLayout *DL,
const DominatorTree *DT) { const DominatorTree *DT) {
return ::isValidAssumeForContext(const_cast<Instruction*>(I), return ::isValidAssumeForContext(const_cast<Instruction *>(I),
Query(nullptr, CxtI, DT), DL); Query(nullptr, CxtI, DT));
} }
template<typename LHS, typename RHS> template<typename LHS, typename RHS>
Context not available.
} }
static void computeKnownBitsFromAssume(Value *V, APInt &KnownZero, static void computeKnownBitsFromAssume(Value *V, APInt &KnownZero,
APInt &KnownOne, APInt &KnownOne, const DataLayout &DL,
const DataLayout *DL,
unsigned Depth, const Query &Q) { unsigned Depth, const Query &Q) {
// Use of assumptions is context-sensitive. If we don't have a context, we // Use of assumptions is context-sensitive. If we don't have a context, we
// cannot use them! // cannot use them!
Context not available.
Value *Arg = I->getArgOperand(0); Value *Arg = I->getArgOperand(0);
if (Arg == V && if (Arg == V && isValidAssumeForContext(I, Q)) {
isValidAssumeForContext(I, Q, DL)) {
assert(BitWidth == 1 && "assume operand is not i1?"); assert(BitWidth == 1 && "assume operand is not i1?");
KnownZero.clearAllBits(); KnownZero.clearAllBits();
KnownOne.setAllBits(); KnownOne.setAllBits();
Context not available.
ConstantInt *C; ConstantInt *C;
// assume(v = a) // assume(v = a)
if (match(Arg, m_c_ICmp(Pred, m_V, m_Value(A))) && if (match(Arg, m_c_ICmp(Pred, m_V, m_Value(A))) &&
Pred == ICmpInst::ICMP_EQ && isValidAssumeForContext(I, Q, DL)) { Pred == ICmpInst::ICMP_EQ && isValidAssumeForContext(I, Q)) {
APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0); APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
computeKnownBits(A, RHSKnownZero, RHSKnownOne, DL, Depth+1, Query(Q, I)); computeKnownBits(A, RHSKnownZero, RHSKnownOne, DL, Depth+1, Query(Q, I));
KnownZero |= RHSKnownZero; KnownZero |= RHSKnownZero;
KnownOne |= RHSKnownOne; KnownOne |= RHSKnownOne;
// assume(v & b = a) // assume(v & b = a)
} else if (match(Arg, m_c_ICmp(Pred, m_c_And(m_V, m_Value(B)), } else if (match(Arg,
m_Value(A))) && m_c_ICmp(Pred, m_c_And(m_V, m_Value(B)), m_Value(A))) &&
Pred == ICmpInst::ICMP_EQ && isValidAssumeForContext(I, Q, DL)) { Pred == ICmpInst::ICMP_EQ && isValidAssumeForContext(I, Q)) {
APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0); APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
computeKnownBits(A, RHSKnownZero, RHSKnownOne, DL, Depth+1, Query(Q, I)); computeKnownBits(A, RHSKnownZero, RHSKnownOne, DL, Depth+1, Query(Q, I));
APInt MaskKnownZero(BitWidth, 0), MaskKnownOne(BitWidth, 0); APInt MaskKnownZero(BitWidth, 0), MaskKnownOne(BitWidth, 0);
Context not available.
// assume(~(v & b) = a) // assume(~(v & b) = a)
} else if (match(Arg, m_c_ICmp(Pred, m_Not(m_c_And(m_V, m_Value(B))), } else if (match(Arg, m_c_ICmp(Pred, m_Not(m_c_And(m_V, m_Value(B))),
m_Value(A))) && m_Value(A))) &&
Pred == ICmpInst::ICMP_EQ && isValidAssumeForContext(I, Q, DL)) { Pred == ICmpInst::ICMP_EQ && isValidAssumeForContext(I, Q)) {
APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0); APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
computeKnownBits(A, RHSKnownZero, RHSKnownOne, DL, Depth+1, Query(Q, I)); computeKnownBits(A, RHSKnownZero, RHSKnownOne, DL, Depth+1, Query(Q, I));
APInt MaskKnownZero(BitWidth, 0), MaskKnownOne(BitWidth, 0); APInt MaskKnownZero(BitWidth, 0), MaskKnownOne(BitWidth, 0);
Context not available.
KnownZero |= RHSKnownOne & MaskKnownOne; KnownZero |= RHSKnownOne & MaskKnownOne;
KnownOne |= RHSKnownZero & MaskKnownOne; KnownOne |= RHSKnownZero & MaskKnownOne;
// assume(v | b = a) // assume(v | b = a)
} else if (match(Arg, m_c_ICmp(Pred, m_c_Or(m_V, m_Value(B)), } else if (match(Arg,
m_Value(A))) && m_c_ICmp(Pred, m_c_Or(m_V, m_Value(B)), m_Value(A))) &&
Pred == ICmpInst::ICMP_EQ && isValidAssumeForContext(I, Q, DL)) { Pred == ICmpInst::ICMP_EQ && isValidAssumeForContext(I, Q)) {
APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0); APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
computeKnownBits(A, RHSKnownZero, RHSKnownOne, DL, Depth+1, Query(Q, I)); computeKnownBits(A, RHSKnownZero, RHSKnownOne, DL, Depth+1, Query(Q, I));
APInt BKnownZero(BitWidth, 0), BKnownOne(BitWidth, 0); APInt BKnownZero(BitWidth, 0), BKnownOne(BitWidth, 0);
Context not available.
// assume(~(v | b) = a) // assume(~(v | b) = a)
} else if (match(Arg, m_c_ICmp(Pred, m_Not(m_c_Or(m_V, m_Value(B))), } else if (match(Arg, m_c_ICmp(Pred, m_Not(m_c_Or(m_V, m_Value(B))),
m_Value(A))) && m_Value(A))) &&
Pred == ICmpInst::ICMP_EQ && isValidAssumeForContext(I, Q, DL)) { Pred == ICmpInst::ICMP_EQ && isValidAssumeForContext(I, Q)) {
APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0); APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
computeKnownBits(A, RHSKnownZero, RHSKnownOne, DL, Depth+1, Query(Q, I)); computeKnownBits(A, RHSKnownZero, RHSKnownOne, DL, Depth+1, Query(Q, I));
APInt BKnownZero(BitWidth, 0), BKnownOne(BitWidth, 0); APInt BKnownZero(BitWidth, 0), BKnownOne(BitWidth, 0);
Context not available.
KnownZero |= RHSKnownOne & BKnownZero; KnownZero |= RHSKnownOne & BKnownZero;
KnownOne |= RHSKnownZero & BKnownZero; KnownOne |= RHSKnownZero & BKnownZero;
// assume(v ^ b = a) // assume(v ^ b = a)
} else if (match(Arg, m_c_ICmp(Pred, m_c_Xor(m_V, m_Value(B)), } else if (match(Arg,
m_Value(A))) && m_c_ICmp(Pred, m_c_Xor(m_V, m_Value(B)), m_Value(A))) &&
Pred == ICmpInst::ICMP_EQ && isValidAssumeForContext(I, Q, DL)) { Pred == ICmpInst::ICMP_EQ && isValidAssumeForContext(I, Q)) {
APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0); APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
computeKnownBits(A, RHSKnownZero, RHSKnownOne, DL, Depth+1, Query(Q, I)); computeKnownBits(A, RHSKnownZero, RHSKnownOne, DL, Depth+1, Query(Q, I));
APInt BKnownZero(BitWidth, 0), BKnownOne(BitWidth, 0); APInt BKnownZero(BitWidth, 0), BKnownOne(BitWidth, 0);
Context not available.
// assume(~(v ^ b) = a) // assume(~(v ^ b) = a)
} else if (match(Arg, m_c_ICmp(Pred, m_Not(m_c_Xor(m_V, m_Value(B))), } else if (match(Arg, m_c_ICmp(Pred, m_Not(m_c_Xor(m_V, m_Value(B))),
m_Value(A))) && m_Value(A))) &&
Pred == ICmpInst::ICMP_EQ && isValidAssumeForContext(I, Q, DL)) { Pred == ICmpInst::ICMP_EQ && isValidAssumeForContext(I, Q)) {
APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0); APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
computeKnownBits(A, RHSKnownZero, RHSKnownOne, DL, Depth+1, Query(Q, I)); computeKnownBits(A, RHSKnownZero, RHSKnownOne, DL, Depth+1, Query(Q, I));
APInt BKnownZero(BitWidth, 0), BKnownOne(BitWidth, 0); APInt BKnownZero(BitWidth, 0), BKnownOne(BitWidth, 0);
Context not available.
// assume(v << c = a) // assume(v << c = a)
} else if (match(Arg, m_c_ICmp(Pred, m_Shl(m_V, m_ConstantInt(C)), } else if (match(Arg, m_c_ICmp(Pred, m_Shl(m_V, m_ConstantInt(C)),
m_Value(A))) && m_Value(A))) &&
Pred == ICmpInst::ICMP_EQ && isValidAssumeForContext(I, Q, DL)) { Pred == ICmpInst::ICMP_EQ && isValidAssumeForContext(I, Q)) {
APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0); APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
computeKnownBits(A, RHSKnownZero, RHSKnownOne, DL, Depth+1, Query(Q, I)); computeKnownBits(A, RHSKnownZero, RHSKnownOne, DL, Depth+1, Query(Q, I));
// For those bits in RHS that are known, we can propagate them to known // For those bits in RHS that are known, we can propagate them to known
Context not available.
// assume(~(v << c) = a) // assume(~(v << c) = a)
} else if (match(Arg, m_c_ICmp(Pred, m_Not(m_Shl(m_V, m_ConstantInt(C))), } else if (match(Arg, m_c_ICmp(Pred, m_Not(m_Shl(m_V, m_ConstantInt(C))),
m_Value(A))) && m_Value(A))) &&
Pred == ICmpInst::ICMP_EQ && isValidAssumeForContext(I, Q, DL)) { Pred == ICmpInst::ICMP_EQ && isValidAssumeForContext(I, Q)) {
APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0); APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
computeKnownBits(A, RHSKnownZero, RHSKnownOne, DL, Depth+1, Query(Q, I)); computeKnownBits(A, RHSKnownZero, RHSKnownOne, DL, Depth+1, Query(Q, I));
// For those bits in RHS that are known, we can propagate them inverted // For those bits in RHS that are known, we can propagate them inverted
Context not available.
// assume(v >> c = a) // assume(v >> c = a)
} else if (match(Arg, } else if (match(Arg,
m_c_ICmp(Pred, m_CombineOr(m_LShr(m_V, m_ConstantInt(C)), m_c_ICmp(Pred, m_CombineOr(m_LShr(m_V, m_ConstantInt(C)),
m_AShr(m_V, m_AShr(m_V, m_ConstantInt(C))),
m_ConstantInt(C))), m_Value(A))) &&
m_Value(A))) && Pred == ICmpInst::ICMP_EQ && isValidAssumeForContext(I, Q)) {
Pred == ICmpInst::ICMP_EQ && isValidAssumeForContext(I, Q, DL)) {
APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0); APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
computeKnownBits(A, RHSKnownZero, RHSKnownOne, DL, Depth+1, Query(Q, I)); computeKnownBits(A, RHSKnownZero, RHSKnownOne, DL, Depth+1, Query(Q, I));
// For those bits in RHS that are known, we can propagate them to known // For those bits in RHS that are known, we can propagate them to known
Context not available.
KnownOne |= RHSKnownOne << C->getZExtValue(); KnownOne |= RHSKnownOne << C->getZExtValue();
// assume(~(v >> c) = a) // assume(~(v >> c) = a)
} else if (match(Arg, m_c_ICmp(Pred, m_Not(m_CombineOr( } else if (match(Arg, m_c_ICmp(Pred, m_Not(m_CombineOr(
m_LShr(m_V, m_ConstantInt(C)), m_LShr(m_V, m_ConstantInt(C)),
m_AShr(m_V, m_ConstantInt(C)))), m_AShr(m_V, m_ConstantInt(C)))),
m_Value(A))) && m_Value(A))) &&
Pred == ICmpInst::ICMP_EQ && isValidAssumeForContext(I, Q, DL)) { Pred == ICmpInst::ICMP_EQ && isValidAssumeForContext(I, Q)) {
APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0); APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
computeKnownBits(A, RHSKnownZero, RHSKnownOne, DL, Depth+1, Query(Q, I)); computeKnownBits(A, RHSKnownZero, RHSKnownOne, DL, Depth+1, Query(Q, I));
// For those bits in RHS that are known, we can propagate them inverted // For those bits in RHS that are known, we can propagate them inverted
Context not available.
KnownOne |= RHSKnownZero << C->getZExtValue(); KnownOne |= RHSKnownZero << C->getZExtValue();
// assume(v >=_s c) where c is non-negative // assume(v >=_s c) where c is non-negative
} else if (match(Arg, m_ICmp(Pred, m_V, m_Value(A))) && } else if (match(Arg, m_ICmp(Pred, m_V, m_Value(A))) &&
Pred == ICmpInst::ICMP_SGE && Pred == ICmpInst::ICMP_SGE && isValidAssumeForContext(I, Q)) {
isValidAssumeForContext(I, Q, DL)) {
APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0); APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
computeKnownBits(A, RHSKnownZero, RHSKnownOne, DL, Depth+1, Query(Q, I)); computeKnownBits(A, RHSKnownZero, RHSKnownOne, DL, Depth+1, Query(Q, I));
Context not available.
} }
// assume(v >_s c) where c is at least -1. // assume(v >_s c) where c is at least -1.
} else if (match(Arg, m_ICmp(Pred, m_V, m_Value(A))) && } else if (match(Arg, m_ICmp(Pred, m_V, m_Value(A))) &&
Pred == ICmpInst::ICMP_SGT && Pred == ICmpInst::ICMP_SGT && isValidAssumeForContext(I, Q)) {
isValidAssumeForContext(I, Q, DL)) {
APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0); APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
computeKnownBits(A, RHSKnownZero, RHSKnownOne, DL, Depth+1, Query(Q, I)); computeKnownBits(A, RHSKnownZero, RHSKnownOne, DL, Depth+1, Query(Q, I));
Context not available.
} }
// assume(v <=_s c) where c is negative // assume(v <=_s c) where c is negative
} else if (match(Arg, m_ICmp(Pred, m_V, m_Value(A))) && } else if (match(Arg, m_ICmp(Pred, m_V, m_Value(A))) &&
Pred == ICmpInst::ICMP_SLE && Pred == ICmpInst::ICMP_SLE && isValidAssumeForContext(I, Q)) {
isValidAssumeForContext(I, Q, DL)) {
APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0); APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
computeKnownBits(A, RHSKnownZero, RHSKnownOne, DL, Depth+1, Query(Q, I)); computeKnownBits(A, RHSKnownZero, RHSKnownOne, DL, Depth+1, Query(Q, I));
Context not available.
} }
// assume(v <_s c) where c is non-positive // assume(v <_s c) where c is non-positive
} else if (match(Arg, m_ICmp(Pred, m_V, m_Value(A))) && } else if (match(Arg, m_ICmp(Pred, m_V, m_Value(A))) &&
Pred == ICmpInst::ICMP_SLT && Pred == ICmpInst::ICMP_SLT && isValidAssumeForContext(I, Q)) {
isValidAssumeForContext(I, Q, DL)) {
APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0); APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
computeKnownBits(A, RHSKnownZero, RHSKnownOne, DL, Depth+1, Query(Q, I)); computeKnownBits(A, RHSKnownZero, RHSKnownOne, DL, Depth+1, Query(Q, I));
Context not available.
} }
// assume(v <=_u c) // assume(v <=_u c)
} else if (match(Arg, m_ICmp(Pred, m_V, m_Value(A))) && } else if (match(Arg, m_ICmp(Pred, m_V, m_Value(A))) &&
Pred == ICmpInst::ICMP_ULE && Pred == ICmpInst::ICMP_ULE && isValidAssumeForContext(I, Q)) {
isValidAssumeForContext(I, Q, DL)) {
APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0); APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
computeKnownBits(A, RHSKnownZero, RHSKnownOne, DL, Depth+1, Query(Q, I)); computeKnownBits(A, RHSKnownZero, RHSKnownOne, DL, Depth+1, Query(Q, I));
Context not available.
APInt::getHighBitsSet(BitWidth, RHSKnownZero.countLeadingOnes()); APInt::getHighBitsSet(BitWidth, RHSKnownZero.countLeadingOnes());
// assume(v <_u c) // assume(v <_u c)
} else if (match(Arg, m_ICmp(Pred, m_V, m_Value(A))) && } else if (match(Arg, m_ICmp(Pred, m_V, m_Value(A))) &&
Pred == ICmpInst::ICMP_ULT && Pred == ICmpInst::ICMP_ULT && isValidAssumeForContext(I, Q)) {
isValidAssumeForContext(I, Q, DL)) {
APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0); APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
computeKnownBits(A, RHSKnownZero, RHSKnownOne, DL, Depth+1, Query(Q, I)); computeKnownBits(A, RHSKnownZero, RHSKnownOne, DL, Depth+1, Query(Q, I));
// Whatever high bits in c are zero are known to be zero (if c is a power // Whatever high bits in c are zero are known to be zero (if c is a power
// of 2, then one more). // of 2, then one more).
if (isKnownToBeAPowerOfTwo(A, false, Depth+1, Query(Q, I))) if (isKnownToBeAPowerOfTwo(A, false, Depth + 1, Query(Q, I), DL))
KnownZero |= KnownZero |=
APInt::getHighBitsSet(BitWidth, RHSKnownZero.countLeadingOnes()+1); APInt::getHighBitsSet(BitWidth, RHSKnownZero.countLeadingOnes()+1);
else else
Context not available.
/// same width as the vector element, and the bit is set only if it is true /// same width as the vector element, and the bit is set only if it is true
/// for all of the elements in the vector. /// for all of the elements in the vector.
void computeKnownBits(Value *V, APInt &KnownZero, APInt &KnownOne, void computeKnownBits(Value *V, APInt &KnownZero, APInt &KnownOne,
const DataLayout *TD, unsigned Depth, const DataLayout &TD, unsigned Depth, const Query &Q) {
const Query &Q) {
assert(V && "No Value?"); assert(V && "No Value?");
assert(Depth <= MaxDepth && "Limit Search Depth"); assert(Depth <= MaxDepth && "Limit Search Depth");
unsigned BitWidth = KnownZero.getBitWidth(); unsigned BitWidth = KnownZero.getBitWidth();
Context not available.
assert((V->getType()->isIntOrIntVectorTy() || assert((V->getType()->isIntOrIntVectorTy() ||
V->getType()->getScalarType()->isPointerTy()) && V->getType()->getScalarType()->isPointerTy()) &&
"Not integer or pointer type!"); "Not integer or pointer type!");
assert((!TD || assert((TD.getTypeSizeInBits(V->getType()->getScalarType()) == BitWidth) &&
TD->getTypeSizeInBits(V->getType()->getScalarType()) == BitWidth) &&
(!V->getType()->isIntOrIntVectorTy() || (!V->getType()->isIntOrIntVectorTy() ||
V->getType()->getScalarSizeInBits() == BitWidth) && V->getType()->getScalarSizeInBits() == BitWidth) &&
KnownZero.getBitWidth() == BitWidth && KnownZero.getBitWidth() == BitWidth &&
Context not available.
// The address of an aligned GlobalValue has trailing zeros. // The address of an aligned GlobalValue has trailing zeros.
if (auto *GO = dyn_cast<GlobalObject>(V)) { if (auto *GO = dyn_cast<GlobalObject>(V)) {
unsigned Align = GO->getAlignment(); unsigned Align = GO->getAlignment();
if (Align == 0 && TD) { if (Align == 0) {
if (auto *GVar = dyn_cast<GlobalVariable>(GO)) { if (auto *GVar = dyn_cast<GlobalVariable>(GO)) {
Type *ObjectType = GVar->getType()->getElementType(); Type *ObjectType = GVar->getType()->getElementType();
if (ObjectType->isSized()) { if (ObjectType->isSized()) {
Context not available.
// it the preferred alignment. Otherwise, we have to assume that it // it the preferred alignment. Otherwise, we have to assume that it
// may only have the minimum ABI alignment. // may only have the minimum ABI alignment.
if (!GVar->isDeclaration() && !GVar->isWeakForLinker()) if (!GVar->isDeclaration() && !GVar->isWeakForLinker())
Align = TD->getPreferredAlignment(GVar); Align = TD.getPreferredAlignment(GVar);
else else
Align = TD->getABITypeAlignment(ObjectType); Align = TD.getABITypeAlignment(ObjectType);
} }
} }
} }
Context not available.
if (Argument *A = dyn_cast<Argument>(V)) { if (Argument *A = dyn_cast<Argument>(V)) {
unsigned Align = A->getType()->isPointerTy() ? A->getParamAlignment() : 0; unsigned Align = A->getType()->isPointerTy() ? A->getParamAlignment() : 0;
if (!Align && TD && A->hasStructRetAttr()) { if (!Align && A->hasStructRetAttr()) {
// An sret parameter has at least the ABI alignment of the return type. // An sret parameter has at least the ABI alignment of the return type.
Type *EltTy = cast<PointerType>(A->getType())->getElementType(); Type *EltTy = cast<PointerType>(A->getType())->getElementType();
if (EltTy->isSized()) if (EltTy->isSized())
Align = TD->getABITypeAlignment(EltTy); Align = TD.getABITypeAlignment(EltTy);
} }
if (Align) if (Align)
Context not available.
case Instruction::PtrToInt: case Instruction::PtrToInt:
case Instruction::IntToPtr: case Instruction::IntToPtr:
case Instruction::AddrSpaceCast: // Pointers could be different sizes. case Instruction::AddrSpaceCast: // Pointers could be different sizes.
// We can't handle these if we don't know the pointer size.
if (!TD) break;
// FALL THROUGH and handle them the same as zext/trunc. // FALL THROUGH and handle them the same as zext/trunc.
case Instruction::ZExt: case Instruction::ZExt:
case Instruction::Trunc: { case Instruction::Trunc: {
Context not available.
unsigned SrcBitWidth; unsigned SrcBitWidth;
// Note that we handle pointer operands here because of inttoptr/ptrtoint // Note that we handle pointer operands here because of inttoptr/ptrtoint
// which fall through here. // which fall through here.
if(TD) { SrcBitWidth = TD.getTypeSizeInBits(SrcTy->getScalarType());
SrcBitWidth = TD->getTypeSizeInBits(SrcTy->getScalarType());
} else {
SrcBitWidth = SrcTy->getScalarSizeInBits();
if (!SrcBitWidth) break;
}
assert(SrcBitWidth && "SrcBitWidth can't be zero"); assert(SrcBitWidth && "SrcBitWidth can't be zero");
KnownZero = KnownZero.zextOrTrunc(SrcBitWidth); KnownZero = KnownZero.zextOrTrunc(SrcBitWidth);
Context not available.
case Instruction::Alloca: { case Instruction::Alloca: {
AllocaInst *AI = cast<AllocaInst>(V); AllocaInst *AI = cast<AllocaInst>(V);
unsigned Align = AI->getAlignment(); unsigned Align = AI->getAlignment();
if (Align == 0 && TD) if (Align == 0)
Align = TD->getABITypeAlignment(AI->getType()->getElementType()); Align = TD.getABITypeAlignment(AI->getType()->getElementType());
if (Align > 0) if (Align > 0)
KnownZero = APInt::getLowBitsSet(BitWidth, countTrailingZeros(Align)); KnownZero = APInt::getLowBitsSet(BitWidth, countTrailingZeros(Align));
Context not available.
Value *Index = I->getOperand(i); Value *Index = I->getOperand(i);
if (StructType *STy = dyn_cast<StructType>(*GTI)) { if (StructType *STy = dyn_cast<StructType>(*GTI)) {
// Handle struct member offset arithmetic. // Handle struct member offset arithmetic.
if (!TD) {
TrailZ = 0;
break;
}
// Handle case when index is vector zeroinitializer // Handle case when index is vector zeroinitializer
Constant *CIndex = cast<Constant>(Index); Constant *CIndex = cast<Constant>(Index);
Context not available.
Index = CIndex->getSplatValue(); Index = CIndex->getSplatValue();
unsigned Idx = cast<ConstantInt>(Index)->getZExtValue(); unsigned Idx = cast<ConstantInt>(Index)->getZExtValue();
const StructLayout *SL = TD->getStructLayout(STy); const StructLayout *SL = TD.getStructLayout(STy);
uint64_t Offset = SL->getElementOffset(Idx); uint64_t Offset = SL->getElementOffset(Idx);
TrailZ = std::min<unsigned>(TrailZ, TrailZ = std::min<unsigned>(TrailZ,
countTrailingZeros(Offset)); countTrailingZeros(Offset));
Context not available.
break; break;
} }
unsigned GEPOpiBits = Index->getType()->getScalarSizeInBits(); unsigned GEPOpiBits = Index->getType()->getScalarSizeInBits();
uint64_t TypeSize = TD ? TD->getTypeAllocSize(IndexedTy) : 1; uint64_t TypeSize = TD.getTypeAllocSize(IndexedTy);
LocalKnownZero = LocalKnownOne = APInt(GEPOpiBits, 0); LocalKnownZero = LocalKnownOne = APInt(GEPOpiBits, 0);
computeKnownBits(Index, LocalKnownZero, LocalKnownOne, TD, Depth+1, Q); computeKnownBits(Index, LocalKnownZero, LocalKnownOne, TD, Depth+1, Q);
TrailZ = std::min(TrailZ, TrailZ = std::min(TrailZ,
Context not available.
/// Determine whether the sign bit is known to be zero or one. /// Determine whether the sign bit is known to be zero or one.
/// Convenience wrapper around computeKnownBits. /// Convenience wrapper around computeKnownBits.
void ComputeSignBit(Value *V, bool &KnownZero, bool &KnownOne, void ComputeSignBit(Value *V, bool &KnownZero, bool &KnownOne,
const DataLayout *TD, unsigned Depth, const DataLayout &TD, unsigned Depth, const Query &Q) {
const Query &Q) {
unsigned BitWidth = getBitWidth(V->getType(), TD); unsigned BitWidth = getBitWidth(V->getType(), TD);
if (!BitWidth) { if (!BitWidth) {
KnownZero = false; KnownZero = false;
Context not available.
/// be a power of two when defined. Supports values with integer or pointer /// be a power of two when defined. Supports values with integer or pointer
/// types and vectors of integers. /// types and vectors of integers.
bool isKnownToBeAPowerOfTwo(Value *V, bool OrZero, unsigned Depth, bool isKnownToBeAPowerOfTwo(Value *V, bool OrZero, unsigned Depth,
const Query &Q) { const Query &Q, const DataLayout &DL) {
if (Constant *C = dyn_cast<Constant>(V)) { if (Constant *C = dyn_cast<Constant>(V)) {
if (C->isNullValue()) if (C->isNullValue())
return OrZero; return OrZero;
Context not available.
// A shift of a power of two is a power of two or zero. // A shift of a power of two is a power of two or zero.
if (OrZero && (match(V, m_Shl(m_Value(X), m_Value())) || if (OrZero && (match(V, m_Shl(m_Value(X), m_Value())) ||
match(V, m_Shr(m_Value(X), m_Value())))) match(V, m_Shr(m_Value(X), m_Value()))))
return isKnownToBeAPowerOfTwo(X, /*OrZero*/true, Depth, Q); return isKnownToBeAPowerOfTwo(X, /*OrZero*/ true, Depth, Q, DL);
if (ZExtInst *ZI = dyn_cast<ZExtInst>(V)) if (ZExtInst *ZI = dyn_cast<ZExtInst>(V))
return isKnownToBeAPowerOfTwo(ZI->getOperand(0), OrZero, Depth, Q); return isKnownToBeAPowerOfTwo(ZI->getOperand(0), OrZero, Depth, Q, DL);
if (SelectInst *SI = dyn_cast<SelectInst>(V)) if (SelectInst *SI = dyn_cast<SelectInst>(V))
return return isKnownToBeAPowerOfTwo(SI->getTrueValue(), OrZero, Depth, Q, DL) &&
isKnownToBeAPowerOfTwo(SI->getTrueValue(), OrZero, Depth, Q) && isKnownToBeAPowerOfTwo(SI->getFalseValue(), OrZero, Depth, Q, DL);
isKnownToBeAPowerOfTwo(SI->getFalseValue(), OrZero, Depth, Q);
if (OrZero && match(V, m_And(m_Value(X), m_Value(Y)))) { if (OrZero && match(V, m_And(m_Value(X), m_Value(Y)))) {
// A power of two and'd with anything is a power of two or zero. // A power of two and'd with anything is a power of two or zero.
if (isKnownToBeAPowerOfTwo(X, /*OrZero*/true, Depth, Q) || if (isKnownToBeAPowerOfTwo(X, /*OrZero*/ true, Depth, Q, DL) ||
isKnownToBeAPowerOfTwo(Y, /*OrZero*/true, Depth, Q)) isKnownToBeAPowerOfTwo(Y, /*OrZero*/ true, Depth, Q, DL))
return true; return true;
// X & (-X) is always a power of two or zero. // X & (-X) is always a power of two or zero.
if (match(X, m_Neg(m_Specific(Y))) || match(Y, m_Neg(m_Specific(X)))) if (match(X, m_Neg(m_Specific(Y))) || match(Y, m_Neg(m_Specific(X))))
Context not available.
if (OrZero || VOBO->hasNoUnsignedWrap() || VOBO->hasNoSignedWrap()) { if (OrZero || VOBO->hasNoUnsignedWrap() || VOBO->hasNoSignedWrap()) {
if (match(X, m_And(m_Specific(Y), m_Value())) || if (match(X, m_And(m_Specific(Y), m_Value())) ||
match(X, m_And(m_Value(), m_Specific(Y)))) match(X, m_And(m_Value(), m_Specific(Y))))
if (isKnownToBeAPowerOfTwo(Y, OrZero, Depth, Q)) if (isKnownToBeAPowerOfTwo(Y, OrZero, Depth, Q, DL))
return true; return true;
if (match(Y, m_And(m_Specific(X), m_Value())) || if (match(Y, m_And(m_Specific(X), m_Value())) ||
match(Y, m_And(m_Value(), m_Specific(X)))) match(Y, m_And(m_Value(), m_Specific(X))))
if (isKnownToBeAPowerOfTwo(X, OrZero, Depth, Q)) if (isKnownToBeAPowerOfTwo(X, OrZero, Depth, Q, DL))
return true; return true;
unsigned BitWidth = V->getType()->getScalarSizeInBits(); unsigned BitWidth = V->getType()->getScalarSizeInBits();
APInt LHSZeroBits(BitWidth, 0), LHSOneBits(BitWidth, 0); APInt LHSZeroBits(BitWidth, 0), LHSOneBits(BitWidth, 0);
computeKnownBits(X, LHSZeroBits, LHSOneBits, nullptr, Depth, Q); computeKnownBits(X, LHSZeroBits, LHSOneBits, DL, Depth, Q);
APInt RHSZeroBits(BitWidth, 0), RHSOneBits(BitWidth, 0); APInt RHSZeroBits(BitWidth, 0), RHSOneBits(BitWidth, 0);
computeKnownBits(Y, RHSZeroBits, RHSOneBits, nullptr, Depth, Q); computeKnownBits(Y, RHSZeroBits, RHSOneBits, DL, Depth, Q);
// If i8 V is a power of two or zero: // If i8 V is a power of two or zero:
// ZeroBits: 1 1 1 0 1 1 1 1 // ZeroBits: 1 1 1 0 1 1 1 1
// ~ZeroBits: 0 0 0 1 0 0 0 0 // ~ZeroBits: 0 0 0 1 0 0 0 0
Context not available.
if (match(V, m_Exact(m_LShr(m_Value(), m_Value()))) || if (match(V, m_Exact(m_LShr(m_Value(), m_Value()))) ||
match(V, m_Exact(m_UDiv(m_Value(), m_Value())))) { match(V, m_Exact(m_UDiv(m_Value(), m_Value())))) {
return isKnownToBeAPowerOfTwo(cast<Operator>(V)->getOperand(0), OrZero, return isKnownToBeAPowerOfTwo(cast<Operator>(V)->getOperand(0), OrZero,
Depth, Q); Depth, Q, DL);
} }
return false; return false;
Context not available.
/// to be non-null. /// to be non-null.
/// ///
/// Currently this routine does not support vector GEPs. /// Currently this routine does not support vector GEPs.
static bool isGEPKnownNonNull(GEPOperator *GEP, const DataLayout *DL, static bool isGEPKnownNonNull(GEPOperator *GEP, const DataLayout &DL,
unsigned Depth, const Query &Q) { unsigned Depth, const Query &Q) {
if (!GEP->isInBounds() || GEP->getPointerAddressSpace() != 0) if (!GEP->isInBounds() || GEP->getPointerAddressSpace() != 0)
return false; return false;
Context not available.
if (isKnownNonZero(GEP->getPointerOperand(), DL, Depth, Q)) if (isKnownNonZero(GEP->getPointerOperand(), DL, Depth, Q))
return true; return true;
// Past this, if we don't have DataLayout, we can't do much.
if (!DL)
return false;
// Walk the GEP operands and see if any operand introduces a non-zero offset. // Walk the GEP operands and see if any operand introduces a non-zero offset.
// If so, then the GEP cannot produce a null pointer, as doing so would // If so, then the GEP cannot produce a null pointer, as doing so would
// inherently violate the inbounds contract within address space zero. // inherently violate the inbounds contract within address space zero.
Context not available.
if (StructType *STy = dyn_cast<StructType>(*GTI)) { if (StructType *STy = dyn_cast<StructType>(*GTI)) {
ConstantInt *OpC = cast<ConstantInt>(GTI.getOperand()); ConstantInt *OpC = cast<ConstantInt>(GTI.getOperand());
unsigned ElementIdx = OpC->getZExtValue(); unsigned ElementIdx = OpC->getZExtValue();
const StructLayout *SL = DL->getStructLayout(STy); const StructLayout *SL = DL.getStructLayout(STy);
uint64_t ElementOffset = SL->getElementOffset(ElementIdx); uint64_t ElementOffset = SL->getElementOffset(ElementIdx);
if (ElementOffset > 0) if (ElementOffset > 0)
return true; return true;
Context not available.
} }
// If we have a zero-sized type, the index doesn't matter. Keep looping. // If we have a zero-sized type, the index doesn't matter. Keep looping.
if (DL->getTypeAllocSize(GTI.getIndexedType()) == 0) if (DL.getTypeAllocSize(GTI.getIndexedType()) == 0)
continue; continue;
// Fast path the constant operand case both for efficiency and so we don't // Fast path the constant operand case both for efficiency and so we don't
Context not available.
/// For vectors return true if every element is known to be non-zero when /// For vectors return true if every element is known to be non-zero when
/// defined. Supports values with integer or pointer type and vectors of /// defined. Supports values with integer or pointer type and vectors of
/// integers. /// integers.
bool isKnownNonZero(Value *V, const DataLayout *TD, unsigned Depth, bool isKnownNonZero(Value *V, const DataLayout &TD, unsigned Depth,
const Query &Q) { const Query &Q) {
if (Constant *C = dyn_cast<Constant>(V)) { if (Constant *C = dyn_cast<Constant>(V)) {
if (C->isNullValue()) if (C->isNullValue())
Context not available.
// The sum of a non-negative number and a power of two is not zero. // The sum of a non-negative number and a power of two is not zero.
if (XKnownNonNegative && if (XKnownNonNegative &&
isKnownToBeAPowerOfTwo(Y, /*OrZero*/false, Depth, Q)) isKnownToBeAPowerOfTwo(Y, /*OrZero*/ false, Depth, Q, TD))
return true; return true;
if (YKnownNonNegative && if (YKnownNonNegative &&
isKnownToBeAPowerOfTwo(X, /*OrZero*/false, Depth, Q)) isKnownToBeAPowerOfTwo(X, /*OrZero*/ false, Depth, Q, TD))
return true; return true;
} }
// X * Y. // X * Y.
Context not available.
/// where V is a vector, the mask, known zero, and known one values are the /// where V is a vector, the mask, known zero, and known one values are the
/// same width as the vector element, and the bit is set only if it is true /// same width as the vector element, and the bit is set only if it is true
/// for all of the elements in the vector. /// for all of the elements in the vector.
bool MaskedValueIsZero(Value *V, const APInt &Mask, bool MaskedValueIsZero(Value *V, const APInt &Mask, const DataLayout &TD,
const DataLayout *TD, unsigned Depth, unsigned Depth, const Query &Q) {
const Query &Q) {
APInt KnownZero(Mask.getBitWidth(), 0), KnownOne(Mask.getBitWidth(), 0); APInt KnownZero(Mask.getBitWidth(), 0), KnownOne(Mask.getBitWidth(), 0);
computeKnownBits(V, KnownZero, KnownOne, TD, Depth, Q); computeKnownBits(V, KnownZero, KnownOne, TD, Depth, Q);
return (KnownZero & Mask) == Mask; return (KnownZero & Mask) == Mask;
Context not available.
/// ///
/// 'Op' must have a scalar integer type. /// 'Op' must have a scalar integer type.
/// ///
unsigned ComputeNumSignBits(Value *V, const DataLayout *TD, unsigned ComputeNumSignBits(Value *V, const DataLayout &TD, unsigned Depth,
unsigned Depth, const Query &Q) { const Query &Q) {
assert((TD || V->getType()->isIntOrIntVectorTy()) && unsigned TyBits = TD.getTypeSizeInBits(V->getType()->getScalarType());
"ComputeNumSignBits requires a DataLayout object to operate "
"on non-integer values!");
Type *Ty = V->getType();
unsigned TyBits = TD ? TD->getTypeSizeInBits(V->getType()->getScalarType()) :
Ty->getScalarSizeInBits();
unsigned Tmp, Tmp2; unsigned Tmp, Tmp2;
unsigned FirstAnswer = 1; unsigned FirstAnswer = 1;
Context not available.
/// Analyze the specified pointer to see if it can be expressed as a base /// Analyze the specified pointer to see if it can be expressed as a base
/// pointer plus a constant offset. Return the base and offset to the caller. /// pointer plus a constant offset. Return the base and offset to the caller.
Value *llvm::GetPointerBaseWithConstantOffset(Value *Ptr, int64_t &Offset, Value *llvm::GetPointerBaseWithConstantOffset(Value *Ptr, int64_t &Offset,
const DataLayout *DL) { const DataLayout &DL) {
// Without DataLayout, conservatively assume 64-bit offsets, which is // Without DataLayout, conservatively assume 64-bit offsets, which is
// the widest we support. // the widest we support.
unsigned BitWidth = DL ? DL->getPointerTypeSizeInBits(Ptr->getType()) : 64; unsigned BitWidth = DL.getPointerTypeSizeInBits(Ptr->getType());
APInt ByteOffset(BitWidth, 0); APInt ByteOffset(BitWidth, 0);
while (1) { while (1) {
if (Ptr->getType()->isVectorTy()) if (Ptr->getType()->isVectorTy())
break; break;
if (GEPOperator *GEP = dyn_cast<GEPOperator>(Ptr)) { if (GEPOperator *GEP = dyn_cast<GEPOperator>(Ptr)) {
if (DL) { APInt GEPOffset(BitWidth, 0);
APInt GEPOffset(BitWidth, 0); if (!GEP->accumulateConstantOffset(DL, GEPOffset))
if (!GEP->accumulateConstantOffset(*DL, GEPOffset)) break;
break;
ByteOffset += GEPOffset; ByteOffset += GEPOffset;
}
Ptr = GEP->getPointerOperand(); Ptr = GEP->getPointerOperand();
} else if (Operator::getOpcode(Ptr) == Instruction::BitCast || } else if (Operator::getOpcode(Ptr) == Instruction::BitCast ||
Context not available.
return Len == ~0ULL ? 1 : Len; return Len == ~0ULL ? 1 : Len;
} }
Value * Value *llvm::GetUnderlyingObject(Value *V, const DataLayout &TD,
llvm::GetUnderlyingObject(Value *V, const DataLayout *TD, unsigned MaxLookup) { unsigned MaxLookup) {
if (!V->getType()->isPointerTy()) if (!V->getType()->isPointerTy())
return V; return V;
for (unsigned Count = 0; MaxLookup == 0 || Count < MaxLookup; ++Count) { for (unsigned Count = 0; MaxLookup == 0 || Count < MaxLookup; ++Count) {
Context not available.
return V; return V;
} }
void void llvm::GetUnderlyingObjects(Value *V, SmallVectorImpl<Value *> &Objects,
llvm::GetUnderlyingObjects(Value *V, const DataLayout &TD, unsigned MaxLookup) {
SmallVectorImpl<Value *> &Objects,
const DataLayout *TD,
unsigned MaxLookup) {
SmallPtrSet<Value *, 4> Visited; SmallPtrSet<Value *, 4> Visited;
SmallVector<Value *, 4> Worklist; SmallVector<Value *, 4> Worklist;
Worklist.push_back(V); Worklist.push_back(V);
Context not available.
return true; return true;
} }
bool llvm::isSafeToSpeculativelyExecute(const Value *V, bool llvm::isSafeToSpeculativelyExecute(const Value *V) {
const DataLayout *TD) {
const Operator *Inst = dyn_cast<Operator>(V); const Operator *Inst = dyn_cast<Operator>(V);
if (!Inst) if (!Inst)
return false; return false;
Context not available.
// Speculative load may create a race that did not exist in the source. // Speculative load may create a race that did not exist in the source.
LI->getParent()->getParent()->hasFnAttribute(Attribute::SanitizeThread)) LI->getParent()->getParent()->hasFnAttribute(Attribute::SanitizeThread))
return false; return false;
return LI->getPointerOperand()->isDereferenceablePointer(TD); const DataLayout &DL = LI->getModule()->getDataLayout();
return LI->getPointerOperand()->isDereferenceablePointer(DL);
} }
case Instruction::Call: { case Instruction::Call: {
if (const IntrinsicInst *II = dyn_cast<IntrinsicInst>(Inst)) { if (const IntrinsicInst *II = dyn_cast<IntrinsicInst>(Inst)) {
Context not available.
} }
OverflowResult llvm::computeOverflowForUnsignedMul(Value *LHS, Value *RHS, OverflowResult llvm::computeOverflowForUnsignedMul(Value *LHS, Value *RHS,
const DataLayout *DL, const DataLayout &DL,
AssumptionCache *AC, AssumptionCache *AC,
const Instruction *CxtI, const Instruction *CxtI,
const DominatorTree *DT) { const DominatorTree *DT) {
Context not available.
} }
OverflowResult llvm::computeOverflowForUnsignedAdd(Value *LHS, Value *RHS, OverflowResult llvm::computeOverflowForUnsignedAdd(Value *LHS, Value *RHS,
const DataLayout *DL, const DataLayout &DL,
AssumptionCache *AC, AssumptionCache *AC,
const Instruction *CxtI, const Instruction *CxtI,
const DominatorTree *DT) { const DominatorTree *DT) {
Context not available.

lib/CodeGen/AsmPrinter/AsmPrinter.cpp

Context not available.
// If the code isn't optimized, there may be outstanding folding // If the code isn't optimized, there may be outstanding folding
// opportunities. Attempt to fold the expression using DataLayout as a // opportunities. Attempt to fold the expression using DataLayout as a
// last resort before giving up. // last resort before giving up.
if (Constant *C = ConstantFoldConstantExpression( if (Constant *C = ConstantFoldConstantExpression(CE, *TM.getDataLayout()))
CE, TM.getDataLayout()))
if (C != CE) if (C != CE)
return lowerConstant(C); return lowerConstant(C);
Context not available.
// If the constant expression's size is greater than 64-bits, then we have // If the constant expression's size is greater than 64-bits, then we have
// to emit the value in chunks. Try to constant fold the value and emit it // to emit the value in chunks. Try to constant fold the value and emit it
// that way. // that way.
Constant *New = ConstantFoldConstantExpression(CE, DL); Constant *New = ConstantFoldConstantExpression(CE, *DL);
if (New && New != CE) if (New && New != CE)
return emitGlobalConstantImpl(New, AP); return emitGlobalConstantImpl(New, AP);
} }
Context not available.

lib/CodeGen/CodeGenPrepare.cpp

Context not available.
WeakVH IterHandle(CurInstIterator); WeakVH IterHandle(CurInstIterator);
replaceAndRecursivelySimplify(CI, RetVal, replaceAndRecursivelySimplify(CI, RetVal,
TLI ? TLI->getDataLayout() : nullptr,
TLInfo, ModifiedDT ? nullptr : DT); TLInfo, ModifiedDT ? nullptr : DT);
// If the iterator instruction was recursively deleted, start over at the // If the iterator instruction was recursively deleted, start over at the
Context not available.
// From here on out we're working with named functions. // From here on out we're working with named functions.
if (!CI->getCalledFunction()) return false; if (!CI->getCalledFunction()) return false;
// We'll need DataLayout from here on out.
const DataLayout *TD = TLI ? TLI->getDataLayout() : nullptr;
if (!TD) return false;
// Lower all default uses of _chk calls. This is very similar // Lower all default uses of _chk calls. This is very similar
// to what InstCombineCalls does, but here we are only lowering calls // to what InstCombineCalls does, but here we are only lowering calls
// to fortified library functions (e.g. __memcpy_chk) that have the default // to fortified library functions (e.g. __memcpy_chk) that have the default
// "don't know" as the objectsize. Anything else should be left alone. // "don't know" as the objectsize. Anything else should be left alone.
FortifiedLibCallSimplifier Simplifier(TD, TLInfo, true); FortifiedLibCallSimplifier Simplifier(TLInfo, true);
if (Value *V = Simplifier.optimizeCall(CI)) { if (Value *V = Simplifier.optimizeCall(CI)) {
CI->replaceAllUsesWith(V); CI->replaceAllUsesWith(V);
CI->eraseFromParent(); CI->eraseFromParent();
Context not available.
// It is possible for very late stage optimizations (such as SimplifyCFG) // It is possible for very late stage optimizations (such as SimplifyCFG)
// to introduce PHI nodes too late to be cleaned up. If we detect such a // to introduce PHI nodes too late to be cleaned up. If we detect such a
// trivial PHI, go ahead and zap it here. // trivial PHI, go ahead and zap it here.
if (Value *V = SimplifyInstruction(P, TLI ? TLI->getDataLayout() : nullptr, const DataLayout &DL = I->getModule()->getDataLayout();
TLInfo, DT)) { if (Value *V = SimplifyInstruction(P, DL, TLInfo, DT)) {
P->replaceAllUsesWith(V); P->replaceAllUsesWith(V);
P->eraseFromParent(); P->eraseFromParent();
++NumPHIsElim; ++NumPHIsElim;
Context not available.

lib/CodeGen/MachineFunction.cpp

Context not available.
// DataLayout. // DataLayout.
if (isa<PointerType>(A->getType())) if (isa<PointerType>(A->getType()))
A = ConstantFoldInstOperands(Instruction::PtrToInt, IntTy, A = ConstantFoldInstOperands(Instruction::PtrToInt, IntTy,
const_cast<Constant*>(A), TD); const_cast<Constant *>(A), *TD);
else if (A->getType() != IntTy) else if (A->getType() != IntTy)
A = ConstantFoldInstOperands(Instruction::BitCast, IntTy, A = ConstantFoldInstOperands(Instruction::BitCast, IntTy,
const_cast<Constant*>(A), TD); const_cast<Constant *>(A), *TD);
if (isa<PointerType>(B->getType())) if (isa<PointerType>(B->getType()))
B = ConstantFoldInstOperands(Instruction::PtrToInt, IntTy, B = ConstantFoldInstOperands(Instruction::PtrToInt, IntTy,
const_cast<Constant*>(B), TD); const_cast<Constant *>(B), *TD);
else if (B->getType() != IntTy) else if (B->getType() != IntTy)
B = ConstantFoldInstOperands(Instruction::BitCast, IntTy, B = ConstantFoldInstOperands(Instruction::BitCast, IntTy,
const_cast<Constant*>(B), TD); const_cast<Constant *>(B), *TD);
return A == B; return A == B;
} }
Context not available.

lib/CodeGen/ScheduleDAGInstrs.cpp

Context not available.
/// getUnderlyingObjects - This is a wrapper around GetUnderlyingObjects /// getUnderlyingObjects - This is a wrapper around GetUnderlyingObjects
/// and adds support for basic ptrtoint+arithmetic+inttoptr sequences. /// and adds support for basic ptrtoint+arithmetic+inttoptr sequences.
static void getUnderlyingObjects(const Value *V, static void getUnderlyingObjects(const Value *V,
SmallVectorImpl<Value *> &Objects) { SmallVectorImpl<Value *> &Objects,
const DataLayout &DL) {
SmallPtrSet<const Value *, 16> Visited; SmallPtrSet<const Value *, 16> Visited;
SmallVector<const Value *, 4> Working(1, V); SmallVector<const Value *, 4> Working(1, V);
do { do {
V = Working.pop_back_val(); V = Working.pop_back_val();
SmallVector<Value *, 4> Objs; SmallVector<Value *, 4> Objs;
GetUnderlyingObjects(const_cast<Value *>(V), Objs); GetUnderlyingObjects(const_cast<Value *>(V), Objs, DL);
for (SmallVectorImpl<Value *>::iterator I = Objs.begin(), IE = Objs.end(); for (SmallVectorImpl<Value *>::iterator I = Objs.begin(), IE = Objs.end();
I != IE; ++I) { I != IE; ++I) {
Context not available.
/// object, return the Value for that object. /// object, return the Value for that object.
static void getUnderlyingObjectsForInstr(const MachineInstr *MI, static void getUnderlyingObjectsForInstr(const MachineInstr *MI,
const MachineFrameInfo *MFI, const MachineFrameInfo *MFI,
UnderlyingObjectsVector &Objects) { UnderlyingObjectsVector &Objects,
const DataLayout &DL) {
if (!MI->hasOneMemOperand() || if (!MI->hasOneMemOperand() ||
(!(*MI->memoperands_begin())->getValue() && (!(*MI->memoperands_begin())->getValue() &&
!(*MI->memoperands_begin())->getPseudoValue()) || !(*MI->memoperands_begin())->getPseudoValue()) ||
Context not available.
return; return;
SmallVector<Value *, 4> Objs; SmallVector<Value *, 4> Objs;
getUnderlyingObjects(V, Objs); getUnderlyingObjects(V, Objs, DL);
for (SmallVectorImpl<Value *>::iterator I = Objs.begin(), IE = Objs.end(); for (SmallVectorImpl<Value *>::iterator I = Objs.begin(), IE = Objs.end();
I != IE; ++I) { I != IE; ++I) {
Context not available.
// This MI might have either incomplete info, or known to be unsafe // This MI might have either incomplete info, or known to be unsafe
// to deal with (i.e. volatile object). // to deal with (i.e. volatile object).
static inline bool isUnsafeMemoryObject(MachineInstr *MI, static inline bool isUnsafeMemoryObject(MachineInstr *MI,
const MachineFrameInfo *MFI) { const MachineFrameInfo *MFI,
const DataLayout &DL) {
if (!MI || MI->memoperands_empty()) if (!MI || MI->memoperands_empty())
return true; return true;
// We purposefully do no check for hasOneMemOperand() here // We purposefully do no check for hasOneMemOperand() here
Context not available.
return true; return true;
SmallVector<Value *, 4> Objs; SmallVector<Value *, 4> Objs;
getUnderlyingObjects(V, Objs); getUnderlyingObjects(V, Objs, DL);
for (SmallVectorImpl<Value *>::iterator I = Objs.begin(), for (SmallVectorImpl<Value *>::iterator I = Objs.begin(),
IE = Objs.end(); I != IE; ++I) { IE = Objs.end(); I != IE; ++I) {
// Does this pointer refer to a distinct and identifiable object? // Does this pointer refer to a distinct and identifiable object?
Context not available.
/// these two MIs be reordered during scheduling from memory dependency /// these two MIs be reordered during scheduling from memory dependency
/// point of view. /// point of view.
static bool MIsNeedChainEdge(AliasAnalysis *AA, const MachineFrameInfo *MFI, static bool MIsNeedChainEdge(AliasAnalysis *AA, const MachineFrameInfo *MFI,
MachineInstr *MIa, const DataLayout &DL, MachineInstr *MIa,
MachineInstr *MIb) { MachineInstr *MIb) {
const MachineFunction *MF = MIa->getParent()->getParent(); const MachineFunction *MF = MIa->getParent()->getParent();
const TargetInstrInfo *TII = MF->getSubtarget().getInstrInfo(); const TargetInstrInfo *TII = MF->getSubtarget().getInstrInfo();
Context not available.
if (!MIa->hasOneMemOperand() || !MIb->hasOneMemOperand()) if (!MIa->hasOneMemOperand() || !MIb->hasOneMemOperand())
return true; return true;
if (isUnsafeMemoryObject(MIa, MFI) || isUnsafeMemoryObject(MIb, MFI)) if (isUnsafeMemoryObject(MIa, MFI, DL) || isUnsafeMemoryObject(MIb, MFI, DL))
return true; return true;
// If we are dealing with two "normal" loads, we do not need an edge // If we are dealing with two "normal" loads, we do not need an edge
Context not available.
/// This recursive function iterates over chain deps of SUb looking for /// This recursive function iterates over chain deps of SUb looking for
/// "latest" node that needs a chain edge to SUa. /// "latest" node that needs a chain edge to SUa.
static unsigned static unsigned iterateChainSucc(AliasAnalysis *AA, const MachineFrameInfo *MFI,
iterateChainSucc(AliasAnalysis *AA, const MachineFrameInfo *MFI, const DataLayout &DL, SUnit *SUa, SUnit *SUb,
SUnit *SUa, SUnit *SUb, SUnit *ExitSU, unsigned *Depth, SUnit *ExitSU, unsigned *Depth,
SmallPtrSetImpl<const SUnit*> &Visited) { SmallPtrSetImpl<const SUnit *> &Visited) {
if (!SUa || !SUb || SUb == ExitSU) if (!SUa || !SUb || SUb == ExitSU)
return *Depth; return *Depth;
Context not available.
// add that edge to the predecessors chain of SUb, // add that edge to the predecessors chain of SUb,
// and stop descending. // and stop descending.
if (*Depth > 200 || if (*Depth > 200 ||
MIsNeedChainEdge(AA, MFI, SUa->getInstr(), SUb->getInstr())) { MIsNeedChainEdge(AA, MFI, DL, SUa->getInstr(), SUb->getInstr())) {
SUb->addPred(SDep(SUa, SDep::MayAliasMem)); SUb->addPred(SDep(SUa, SDep::MayAliasMem));
return *Depth; return *Depth;
} }
Context not available.
for (SUnit::const_succ_iterator I = SUb->Succs.begin(), E = SUb->Succs.end(); for (SUnit::const_succ_iterator I = SUb->Succs.begin(), E = SUb->Succs.end();
I != E; ++I) I != E; ++I)
if (I->isNormalMemoryOrBarrier()) if (I->isNormalMemoryOrBarrier())
iterateChainSucc (AA, MFI, SUa, I->getSUnit(), ExitSU, Depth, Visited); iterateChainSucc(AA, MFI, DL, SUa, I->getSUnit(), ExitSU, Depth, Visited);
return *Depth; return *Depth;
} }
Context not available.
/// checks whether SU can be aliasing any node dominated /// checks whether SU can be aliasing any node dominated
/// by it. /// by it.
static void adjustChainDeps(AliasAnalysis *AA, const MachineFrameInfo *MFI, static void adjustChainDeps(AliasAnalysis *AA, const MachineFrameInfo *MFI,
SUnit *SU, SUnit *ExitSU, std::set<SUnit *> &CheckList, const DataLayout &DL, SUnit *SU, SUnit *ExitSU,
std::set<SUnit *> &CheckList,
unsigned LatencyToLoad) { unsigned LatencyToLoad) {
if (!SU) if (!SU)
return; return;
Context not available.
I != IE; ++I) { I != IE; ++I) {
if (SU == *I) if (SU == *I)
continue; continue;
if (MIsNeedChainEdge(AA, MFI, SU->getInstr(), (*I)->getInstr())) { if (MIsNeedChainEdge(AA, MFI, DL, SU->getInstr(), (*I)->getInstr())) {
SDep Dep(SU, SDep::MayAliasMem); SDep Dep(SU, SDep::MayAliasMem);
Dep.setLatency(((*I)->getInstr()->mayLoad()) ? LatencyToLoad : 0); Dep.setLatency(((*I)->getInstr()->mayLoad()) ? LatencyToLoad : 0);
(*I)->addPred(Dep); (*I)->addPred(Dep);
Context not available.
for (SUnit::const_succ_iterator J = (*I)->Succs.begin(), for (SUnit::const_succ_iterator J = (*I)->Succs.begin(),
JE = (*I)->Succs.end(); J != JE; ++J) JE = (*I)->Succs.end(); J != JE; ++J)
if (J->isNormalMemoryOrBarrier()) if (J->isNormalMemoryOrBarrier())
iterateChainSucc (AA, MFI, SU, J->getSUnit(), iterateChainSucc(AA, MFI, DL, SU, J->getSUnit(), ExitSU, &Depth,
ExitSU, &Depth, Visited); Visited);
} }
} }
/// Check whether two objects need a chain edge, if so, add it /// Check whether two objects need a chain edge, if so, add it
/// otherwise remember the rejected SU. /// otherwise remember the rejected SU.
static inline static inline void addChainDependency(AliasAnalysis *AA,
void addChainDependency (AliasAnalysis *AA, const MachineFrameInfo *MFI, const MachineFrameInfo *MFI,
SUnit *SUa, SUnit *SUb, const DataLayout &DL, SUnit *SUa,
std::set<SUnit *> &RejectList, SUnit *SUb, std::set<SUnit *> &RejectList,
unsigned TrueMemOrderLatency = 0, unsigned TrueMemOrderLatency = 0,
bool isNormalMemory = false) { bool isNormalMemory = false) {
// If this is a false dependency, // If this is a false dependency,
// do not add the edge, but rememeber the rejected node. // do not add the edge, but rememeber the rejected node.
if (MIsNeedChainEdge(AA, MFI, SUa->getInstr(), SUb->getInstr())) { if (MIsNeedChainEdge(AA, MFI, DL, SUa->getInstr(), SUb->getInstr())) {
SDep Dep(SUa, isNormalMemory ? SDep::MayAliasMem : SDep::Barrier); SDep Dep(SUa, isNormalMemory ? SDep::MayAliasMem : SDep::Barrier);
Dep.setLatency(TrueMemOrderLatency); Dep.setLatency(TrueMemOrderLatency);
SUb->addPred(Dep); SUb->addPred(Dep);
Context not available.
BarrierChain = SU; BarrierChain = SU;
// This is a barrier event that acts as a pivotal node in the DAG, // This is a barrier event that acts as a pivotal node in the DAG,
// so it is safe to clear list of exposed nodes. // so it is safe to clear list of exposed nodes.
adjustChainDeps(AA, MFI, SU, &ExitSU, RejectMemNodes, adjustChainDeps(AA, MFI, *TM.getDataLayout(), SU, &ExitSU, RejectMemNodes,
TrueMemOrderLatency); TrueMemOrderLatency);
RejectMemNodes.clear(); RejectMemNodes.clear();
NonAliasMemDefs.clear(); NonAliasMemDefs.clear();
Context not available.
unsigned ChainLatency = 0; unsigned ChainLatency = 0;
if (AliasChain->getInstr()->mayLoad()) if (AliasChain->getInstr()->mayLoad())
ChainLatency = TrueMemOrderLatency; ChainLatency = TrueMemOrderLatency;
addChainDependency(AAForDep, MFI, SU, AliasChain, RejectMemNodes, addChainDependency(AAForDep, MFI, *TM.getDataLayout(), SU, AliasChain,
ChainLatency); RejectMemNodes, ChainLatency);
} }
AliasChain = SU; AliasChain = SU;
for (unsigned k = 0, m = PendingLoads.size(); k != m; ++k) for (unsigned k = 0, m = PendingLoads.size(); k != m; ++k)
addChainDependency(AAForDep, MFI, SU, PendingLoads[k], RejectMemNodes, addChainDependency(AAForDep, MFI, *TM.getDataLayout(), SU,
PendingLoads[k], RejectMemNodes,
TrueMemOrderLatency); TrueMemOrderLatency);
for (MapVector<ValueType, std::vector<SUnit *> >::iterator I = for (MapVector<ValueType, std::vector<SUnit *> >::iterator I =
AliasMemDefs.begin(), E = AliasMemDefs.end(); I != E; ++I) { AliasMemDefs.begin(), E = AliasMemDefs.end(); I != E; ++I) {
for (unsigned i = 0, e = I->second.size(); i != e; ++i) for (unsigned i = 0, e = I->second.size(); i != e; ++i)
addChainDependency(AAForDep, MFI, SU, I->second[i], RejectMemNodes); addChainDependency(AAForDep, MFI, *TM.getDataLayout(), SU,
I->second[i], RejectMemNodes);
} }
for (MapVector<ValueType, std::vector<SUnit *> >::iterator I = for (MapVector<ValueType, std::vector<SUnit *> >::iterator I =
AliasMemUses.begin(), E = AliasMemUses.end(); I != E; ++I) { AliasMemUses.begin(), E = AliasMemUses.end(); I != E; ++I) {
for (unsigned i = 0, e = I->second.size(); i != e; ++i) for (unsigned i = 0, e = I->second.size(); i != e; ++i)
addChainDependency(AAForDep, MFI, SU, I->second[i], RejectMemNodes, addChainDependency(AAForDep, MFI, *TM.getDataLayout(), SU,
TrueMemOrderLatency); I->second[i], RejectMemNodes, TrueMemOrderLatency);
} }
adjustChainDeps(AA, MFI, SU, &ExitSU, RejectMemNodes, adjustChainDeps(AA, MFI, *TM.getDataLayout(), SU, &ExitSU, RejectMemNodes,
TrueMemOrderLatency); TrueMemOrderLatency);
PendingLoads.clear(); PendingLoads.clear();
AliasMemDefs.clear(); AliasMemDefs.clear();
Context not available.
BarrierChain->addPred(SDep(SU, SDep::Barrier)); BarrierChain->addPred(SDep(SU, SDep::Barrier));
UnderlyingObjectsVector Objs; UnderlyingObjectsVector Objs;
getUnderlyingObjectsForInstr(MI, MFI, Objs); getUnderlyingObjectsForInstr(MI, MFI, Objs, *TM.getDataLayout());
if (Objs.empty()) { if (Objs.empty()) {
// Treat all other stores conservatively. // Treat all other stores conservatively.
Context not available.
((ThisMayAlias) ? AliasMemDefs.end() : NonAliasMemDefs.end()); ((ThisMayAlias) ? AliasMemDefs.end() : NonAliasMemDefs.end());
if (I != IE) { if (I != IE) {
for (unsigned i = 0, e = I->second.size(); i != e; ++i) for (unsigned i = 0, e = I->second.size(); i != e; ++i)
addChainDependency(AAForDep, MFI, SU, I->second[i], RejectMemNodes, addChainDependency(AAForDep, MFI, *TM.getDataLayout(), SU,
0, true); I->second[i], RejectMemNodes, 0, true);
// If we're not using AA, then we only need one store per object. // If we're not using AA, then we only need one store per object.
if (!AAForDep) if (!AAForDep)
Context not available.
((ThisMayAlias) ? AliasMemUses.end() : NonAliasMemUses.end()); ((ThisMayAlias) ? AliasMemUses.end() : NonAliasMemUses.end());
if (J != JE) { if (J != JE) {
for (unsigned i = 0, e = J->second.size(); i != e; ++i) for (unsigned i = 0, e = J->second.size(); i != e; ++i)
addChainDependency(AAForDep, MFI, SU, J->second[i], RejectMemNodes, addChainDependency(AAForDep, MFI, *TM.getDataLayout(), SU,
J->second[i], RejectMemNodes,
TrueMemOrderLatency, true); TrueMemOrderLatency, true);
J->second.clear(); J->second.clear();
} }
Context not available.
// Add dependencies from all the PendingLoads, i.e. loads // Add dependencies from all the PendingLoads, i.e. loads
// with no underlying object. // with no underlying object.
for (unsigned k = 0, m = PendingLoads.size(); k != m; ++k) for (unsigned k = 0, m = PendingLoads.size(); k != m; ++k)
addChainDependency(AAForDep, MFI, SU, PendingLoads[k], RejectMemNodes, addChainDependency(AAForDep, MFI, *TM.getDataLayout(), SU,
PendingLoads[k], RejectMemNodes,
TrueMemOrderLatency); TrueMemOrderLatency);
// Add dependence on alias chain, if needed. // Add dependence on alias chain, if needed.
if (AliasChain) if (AliasChain)
addChainDependency(AAForDep, MFI, SU, AliasChain, RejectMemNodes); addChainDependency(AAForDep, MFI, *TM.getDataLayout(), SU, AliasChain,
RejectMemNodes);
} }
adjustChainDeps(AA, MFI, SU, &ExitSU, RejectMemNodes, adjustChainDeps(AA, MFI, *TM.getDataLayout(), SU, &ExitSU, RejectMemNodes,
TrueMemOrderLatency); TrueMemOrderLatency);
} else if (MI->mayLoad()) { } else if (MI->mayLoad()) {
bool MayAlias = true; bool MayAlias = true;
Context not available.
// Invariant load, no chain dependencies needed! // Invariant load, no chain dependencies needed!
} else { } else {
UnderlyingObjectsVector Objs; UnderlyingObjectsVector Objs;
getUnderlyingObjectsForInstr(MI, MFI, Objs); getUnderlyingObjectsForInstr(MI, MFI, Objs, *TM.getDataLayout());
if (Objs.empty()) { if (Objs.empty()) {
// A load with no underlying object. Depend on all // A load with no underlying object. Depend on all
Context not available.
for (MapVector<ValueType, std::vector<SUnit *> >::iterator I = for (MapVector<ValueType, std::vector<SUnit *> >::iterator I =
AliasMemDefs.begin(), E = AliasMemDefs.end(); I != E; ++I) AliasMemDefs.begin(), E = AliasMemDefs.end(); I != E; ++I)
for (unsigned i = 0, e = I->second.size(); i != e; ++i) for (unsigned i = 0, e = I->second.size(); i != e; ++i)
addChainDependency(AAForDep, MFI, SU, I->second[i], addChainDependency(AAForDep, MFI, *TM.getDataLayout(), SU,
RejectMemNodes); I->second[i], RejectMemNodes);
PendingLoads.push_back(SU); PendingLoads.push_back(SU);
MayAlias = true; MayAlias = true;
Context not available.
((ThisMayAlias) ? AliasMemDefs.end() : NonAliasMemDefs.end()); ((ThisMayAlias) ? AliasMemDefs.end() : NonAliasMemDefs.end());
if (I != IE) if (I != IE)
for (unsigned i = 0, e = I->second.size(); i != e; ++i) for (unsigned i = 0, e = I->second.size(); i != e; ++i)
addChainDependency(AAForDep, MFI, SU, I->second[i], addChainDependency(AAForDep, MFI, *TM.getDataLayout(), SU,
RejectMemNodes, 0, true); I->second[i], RejectMemNodes, 0, true);
if (ThisMayAlias) if (ThisMayAlias)
AliasMemUses[V].push_back(SU); AliasMemUses[V].push_back(SU);
else else
NonAliasMemUses[V].push_back(SU); NonAliasMemUses[V].push_back(SU);
} }
if (MayAlias) if (MayAlias)
adjustChainDeps(AA, MFI, SU, &ExitSU, RejectMemNodes, /*Latency=*/0); adjustChainDeps(AA, MFI, *TM.getDataLayout(), SU, &ExitSU,
RejectMemNodes, /*Latency=*/0);
// Add dependencies on alias and barrier chains, if needed. // Add dependencies on alias and barrier chains, if needed.
if (MayAlias && AliasChain) if (MayAlias && AliasChain)
addChainDependency(AAForDep, MFI, SU, AliasChain, RejectMemNodes); addChainDependency(AAForDep, MFI, *TM.getDataLayout(), SU, AliasChain,
RejectMemNodes);
if (BarrierChain) if (BarrierChain)
BarrierChain->addPred(SDep(SU, SDep::Barrier)); BarrierChain->addPred(SDep(SU, SDep::Barrier));
} }
Context not available.

lib/CodeGen/SelectionDAG/SelectionDAG.cpp

Context not available.
if (TLI->isGAPlusOffset(Ptr.getNode(), GV, GVOffset)) { if (TLI->isGAPlusOffset(Ptr.getNode(), GV, GVOffset)) {
unsigned PtrWidth = TLI->getPointerTypeSizeInBits(GV->getType()); unsigned PtrWidth = TLI->getPointerTypeSizeInBits(GV->getType());
APInt KnownZero(PtrWidth, 0), KnownOne(PtrWidth, 0); APInt KnownZero(PtrWidth, 0), KnownOne(PtrWidth, 0);
llvm::computeKnownBits(const_cast<GlobalValue*>(GV), KnownZero, KnownOne, llvm::computeKnownBits(const_cast<GlobalValue *>(GV), KnownZero, KnownOne,
TLI->getDataLayout()); *TLI->getDataLayout());
unsigned AlignBits = KnownZero.countTrailingOnes(); unsigned AlignBits = KnownZero.countTrailingOnes();
unsigned Align = AlignBits ? 1 << std::min(31U, AlignBits) : 0; unsigned Align = AlignBits ? 1 << std::min(31U, AlignBits) : 0;
if (Align) if (Align)
Context not available.

lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

Context not available.
return nullptr; return nullptr;
SmallVector<Value *, 4> Allocas; SmallVector<Value *, 4> Allocas;
GetUnderlyingObjects(I.getArgOperand(1), Allocas, DL); GetUnderlyingObjects(I.getArgOperand(1), Allocas, *DL);
for (SmallVectorImpl<Value*>::iterator Object = Allocas.begin(), for (SmallVectorImpl<Value*>::iterator Object = Allocas.begin(),
E = Allocas.end(); Object != E; ++Object) { E = Allocas.end(); Object != E; ++Object) {
Context not available.
LoadInput = ConstantExpr::getBitCast(const_cast<Constant *>(LoadInput), LoadInput = ConstantExpr::getBitCast(const_cast<Constant *>(LoadInput),
PointerType::getUnqual(LoadTy)); PointerType::getUnqual(LoadTy));
if (const Constant *LoadCst = if (const Constant *LoadCst = ConstantFoldLoadFromConstPtr(
ConstantFoldLoadFromConstPtr(const_cast<Constant *>(LoadInput), const_cast<Constant *>(LoadInput), *Builder.DL))
Builder.DL))
return Builder.getValue(LoadCst); return Builder.getValue(LoadCst);
} }
Context not available.

lib/CodeGen/TargetLoweringBase.cpp

Context not available.
} }
/// NOTE: The TargetMachine owns TLOF. /// NOTE: The TargetMachine owns TLOF.
TargetLoweringBase::TargetLoweringBase(const TargetMachine &tm) TargetLoweringBase::TargetLoweringBase(const TargetMachine &tm) : TM(tm) {
: TM(tm), DL(TM.getDataLayout()) {
initActions(); initActions();
// Perform these initializations only once. // Perform these initializations only once.
IsLittleEndian = DL->isLittleEndian(); IsLittleEndian = getDataLayout()->isLittleEndian();
MaxStoresPerMemset = MaxStoresPerMemcpy = MaxStoresPerMemmove = 8; MaxStoresPerMemset = MaxStoresPerMemcpy = MaxStoresPerMemmove = 8;
MaxStoresPerMemsetOptSize = MaxStoresPerMemcpyOptSize MaxStoresPerMemsetOptSize = MaxStoresPerMemcpyOptSize
= MaxStoresPerMemmoveOptSize = 4; = MaxStoresPerMemmoveOptSize = 4;
Context not available.
} }
unsigned TargetLoweringBase::getPointerSizeInBits(uint32_t AS) const { unsigned TargetLoweringBase::getPointerSizeInBits(uint32_t AS) const {
return DL->getPointerSizeInBits(AS); return getDataLayout()->getPointerSizeInBits(AS);
} }
unsigned TargetLoweringBase::getPointerTypeSizeInBits(Type *Ty) const { unsigned TargetLoweringBase::getPointerTypeSizeInBits(Type *Ty) const {
Context not available.
} }
MVT TargetLoweringBase::getScalarShiftAmountTy(EVT LHSTy) const { MVT TargetLoweringBase::getScalarShiftAmountTy(EVT LHSTy) const {
return MVT::getIntegerVT(8*DL->getPointerSize(0)); return MVT::getIntegerVT(8 * getDataLayout()->getPointerSize(0));
} }
EVT TargetLoweringBase::getShiftAmountTy(EVT LHSTy) const { EVT TargetLoweringBase::getShiftAmountTy(EVT LHSTy) const {
Context not available.
/// function arguments in the caller parameter area. This is the actual /// function arguments in the caller parameter area. This is the actual
/// alignment, not its logarithm. /// alignment, not its logarithm.
unsigned TargetLoweringBase::getByValTypeAlignment(Type *Ty) const { unsigned TargetLoweringBase::getByValTypeAlignment(Type *Ty) const {
return DL->getABITypeAlignment(Ty); return getDataLayout()->getABITypeAlignment(Ty);
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
Context not available.

lib/CodeGen/WinEHPrepare.cpp

Context not available.
BasicBlock::iterator II = LPad; BasicBlock::iterator II = LPad;
CloneAndPruneIntoFromInst( CloneAndPruneIntoFromInst(Handler, SrcFn, ++II, VMap,
Handler, SrcFn, ++II, VMap, /*ModuleLevelChanges=*/false, Returns, "",
/*ModuleLevelChanges=*/false, Returns, "", &InlinedFunctionInfo, &InlinedFunctionInfo, Director.get());
&SrcFn->getParent()->getDataLayout(), Director.get());
// Move all the instructions in the first cloned block into our entry block. // Move all the instructions in the first cloned block into our entry block.
BasicBlock *FirstClonedBB = std::next(Function::iterator(Entry)); BasicBlock *FirstClonedBB = std::next(Function::iterator(Entry));
Context not available.

lib/IR/Instructions.cpp

Context not available.
return isNoopCast(getOpcode(), getOperand(0)->getType(), getType(), IntPtrTy); return isNoopCast(getOpcode(), getOperand(0)->getType(), getType(), IntPtrTy);
} }
bool CastInst::isNoopCast(const DataLayout *DL) const { bool CastInst::isNoopCast(const DataLayout &DL) const {
if (!DL) {
// Assume maximum pointer size.
return isNoopCast(Type::getInt64Ty(getContext()));
}
Type *PtrOpTy = nullptr; Type *PtrOpTy = nullptr;
if (getOpcode() == Instruction::PtrToInt) if (getOpcode() == Instruction::PtrToInt)
PtrOpTy = getOperand(0)->getType(); PtrOpTy = getOperand(0)->getType();
else if (getOpcode() == Instruction::IntToPtr) else if (getOpcode() == Instruction::IntToPtr)
PtrOpTy = getType(); PtrOpTy = getType();
Type *IntPtrTy = PtrOpTy Type *IntPtrTy =
? DL->getIntPtrType(PtrOpTy) PtrOpTy ? DL.getIntPtrType(PtrOpTy) : DL.getIntPtrType(getContext(), 0);
: DL->getIntPtrType(getContext(), 0);
return isNoopCast(getOpcode(), getOperand(0)->getType(), getType(), IntPtrTy); return isNoopCast(getOpcode(), getOperand(0)->getType(), getType(), IntPtrTy);
} }
Context not available.
} }
bool CastInst::isBitOrNoopPointerCastable(Type *SrcTy, Type *DestTy, bool CastInst::isBitOrNoopPointerCastable(Type *SrcTy, Type *DestTy,
const DataLayout *DL) { const DataLayout &DL) {
if (auto *PtrTy = dyn_cast<PointerType>(SrcTy)) if (auto *PtrTy = dyn_cast<PointerType>(SrcTy))
if (auto *IntTy = dyn_cast<IntegerType>(DestTy)) if (auto *IntTy = dyn_cast<IntegerType>(DestTy))
return DL && IntTy->getBitWidth() == DL->getPointerTypeSizeInBits(PtrTy); return IntTy->getBitWidth() == DL.getPointerTypeSizeInBits(PtrTy);
if (auto *PtrTy = dyn_cast<PointerType>(DestTy)) if (auto *PtrTy = dyn_cast<PointerType>(DestTy))
if (auto *IntTy = dyn_cast<IntegerType>(SrcTy)) if (auto *IntTy = dyn_cast<IntegerType>(SrcTy))
return DL && IntTy->getBitWidth() == DL->getPointerTypeSizeInBits(PtrTy); return IntTy->getBitWidth() == DL.getPointerTypeSizeInBits(PtrTy);
return isBitCastable(SrcTy, DestTy); return isBitCastable(SrcTy, DestTy);
} }
Context not available.

lib/IR/Value.cpp

Context not available.
/// ///
/// Test if V is always a pointer to allocated and suitably aligned memory for /// Test if V is always a pointer to allocated and suitably aligned memory for
/// a simple load or store. /// a simple load or store.
static bool isDereferenceablePointer(const Value *V, const DataLayout *DL, static bool isDereferenceablePointer(const Value *V, const DataLayout &DL,
SmallPtrSetImpl<const Value *> &Visited) { SmallPtrSetImpl<const Value *> &Visited) {
// Note that it is not safe to speculate into a malloc'd region because // Note that it is not safe to speculate into a malloc'd region because
// malloc may return null. // malloc may return null.
Context not available.
// to a type of smaller size (or the same size), and the alignment // to a type of smaller size (or the same size), and the alignment
// is at least as large as for the resulting pointer type, then // is at least as large as for the resulting pointer type, then
// we can look through the bitcast. // we can look through the bitcast.
if (DL) if (const BitCastOperator *BC = dyn_cast<BitCastOperator>(V)) {
if (const BitCastOperator *BC = dyn_cast<BitCastOperator>(V)) { Type *STy = BC->getSrcTy()->getPointerElementType(),
Type *STy = BC->getSrcTy()->getPointerElementType(), *DTy = BC->getDestTy()->getPointerElementType();
*DTy = BC->getDestTy()->getPointerElementType(); if (STy->isSized() && DTy->isSized() &&
if (STy->isSized() && DTy->isSized() && (DL.getTypeStoreSize(STy) >= DL.getTypeStoreSize(DTy)) &&
(DL->getTypeStoreSize(STy) >= (DL.getABITypeAlignment(STy) >= DL.getABITypeAlignment(DTy)))
DL->getTypeStoreSize(DTy)) && return isDereferenceablePointer(BC->getOperand(0), DL, Visited);
(DL->getABITypeAlignment(STy) >= }
DL->getABITypeAlignment(DTy)))
return isDereferenceablePointer(BC->getOperand(0), DL, Visited);
}
// Global variables which can't collapse to null are ok. // Global variables which can't collapse to null are ok.
if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(V)) if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(V))
Context not available.
return true; return true;
else if (uint64_t Bytes = A->getDereferenceableBytes()) { else if (uint64_t Bytes = A->getDereferenceableBytes()) {
Type *Ty = V->getType()->getPointerElementType(); Type *Ty = V->getType()->getPointerElementType();
if (Ty->isSized() && DL && DL->getTypeStoreSize(Ty) <= Bytes) if (Ty->isSized() && DL.getTypeStoreSize(Ty) <= Bytes)
return true; return true;
} }
Context not available.
if (ImmutableCallSite CS = V) { if (ImmutableCallSite CS = V) {
if (uint64_t Bytes = CS.getDereferenceableBytes(0)) { if (uint64_t Bytes = CS.getDereferenceableBytes(0)) {
Type *Ty = V->getType()->getPointerElementType(); Type *Ty = V->getType()->getPointerElementType();
if (Ty->isSized() && DL && DL->getTypeStoreSize(Ty) <= Bytes) if (Ty->isSized() && DL.getTypeStoreSize(Ty) <= Bytes)
return true; return true;
} }
} }
Context not available.
return false; return false;
} }
bool Value::isDereferenceablePointer(const DataLayout *DL) const { bool Value::isDereferenceablePointer(const DataLayout &DL) const {
// When dereferenceability information is provided by a dereferenceable // When dereferenceability information is provided by a dereferenceable
// attribute, we know exactly how many bytes are dereferenceable. If we can // attribute, we know exactly how many bytes are dereferenceable. If we can
// determine the exact offset to the attributed variable, we can use that // determine the exact offset to the attributed variable, we can use that
// information here. // information here.
Type *Ty = getType()->getPointerElementType(); Type *Ty = getType()->getPointerElementType();
if (Ty->isSized() && DL) { if (Ty->isSized()) {
APInt Offset(DL->getTypeStoreSizeInBits(getType()), 0); APInt Offset(DL.getTypeStoreSizeInBits(getType()), 0);
const Value *BV = stripAndAccumulateInBoundsConstantOffsets(*DL, Offset); const Value *BV = stripAndAccumulateInBoundsConstantOffsets(DL, Offset);
APInt DerefBytes(Offset.getBitWidth(), 0); APInt DerefBytes(Offset.getBitWidth(), 0);
if (const Argument *A = dyn_cast<Argument>(BV)) if (const Argument *A = dyn_cast<Argument>(BV))
Context not available.
DerefBytes = CS.getDereferenceableBytes(0); DerefBytes = CS.getDereferenceableBytes(0);
if (DerefBytes.getBoolValue() && Offset.isNonNegative()) { if (DerefBytes.getBoolValue() && Offset.isNonNegative()) {
if (DerefBytes.uge(Offset + DL->getTypeStoreSize(Ty))) if (DerefBytes.uge(Offset + DL.getTypeStoreSize(Ty)))
return true; return true;
} }
} }
Context not available.

lib/Target/Mips/MipsDelaySlotFiller.cpp

Context not available.
/// memory instruction can be moved to a delay slot. /// memory instruction can be moved to a delay slot.
class MemDefsUses : public InspectMemInstr { class MemDefsUses : public InspectMemInstr {
public: public:
MemDefsUses(const MachineFrameInfo *MFI); MemDefsUses(const DataLayout &DL, const MachineFrameInfo *MFI);
private: private:
typedef PointerUnion<const Value *, const PseudoSourceValue *> ValueType; typedef PointerUnion<const Value *, const PseudoSourceValue *> ValueType;
Context not available.
const MachineFrameInfo *MFI; const MachineFrameInfo *MFI;
SmallPtrSet<ValueType, 4> Uses, Defs; SmallPtrSet<ValueType, 4> Uses, Defs;
const DataLayout &DL;
/// Flags indicating whether loads or stores with no underlying objects have /// Flags indicating whether loads or stores with no underlying objects have
/// been seen. /// been seen.
Context not available.
return true; return true;
} }
MemDefsUses::MemDefsUses(const MachineFrameInfo *MFI_) MemDefsUses::MemDefsUses(const DataLayout &DL, const MachineFrameInfo *MFI_)
: InspectMemInstr(false), MFI(MFI_), SeenNoObjLoad(false), : InspectMemInstr(false), MFI(MFI_), DL(DL), SeenNoObjLoad(false),
SeenNoObjStore(false) {} SeenNoObjStore(false) {}
bool MemDefsUses::hasHazard_(const MachineInstr &MI) { bool MemDefsUses::hasHazard_(const MachineInstr &MI) {
bool HasHazard = false; bool HasHazard = false;
Context not available.
const Value *V = (*MI.memoperands_begin())->getValue(); const Value *V = (*MI.memoperands_begin())->getValue();
SmallVector<Value *, 4> Objs; SmallVector<Value *, 4> Objs;
GetUnderlyingObjects(const_cast<Value *>(V), Objs); GetUnderlyingObjects(const_cast<Value *>(V), Objs, DL);
for (SmallVectorImpl<Value *>::iterator I = Objs.begin(), E = Objs.end(); for (SmallVectorImpl<Value *>::iterator I = Objs.begin(), E = Objs.end();
I != E; ++I) { I != E; ++I) {
Context not available.
return false; return false;
RegDefsUses RegDU(*MBB.getParent()->getSubtarget().getRegisterInfo()); RegDefsUses RegDU(*MBB.getParent()->getSubtarget().getRegisterInfo());
MemDefsUses MemDU(MBB.getParent()->getFrameInfo()); MemDefsUses MemDU(*TM.getDataLayout(), MBB.getParent()->getFrameInfo());
ReverseIter Filler; ReverseIter Filler;
RegDU.init(*Slot); RegDU.init(*Slot);
Context not available.
IM.reset(new LoadFromStackOrConst()); IM.reset(new LoadFromStackOrConst());
} else { } else {
const MachineFrameInfo *MFI = MBB.getParent()->getFrameInfo(); const MachineFrameInfo *MFI = MBB.getParent()->getFrameInfo();
IM.reset(new MemDefsUses(MFI)); IM.reset(new MemDefsUses(*TM.getDataLayout(), MFI));
} }
if (!searchRange(MBB, SuccBB->begin(), SuccBB->end(), RegDU, *IM, Slot, if (!searchRange(MBB, SuccBB->begin(), SuccBB->end(), RegDU, *IM, Slot,
Context not available.

lib/Target/NVPTX/NVPTXAsmPrinter.cpp

Context not available.
break; break;
} else if (const ConstantExpr *Cexpr = dyn_cast<ConstantExpr>(CPV)) { } else if (const ConstantExpr *Cexpr = dyn_cast<ConstantExpr>(CPV)) {
if (const ConstantInt *constInt = dyn_cast<ConstantInt>( if (const ConstantInt *constInt = dyn_cast<ConstantInt>(
ConstantFoldConstantExpression(Cexpr, TD))) { ConstantFoldConstantExpression(Cexpr, *TD))) {
int int32 = (int)(constInt->getZExtValue()); int int32 = (int)(constInt->getZExtValue());
ptr = (unsigned char *)&int32; ptr = (unsigned char *)&int32;
aggBuffer->addBytes(ptr, 4, Bytes); aggBuffer->addBytes(ptr, 4, Bytes);
Context not available.
break; break;
} else if (const ConstantExpr *Cexpr = dyn_cast<ConstantExpr>(CPV)) { } else if (const ConstantExpr *Cexpr = dyn_cast<ConstantExpr>(CPV)) {
if (const ConstantInt *constInt = dyn_cast<ConstantInt>( if (const ConstantInt *constInt = dyn_cast<ConstantInt>(
ConstantFoldConstantExpression(Cexpr, TD))) { ConstantFoldConstantExpression(Cexpr, *TD))) {
long long int64 = (long long)(constInt->getZExtValue()); long long int64 = (long long)(constInt->getZExtValue());
ptr = (unsigned char *)&int64; ptr = (unsigned char *)&int64;
aggBuffer->addBytes(ptr, 8, Bytes); aggBuffer->addBytes(ptr, 8, Bytes);
Context not available.

lib/Target/PowerPC/PPCCTRLoops.cpp

Context not available.
// selected branch. // selected branch.
MadeChange = true; MadeChange = true;
SCEVExpander SCEVE(*SE, "loopcnt"); SCEVExpander SCEVE(*SE, Preheader->getModule()->getDataLayout(), "loopcnt");
LLVMContext &C = SE->getContext(); LLVMContext &C = SE->getContext();
Type *CountType = TT.isArch64Bit() ? Type::getInt64Ty(C) : Type *CountType = TT.isArch64Bit() ? Type::getInt64Ty(C) :
Type::getInt32Ty(C); Type::getInt32Ty(C);
Context not available.

lib/Target/PowerPC/PPCLoopDataPrefetch.cpp

Context not available.
PrefLoads.push_back(std::make_pair(MemI, LSCEVAddRec)); PrefLoads.push_back(std::make_pair(MemI, LSCEVAddRec));
Type *I8Ptr = Type::getInt8PtrTy((*I)->getContext(), PtrAddrSpace); Type *I8Ptr = Type::getInt8PtrTy((*I)->getContext(), PtrAddrSpace);
SCEVExpander SCEVE(*SE, "prefaddr"); SCEVExpander SCEVE(*SE, J->getModule()->getDataLayout(), "prefaddr");
Value *PrefPtrValue = SCEVE.expandCodeFor(NextLSCEV, I8Ptr, MemI); Value *PrefPtrValue = SCEVE.expandCodeFor(NextLSCEV, I8Ptr, MemI);
IRBuilder<> Builder(MemI); IRBuilder<> Builder(MemI);
Context not available.

lib/Target/PowerPC/PPCLoopPreIncPrep.cpp

Context not available.
MemI->hasName() ? MemI->getName() + ".phi" : "", MemI->hasName() ? MemI->getName() + ".phi" : "",
Header->getFirstNonPHI()); Header->getFirstNonPHI());
SCEVExpander SCEVE(*SE, "pistart"); SCEVExpander SCEVE(*SE, Header->getModule()->getDataLayout(), "pistart");
Value *BasePtrStart = SCEVE.expandCodeFor(BasePtrStartSCEV, I8PtrTy, Value *BasePtrStart = SCEVE.expandCodeFor(BasePtrStartSCEV, I8PtrTy,
LoopPredecessor->getTerminator()); LoopPredecessor->getTerminator());
Context not available.

lib/Target/R600/AMDGPUTargetTransformInfo.cpp

Context not available.
#include "llvm/Analysis/TargetTransformInfo.h" #include "llvm/Analysis/TargetTransformInfo.h"
#include "llvm/Analysis/ValueTracking.h" #include "llvm/Analysis/ValueTracking.h"
#include "llvm/CodeGen/BasicTTIImpl.h" #include "llvm/CodeGen/BasicTTIImpl.h"
#include "llvm/IR/Module.h"
#include "llvm/Support/Debug.h" #include "llvm/Support/Debug.h"
#include "llvm/Target/CostTable.h" #include "llvm/Target/CostTable.h"
#include "llvm/Target/TargetLowering.h" #include "llvm/Target/TargetLowering.h"
Context not available.
// TODO: Do we want runtime unrolling? // TODO: Do we want runtime unrolling?
for (const BasicBlock *BB : L->getBlocks()) { for (const BasicBlock *BB : L->getBlocks()) {
const DataLayout &DL = BB->getModule()->getDataLayout();
for (const Instruction &I : *BB) { for (const Instruction &I : *BB) {
const GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(&I); const GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(&I);
if (!GEP || GEP->getAddressSpace() != AMDGPUAS::PRIVATE_ADDRESS) if (!GEP || GEP->getAddressSpace() != AMDGPUAS::PRIVATE_ADDRESS)
continue; continue;
const Value *Ptr = GEP->getPointerOperand(); const Value *Ptr = GEP->getPointerOperand();
const AllocaInst *Alloca = dyn_cast<AllocaInst>(GetUnderlyingObject(Ptr)); const AllocaInst *Alloca =
dyn_cast<AllocaInst>(GetUnderlyingObject(Ptr, DL));
if (Alloca) { if (Alloca) {
// We want to do whatever we can to limit the number of alloca // We want to do whatever we can to limit the number of alloca
// instructions that make it through to the code generator. allocas // instructions that make it through to the code generator. allocas
Context not available.

lib/Target/R600/R600ISelLowering.cpp

Context not available.
// Lower loads constant address space global variable loads // Lower loads constant address space global variable loads
if (LoadNode->getAddressSpace() == AMDGPUAS::CONSTANT_ADDRESS && if (LoadNode->getAddressSpace() == AMDGPUAS::CONSTANT_ADDRESS &&
isa<GlobalVariable>( isa<GlobalVariable>(GetUnderlyingObject(
GetUnderlyingObject(LoadNode->getMemOperand()->getValue()))) { LoadNode->getMemOperand()->getValue(), *getDataLayout()))) {
SDValue Ptr = DAG.getZExtOrTrunc(LoadNode->getBasePtr(), DL, SDValue Ptr = DAG.getZExtOrTrunc(LoadNode->getBasePtr(), DL,
getPointerTy(AMDGPUAS::PRIVATE_ADDRESS)); getPointerTy(AMDGPUAS::PRIVATE_ADDRESS));
Context not available.

lib/Transforms/IPO/ArgumentPromotion.cpp

Context not available.
bool runOnSCC(CallGraphSCC &SCC) override; bool runOnSCC(CallGraphSCC &SCC) override;
static char ID; // Pass identification, replacement for typeid static char ID; // Pass identification, replacement for typeid
explicit ArgPromotion(unsigned maxElements = 3) explicit ArgPromotion(unsigned maxElements = 3)
: CallGraphSCCPass(ID), DL(nullptr), maxElements(maxElements) { : CallGraphSCCPass(ID), maxElements(maxElements) {
initializeArgPromotionPass(*PassRegistry::getPassRegistry()); initializeArgPromotionPass(*PassRegistry::getPassRegistry());
} }
/// A vector used to hold the indices of a single GEP instruction /// A vector used to hold the indices of a single GEP instruction
typedef std::vector<uint64_t> IndicesVector; typedef std::vector<uint64_t> IndicesVector;
const DataLayout *DL;
private: private:
bool isDenselyPacked(Type *type); bool isDenselyPacked(Type *type, const DataLayout &DL);
bool canPaddingBeAccessed(Argument *Arg); bool canPaddingBeAccessed(Argument *Arg);
CallGraphNode *PromoteArguments(CallGraphNode *CGN); CallGraphNode *PromoteArguments(CallGraphNode *CGN);
bool isSafeToPromoteArgument(Argument *Arg, bool isByVal) const; bool isSafeToPromoteArgument(Argument *Arg, bool isByVal) const;
Context not available.
} }
/// \brief Checks if a type could have padding bytes. /// \brief Checks if a type could have padding bytes.
bool ArgPromotion::isDenselyPacked(Type *type) { bool ArgPromotion::isDenselyPacked(Type *type, const DataLayout &DL) {
// There is no size information, so be conservative. // There is no size information, so be conservative.
if (!type->isSized()) if (!type->isSized())
Context not available.
// If the alloc size is not equal to the storage size, then there are padding // If the alloc size is not equal to the storage size, then there are padding
// bytes. For x86_fp80 on x86-64, size: 80 alloc size: 128. // bytes. For x86_fp80 on x86-64, size: 80 alloc size: 128.
if (!DL || DL->getTypeSizeInBits(type) != DL->getTypeAllocSizeInBits(type)) if (DL.getTypeSizeInBits(type) != DL.getTypeAllocSizeInBits(type))
return false; return false;
if (!isa<CompositeType>(type)) if (!isa<CompositeType>(type))
Context not available.
// For homogenous sequential types, check for padding within members. // For homogenous sequential types, check for padding within members.
if (SequentialType *seqTy = dyn_cast<SequentialType>(type)) if (SequentialType *seqTy = dyn_cast<SequentialType>(type))
return isa<PointerType>(seqTy) || isDenselyPacked(seqTy->getElementType()); return isa<PointerType>(seqTy) ||
isDenselyPacked(seqTy->getElementType(), DL);
// Check for padding within and between elements of a struct. // Check for padding within and between elements of a struct.
StructType *StructTy = cast<StructType>(type); StructType *StructTy = cast<StructType>(type);
const StructLayout *Layout = DL->getStructLayout(StructTy); const StructLayout *Layout = DL.getStructLayout(StructTy);
uint64_t StartPos = 0; uint64_t StartPos = 0;
for (unsigned i = 0, E = StructTy->getNumElements(); i < E; ++i) { for (unsigned i = 0, E = StructTy->getNumElements(); i < E; ++i) {
Type *ElTy = StructTy->getElementType(i); Type *ElTy = StructTy->getElementType(i);
if (!isDenselyPacked(ElTy)) if (!isDenselyPacked(ElTy, DL))
return false; return false;
if (StartPos != Layout->getElementOffsetInBits(i)) if (StartPos != Layout->getElementOffsetInBits(i))
return false; return false;
StartPos += DL->getTypeAllocSizeInBits(ElTy); StartPos += DL.getTypeAllocSizeInBits(ElTy);
} }
return true; return true;
Context not available.
// Make sure that it is local to this module. // Make sure that it is local to this module.
if (!F || !F->hasLocalLinkage()) return nullptr; if (!F || !F->hasLocalLinkage()) return nullptr;
DL = &F->getParent()->getDataLayout();
// First check: see if there are any pointer arguments! If not, quick exit. // First check: see if there are any pointer arguments! If not, quick exit.
SmallVector<Argument*, 16> PointerArgs; SmallVector<Argument*, 16> PointerArgs;
for (Function::arg_iterator I = F->arg_begin(), E = F->arg_end(); I != E; ++I) for (Function::arg_iterator I = F->arg_begin(), E = F->arg_end(); I != E; ++I)
Context not available.
// IR, while in the callee the classification is determined dynamically based // IR, while in the callee the classification is determined dynamically based
// on the number of registers consumed so far. // on the number of registers consumed so far.
if (F->isVarArg()) return nullptr; if (F->isVarArg()) return nullptr;
const DataLayout &DL = F->getParent()->getDataLayout();
// Check to see which arguments are promotable. If an argument is promotable, // Check to see which arguments are promotable. If an argument is promotable,
// add it to ArgsToPromote. // add it to ArgsToPromote.
Context not available.
// packed or if we can prove the padding bytes are never accessed. This does // packed or if we can prove the padding bytes are never accessed. This does
// not apply to inalloca. // not apply to inalloca.
bool isSafeToPromote = bool isSafeToPromote =
PtrArg->hasByValAttr() && PtrArg->hasByValAttr() &&
(isDenselyPacked(AgTy) || !canPaddingBeAccessed(PtrArg)); (isDenselyPacked(AgTy, DL) || !canPaddingBeAccessed(PtrArg));
if (isSafeToPromote) { if (isSafeToPromote) {
if (StructType *STy = dyn_cast<StructType>(AgTy)) { if (StructType *STy = dyn_cast<StructType>(AgTy)) {
if (maxElements > 0 && STy->getNumElements() > maxElements) { if (maxElements > 0 && STy->getNumElements() > maxElements) {
Context not available.
/// AllCallersPassInValidPointerForArgument - Return true if we can prove that /// AllCallersPassInValidPointerForArgument - Return true if we can prove that
/// all callees pass in a valid pointer for the specified function argument. /// all callees pass in a valid pointer for the specified function argument.
static bool AllCallersPassInValidPointerForArgument(Argument *Arg, static bool AllCallersPassInValidPointerForArgument(Argument *Arg) {
const DataLayout *DL) {
Function *Callee = Arg->getParent(); Function *Callee = Arg->getParent();
const DataLayout &DL = Callee->getParent()->getDataLayout();
unsigned ArgNo = Arg->getArgNo(); unsigned ArgNo = Arg->getArgNo();
Context not available.
GEPIndicesSet ToPromote; GEPIndicesSet ToPromote;
// If the pointer is always valid, any load with first index 0 is valid. // If the pointer is always valid, any load with first index 0 is valid.
if (isByValOrInAlloca || AllCallersPassInValidPointerForArgument(Arg, DL)) if (isByValOrInAlloca || AllCallersPassInValidPointerForArgument(Arg))
SafeToUnconditionallyLoad.insert(IndicesVector(1, 0)); SafeToUnconditionallyLoad.insert(IndicesVector(1, 0));
// First, iterate the entry block and mark loads of (geps of) arguments as // First, iterate the entry block and mark loads of (geps of) arguments as
Context not available.

lib/Transforms/IPO/ConstantMerge.cpp

Context not available.
// alignment to a concrete value. // alignment to a concrete value.
unsigned getAlignment(GlobalVariable *GV) const; unsigned getAlignment(GlobalVariable *GV) const;
const DataLayout *DL;
}; };
} }
Context not available.
return A.hasUnnamedAddr(); return A.hasUnnamedAddr();
} }
bool ConstantMerge::hasKnownAlignment(GlobalVariable *GV) const {
return DL || GV->getAlignment() != 0;
}
unsigned ConstantMerge::getAlignment(GlobalVariable *GV) const { unsigned ConstantMerge::getAlignment(GlobalVariable *GV) const {
unsigned Align = GV->getAlignment(); unsigned Align = GV->getAlignment();
if (Align) if (Align)
return Align; return Align;
if (DL) return GV->getParent()->getDataLayout().getPreferredAlignment(GV);
return DL->getPreferredAlignment(GV);
return 0;
} }
bool ConstantMerge::runOnModule(Module &M) { bool ConstantMerge::runOnModule(Module &M) {
DL = &M.getDataLayout();
// Find all the globals that are marked "used". These cannot be merged. // Find all the globals that are marked "used". These cannot be merged.
SmallPtrSet<const GlobalValue*, 8> UsedGlobals; SmallPtrSet<const GlobalValue*, 8> UsedGlobals;
FindUsedValues(M.getGlobalVariable("llvm.used"), UsedGlobals); FindUsedValues(M.getGlobalVariable("llvm.used"), UsedGlobals);
FindUsedValues(M.getGlobalVariable("llvm.compiler.used"), UsedGlobals); FindUsedValues(M.getGlobalVariable("llvm.compiler.used"), UsedGlobals);
// Map unique <constants, has-unknown-alignment> pairs to globals. We don't // Map unique constants to globals.
// want to merge globals of unknown alignment with those of explicit DenseMap<Constant *, GlobalVariable *> CMap;
// alignment. If we have DataLayout, we always know the alignment.
DenseMap<PointerIntPair<Constant*, 1, bool>, GlobalVariable*> CMap;
// Replacements - This vector contains a list of replacements to perform. // Replacements - This vector contains a list of replacements to perform.
SmallVector<std::pair<GlobalVariable*, GlobalVariable*>, 32> Replacements; SmallVector<std::pair<GlobalVariable*, GlobalVariable*>, 32> Replacements;
Context not available.
Constant *Init = GV->getInitializer(); Constant *Init = GV->getInitializer();
// Check to see if the initializer is already known. // Check to see if the initializer is already known.
PointerIntPair<Constant*, 1, bool> Pair(Init, hasKnownAlignment(GV)); GlobalVariable *&Slot = CMap[Init];
GlobalVariable *&Slot = CMap[Pair];
// If this is the first constant we find or if the old one is local, // If this is the first constant we find or if the old one is local,
// replace with the current one. If the current is externally visible // replace with the current one. If the current is externally visible
Context not available.
Constant *Init = GV->getInitializer(); Constant *Init = GV->getInitializer();
// Check to see if the initializer is already known. // Check to see if the initializer is already known.
PointerIntPair<Constant*, 1, bool> Pair(Init, hasKnownAlignment(GV)); GlobalVariable *Slot = CMap[Init];
GlobalVariable *Slot = CMap[Pair];
if (!Slot || Slot == GV) if (!Slot || Slot == GV)
continue; continue;
Context not available.

lib/Transforms/IPO/GlobalOpt.cpp

Context not available.
const GlobalStatus &GS); const GlobalStatus &GS);
bool OptimizeEmptyGlobalCXXDtors(Function *CXAAtExitFn); bool OptimizeEmptyGlobalCXXDtors(Function *CXAAtExitFn);
// const DataLayout *DL;
TargetLibraryInfo *TLI; TargetLibraryInfo *TLI;
SmallSet<const Comdat *, 8> NotDiscardableComdats; SmallSet<const Comdat *, 8> NotDiscardableComdats;
}; };
Context not available.
Constant *SubInit = nullptr; Constant *SubInit = nullptr;
if (!isa<ConstantExpr>(GEP->getOperand(0))) { if (!isa<ConstantExpr>(GEP->getOperand(0))) {
ConstantExpr *CE = dyn_cast_or_null<ConstantExpr>( ConstantExpr *CE = dyn_cast_or_null<ConstantExpr>(
ConstantFoldInstruction(GEP, &DL, TLI)); ConstantFoldInstruction(GEP, DL, TLI));
if (Init && CE && CE->getOpcode() == Instruction::GetElementPtr) if (Init && CE && CE->getOpcode() == Instruction::GetElementPtr)
SubInit = ConstantFoldLoadThroughGEPConstantExpr(Init, CE); SubInit = ConstantFoldLoadThroughGEPConstantExpr(Init, CE);
Context not available.
TargetLibraryInfo *TLI) { TargetLibraryInfo *TLI) {
for (Value::user_iterator UI = V->user_begin(), E = V->user_end(); UI != E; ) for (Value::user_iterator UI = V->user_begin(), E = V->user_end(); UI != E; )
if (Instruction *I = dyn_cast<Instruction>(*UI++)) if (Instruction *I = dyn_cast<Instruction>(*UI++))
if (Constant *NewC = ConstantFoldInstruction(I, &DL, TLI)) { if (Constant *NewC = ConstantFoldInstruction(I, DL, TLI)) {
I->replaceAllUsesWith(NewC); I->replaceAllUsesWith(NewC);
// Advance UI to the next non-I use to avoid invalidating it! // Advance UI to the next non-I use to avoid invalidating it!
Context not available.
// This eliminates dynamic allocation, avoids an indirection accessing the // This eliminates dynamic allocation, avoids an indirection accessing the
// data, and exposes the resultant global to further GlobalOpt. // data, and exposes the resultant global to further GlobalOpt.
// We cannot optimize the malloc if we cannot determine malloc array size. // We cannot optimize the malloc if we cannot determine malloc array size.
Value *NElems = getMallocArraySize(CI, &DL, TLI, true); Value *NElems = getMallocArraySize(CI, DL, TLI, true);
if (!NElems) if (!NElems)
return false; return false;
Context not available.
CI = cast<CallInst>(Malloc); CI = cast<CallInst>(Malloc);
} }
GVI = PerformHeapAllocSRoA(GV, CI, getMallocArraySize(CI, &DL, TLI, true), GVI = PerformHeapAllocSRoA(GV, CI, getMallocArraySize(CI, DL, TLI, true),
DL, TLI); DL, TLI);
return true; return true;
} }
Context not available.
if (GV->hasInitializer()) if (GV->hasInitializer())
if (ConstantExpr *CE = dyn_cast<ConstantExpr>(GV->getInitializer())) { if (ConstantExpr *CE = dyn_cast<ConstantExpr>(GV->getInitializer())) {
auto &DL = M.getDataLayout(); auto &DL = M.getDataLayout();
Constant *New = ConstantFoldConstantExpression(CE, &DL, TLI); Constant *New = ConstantFoldConstantExpression(CE, DL, TLI);
if (New && New != CE) if (New && New != CE)
GV->setInitializer(New); GV->setInitializer(New);
} }
Context not available.
Constant *Ptr = getVal(SI->getOperand(1)); Constant *Ptr = getVal(SI->getOperand(1));
if (ConstantExpr *CE = dyn_cast<ConstantExpr>(Ptr)) { if (ConstantExpr *CE = dyn_cast<ConstantExpr>(Ptr)) {
DEBUG(dbgs() << "Folding constant ptr expression: " << *Ptr); DEBUG(dbgs() << "Folding constant ptr expression: " << *Ptr);
Ptr = ConstantFoldConstantExpression(CE, &DL, TLI); Ptr = ConstantFoldConstantExpression(CE, DL, TLI);
DEBUG(dbgs() << "; To: " << *Ptr << "\n"); DEBUG(dbgs() << "; To: " << *Ptr << "\n");
} }
if (!isSimpleEnoughPointerToCommit(Ptr)) { if (!isSimpleEnoughPointerToCommit(Ptr)) {
Context not available.
Ptr = ConstantExpr::getGetElementPtr(Ptr, IdxList); Ptr = ConstantExpr::getGetElementPtr(Ptr, IdxList);
if (ConstantExpr *CE = dyn_cast<ConstantExpr>(Ptr)) if (ConstantExpr *CE = dyn_cast<ConstantExpr>(Ptr))
Ptr = ConstantFoldConstantExpression(CE, &DL, TLI); Ptr = ConstantFoldConstantExpression(CE, DL, TLI);
// If we can't improve the situation by introspecting NewTy, // If we can't improve the situation by introspecting NewTy,
// we have to give up. // we have to give up.
Context not available.
Constant *Ptr = getVal(LI->getOperand(0)); Constant *Ptr = getVal(LI->getOperand(0));
if (ConstantExpr *CE = dyn_cast<ConstantExpr>(Ptr)) { if (ConstantExpr *CE = dyn_cast<ConstantExpr>(Ptr)) {
Ptr = ConstantFoldConstantExpression(CE, &DL, TLI); Ptr = ConstantFoldConstantExpression(CE, DL, TLI);
DEBUG(dbgs() << "Found a constant pointer expression, constant " DEBUG(dbgs() << "Found a constant pointer expression, constant "
"folding: " << *Ptr << "\n"); "folding: " << *Ptr << "\n");
} }
Context not available.
if (!CurInst->use_empty()) { if (!CurInst->use_empty()) {
if (ConstantExpr *CE = dyn_cast<ConstantExpr>(InstResult)) if (ConstantExpr *CE = dyn_cast<ConstantExpr>(InstResult))
InstResult = ConstantFoldConstantExpression(CE, &DL, TLI); InstResult = ConstantFoldConstantExpression(CE, DL, TLI);
setVal(CurInst, InstResult); setVal(CurInst, InstResult);
} }
Context not available.

lib/Transforms/IPO/LowerBitSets.cpp

Context not available.
} }
bool BitSetInfo::containsValue( bool BitSetInfo::containsValue(
const DataLayout *DL, const DataLayout &DL,
const DenseMap<GlobalVariable *, uint64_t> &GlobalLayout, Value *V, const DenseMap<GlobalVariable *, uint64_t> &GlobalLayout, Value *V,
uint64_t COffset) const { uint64_t COffset) const {
if (auto GV = dyn_cast<GlobalVariable>(V)) { if (auto GV = dyn_cast<GlobalVariable>(V)) {
Context not available.
} }
if (auto GEP = dyn_cast<GEPOperator>(V)) { if (auto GEP = dyn_cast<GEPOperator>(V)) {
APInt APOffset(DL->getPointerSizeInBits(0), 0); APInt APOffset(DL.getPointerSizeInBits(0), 0);
bool Result = GEP->accumulateConstantOffset(*DL, APOffset); bool Result = GEP->accumulateConstantOffset(DL, APOffset);
if (!Result) if (!Result)
return false; return false;
COffset += APOffset.getZExtValue(); COffset += APOffset.getZExtValue();
Context not available.
Module *M; Module *M;
const DataLayout *DL;
IntegerType *Int1Ty; IntegerType *Int1Ty;
IntegerType *Int8Ty; IntegerType *Int8Ty;
IntegerType *Int32Ty; IntegerType *Int32Ty;
Context not available.
bool LowerBitSets::doInitialization(Module &Mod) { bool LowerBitSets::doInitialization(Module &Mod) {
M = &Mod; M = &Mod;
DL = &Mod.getDataLayout(); const DataLayout &DL = Mod.getDataLayout();
Int1Ty = Type::getInt1Ty(M->getContext()); Int1Ty = Type::getInt1Ty(M->getContext());
Int8Ty = Type::getInt8Ty(M->getContext()); Int8Ty = Type::getInt8Ty(M->getContext());
Int32Ty = Type::getInt32Ty(M->getContext()); Int32Ty = Type::getInt32Ty(M->getContext());
Int32PtrTy = PointerType::getUnqual(Int32Ty); Int32PtrTy = PointerType::getUnqual(Int32Ty);
Int64Ty = Type::getInt64Ty(M->getContext()); Int64Ty = Type::getInt64Ty(M->getContext());
IntPtrTy = DL->getIntPtrType(M->getContext(), 0); IntPtrTy = DL.getIntPtrType(M->getContext(), 0);
BitSetNM = M->getNamedMetadata("llvm.bitsets"); BitSetNM = M->getNamedMetadata("llvm.bitsets");
Context not available.
GlobalVariable *CombinedGlobal, GlobalVariable *CombinedGlobal,
const DenseMap<GlobalVariable *, uint64_t> &GlobalLayout) { const DenseMap<GlobalVariable *, uint64_t> &GlobalLayout) {
Value *Ptr = CI->getArgOperand(0); Value *Ptr = CI->getArgOperand(0);
const DataLayout &DL = M->getDataLayout();
if (BSI.containsValue(DL, GlobalLayout, Ptr)) if (BSI.containsValue(DL, GlobalLayout, Ptr))
return ConstantInt::getTrue(CombinedGlobal->getParent()->getContext()); return ConstantInt::getTrue(CombinedGlobal->getParent()->getContext());
Context not available.
Value *OffsetSHR = Value *OffsetSHR =
B.CreateLShr(PtrOffset, ConstantInt::get(IntPtrTy, BSI.AlignLog2)); B.CreateLShr(PtrOffset, ConstantInt::get(IntPtrTy, BSI.AlignLog2));
Value *OffsetSHL = B.CreateShl( Value *OffsetSHL = B.CreateShl(
PtrOffset, ConstantInt::get(IntPtrTy, DL->getPointerSizeInBits(0) - PtrOffset,
BSI.AlignLog2)); ConstantInt::get(IntPtrTy, DL.getPointerSizeInBits(0) - BSI.AlignLog2));
BitOffset = B.CreateOr(OffsetSHR, OffsetSHL); BitOffset = B.CreateOr(OffsetSHR, OffsetSHL);
} }
Context not available.
const std::vector<GlobalVariable *> &Globals) { const std::vector<GlobalVariable *> &Globals) {
// Build a new global with the combined contents of the referenced globals. // Build a new global with the combined contents of the referenced globals.
std::vector<Constant *> GlobalInits; std::vector<Constant *> GlobalInits;
const DataLayout &DL = M->getDataLayout();
for (GlobalVariable *G : Globals) { for (GlobalVariable *G : Globals) {
GlobalInits.push_back(G->getInitializer()); GlobalInits.push_back(G->getInitializer());
uint64_t InitSize = DL->getTypeAllocSize(G->getInitializer()->getType()); uint64_t InitSize = DL.getTypeAllocSize(G->getInitializer()->getType());
// Compute the amount of padding required to align the next element to the // Compute the amount of padding required to align the next element to the
// next power of 2. // next power of 2.
Context not available.
GlobalValue::PrivateLinkage, NewInit); GlobalValue::PrivateLinkage, NewInit);
const StructLayout *CombinedGlobalLayout = const StructLayout *CombinedGlobalLayout =
DL->getStructLayout(cast<StructType>(NewInit->getType())); DL.getStructLayout(cast<StructType>(NewInit->getType()));
// Compute the offsets of the original globals within the new global. // Compute the offsets of the original globals within the new global.
DenseMap<GlobalVariable *, uint64_t> GlobalLayout; DenseMap<GlobalVariable *, uint64_t> GlobalLayout;
Context not available.

lib/Transforms/IPO/MergeFunctions.cpp

Context not available.
/// side of claiming that two functions are different). /// side of claiming that two functions are different).
class FunctionComparator { class FunctionComparator {
public: public:
FunctionComparator(const DataLayout *DL, const Function *F1, FunctionComparator(const Function *F1, const Function *F2)
const Function *F2) : FnL(F1), FnR(F2) {}
: FnL(F1), FnR(F2), DL(DL) {}
/// Test whether the two functions have equivalent behaviour. /// Test whether the two functions have equivalent behaviour.
int compare(); int compare();
Context not available.
/// Parts to be compared for each comparison stage, /// Parts to be compared for each comparison stage,
/// most significant stage first: /// most significant stage first:
/// 1. Address space. As numbers. /// 1. Address space. As numbers.
/// 2. Constant offset, (if "DataLayout *DL" field is not NULL, /// 2. Constant offset, (using GEPOperator::accumulateConstantOffset method).
/// using GEPOperator::accumulateConstantOffset method).
/// 3. Pointer operand type (using cmpType method). /// 3. Pointer operand type (using cmpType method).
/// 4. Number of operands. /// 4. Number of operands.
/// 5. Compare operands, using cmpValues method. /// 5. Compare operands, using cmpValues method.
Context not available.
// The two functions undergoing comparison. // The two functions undergoing comparison.
const Function *FnL, *FnR; const Function *FnL, *FnR;
const DataLayout *DL;
/// Assign serial numbers to values from left function, and values from /// Assign serial numbers to values from left function, and values from
/// right function. /// right function.
/// Explanation: /// Explanation:
Context not available.
class FunctionNode { class FunctionNode {
AssertingVH<Function> F; AssertingVH<Function> F;
const DataLayout *DL;
public: public:
FunctionNode(Function *F, const DataLayout *DL) : F(F), DL(DL) {} FunctionNode(Function *F) : F(F) {}
Function *getFunc() const { return F; } Function *getFunc() const { return F; }
void release() { F = 0; } void release() { F = 0; }
bool operator<(const FunctionNode &RHS) const { bool operator<(const FunctionNode &RHS) const {
return (FunctionComparator(DL, F, RHS.getFunc()).compare()) == -1; return (FunctionComparator(F, RHS.getFunc()).compare()) == -1;
} }
}; };
} }
Context not available.
PointerType *PTyL = dyn_cast<PointerType>(TyL); PointerType *PTyL = dyn_cast<PointerType>(TyL);
PointerType *PTyR = dyn_cast<PointerType>(TyR); PointerType *PTyR = dyn_cast<PointerType>(TyR);
if (DL) { const DataLayout &DL = FnL->getParent()->getDataLayout();
if (PTyL && PTyL->getAddressSpace() == 0) TyL = DL->getIntPtrType(TyL); if (PTyL && PTyL->getAddressSpace() == 0)
if (PTyR && PTyR->getAddressSpace() == 0) TyR = DL->getIntPtrType(TyR); TyL = DL.getIntPtrType(TyL);
} if (PTyR && PTyR->getAddressSpace() == 0)
TyR = DL.getIntPtrType(TyR);
if (TyL == TyR) if (TyL == TyR)
return 0; return 0;
Context not available.
// When we have target data, we can reduce the GEP down to the value in bytes // When we have target data, we can reduce the GEP down to the value in bytes
// added to the address. // added to the address.
if (DL) { const DataLayout &DL = FnL->getParent()->getDataLayout();
unsigned BitWidth = DL->getPointerSizeInBits(ASL); unsigned BitWidth = DL.getPointerSizeInBits(ASL);
APInt OffsetL(BitWidth, 0), OffsetR(BitWidth, 0); APInt OffsetL(BitWidth, 0), OffsetR(BitWidth, 0);
if (GEPL->accumulateConstantOffset(*DL, OffsetL) && if (GEPL->accumulateConstantOffset(DL, OffsetL) &&
GEPR->accumulateConstantOffset(*DL, OffsetR)) GEPR->accumulateConstantOffset(DL, OffsetR))
return cmpAPInts(OffsetL, OffsetR); return cmpAPInts(OffsetL, OffsetR);
}
if (int Res = cmpNumbers((uint64_t)GEPL->getPointerOperand()->getType(), if (int Res = cmpNumbers((uint64_t)GEPL->getPointerOperand()->getType(),
(uint64_t)GEPR->getPointerOperand()->getType())) (uint64_t)GEPR->getPointerOperand()->getType()))
Context not available.
/// to modify it. /// to modify it.
FnTreeType FnTree; FnTreeType FnTree;
/// DataLayout for more accurate GEP comparisons. May be NULL.
const DataLayout *DL;
/// Whether or not the target supports global aliases. /// Whether or not the target supports global aliases.
bool HasGlobalAliases; bool HasGlobalAliases;
}; };
Context not available.
for (std::vector<WeakVH>::iterator J = I; J != E && j < Max; ++J, ++j) { for (std::vector<WeakVH>::iterator J = I; J != E && j < Max; ++J, ++j) {
Function *F1 = cast<Function>(*I); Function *F1 = cast<Function>(*I);
Function *F2 = cast<Function>(*J); Function *F2 = cast<Function>(*J);
int Res1 = FunctionComparator(DL, F1, F2).compare(); int Res1 = FunctionComparator(F1, F2).compare();
int Res2 = FunctionComparator(DL, F2, F1).compare(); int Res2 = FunctionComparator(F2, F1).compare();
// If F1 <= F2, then F2 >= F1, otherwise report failure. // If F1 <= F2, then F2 >= F1, otherwise report failure.
if (Res1 != -Res2) { if (Res1 != -Res2) {
Context not available.
continue; continue;
Function *F3 = cast<Function>(*K); Function *F3 = cast<Function>(*K);
int Res3 = FunctionComparator(DL, F1, F3).compare(); int Res3 = FunctionComparator(F1, F3).compare();
int Res4 = FunctionComparator(DL, F2, F3).compare(); int Res4 = FunctionComparator(F2, F3).compare();
bool Transitive = true; bool Transitive = true;
Context not available.
bool MergeFunctions::runOnModule(Module &M) { bool MergeFunctions::runOnModule(Module &M) {
bool Changed = false; bool Changed = false;
DL = &M.getDataLayout();
for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) { for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) {
if (!I->isDeclaration() && !I->hasAvailableExternallyLinkage()) if (!I->isDeclaration() && !I->hasAvailableExternallyLinkage())
Context not available.
// that was already inserted. // that was already inserted.
bool MergeFunctions::insert(Function *NewFunction) { bool MergeFunctions::insert(Function *NewFunction) {
std::pair<FnTreeType::iterator, bool> Result = std::pair<FnTreeType::iterator, bool> Result =
FnTree.insert(FunctionNode(NewFunction, DL)); FnTree.insert(FunctionNode(NewFunction));
if (Result.second) { if (Result.second) {
DEBUG(dbgs() << "Inserting as unique: " << NewFunction->getName() << '\n'); DEBUG(dbgs() << "Inserting as unique: " << NewFunction->getName() << '\n');
Context not available.
void MergeFunctions::remove(Function *F) { void MergeFunctions::remove(Function *F) {
// We need to make sure we remove F, not a function "equal" to F per the // We need to make sure we remove F, not a function "equal" to F per the
// function equality comparator. // function equality comparator.
FnTreeType::iterator found = FnTree.find(FunctionNode(F, DL)); FnTreeType::iterator found = FnTree.find(FunctionNode(F));
size_t Erased = 0; size_t Erased = 0;
if (found != FnTree.end() && found->getFunc() == F) { if (found != FnTree.end() && found->getFunc() == F) {
Erased = 1; Erased = 1;
Context not available.

lib/Transforms/InstCombine/InstCombineAddSub.cpp

Context not available.
/// This basically requires proving that the add in the original type would not /// This basically requires proving that the add in the original type would not
/// overflow to change the sign bit or have a carry out. /// overflow to change the sign bit or have a carry out.
bool InstCombiner::WillNotOverflowSignedAdd(Value *LHS, Value *RHS, bool InstCombiner::WillNotOverflowSignedAdd(Value *LHS, Value *RHS,
Instruction *CxtI) { Instruction &CxtI) {
// There are different heuristics we can use for this. Here are some simple // There are different heuristics we can use for this. Here are some simple
// ones. // ones.
Context not available.
// //
// Since the carry into the most significant position is always equal to // Since the carry into the most significant position is always equal to
// the carry out of the addition, there is no signed overflow. // the carry out of the addition, there is no signed overflow.
if (ComputeNumSignBits(LHS, 0, CxtI) > 1 && if (ComputeNumSignBits(LHS, 0, &CxtI) > 1 &&
ComputeNumSignBits(RHS, 0, CxtI) > 1) ComputeNumSignBits(RHS, 0, &CxtI) > 1)
return true; return true;
unsigned BitWidth = LHS->getType()->getScalarSizeInBits(); unsigned BitWidth = LHS->getType()->getScalarSizeInBits();
APInt LHSKnownZero(BitWidth, 0); APInt LHSKnownZero(BitWidth, 0);
APInt LHSKnownOne(BitWidth, 0); APInt LHSKnownOne(BitWidth, 0);
computeKnownBits(LHS, LHSKnownZero, LHSKnownOne, 0, CxtI); computeKnownBits(LHS, LHSKnownZero, LHSKnownOne, 0, &CxtI);
APInt RHSKnownZero(BitWidth, 0); APInt RHSKnownZero(BitWidth, 0);
APInt RHSKnownOne(BitWidth, 0); APInt RHSKnownOne(BitWidth, 0);
computeKnownBits(RHS, RHSKnownZero, RHSKnownOne, 0, CxtI); computeKnownBits(RHS, RHSKnownZero, RHSKnownOne, 0, &CxtI);
// Addition of two 2's compliment numbers having opposite signs will never // Addition of two 2's compliment numbers having opposite signs will never
// overflow. // overflow.
Context not available.
/// overflow to change the sign bit or have a carry out. /// overflow to change the sign bit or have a carry out.
/// TODO: Handle this for Vectors. /// TODO: Handle this for Vectors.
bool InstCombiner::WillNotOverflowSignedSub(Value *LHS, Value *RHS, bool InstCombiner::WillNotOverflowSignedSub(Value *LHS, Value *RHS,
Instruction *CxtI) { Instruction &CxtI) {
// If LHS and RHS each have at least two sign bits, the subtraction // If LHS and RHS each have at least two sign bits, the subtraction
// cannot overflow. // cannot overflow.
if (ComputeNumSignBits(LHS, 0, CxtI) > 1 && if (ComputeNumSignBits(LHS, 0, &CxtI) > 1 &&
ComputeNumSignBits(RHS, 0, CxtI) > 1) ComputeNumSignBits(RHS, 0, &CxtI) > 1)
return true; return true;
unsigned BitWidth = LHS->getType()->getScalarSizeInBits(); unsigned BitWidth = LHS->getType()->getScalarSizeInBits();
APInt LHSKnownZero(BitWidth, 0); APInt LHSKnownZero(BitWidth, 0);
APInt LHSKnownOne(BitWidth, 0); APInt LHSKnownOne(BitWidth, 0);
computeKnownBits(LHS, LHSKnownZero, LHSKnownOne, 0, CxtI); computeKnownBits(LHS, LHSKnownZero, LHSKnownOne, 0, &CxtI);
APInt RHSKnownZero(BitWidth, 0); APInt RHSKnownZero(BitWidth, 0);
APInt RHSKnownOne(BitWidth, 0); APInt RHSKnownOne(BitWidth, 0);
computeKnownBits(RHS, RHSKnownZero, RHSKnownOne, 0, CxtI); computeKnownBits(RHS, RHSKnownZero, RHSKnownOne, 0, &CxtI);
// Subtraction of two 2's compliment numbers having identical signs will // Subtraction of two 2's compliment numbers having identical signs will
// never overflow. // never overflow.
Context not available.
/// \brief Return true if we can prove that: /// \brief Return true if we can prove that:
/// (sub LHS, RHS) === (sub nuw LHS, RHS) /// (sub LHS, RHS) === (sub nuw LHS, RHS)
bool InstCombiner::WillNotOverflowUnsignedSub(Value *LHS, Value *RHS, bool InstCombiner::WillNotOverflowUnsignedSub(Value *LHS, Value *RHS,
Instruction *CxtI) { Instruction &CxtI) {
// If the LHS is negative and the RHS is non-negative, no unsigned wrap. // If the LHS is negative and the RHS is non-negative, no unsigned wrap.
bool LHSKnownNonNegative, LHSKnownNegative; bool LHSKnownNonNegative, LHSKnownNegative;
bool RHSKnownNonNegative, RHSKnownNegative; bool RHSKnownNonNegative, RHSKnownNegative;
ComputeSignBit(LHS, LHSKnownNonNegative, LHSKnownNegative, /*Depth=*/0, CxtI); ComputeSignBit(LHS, LHSKnownNonNegative, LHSKnownNegative, /*Depth=*/0,
ComputeSignBit(RHS, RHSKnownNonNegative, RHSKnownNegative, /*Depth=*/0, CxtI); &CxtI);
ComputeSignBit(RHS, RHSKnownNonNegative, RHSKnownNegative, /*Depth=*/0,
&CxtI);
if (LHSKnownNegative && RHSKnownNonNegative) if (LHSKnownNegative && RHSKnownNonNegative)
return true; return true;
Context not available.
} }
Instruction *InstCombiner::visitAdd(BinaryOperator &I) { Instruction *InstCombiner::visitAdd(BinaryOperator &I) {
bool Changed = SimplifyAssociativeOrCommutative(I); bool Changed = SimplifyAssociativeOrCommutative(I);
Value *LHS = I.getOperand(0), *RHS = I.getOperand(1); Value *LHS = I.getOperand(0), *RHS = I.getOperand(1);
if (Value *V = SimplifyVectorOp(I)) if (Value *V = SimplifyVectorOp(I))
return ReplaceInstUsesWith(I, V); return ReplaceInstUsesWith(I, V);
if (Value *V = SimplifyAddInst(LHS, RHS, I.hasNoSignedWrap(), if (Value *V = SimplifyAddInst(LHS, RHS, I.hasNoSignedWrap(),
I.hasNoUnsignedWrap(), DL, TLI, DT, AC)) I.hasNoUnsignedWrap(), DL, TLI, DT, AC))
return ReplaceInstUsesWith(I, V); return ReplaceInstUsesWith(I, V);
// (A*B)+(A*C) -> A*(B+C) etc // (A*B)+(A*C) -> A*(B+C) etc
if (Value *V = SimplifyUsingDistributiveLaws(I)) if (Value *V = SimplifyUsingDistributiveLaws(I))
Context not available.
ConstantExpr::getTrunc(RHSC, LHSConv->getOperand(0)->getType()); ConstantExpr::getTrunc(RHSC, LHSConv->getOperand(0)->getType());
if (LHSConv->hasOneUse() && if (LHSConv->hasOneUse() &&
ConstantExpr::getSExt(CI, I.getType()) == RHSC && ConstantExpr::getSExt(CI, I.getType()) == RHSC &&
WillNotOverflowSignedAdd(LHSConv->getOperand(0), CI, &I)) { WillNotOverflowSignedAdd(LHSConv->getOperand(0), CI, I)) {
// Insert the new, smaller add. // Insert the new, smaller add.
Value *NewAdd = Builder->CreateNSWAdd(LHSConv->getOperand(0), Value *NewAdd = Builder->CreateNSWAdd(LHSConv->getOperand(0),
CI, "addconv"); CI, "addconv");
Context not available.
// Only do this if x/y have the same type, if at last one of them has a // Only do this if x/y have the same type, if at last one of them has a
// single use (so we don't increase the number of sexts), and if the // single use (so we don't increase the number of sexts), and if the
// integer add will not overflow. // integer add will not overflow.
if (LHSConv->getOperand(0)->getType()==RHSConv->getOperand(0)->getType()&& if (LHSConv->getOperand(0)->getType() ==
RHSConv->getOperand(0)->getType() &&
(LHSConv->hasOneUse() || RHSConv->hasOneUse()) && (LHSConv->hasOneUse() || RHSConv->hasOneUse()) &&
WillNotOverflowSignedAdd(LHSConv->getOperand(0), WillNotOverflowSignedAdd(LHSConv->getOperand(0),
RHSConv->getOperand(0), &I)) { RHSConv->getOperand(0), I)) {
// Insert the new integer add. // Insert the new integer add.
Value *NewAdd = Builder->CreateNSWAdd(LHSConv->getOperand(0), Value *NewAdd = Builder->CreateNSWAdd(LHSConv->getOperand(0),
RHSConv->getOperand(0), "addconv"); RHSConv->getOperand(0), "addconv");
Context not available.
// TODO(jingyue): Consider WillNotOverflowSignedAdd and // TODO(jingyue): Consider WillNotOverflowSignedAdd and
// WillNotOverflowUnsignedAdd to reduce the number of invocations of // WillNotOverflowUnsignedAdd to reduce the number of invocations of
// computeKnownBits. // computeKnownBits.
if (!I.hasNoSignedWrap() && WillNotOverflowSignedAdd(LHS, RHS, &I)) { if (!I.hasNoSignedWrap() && WillNotOverflowSignedAdd(LHS, RHS, I)) {
Changed = true; Changed = true;
I.setHasNoSignedWrap(true); I.setHasNoSignedWrap(true);
} }
Context not available.
ConstantExpr::getFPToSI(CFP, LHSConv->getOperand(0)->getType()); ConstantExpr::getFPToSI(CFP, LHSConv->getOperand(0)->getType());
if (LHSConv->hasOneUse() && if (LHSConv->hasOneUse() &&
ConstantExpr::getSIToFP(CI, I.getType()) == CFP && ConstantExpr::getSIToFP(CI, I.getType()) == CFP &&
WillNotOverflowSignedAdd(LHSConv->getOperand(0), CI, &I)) { WillNotOverflowSignedAdd(LHSConv->getOperand(0), CI, I)) {
// Insert the new integer add. // Insert the new integer add.
Value *NewAdd = Builder->CreateNSWAdd(LHSConv->getOperand(0), Value *NewAdd = Builder->CreateNSWAdd(LHSConv->getOperand(0),
CI, "addconv"); CI, "addconv");
Context not available.
// Only do this if x/y have the same type, if at last one of them has a // Only do this if x/y have the same type, if at last one of them has a
// single use (so we don't increase the number of int->fp conversions), // single use (so we don't increase the number of int->fp conversions),
// and if the integer add will not overflow. // and if the integer add will not overflow.
if (LHSConv->getOperand(0)->getType()==RHSConv->getOperand(0)->getType()&& if (LHSConv->getOperand(0)->getType() ==
RHSConv->getOperand(0)->getType() &&
(LHSConv->hasOneUse() || RHSConv->hasOneUse()) && (LHSConv->hasOneUse() || RHSConv->hasOneUse()) &&
WillNotOverflowSignedAdd(LHSConv->getOperand(0), WillNotOverflowSignedAdd(LHSConv->getOperand(0),
RHSConv->getOperand(0), &I)) { RHSConv->getOperand(0), I)) {
// Insert the new integer add. // Insert the new integer add.
Value *NewAdd = Builder->CreateNSWAdd(LHSConv->getOperand(0), Value *NewAdd = Builder->CreateNSWAdd(LHSConv->getOperand(0),
RHSConv->getOperand(0),"addconv"); RHSConv->getOperand(0),"addconv");
Context not available.
/// ///
Value *InstCombiner::OptimizePointerDifference(Value *LHS, Value *RHS, Value *InstCombiner::OptimizePointerDifference(Value *LHS, Value *RHS,
Type *Ty) { Type *Ty) {
assert(DL && "Must have target data info for this");
// If LHS is a gep based on RHS or RHS is a gep based on LHS, we can optimize // If LHS is a gep based on RHS or RHS is a gep based on LHS, we can optimize
// this. // this.
bool Swapped = false; bool Swapped = false;
Context not available.
// Optimize pointer differences into the same array into a size. Consider: // Optimize pointer differences into the same array into a size. Consider:
// &A[10] - &A[0]: we should compile this to "10". // &A[10] - &A[0]: we should compile this to "10".
if (DL) { Value *LHSOp, *RHSOp;
Value *LHSOp, *RHSOp; if (match(Op0, m_PtrToInt(m_Value(LHSOp))) &&
if (match(Op0, m_PtrToInt(m_Value(LHSOp))) && match(Op1, m_PtrToInt(m_Value(RHSOp))))
match(Op1, m_PtrToInt(m_Value(RHSOp)))) if (Value *Res = OptimizePointerDifference(LHSOp, RHSOp, I.getType()))
if (Value *Res = OptimizePointerDifference(LHSOp, RHSOp, I.getType())) return ReplaceInstUsesWith(I, Res);
return ReplaceInstUsesWith(I, Res);
// trunc(p)-trunc(q) -> trunc(p-q)
// trunc(p)-trunc(q) -> trunc(p-q) if (match(Op0, m_Trunc(m_PtrToInt(m_Value(LHSOp)))) &&
if (match(Op0, m_Trunc(m_PtrToInt(m_Value(LHSOp)))) && match(Op1, m_Trunc(m_PtrToInt(m_Value(RHSOp)))))
match(Op1, m_Trunc(m_PtrToInt(m_Value(RHSOp))))) if (Value *Res = OptimizePointerDifference(LHSOp, RHSOp, I.getType()))
if (Value *Res = OptimizePointerDifference(LHSOp, RHSOp, I.getType())) return ReplaceInstUsesWith(I, Res);
return ReplaceInstUsesWith(I, Res);
}
bool Changed = false; bool Changed = false;
if (!I.hasNoSignedWrap() && WillNotOverflowSignedSub(Op0, Op1, &I)) { if (!I.hasNoSignedWrap() && WillNotOverflowSignedSub(Op0, Op1, I)) {
Changed = true; Changed = true;
I.setHasNoSignedWrap(true); I.setHasNoSignedWrap(true);
} }
if (!I.hasNoUnsignedWrap() && WillNotOverflowUnsignedSub(Op0, Op1, &I)) { if (!I.hasNoUnsignedWrap() && WillNotOverflowUnsignedSub(Op0, Op1, I)) {
Changed = true; Changed = true;
I.setHasNoUnsignedWrap(true); I.setHasNoUnsignedWrap(true);
} }
Context not available.

lib/Transforms/InstCombine/InstCombineAndOrXor.cpp

Context not available.
Value *Mask = nullptr; Value *Mask = nullptr;
Value *Masked = nullptr; Value *Masked = nullptr;
if (LAnd->getOperand(0) == RAnd->getOperand(0) && if (LAnd->getOperand(0) == RAnd->getOperand(0) &&
isKnownToBeAPowerOfTwo(LAnd->getOperand(1), false, 0, AC, CxtI, DT) && isKnownToBeAPowerOfTwo(LAnd->getOperand(1), DL, false, 0, AC, CxtI,
isKnownToBeAPowerOfTwo(RAnd->getOperand(1), false, 0, AC, CxtI, DT)) { DT) &&
isKnownToBeAPowerOfTwo(RAnd->getOperand(1), DL, false, 0, AC, CxtI,
DT)) {
Mask = Builder->CreateOr(LAnd->getOperand(1), RAnd->getOperand(1)); Mask = Builder->CreateOr(LAnd->getOperand(1), RAnd->getOperand(1));
Masked = Builder->CreateAnd(LAnd->getOperand(0), Mask); Masked = Builder->CreateAnd(LAnd->getOperand(0), Mask);
} else if (LAnd->getOperand(1) == RAnd->getOperand(1) && } else if (LAnd->getOperand(1) == RAnd->getOperand(1) &&
isKnownToBeAPowerOfTwo(LAnd->getOperand(0), false, 0, AC, CxtI, isKnownToBeAPowerOfTwo(LAnd->getOperand(0), DL, false, 0, AC,
DT) && CxtI, DT) &&
isKnownToBeAPowerOfTwo(RAnd->getOperand(0), false, 0, AC, CxtI, isKnownToBeAPowerOfTwo(RAnd->getOperand(0), DL, false, 0, AC,
DT)) { CxtI, DT)) {
Mask = Builder->CreateOr(LAnd->getOperand(0), RAnd->getOperand(0)); Mask = Builder->CreateOr(LAnd->getOperand(0), RAnd->getOperand(0));
Masked = Builder->CreateAnd(LAnd->getOperand(1), Mask); Masked = Builder->CreateAnd(LAnd->getOperand(1), Mask);
} }
Context not available.

lib/Transforms/InstCombine/InstCombineCalls.cpp

Context not available.
#include "llvm/ADT/Statistic.h" #include "llvm/ADT/Statistic.h"
#include "llvm/Analysis/MemoryBuiltins.h" #include "llvm/Analysis/MemoryBuiltins.h"
#include "llvm/IR/CallSite.h" #include "llvm/IR/CallSite.h"
#include "llvm/IR/DataLayout.h"
#include "llvm/IR/Dominators.h" #include "llvm/IR/Dominators.h"
#include "llvm/IR/PatternMatch.h" #include "llvm/IR/PatternMatch.h"
#include "llvm/IR/Statepoint.h" #include "llvm/IR/Statepoint.h"
Context not available.
} }
Instruction *InstCombiner::SimplifyMemTransfer(MemIntrinsic *MI) { Instruction *InstCombiner::SimplifyMemTransfer(MemIntrinsic *MI) {
unsigned DstAlign = getKnownAlignment(MI->getArgOperand(0), DL, AC, MI, DT); unsigned DstAlign = getKnownAlignment(MI->getArgOperand(0), *MI, AC, DT);
unsigned SrcAlign = getKnownAlignment(MI->getArgOperand(1), DL, AC, MI, DT); unsigned SrcAlign = getKnownAlignment(MI->getArgOperand(1), *MI, AC, DT);
unsigned MinAlign = std::min(DstAlign, SrcAlign); unsigned MinAlign = std::min(DstAlign, SrcAlign);
unsigned CopyAlign = MI->getAlignment(); unsigned CopyAlign = MI->getAlignment();
Context not available.
if (StrippedDest != MI->getArgOperand(0)) { if (StrippedDest != MI->getArgOperand(0)) {
Type *SrcETy = cast<PointerType>(StrippedDest->getType()) Type *SrcETy = cast<PointerType>(StrippedDest->getType())
->getElementType(); ->getElementType();
if (DL && SrcETy->isSized() && DL->getTypeStoreSize(SrcETy) == Size) { if (SrcETy->isSized() && DL.getTypeStoreSize(SrcETy) == Size) {
// The SrcETy might be something like {{{double}}} or [1 x double]. Rip // The SrcETy might be something like {{{double}}} or [1 x double]. Rip
// down through these levels if so. // down through these levels if so.
SrcETy = reduceToSingleValueType(SrcETy); SrcETy = reduceToSingleValueType(SrcETy);
Context not available.
} }
Instruction *InstCombiner::SimplifyMemSet(MemSetInst *MI) { Instruction *InstCombiner::SimplifyMemSet(MemSetInst *MI) {
unsigned Alignment = getKnownAlignment(MI->getDest(), DL, AC, MI, DT); unsigned Alignment = getKnownAlignment(MI->getDest(), *MI, AC, DT);
if (MI->getAlignment() < Alignment) { if (MI->getAlignment() < Alignment) {
MI->setAlignment(ConstantInt::get(MI->getAlignmentType(), MI->setAlignment(ConstantInt::get(MI->getAlignmentType(),
Alignment, false)); Alignment, false));
Context not available.
// can prove that it will never overflow. // can prove that it will never overflow.
if (II->getIntrinsicID() == Intrinsic::sadd_with_overflow) { if (II->getIntrinsicID() == Intrinsic::sadd_with_overflow) {
Value *LHS = II->getArgOperand(0), *RHS = II->getArgOperand(1); Value *LHS = II->getArgOperand(0), *RHS = II->getArgOperand(1);
if (WillNotOverflowSignedAdd(LHS, RHS, II)) { if (WillNotOverflowSignedAdd(LHS, RHS, *II)) {
return CreateOverflowTuple(II, Builder->CreateNSWAdd(LHS, RHS), false); return CreateOverflowTuple(II, Builder->CreateNSWAdd(LHS, RHS), false);
} }
} }
Context not available.
} }
} }
if (II->getIntrinsicID() == Intrinsic::ssub_with_overflow) { if (II->getIntrinsicID() == Intrinsic::ssub_with_overflow) {
if (WillNotOverflowSignedSub(LHS, RHS, II)) { if (WillNotOverflowSignedSub(LHS, RHS, *II)) {
return CreateOverflowTuple(II, Builder->CreateNSWSub(LHS, RHS), false); return CreateOverflowTuple(II, Builder->CreateNSWSub(LHS, RHS), false);
} }
} else { } else {
if (WillNotOverflowUnsignedSub(LHS, RHS, II)) { if (WillNotOverflowUnsignedSub(LHS, RHS, *II)) {
return CreateOverflowTuple(II, Builder->CreateNUWSub(LHS, RHS), false); return CreateOverflowTuple(II, Builder->CreateNUWSub(LHS, RHS), false);
} }
} }
Context not available.
} }
if (II->getIntrinsicID() == Intrinsic::smul_with_overflow) { if (II->getIntrinsicID() == Intrinsic::smul_with_overflow) {
Value *LHS = II->getArgOperand(0), *RHS = II->getArgOperand(1); Value *LHS = II->getArgOperand(0), *RHS = II->getArgOperand(1);
if (WillNotOverflowSignedMul(LHS, RHS, II)) { if (WillNotOverflowSignedMul(LHS, RHS, *II)) {
return CreateOverflowTuple(II, Builder->CreateNSWMul(LHS, RHS), false); return CreateOverflowTuple(II, Builder->CreateNSWMul(LHS, RHS), false);
} }
} }
Context not available.
case Intrinsic::ppc_altivec_lvx: case Intrinsic::ppc_altivec_lvx:
case Intrinsic::ppc_altivec_lvxl: case Intrinsic::ppc_altivec_lvxl:
// Turn PPC lvx -> load if the pointer is known aligned. // Turn PPC lvx -> load if the pointer is known aligned.
if (getOrEnforceKnownAlignment(II->getArgOperand(0), 16, DL, AC, II, DT) >= if (getOrEnforceKnownAlignment(II->getArgOperand(0), 16, *II, AC, DT) >=
16) { 16) {
Value *Ptr = Builder->CreateBitCast(II->getArgOperand(0), Value *Ptr = Builder->CreateBitCast(II->getArgOperand(0),
PointerType::getUnqual(II->getType())); PointerType::getUnqual(II->getType()));
Context not available.
case Intrinsic::ppc_altivec_stvx: case Intrinsic::ppc_altivec_stvx:
case Intrinsic::ppc_altivec_stvxl: case Intrinsic::ppc_altivec_stvxl:
// Turn stvx -> store if the pointer is known aligned. // Turn stvx -> store if the pointer is known aligned.
if (getOrEnforceKnownAlignment(II->getArgOperand(1), 16, DL, AC, II, DT) >= if (getOrEnforceKnownAlignment(II->getArgOperand(1), 16, *II, AC, DT) >=
16) { 16) {
Type *OpPtrTy = Type *OpPtrTy =
PointerType::getUnqual(II->getArgOperand(0)->getType()); PointerType::getUnqual(II->getArgOperand(0)->getType());
Context not available.
} }
case Intrinsic::ppc_qpx_qvlfs: case Intrinsic::ppc_qpx_qvlfs:
// Turn PPC QPX qvlfs -> load if the pointer is known aligned. // Turn PPC QPX qvlfs -> load if the pointer is known aligned.
if (getOrEnforceKnownAlignment(II->getArgOperand(0), 16, DL, AC, II, DT) >= if (getOrEnforceKnownAlignment(II->getArgOperand(0), 16, *II, AC, DT) >=
16) { 16) {
Value *Ptr = Builder->CreateBitCast(II->getArgOperand(0), Value *Ptr = Builder->CreateBitCast(II->getArgOperand(0),
PointerType::getUnqual(II->getType())); PointerType::getUnqual(II->getType()));
Context not available.
break; break;
case Intrinsic::ppc_qpx_qvlfd: case Intrinsic::ppc_qpx_qvlfd:
// Turn PPC QPX qvlfd -> load if the pointer is known aligned. // Turn PPC QPX qvlfd -> load if the pointer is known aligned.
if (getOrEnforceKnownAlignment(II->getArgOperand(0), 32, DL, AC, II, DT) >= if (getOrEnforceKnownAlignment(II->getArgOperand(0), 32, *II, AC, DT) >=
32) { 32) {
Value *Ptr = Builder->CreateBitCast(II->getArgOperand(0), Value *Ptr = Builder->CreateBitCast(II->getArgOperand(0),
PointerType::getUnqual(II->getType())); PointerType::getUnqual(II->getType()));
Context not available.
break; break;
case Intrinsic::ppc_qpx_qvstfs: case Intrinsic::ppc_qpx_qvstfs:
// Turn PPC QPX qvstfs -> store if the pointer is known aligned. // Turn PPC QPX qvstfs -> store if the pointer is known aligned.
if (getOrEnforceKnownAlignment(II->getArgOperand(1), 16, DL, AC, II, DT) >= if (getOrEnforceKnownAlignment(II->getArgOperand(1), 16, *II, AC, DT) >=
16) { 16) {
Type *OpPtrTy = Type *OpPtrTy =
PointerType::getUnqual(II->getArgOperand(0)->getType()); PointerType::getUnqual(II->getArgOperand(0)->getType());
Context not available.
break; break;
case Intrinsic::ppc_qpx_qvstfd: case Intrinsic::ppc_qpx_qvstfd:
// Turn PPC QPX qvstfd -> store if the pointer is known aligned. // Turn PPC QPX qvstfd -> store if the pointer is known aligned.
if (getOrEnforceKnownAlignment(II->getArgOperand(1), 32, DL, AC, II, DT) >= if (getOrEnforceKnownAlignment(II->getArgOperand(1), 32, *II, AC, DT) >=
32) { 32) {
Type *OpPtrTy = Type *OpPtrTy =
PointerType::getUnqual(II->getArgOperand(0)->getType()); PointerType::getUnqual(II->getArgOperand(0)->getType());
Context not available.
case Intrinsic::x86_sse2_storeu_pd: case Intrinsic::x86_sse2_storeu_pd:
case Intrinsic::x86_sse2_storeu_dq: case Intrinsic::x86_sse2_storeu_dq:
// Turn X86 storeu -> store if the pointer is known aligned. // Turn X86 storeu -> store if the pointer is known aligned.
if (getOrEnforceKnownAlignment(II->getArgOperand(0), 16, DL, AC, II, DT) >= if (getOrEnforceKnownAlignment(II->getArgOperand(0), 16, *II, AC, DT) >=
16) { 16) {
Type *OpPtrTy = Type *OpPtrTy =
PointerType::getUnqual(II->getArgOperand(1)->getType()); PointerType::getUnqual(II->getArgOperand(1)->getType());
Context not available.
unsigned LowHalfElts = VWidth / 2; unsigned LowHalfElts = VWidth / 2;
APInt InputDemandedElts(APInt::getBitsSet(VWidth, 0, LowHalfElts)); APInt InputDemandedElts(APInt::getBitsSet(VWidth, 0, LowHalfElts));
APInt UndefElts(VWidth, 0); APInt UndefElts(VWidth, 0);
if (Value *TmpV = SimplifyDemandedVectorElts(II->getArgOperand(0), if (Value *TmpV = SimplifyDemandedVectorElts(
InputDemandedElts, II->getArgOperand(0), InputDemandedElts, UndefElts)) {
UndefElts)) {
II->setArgOperand(0, TmpV); II->setArgOperand(0, TmpV);
return II; return II;
} }
Context not available.
unsigned Idx = unsigned Idx =
cast<ConstantInt>(Mask->getAggregateElement(i))->getZExtValue(); cast<ConstantInt>(Mask->getAggregateElement(i))->getZExtValue();
Idx &= 31; // Match the hardware behavior. Idx &= 31; // Match the hardware behavior.
if (DL && DL->isLittleEndian()) if (DL.isLittleEndian())
Idx = 31 - Idx; Idx = 31 - Idx;
if (!ExtractedElts[Idx]) { if (!ExtractedElts[Idx]) {
Value *Op0ToUse = (DL && DL->isLittleEndian()) ? Op1 : Op0; Value *Op0ToUse = (DL.isLittleEndian()) ? Op1 : Op0;
Value *Op1ToUse = (DL && DL->isLittleEndian()) ? Op0 : Op1; Value *Op1ToUse = (DL.isLittleEndian()) ? Op0 : Op1;
ExtractedElts[Idx] = ExtractedElts[Idx] =
Builder->CreateExtractElement(Idx < 16 ? Op0ToUse : Op1ToUse, Builder->CreateExtractElement(Idx < 16 ? Op0ToUse : Op1ToUse,
Builder->getInt32(Idx&15)); Builder->getInt32(Idx&15));
Context not available.
case Intrinsic::arm_neon_vst2lane: case Intrinsic::arm_neon_vst2lane:
case Intrinsic::arm_neon_vst3lane: case Intrinsic::arm_neon_vst3lane:
case Intrinsic::arm_neon_vst4lane: { case Intrinsic::arm_neon_vst4lane: {
unsigned MemAlign = getKnownAlignment(II->getArgOperand(0), DL, AC, II, DT); unsigned MemAlign = getKnownAlignment(II->getArgOperand(0), *II, AC, DT);
unsigned AlignArg = II->getNumArgOperands() - 1; unsigned AlignArg = II->getNumArgOperands() - 1;
ConstantInt *IntrAlign = dyn_cast<ConstantInt>(II->getArgOperand(AlignArg)); ConstantInt *IntrAlign = dyn_cast<ConstantInt>(II->getArgOperand(AlignArg));
if (IntrAlign && IntrAlign->getZExtValue() < MemAlign) { if (IntrAlign && IntrAlign->getZExtValue() < MemAlign) {
Context not available.
RHS->getType()->isPointerTy() && RHS->getType()->isPointerTy() &&
cast<Constant>(RHS)->isNullValue()) { cast<Constant>(RHS)->isNullValue()) {
LoadInst* LI = cast<LoadInst>(LHS); LoadInst* LI = cast<LoadInst>(LHS);
if (isValidAssumeForContext(II, LI, DL, DT)) { if (isValidAssumeForContext(II, LI, DT)) {
MDNode *MD = MDNode::get(II->getContext(), None); MDNode *MD = MDNode::get(II->getContext(), None);
LI->setMetadata(LLVMContext::MD_nonnull, MD); LI->setMetadata(LLVMContext::MD_nonnull, MD);
return EraseInstFromFunction(*II); return EraseInstFromFunction(*II);
Context not available.
/// isSafeToEliminateVarargsCast - If this cast does not affect the value /// isSafeToEliminateVarargsCast - If this cast does not affect the value
/// passed through the varargs area, we can eliminate the use of the cast. /// passed through the varargs area, we can eliminate the use of the cast.
static bool isSafeToEliminateVarargsCast(const CallSite CS, static bool isSafeToEliminateVarargsCast(const CallSite CS,
const CastInst * const CI, const DataLayout &DL,
const DataLayout * const DL, const CastInst *const CI,
const int ix) { const int ix) {
if (!CI->isLosslessCast()) if (!CI->isLosslessCast())
return false; return false;
Context not available.
Type* DstTy = cast<PointerType>(CI->getType())->getElementType(); Type* DstTy = cast<PointerType>(CI->getType())->getElementType();
if (!SrcTy->isSized() || !DstTy->isSized()) if (!SrcTy->isSized() || !DstTy->isSized())
return false; return false;
if (!DL || DL->getTypeAllocSize(SrcTy) != DL->getTypeAllocSize(DstTy)) if (DL.getTypeAllocSize(SrcTy) != DL.getTypeAllocSize(DstTy))
return false; return false;
return true; return true;
} }
Context not available.
// Currently we're only working with the checking functions, memcpy_chk, // Currently we're only working with the checking functions, memcpy_chk,
// mempcpy_chk, memmove_chk, memset_chk, strcpy_chk, stpcpy_chk, strncpy_chk, // mempcpy_chk, memmove_chk, memset_chk, strcpy_chk, stpcpy_chk, strncpy_chk,
// strcat_chk and strncat_chk. // strcat_chk and strncat_chk.
Instruction *InstCombiner::tryOptimizeCall(CallInst *CI, const DataLayout *DL) { Instruction *InstCombiner::tryOptimizeCall(CallInst *CI) {
if (!CI->getCalledFunction()) return nullptr; if (!CI->getCalledFunction()) return nullptr;
auto InstCombineRAUW = [this](Instruction *From, Value *With) { auto InstCombineRAUW = [this](Instruction *From, Value *With) {
Context not available.
for (CallSite::arg_iterator I = CS.arg_begin() + FTy->getNumParams(), for (CallSite::arg_iterator I = CS.arg_begin() + FTy->getNumParams(),
E = CS.arg_end(); I != E; ++I, ++ix) { E = CS.arg_end(); I != E; ++I, ++ix) {
CastInst *CI = dyn_cast<CastInst>(*I); CastInst *CI = dyn_cast<CastInst>(*I);
if (CI && isSafeToEliminateVarargsCast(CS, CI, DL, ix)) { if (CI && isSafeToEliminateVarargsCast(CS, DL, CI, ix)) {
*I = CI->getOperand(0); *I = CI->getOperand(0);
Changed = true; Changed = true;
} }
Context not available.
// this. None of these calls are seen as possibly dead so go ahead and // this. None of these calls are seen as possibly dead so go ahead and
// delete the instruction now. // delete the instruction now.
if (CallInst *CI = dyn_cast<CallInst>(CS.getInstruction())) { if (CallInst *CI = dyn_cast<CallInst>(CS.getInstruction())) {
Instruction *I = tryOptimizeCall(CI, DL); Instruction *I = tryOptimizeCall(CI);
// If we changed something return the result, etc. Otherwise let // If we changed something return the result, etc. Otherwise let
// the fallthrough check. // the fallthrough check.
if (I) return EraseInstFromFunction(*I); if (I) return EraseInstFromFunction(*I);
Context not available.
CallerPAL.getParamAttributes(i + 1).hasAttribute(i + 1, CallerPAL.getParamAttributes(i + 1).hasAttribute(i + 1,
Attribute::ByVal)) { Attribute::ByVal)) {
PointerType *ParamPTy = dyn_cast<PointerType>(ParamTy); PointerType *ParamPTy = dyn_cast<PointerType>(ParamTy);
if (!ParamPTy || !ParamPTy->getElementType()->isSized() || !DL) if (!ParamPTy || !ParamPTy->getElementType()->isSized())
return false; return false;
Type *CurElTy = ActTy->getPointerElementType(); Type *CurElTy = ActTy->getPointerElementType();
if (DL->getTypeAllocSize(CurElTy) != if (DL.getTypeAllocSize(CurElTy) !=
DL->getTypeAllocSize(ParamPTy->getElementType())) DL.getTypeAllocSize(ParamPTy->getElementType()))
return false; return false;
} }
} }
Context not available.

lib/Transforms/InstCombine/InstCombineCasts.cpp

Context not available.
/// try to eliminate the cast by moving the type information into the alloc. /// try to eliminate the cast by moving the type information into the alloc.
Instruction *InstCombiner::PromoteCastOfAllocation(BitCastInst &CI, Instruction *InstCombiner::PromoteCastOfAllocation(BitCastInst &CI,
AllocaInst &AI) { AllocaInst &AI) {
// This requires DataLayout to get the alloca alignment and size information.
if (!DL) return nullptr;
PointerType *PTy = cast<PointerType>(CI.getType()); PointerType *PTy = cast<PointerType>(CI.getType());
BuilderTy AllocaBuilder(*Builder); BuilderTy AllocaBuilder(*Builder);
Context not available.
Type *CastElTy = PTy->getElementType(); Type *CastElTy = PTy->getElementType();
if (!AllocElTy->isSized() || !CastElTy->isSized()) return nullptr; if (!AllocElTy->isSized() || !CastElTy->isSized()) return nullptr;
unsigned AllocElTyAlign = DL->getABITypeAlignment(AllocElTy); unsigned AllocElTyAlign = DL.getABITypeAlignment(AllocElTy);
unsigned CastElTyAlign = DL->getABITypeAlignment(CastElTy); unsigned CastElTyAlign = DL.getABITypeAlignment(CastElTy);
if (CastElTyAlign < AllocElTyAlign) return nullptr; if (CastElTyAlign < AllocElTyAlign) return nullptr;
// If the allocation has multiple uses, only promote it if we are strictly // If the allocation has multiple uses, only promote it if we are strictly
Context not available.
// same, we open the door to infinite loops of various kinds. // same, we open the door to infinite loops of various kinds.
if (!AI.hasOneUse() && CastElTyAlign == AllocElTyAlign) return nullptr; if (!AI.hasOneUse() && CastElTyAlign == AllocElTyAlign) return nullptr;
uint64_t AllocElTySize = DL->getTypeAllocSize(AllocElTy); uint64_t AllocElTySize = DL.getTypeAllocSize(AllocElTy);
uint64_t CastElTySize = DL->getTypeAllocSize(CastElTy); uint64_t CastElTySize = DL.getTypeAllocSize(CastElTy);
if (CastElTySize == 0 || AllocElTySize == 0) return nullptr; if (CastElTySize == 0 || AllocElTySize == 0) return nullptr;
// If the allocation has multiple uses, only promote it if we're not // If the allocation has multiple uses, only promote it if we're not
// shrinking the amount of memory being allocated. // shrinking the amount of memory being allocated.
uint64_t AllocElTyStoreSize = DL->getTypeStoreSize(AllocElTy); uint64_t AllocElTyStoreSize = DL.getTypeStoreSize(AllocElTy);
uint64_t CastElTyStoreSize = DL->getTypeStoreSize(CastElTy); uint64_t CastElTyStoreSize = DL.getTypeStoreSize(CastElTy);
if (!AI.hasOneUse() && CastElTyStoreSize < AllocElTyStoreSize) return nullptr; if (!AI.hasOneUse() && CastElTyStoreSize < AllocElTyStoreSize) return nullptr;
// See if we can satisfy the modulus by pulling a scale out of the array // See if we can satisfy the modulus by pulling a scale out of the array
Context not available.
PHINode *OPN = cast<PHINode>(I); PHINode *OPN = cast<PHINode>(I);
PHINode *NPN = PHINode::Create(Ty, OPN->getNumIncomingValues()); PHINode *NPN = PHINode::Create(Ty, OPN->getNumIncomingValues());
for (unsigned i = 0, e = OPN->getNumIncomingValues(); i != e; ++i) { for (unsigned i = 0, e = OPN->getNumIncomingValues(); i != e; ++i) {
Value *V =EvaluateInDifferentType(OPN->getIncomingValue(i), Ty, isSigned); Value *V =
EvaluateInDifferentType(OPN->getIncomingValue(i), Ty, isSigned);
NPN->addIncoming(V, OPN->getIncomingBlock(i)); NPN->addIncoming(V, OPN->getIncomingBlock(i));
} }
Res = NPN; Res = NPN;
Context not available.
/// This function is a wrapper around CastInst::isEliminableCastPair. It /// This function is a wrapper around CastInst::isEliminableCastPair. It
/// simply extracts arguments and returns what that function returns. /// simply extracts arguments and returns what that function returns.
static Instruction::CastOps static Instruction::CastOps
isEliminableCastPair( isEliminableCastPair(const CastInst *CI, ///< First cast instruction
const CastInst *CI, ///< The first cast instruction unsigned opcode, ///< Opcode for the second cast
unsigned opcode, ///< The opcode of the second cast instruction Type *DstTy, ///< Target type for the second cast
Type *DstTy, ///< The target type for the second cast instruction const DataLayout &DL) {
const DataLayout *DL ///< The target data for pointer size
) {
Type *SrcTy = CI->getOperand(0)->getType(); // A from above Type *SrcTy = CI->getOperand(0)->getType(); // A from above
Type *MidTy = CI->getType(); // B from above Type *MidTy = CI->getType(); // B from above
// Get the opcodes of the two Cast instructions // Get the opcodes of the two Cast instructions
Instruction::CastOps firstOp = Instruction::CastOps(CI->getOpcode()); Instruction::CastOps firstOp = Instruction::CastOps(CI->getOpcode());
Instruction::CastOps secondOp = Instruction::CastOps(opcode); Instruction::CastOps secondOp = Instruction::CastOps(opcode);
Type *SrcIntPtrTy = DL && SrcTy->isPtrOrPtrVectorTy() ? Type *SrcIntPtrTy =
DL->getIntPtrType(SrcTy) : nullptr; SrcTy->isPtrOrPtrVectorTy() ? DL.getIntPtrType(SrcTy) : nullptr;
Type *MidIntPtrTy = DL && MidTy->isPtrOrPtrVectorTy() ? Type *MidIntPtrTy =
DL->getIntPtrType(MidTy) : nullptr; MidTy->isPtrOrPtrVectorTy() ? DL.getIntPtrType(MidTy) : nullptr;
Type *DstIntPtrTy = DL && DstTy->isPtrOrPtrVectorTy() ? Type *DstIntPtrTy =
DL->getIntPtrType(DstTy) : nullptr; DstTy->isPtrOrPtrVectorTy() ? DL.getIntPtrType(DstTy) : nullptr;
unsigned Res = CastInst::isEliminableCastPair(firstOp, secondOp, SrcTy, MidTy, unsigned Res = CastInst::isEliminableCastPair(firstOp, secondOp, SrcTy, MidTy,
DstTy, SrcIntPtrTy, MidIntPtrTy, DstTy, SrcIntPtrTy, MidIntPtrTy,
DstIntPtrTy); DstIntPtrTy);
Context not available.
// eliminate it now. // eliminate it now.
if (CastInst *CSrc = dyn_cast<CastInst>(Src)) { // A->B->C cast if (CastInst *CSrc = dyn_cast<CastInst>(Src)) { // A->B->C cast
if (Instruction::CastOps opc = if (Instruction::CastOps opc =
isEliminableCastPair(CSrc, CI.getOpcode(), CI.getType(), DL)) { isEliminableCastPair(CSrc, CI.getOpcode(), CI.getType(), DL)) {
// The first cast (CSrc) is eliminable so we need to fix up or replace // The first cast (CSrc) is eliminable so we need to fix up or replace
// the second cast (CI). CSrc will then have a good chance of being dead. // the second cast (CI). CSrc will then have a good chance of being dead.
return CastInst::Create(opc, CSrc->getOperand(0), CI.getType()); return CastInst::Create(opc, CSrc->getOperand(0), CI.getType());
Context not available.
if (isa<PHINode>(Src)) { if (isa<PHINode>(Src)) {
// We don't do this if this would create a PHI node with an illegal type if // We don't do this if this would create a PHI node with an illegal type if
// it is currently legal. // it is currently legal.
if (!Src->getType()->isIntegerTy() || if (!Src->getType()->isIntegerTy() || !CI.getType()->isIntegerTy() ||
!CI.getType()->isIntegerTy() ||
ShouldChangeType(CI.getType(), Src->getType())) ShouldChangeType(CI.getType(), Src->getType()))
if (Instruction *NV = FoldOpIntoPhi(CI)) if (Instruction *NV = FoldOpIntoPhi(CI))
return NV; return NV;
Context not available.
// If the source integer type is not the intptr_t type for this target, do a // If the source integer type is not the intptr_t type for this target, do a
// trunc or zext to the intptr_t type, then inttoptr of it. This allows the // trunc or zext to the intptr_t type, then inttoptr of it. This allows the
// cast to be exposed to other transforms. // cast to be exposed to other transforms.
unsigned AS = CI.getAddressSpace();
if (DL) { if (CI.getOperand(0)->getType()->getScalarSizeInBits() !=
unsigned AS = CI.getAddressSpace(); DL.getPointerSizeInBits(AS)) {
if (CI.getOperand(0)->getType()->getScalarSizeInBits() != Type *Ty = DL.getIntPtrType(CI.getContext(), AS);
DL->getPointerSizeInBits(AS)) { if (CI.getType()->isVectorTy()) // Handle vectors of pointers.
Type *Ty = DL->getIntPtrType(CI.getContext(), AS); Ty = VectorType::get(Ty, CI.getType()->getVectorNumElements());
if (CI.getType()->isVectorTy()) // Handle vectors of pointers.
Ty = VectorType::get(Ty, CI.getType()->getVectorNumElements()); Value *P = Builder->CreateZExtOrTrunc(CI.getOperand(0), Ty);
return new IntToPtrInst(P, CI.getType());
Value *P = Builder->CreateZExtOrTrunc(CI.getOperand(0), Ty);
return new IntToPtrInst(P, CI.getType());
}
} }
if (Instruction *I = commonCastTransforms(CI)) if (Instruction *I = commonCastTransforms(CI))
Context not available.
return &CI; return &CI;
} }
if (!DL)
return commonCastTransforms(CI);
// If the GEP has a single use, and the base pointer is a bitcast, and the // If the GEP has a single use, and the base pointer is a bitcast, and the
// GEP computes a constant offset, see if we can convert these three // GEP computes a constant offset, see if we can convert these three
// instructions into fewer. This typically happens with unions and other // instructions into fewer. This typically happens with unions and other
// non-type-safe code. // non-type-safe code.
unsigned AS = GEP->getPointerAddressSpace(); unsigned AS = GEP->getPointerAddressSpace();
unsigned OffsetBits = DL->getPointerSizeInBits(AS); unsigned OffsetBits = DL.getPointerSizeInBits(AS);
APInt Offset(OffsetBits, 0); APInt Offset(OffsetBits, 0);
BitCastInst *BCI = dyn_cast<BitCastInst>(GEP->getOperand(0)); BitCastInst *BCI = dyn_cast<BitCastInst>(GEP->getOperand(0));
if (GEP->hasOneUse() && if (GEP->hasOneUse() && BCI && GEP->accumulateConstantOffset(DL, Offset)) {
BCI &&
GEP->accumulateConstantOffset(*DL, Offset)) {
// Get the base pointer input of the bitcast, and the type it points to. // Get the base pointer input of the bitcast, and the type it points to.
Value *OrigBase = BCI->getOperand(0); Value *OrigBase = BCI->getOperand(0);
SmallVector<Value*, 8> NewIndices; SmallVector<Value*, 8> NewIndices;
if (FindElementAtOffset(OrigBase->getType(), if (FindElementAtOffset(OrigBase->getType(), Offset.getSExtValue(),
Offset.getSExtValue(),
NewIndices)) { NewIndices)) {
// If we were able to index down into an element, create the GEP // If we were able to index down into an element, create the GEP
// and bitcast the result. This eliminates one bitcast, potentially // and bitcast the result. This eliminates one bitcast, potentially
Context not available.
// do a ptrtoint to intptr_t then do a trunc or zext. This allows the cast // do a ptrtoint to intptr_t then do a trunc or zext. This allows the cast
// to be exposed to other transforms. // to be exposed to other transforms.
if (!DL)
return commonPointerCastTransforms(CI);
Type *Ty = CI.getType(); Type *Ty = CI.getType();
unsigned AS = CI.getPointerAddressSpace(); unsigned AS = CI.getPointerAddressSpace();
if (Ty->getScalarSizeInBits() == DL->getPointerSizeInBits(AS)) if (Ty->getScalarSizeInBits() == DL.getPointerSizeInBits(AS))
return commonPointerCastTransforms(CI); return commonPointerCastTransforms(CI);
Type *PtrTy = DL->getIntPtrType(CI.getContext(), AS); Type *PtrTy = DL.getIntPtrType(CI.getContext(), AS);
if (Ty->isVectorTy()) // Handle vectors of pointers. if (Ty->isVectorTy()) // Handle vectors of pointers.
PtrTy = VectorType::get(PtrTy, Ty->getVectorNumElements()); PtrTy = VectorType::get(PtrTy, Ty->getVectorNumElements());
Context not available.
/// This returns false if the pattern can't be matched or true if it can, /// This returns false if the pattern can't be matched or true if it can,
/// filling in Elements with the elements found here. /// filling in Elements with the elements found here.
static bool CollectInsertionElements(Value *V, unsigned Shift, static bool CollectInsertionElements(Value *V, unsigned Shift,
SmallVectorImpl<Value*> &Elements, SmallVectorImpl<Value *> &Elements,
Type *VecEltTy, InstCombiner &IC) { Type *VecEltTy, bool isBigEndian) {
assert(isMultipleOfTypeSize(Shift, VecEltTy) && assert(isMultipleOfTypeSize(Shift, VecEltTy) &&
"Shift should be a multiple of the element type size"); "Shift should be a multiple of the element type size");
Context not available.
return true; return true;
unsigned ElementIndex = getTypeSizeIndex(Shift, VecEltTy); unsigned ElementIndex = getTypeSizeIndex(Shift, VecEltTy);
if (IC.getDataLayout()->isBigEndian()) if (isBigEndian)
ElementIndex = Elements.size() - ElementIndex - 1; ElementIndex = Elements.size() - ElementIndex - 1;
// Fail if multiple elements are inserted into this slot. // Fail if multiple elements are inserted into this slot.
Context not available.
// it to the right type so it gets properly inserted. // it to the right type so it gets properly inserted.
if (NumElts == 1) if (NumElts == 1)
return CollectInsertionElements(ConstantExpr::getBitCast(C, VecEltTy), return CollectInsertionElements(ConstantExpr::getBitCast(C, VecEltTy),
Shift, Elements, VecEltTy, IC); Shift, Elements, VecEltTy, isBigEndian);
// Okay, this is a constant that covers multiple elements. Slice it up into // Okay, this is a constant that covers multiple elements. Slice it up into
// pieces and insert each element-sized piece into the vector. // pieces and insert each element-sized piece into the vector.
Context not available.
Constant *Piece = ConstantExpr::getLShr(C, ConstantInt::get(C->getType(), Constant *Piece = ConstantExpr::getLShr(C, ConstantInt::get(C->getType(),
ShiftI)); ShiftI));
Piece = ConstantExpr::getTrunc(Piece, ElementIntTy); Piece = ConstantExpr::getTrunc(Piece, ElementIntTy);
if (!CollectInsertionElements(Piece, ShiftI, Elements, VecEltTy, IC)) if (!CollectInsertionElements(Piece, ShiftI, Elements, VecEltTy,
isBigEndian))
return false; return false;
} }
return true; return true;
Context not available.
switch (I->getOpcode()) { switch (I->getOpcode()) {
default: return false; // Unhandled case. default: return false; // Unhandled case.
case Instruction::BitCast: case Instruction::BitCast:
return CollectInsertionElements(I->getOperand(0), Shift, return CollectInsertionElements(I->getOperand(0), Shift, Elements, VecEltTy,
Elements, VecEltTy, IC); isBigEndian);
case Instruction::ZExt: case Instruction::ZExt:
if (!isMultipleOfTypeSize( if (!isMultipleOfTypeSize(
I->getOperand(0)->getType()->getPrimitiveSizeInBits(), I->getOperand(0)->getType()->getPrimitiveSizeInBits(),
VecEltTy)) VecEltTy))
return false; return false;
return CollectInsertionElements(I->getOperand(0), Shift, return CollectInsertionElements(I->getOperand(0), Shift, Elements, VecEltTy,
Elements, VecEltTy, IC); isBigEndian);
case Instruction::Or: case Instruction::Or:
return CollectInsertionElements(I->getOperand(0), Shift, return CollectInsertionElements(I->getOperand(0), Shift, Elements, VecEltTy,
Elements, VecEltTy, IC) && isBigEndian) &&
CollectInsertionElements(I->getOperand(1), Shift, CollectInsertionElements(I->getOperand(1), Shift, Elements, VecEltTy,
Elements, VecEltTy, IC); isBigEndian);
case Instruction::Shl: { case Instruction::Shl: {
// Must be shifting by a constant that is a multiple of the element size. // Must be shifting by a constant that is a multiple of the element size.
ConstantInt *CI = dyn_cast<ConstantInt>(I->getOperand(1)); ConstantInt *CI = dyn_cast<ConstantInt>(I->getOperand(1));
if (!CI) return false; if (!CI) return false;
Shift += CI->getZExtValue(); Shift += CI->getZExtValue();
if (!isMultipleOfTypeSize(Shift, VecEltTy)) return false; if (!isMultipleOfTypeSize(Shift, VecEltTy)) return false;
return CollectInsertionElements(I->getOperand(0), Shift, return CollectInsertionElements(I->getOperand(0), Shift, Elements, VecEltTy,
Elements, VecEltTy, IC); isBigEndian);
} }
} }
Context not available.
/// Into two insertelements that do "buildvector{%inc, %inc5}". /// Into two insertelements that do "buildvector{%inc, %inc5}".
static Value *OptimizeIntegerToVectorInsertions(BitCastInst &CI, static Value *OptimizeIntegerToVectorInsertions(BitCastInst &CI,
InstCombiner &IC) { InstCombiner &IC) {
// We need to know the target byte order to perform this optimization.
if (!IC.getDataLayout()) return nullptr;
VectorType *DestVecTy = cast<VectorType>(CI.getType()); VectorType *DestVecTy = cast<VectorType>(CI.getType());
Value *IntInput = CI.getOperand(0); Value *IntInput = CI.getOperand(0);
SmallVector<Value*, 8> Elements(DestVecTy->getNumElements()); SmallVector<Value*, 8> Elements(DestVecTy->getNumElements());
if (!CollectInsertionElements(IntInput, 0, Elements, if (!CollectInsertionElements(IntInput, 0, Elements,
DestVecTy->getElementType(), IC)) DestVecTy->getElementType(),
IC.getDataLayout().isBigEndian()))
return nullptr; return nullptr;
// If we succeeded, we know that all of the element are specified by Elements // If we succeeded, we know that all of the element are specified by Elements
Context not available.
/// OptimizeIntToFloatBitCast - See if we can optimize an integer->float/double /// OptimizeIntToFloatBitCast - See if we can optimize an integer->float/double
/// bitcast. The various long double bitcasts can't get in here. /// bitcast. The various long double bitcasts can't get in here.
static Instruction *OptimizeIntToFloatBitCast(BitCastInst &CI,InstCombiner &IC){ static Instruction *OptimizeIntToFloatBitCast(BitCastInst &CI, InstCombiner &IC,
// We need to know the target byte order to perform this optimization. const DataLayout &DL) {
if (!IC.getDataLayout()) return nullptr;
Value *Src = CI.getOperand(0); Value *Src = CI.getOperand(0);
Type *DestTy = CI.getType(); Type *DestTy = CI.getType();
Context not available.
} }
unsigned Elt = 0; unsigned Elt = 0;
if (IC.getDataLayout()->isBigEndian()) if (DL.isBigEndian())
Elt = VecTy->getPrimitiveSizeInBits() / DestWidth - 1; Elt = VecTy->getPrimitiveSizeInBits() / DestWidth - 1;
return ExtractElementInst::Create(VecInput, IC.Builder->getInt32(Elt)); return ExtractElementInst::Create(VecInput, IC.Builder->getInt32(Elt));
} }
Context not available.
} }
unsigned Elt = ShAmt->getZExtValue() / DestWidth; unsigned Elt = ShAmt->getZExtValue() / DestWidth;
if (IC.getDataLayout()->isBigEndian()) if (DL.isBigEndian())
Elt = VecTy->getPrimitiveSizeInBits() / DestWidth - 1 - Elt; Elt = VecTy->getPrimitiveSizeInBits() / DestWidth - 1 - Elt;
return ExtractElementInst::Create(VecInput, IC.Builder->getInt32(Elt)); return ExtractElementInst::Create(VecInput, IC.Builder->getInt32(Elt));
} }
Context not available.
// Try to optimize int -> float bitcasts. // Try to optimize int -> float bitcasts.
if ((DestTy->isFloatTy() || DestTy->isDoubleTy()) && isa<IntegerType>(SrcTy)) if ((DestTy->isFloatTy() || DestTy->isDoubleTy()) && isa<IntegerType>(SrcTy))
if (Instruction *I = OptimizeIntToFloatBitCast(CI, *this)) if (Instruction *I = OptimizeIntToFloatBitCast(CI, *this, DL))
return I; return I;
if (VectorType *DestVTy = dyn_cast<VectorType>(DestTy)) { if (VectorType *DestVTy = dyn_cast<VectorType>(DestTy)) {
Context not available.

lib/Transforms/InstCombine/InstCombineCompares.cpp

Context not available.
Instruction *InstCombiner:: Instruction *InstCombiner::
FoldCmpLoadFromIndexedGlobal(GetElementPtrInst *GEP, GlobalVariable *GV, FoldCmpLoadFromIndexedGlobal(GetElementPtrInst *GEP, GlobalVariable *GV,
CmpInst &ICI, ConstantInt *AndCst) { CmpInst &ICI, ConstantInt *AndCst) {
// We need TD information to know the pointer size unless this is inbounds.
if (!GEP->isInBounds() && !DL)
return nullptr;
Constant *Init = GV->getInitializer(); Constant *Init = GV->getInitializer();
if (!isa<ConstantArray>(Init) && !isa<ConstantDataArray>(Init)) if (!isa<ConstantArray>(Init) && !isa<ConstantDataArray>(Init))
return nullptr; return nullptr;
Context not available.
// the array, this will fully represent all the comparison results. // the array, this will fully represent all the comparison results.
uint64_t MagicBitvector = 0; uint64_t MagicBitvector = 0;
// Scan the array and see if one of our patterns matches. // Scan the array and see if one of our patterns matches.
Constant *CompareRHS = cast<Constant>(ICI.getOperand(1)); Constant *CompareRHS = cast<Constant>(ICI.getOperand(1));
for (unsigned i = 0, e = ArrayElementCount; i != e; ++i) { for (unsigned i = 0, e = ArrayElementCount; i != e; ++i) {
Context not available.
// index down like the GEP would do implicitly. We don't have to do this for // index down like the GEP would do implicitly. We don't have to do this for
// an inbounds GEP because the index can't be out of range. // an inbounds GEP because the index can't be out of range.
if (!GEP->isInBounds()) { if (!GEP->isInBounds()) {
Type *IntPtrTy = DL->getIntPtrType(GEP->getType()); Type *IntPtrTy = DL.getIntPtrType(GEP->getType());
unsigned PtrSize = IntPtrTy->getIntegerBitWidth(); unsigned PtrSize = IntPtrTy->getIntegerBitWidth();
if (Idx->getType()->getPrimitiveSizeInBits() > PtrSize) if (Idx->getType()->getPrimitiveSizeInBits() > PtrSize)
Idx = Builder->CreateTrunc(Idx, IntPtrTy); Idx = Builder->CreateTrunc(Idx, IntPtrTy);
Context not available.
// - Default to i32 // - Default to i32
if (ArrayElementCount <= Idx->getType()->getIntegerBitWidth()) if (ArrayElementCount <= Idx->getType()->getIntegerBitWidth())
Ty = Idx->getType(); Ty = Idx->getType();
else if (DL) else
Ty = DL->getSmallestLegalIntType(Init->getContext(), ArrayElementCount); Ty = DL.getSmallestLegalIntType(Init->getContext(), ArrayElementCount);
else if (ArrayElementCount <= 32)
Ty = Type::getInt32Ty(Init->getContext());
if (Ty) { if (Ty) {
Value *V = Builder->CreateIntCast(Idx, Ty, false); Value *V = Builder->CreateIntCast(Idx, Ty, false);
Context not available.
/// ///
/// If we can't emit an optimized form for this expression, this returns null. /// If we can't emit an optimized form for this expression, this returns null.
/// ///
static Value *EvaluateGEPOffsetExpression(User *GEP, InstCombiner &IC) { static Value *EvaluateGEPOffsetExpression(User *GEP, InstCombiner &IC,
const DataLayout &DL = *IC.getDataLayout(); const DataLayout &DL) {
gep_type_iterator GTI = gep_type_begin(GEP); gep_type_iterator GTI = gep_type_begin(GEP);
// Check to see if this gep only has a single variable index. If so, and if // Check to see if this gep only has a single variable index. If so, and if
Context not available.
RHS = RHS->stripPointerCasts(); RHS = RHS->stripPointerCasts();
Value *PtrBase = GEPLHS->getOperand(0); Value *PtrBase = GEPLHS->getOperand(0);
if (DL && PtrBase == RHS && GEPLHS->isInBounds()) { if (PtrBase == RHS && GEPLHS->isInBounds()) {
// ((gep Ptr, OFFSET) cmp Ptr) ---> (OFFSET cmp 0). // ((gep Ptr, OFFSET) cmp Ptr) ---> (OFFSET cmp 0).
// This transformation (ignoring the base and scales) is valid because we // This transformation (ignoring the base and scales) is valid because we
// know pointers can't overflow since the gep is inbounds. See if we can // know pointers can't overflow since the gep is inbounds. See if we can
// output an optimized form. // output an optimized form.
Value *Offset = EvaluateGEPOffsetExpression(GEPLHS, *this); Value *Offset = EvaluateGEPOffsetExpression(GEPLHS, *this, DL);
// If not, synthesize the offset the hard way. // If not, synthesize the offset the hard way.
if (!Offset) if (!Offset)
Context not available.
// If we're comparing GEPs with two base pointers that only differ in type // If we're comparing GEPs with two base pointers that only differ in type
// and both GEPs have only constant indices or just one use, then fold // and both GEPs have only constant indices or just one use, then fold
// the compare with the adjusted indices. // the compare with the adjusted indices.
if (DL && GEPLHS->isInBounds() && GEPRHS->isInBounds() && if (GEPLHS->isInBounds() && GEPRHS->isInBounds() &&
(GEPLHS->hasAllConstantIndices() || GEPLHS->hasOneUse()) && (GEPLHS->hasAllConstantIndices() || GEPLHS->hasOneUse()) &&
(GEPRHS->hasAllConstantIndices() || GEPRHS->hasOneUse()) && (GEPRHS->hasAllConstantIndices() || GEPRHS->hasOneUse()) &&
PtrBase->stripPointerCasts() == PtrBase->stripPointerCasts() ==
GEPRHS->getOperand(0)->stripPointerCasts()) { GEPRHS->getOperand(0)->stripPointerCasts()) {
Value *LOffset = EmitGEPOffset(GEPLHS); Value *LOffset = EmitGEPOffset(GEPLHS);
Value *ROffset = EmitGEPOffset(GEPRHS); Value *ROffset = EmitGEPOffset(GEPRHS);
Context not available.
// Only lower this if the icmp is the only user of the GEP or if we expect // Only lower this if the icmp is the only user of the GEP or if we expect
// the result to fold to a constant! // the result to fold to a constant!
if (DL && if (GEPsInBounds && (isa<ConstantExpr>(GEPLHS) || GEPLHS->hasOneUse()) &&
GEPsInBounds &&
(isa<ConstantExpr>(GEPLHS) || GEPLHS->hasOneUse()) &&
(isa<ConstantExpr>(GEPRHS) || GEPRHS->hasOneUse())) { (isa<ConstantExpr>(GEPRHS) || GEPRHS->hasOneUse())) {
// ((gep Ptr, OFFSET1) cmp (gep Ptr, OFFSET2) ---> (OFFSET1 cmp OFFSET2) // ((gep Ptr, OFFSET1) cmp (gep Ptr, OFFSET2) ---> (OFFSET1 cmp OFFSET2)
Value *L = EmitGEPOffset(GEPLHS); Value *L = EmitGEPOffset(GEPLHS);
Context not available.
// Turn icmp (ptrtoint x), (ptrtoint/c) into a compare of the input if the // Turn icmp (ptrtoint x), (ptrtoint/c) into a compare of the input if the
// integer type is the same size as the pointer type. // integer type is the same size as the pointer type.
if (DL && LHSCI->getOpcode() == Instruction::PtrToInt && if (LHSCI->getOpcode() == Instruction::PtrToInt &&
DL->getPointerTypeSizeInBits(SrcTy) == DestTy->getIntegerBitWidth()) { DL.getPointerTypeSizeInBits(SrcTy) == DestTy->getIntegerBitWidth()) {
Value *RHSOp = nullptr; Value *RHSOp = nullptr;
if (PtrToIntOperator *RHSC = dyn_cast<PtrToIntOperator>(ICI.getOperand(1))) { if (PtrToIntOperator *RHSC = dyn_cast<PtrToIntOperator>(ICI.getOperand(1))) {
Value *RHSCIOp = RHSC->getOperand(0); Value *RHSCIOp = RHSC->getOperand(0);
Context not available.
unsigned BitWidth = 0; unsigned BitWidth = 0;
if (Ty->isIntOrIntVectorTy()) if (Ty->isIntOrIntVectorTy())
BitWidth = Ty->getScalarSizeInBits(); BitWidth = Ty->getScalarSizeInBits();
else if (DL) // Pointers require DL info to get their size. else // Get pointer size.
BitWidth = DL->getTypeSizeInBits(Ty->getScalarType()); BitWidth = DL.getTypeSizeInBits(Ty->getScalarType());
bool isSignBit = false; bool isSignBit = false;
Context not available.
Op0KnownZero, Op0KnownOne, 0)) Op0KnownZero, Op0KnownOne, 0))
return &I; return &I;
if (SimplifyDemandedBits(I.getOperandUse(1), if (SimplifyDemandedBits(I.getOperandUse(1),
APInt::getAllOnesValue(BitWidth), APInt::getAllOnesValue(BitWidth), Op1KnownZero,
Op1KnownZero, Op1KnownOne, 0)) Op1KnownOne, 0))
return &I; return &I;
// Given the known and unknown bits, compute a range that the LHS could be // Given the known and unknown bits, compute a range that the LHS could be
Context not available.
} }
case Instruction::IntToPtr: case Instruction::IntToPtr:
// icmp pred inttoptr(X), null -> icmp pred X, 0 // icmp pred inttoptr(X), null -> icmp pred X, 0
if (RHSC->isNullValue() && DL && if (RHSC->isNullValue() &&
DL->getIntPtrType(RHSC->getType()) == DL.getIntPtrType(RHSC->getType()) == LHSI->getOperand(0)->getType())
LHSI->getOperand(0)->getType())
return new ICmpInst(I.getPredicate(), LHSI->getOperand(0), return new ICmpInst(I.getPredicate(), LHSI->getOperand(0),
Constant::getNullValue(LHSI->getOperand(0)->getType())); Constant::getNullValue(LHSI->getOperand(0)->getType()));
break; break;
Context not available.
// if A is a power of 2. // if A is a power of 2.
if (match(Op0, m_And(m_Value(A), m_Not(m_Value(B)))) && if (match(Op0, m_And(m_Value(A), m_Not(m_Value(B)))) &&
match(Op1, m_Zero()) && match(Op1, m_Zero()) &&
isKnownToBeAPowerOfTwo(A, false, 0, AC, &I, DT) && I.isEquality()) isKnownToBeAPowerOfTwo(A, DL, false, 0, AC, &I, DT) && I.isEquality())
return new ICmpInst(I.getInversePredicate(), return new ICmpInst(I.getInversePredicate(),
Builder->CreateAnd(A, B), Builder->CreateAnd(A, B),
Op1); Op1);
Context not available.

lib/Transforms/InstCombine/InstCombineInternal.h

Context not available.
AssumptionCache *AC; AssumptionCache *AC;
TargetLibraryInfo *TLI; TargetLibraryInfo *TLI;
DominatorTree *DT; DominatorTree *DT;
const DataLayout &DL;
// Optional analyses. When non-null, these can both be used to do better // Optional analyses. When non-null, these can both be used to do better
// combining and will be updated to reflect any changes. // combining and will be updated to reflect any changes.
const DataLayout *DL;
LoopInfo *LI; LoopInfo *LI;
bool MadeIRChange; bool MadeIRChange;
Context not available.
public: public:
InstCombiner(InstCombineWorklist &Worklist, BuilderTy *Builder, InstCombiner(InstCombineWorklist &Worklist, BuilderTy *Builder,
bool MinimizeSize, AssumptionCache *AC, TargetLibraryInfo *TLI, bool MinimizeSize, AssumptionCache *AC, TargetLibraryInfo *TLI,
DominatorTree *DT, const DataLayout *DL, LoopInfo *LI) DominatorTree *DT, const DataLayout &DL, LoopInfo *LI)
: Worklist(Worklist), Builder(Builder), MinimizeSize(MinimizeSize), : Worklist(Worklist), Builder(Builder), MinimizeSize(MinimizeSize),
AC(AC), TLI(TLI), DT(DT), DL(DL), LI(LI), MadeIRChange(false) {} AC(AC), TLI(TLI), DT(DT), DL(DL), LI(LI), MadeIRChange(false) {}
Context not available.
AssumptionCache *getAssumptionCache() const { return AC; } AssumptionCache *getAssumptionCache() const { return AC; }
const DataLayout *getDataLayout() const { return DL; } const DataLayout &getDataLayout() const { return DL; }
DominatorTree *getDominatorTree() const { return DT; } DominatorTree *getDominatorTree() const { return DT; }
Context not available.
Type *Ty); Type *Ty);
Instruction *visitCallSite(CallSite CS); Instruction *visitCallSite(CallSite CS);
Instruction *tryOptimizeCall(CallInst *CI, const DataLayout *DL); Instruction *tryOptimizeCall(CallInst *CI);
bool transformConstExprCastCall(CallSite CS); bool transformConstExprCastCall(CallSite CS);
Instruction *transformCallThroughTrampoline(CallSite CS, Instruction *transformCallThroughTrampoline(CallSite CS,
IntrinsicInst *Tramp); IntrinsicInst *Tramp);
Instruction *transformZExtICmp(ICmpInst *ICI, Instruction &CI, Instruction *transformZExtICmp(ICmpInst *ICI, Instruction &CI,
bool DoXform = true); bool DoXform = true);
Instruction *transformSExtICmp(ICmpInst *ICI, Instruction &CI); Instruction *transformSExtICmp(ICmpInst *ICI, Instruction &CI);
bool WillNotOverflowSignedAdd(Value *LHS, Value *RHS, Instruction *CxtI); bool WillNotOverflowSignedAdd(Value *LHS, Value *RHS, Instruction &CxtI);
bool WillNotOverflowSignedSub(Value *LHS, Value *RHS, Instruction *CxtI); bool WillNotOverflowSignedSub(Value *LHS, Value *RHS, Instruction &CxtI);
bool WillNotOverflowUnsignedSub(Value *LHS, Value *RHS, Instruction *CxtI); bool WillNotOverflowUnsignedSub(Value *LHS, Value *RHS, Instruction &CxtI);
bool WillNotOverflowSignedMul(Value *LHS, Value *RHS, Instruction *CxtI); bool WillNotOverflowSignedMul(Value *LHS, Value *RHS, Instruction &CxtI);
Value *EmitGEPOffset(User *GEP); Value *EmitGEPOffset(User *GEP);
Instruction *scalarizePHI(ExtractElementInst &EI, PHINode *PN); Instruction *scalarizePHI(ExtractElementInst &EI, PHINode *PN);
Value *EvaluateInDifferentElementOrder(Value *V, ArrayRef<int> Mask); Value *EvaluateInDifferentElementOrder(Value *V, ArrayRef<int> Mask);
Context not available.
} }
void computeKnownBits(Value *V, APInt &KnownZero, APInt &KnownOne, void computeKnownBits(Value *V, APInt &KnownZero, APInt &KnownOne,
unsigned Depth = 0, Instruction *CxtI = nullptr) const { unsigned Depth, Instruction *CxtI) const {
return llvm::computeKnownBits(V, KnownZero, KnownOne, DL, Depth, AC, CxtI, return llvm::computeKnownBits(V, KnownZero, KnownOne, DL, Depth, AC, CxtI,
DT); DT);
} }
Context not available.
/// bits. /// bits.
Value *SimplifyDemandedUseBits(Value *V, APInt DemandedMask, APInt &KnownZero, Value *SimplifyDemandedUseBits(Value *V, APInt DemandedMask, APInt &KnownZero,
APInt &KnownOne, unsigned Depth, APInt &KnownOne, unsigned Depth,
Instruction *CxtI = nullptr); Instruction *CxtI);
bool SimplifyDemandedBits(Use &U, APInt DemandedMask, APInt &KnownZero, bool SimplifyDemandedBits(Use &U, APInt DemandedMask, APInt &KnownZero,
APInt &KnownOne, unsigned Depth = 0); APInt &KnownOne, unsigned Depth = 0);
/// Helper routine of SimplifyDemandedUseBits. It tries to simplify demanded /// Helper routine of SimplifyDemandedUseBits. It tries to simplify demanded
Context not available.

lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp

Context not available.
Instruction *InstCombiner::visitAllocaInst(AllocaInst &AI) { Instruction *InstCombiner::visitAllocaInst(AllocaInst &AI) {
// Ensure that the alloca array size argument has type intptr_t, so that // Ensure that the alloca array size argument has type intptr_t, so that
// any casting is exposed early. // any casting is exposed early.
if (DL) { Type *IntPtrTy = DL.getIntPtrType(AI.getType());
Type *IntPtrTy = DL->getIntPtrType(AI.getType()); if (AI.getArraySize()->getType() != IntPtrTy) {
if (AI.getArraySize()->getType() != IntPtrTy) { Value *V = Builder->CreateIntCast(AI.getArraySize(), IntPtrTy, false);
Value *V = Builder->CreateIntCast(AI.getArraySize(), AI.setOperand(0, V);
IntPtrTy, false); return &AI;
AI.setOperand(0, V);
return &AI;
}
} }
// Convert: alloca Ty, C - where C is a constant != 1 into: alloca [C x Ty], 1 // Convert: alloca Ty, C - where C is a constant != 1 into: alloca [C x Ty], 1
Context not available.
// Now that I is pointing to the first non-allocation-inst in the block, // Now that I is pointing to the first non-allocation-inst in the block,
// insert our getelementptr instruction... // insert our getelementptr instruction...
// //
Type *IdxTy = DL Type *IdxTy = DL.getIntPtrType(AI.getType());
? DL->getIntPtrType(AI.getType())
: Type::getInt64Ty(AI.getContext());
Value *NullIdx = Constant::getNullValue(IdxTy); Value *NullIdx = Constant::getNullValue(IdxTy);
Value *Idx[2] = { NullIdx, NullIdx }; Value *Idx[2] = { NullIdx, NullIdx };
Instruction *GEP = Instruction *GEP =
Context not available.
} }
} }
if (DL && AI.getAllocatedType()->isSized()) { if (AI.getAllocatedType()->isSized()) {
// If the alignment is 0 (unspecified), assign it the preferred alignment. // If the alignment is 0 (unspecified), assign it the preferred alignment.
if (AI.getAlignment() == 0) if (AI.getAlignment() == 0)
AI.setAlignment(DL->getPrefTypeAlignment(AI.getAllocatedType())); AI.setAlignment(DL.getPrefTypeAlignment(AI.getAllocatedType()));
// Move all alloca's of zero byte objects to the entry block and merge them // Move all alloca's of zero byte objects to the entry block and merge them
// together. Note that we only do this for alloca's, because malloc should // together. Note that we only do this for alloca's, because malloc should
// allocate and return a unique pointer, even for a zero byte allocation. // allocate and return a unique pointer, even for a zero byte allocation.
if (DL->getTypeAllocSize(AI.getAllocatedType()) == 0) { if (DL.getTypeAllocSize(AI.getAllocatedType()) == 0) {
// For a zero sized alloca there is no point in doing an array allocation. // For a zero sized alloca there is no point in doing an array allocation.
// This is helpful if the array size is a complicated expression not used // This is helpful if the array size is a complicated expression not used
// elsewhere. // elsewhere.
Context not available.
// dominance as the array size was forced to a constant earlier already. // dominance as the array size was forced to a constant earlier already.
AllocaInst *EntryAI = dyn_cast<AllocaInst>(FirstInst); AllocaInst *EntryAI = dyn_cast<AllocaInst>(FirstInst);
if (!EntryAI || !EntryAI->getAllocatedType()->isSized() || if (!EntryAI || !EntryAI->getAllocatedType()->isSized() ||
DL->getTypeAllocSize(EntryAI->getAllocatedType()) != 0) { DL.getTypeAllocSize(EntryAI->getAllocatedType()) != 0) {
AI.moveBefore(FirstInst); AI.moveBefore(FirstInst);
return &AI; return &AI;
} }
Context not available.
// assign it the preferred alignment. // assign it the preferred alignment.
if (EntryAI->getAlignment() == 0) if (EntryAI->getAlignment() == 0)
EntryAI->setAlignment( EntryAI->setAlignment(
DL->getPrefTypeAlignment(EntryAI->getAllocatedType())); DL.getPrefTypeAlignment(EntryAI->getAllocatedType()));
// Replace this zero-sized alloca with the one at the start of the entry // Replace this zero-sized alloca with the one at the start of the entry
// block after ensuring that the address will be aligned enough for both // block after ensuring that the address will be aligned enough for both
// types. // types.
Context not available.
SmallVector<Instruction *, 4> ToDelete; SmallVector<Instruction *, 4> ToDelete;
if (MemTransferInst *Copy = isOnlyCopiedFromConstantGlobal(&AI, ToDelete)) { if (MemTransferInst *Copy = isOnlyCopiedFromConstantGlobal(&AI, ToDelete)) {
unsigned SourceAlign = getOrEnforceKnownAlignment( unsigned SourceAlign = getOrEnforceKnownAlignment(
Copy->getSource(), AI.getAlignment(), DL, AC, &AI, DT); Copy->getSource(), AI.getAlignment(), AI, AC, DT);
if (AI.getAlignment() <= SourceAlign) { if (AI.getAlignment() <= SourceAlign) {
DEBUG(dbgs() << "Found alloca equal to global: " << AI << '\n'); DEBUG(dbgs() << "Found alloca equal to global: " << AI << '\n');
DEBUG(dbgs() << " memcpy = " << *Copy << '\n'); DEBUG(dbgs() << " memcpy = " << *Copy << '\n');
Context not available.
return nullptr; return nullptr;
Type *Ty = LI.getType(); Type *Ty = LI.getType();
const DataLayout &DL = IC.getDataLayout();
// Try to canonicalize loads which are only ever stored to operate over // Try to canonicalize loads which are only ever stored to operate over
// integers instead of any other type. We only do this when the loaded type // integers instead of any other type. We only do this when the loaded type
// is sized and has a size exactly the same as its store size and the store // is sized and has a size exactly the same as its store size and the store
// size is a legal integer type. // size is a legal integer type.
const DataLayout *DL = IC.getDataLayout(); if (!Ty->isIntegerTy() && Ty->isSized() &&
if (!Ty->isIntegerTy() && Ty->isSized() && DL && DL.isLegalInteger(DL.getTypeStoreSizeInBits(Ty)) &&
DL->isLegalInteger(DL->getTypeStoreSizeInBits(Ty)) && DL.getTypeStoreSizeInBits(Ty) == DL.getTypeSizeInBits(Ty)) {
DL->getTypeStoreSizeInBits(Ty) == DL->getTypeSizeInBits(Ty)) {
if (std::all_of(LI.user_begin(), LI.user_end(), [&LI](User *U) { if (std::all_of(LI.user_begin(), LI.user_end(), [&LI](User *U) {
auto *SI = dyn_cast<StoreInst>(U); auto *SI = dyn_cast<StoreInst>(U);
return SI && SI->getPointerOperand() != &LI; return SI && SI->getPointerOperand() != &LI;
})) { })) {
LoadInst *NewLoad = combineLoadToNewType( LoadInst *NewLoad = combineLoadToNewType(
IC, LI, IC, LI,
Type::getIntNTy(LI.getContext(), DL->getTypeStoreSizeInBits(Ty))); Type::getIntNTy(LI.getContext(), DL.getTypeStoreSizeInBits(Ty)));
// Replace all the stores with stores of the newly loaded value. // Replace all the stores with stores of the newly loaded value.
for (auto UI = LI.user_begin(), UE = LI.user_end(); UI != UE;) { for (auto UI = LI.user_begin(), UE = LI.user_end(); UI != UE;) {
auto *SI = cast<StoreInst>(*UI++); auto *SI = cast<StoreInst>(*UI++);
Context not available.
// //
// FIXME: This should probably live in ValueTracking (or similar). // FIXME: This should probably live in ValueTracking (or similar).
static bool isObjectSizeLessThanOrEq(Value *V, uint64_t MaxSize, static bool isObjectSizeLessThanOrEq(Value *V, uint64_t MaxSize,
const DataLayout *DL) { const DataLayout &DL) {
SmallPtrSet<Value *, 4> Visited; SmallPtrSet<Value *, 4> Visited;
SmallVector<Value *, 4> Worklist(1, V); SmallVector<Value *, 4> Worklist(1, V);
Context not available.
if (!CS) if (!CS)
return false; return false;
uint64_t TypeSize = DL->getTypeAllocSize(AI->getAllocatedType()); uint64_t TypeSize = DL.getTypeAllocSize(AI->getAllocatedType());
// Make sure that, even if the multiplication below would wrap as an // Make sure that, even if the multiplication below would wrap as an
// uint64_t, we still do the right thing. // uint64_t, we still do the right thing.
if ((CS->getValue().zextOrSelf(128)*APInt(128, TypeSize)).ugt(MaxSize)) if ((CS->getValue().zextOrSelf(128)*APInt(128, TypeSize)).ugt(MaxSize))
Context not available.
if (!GV->hasDefinitiveInitializer() || !GV->isConstant()) if (!GV->hasDefinitiveInitializer() || !GV->isConstant())
return false; return false;
uint64_t InitSize = DL->getTypeAllocSize(GV->getType()->getElementType()); uint64_t InitSize = DL.getTypeAllocSize(GV->getType()->getElementType());
if (InitSize > MaxSize) if (InitSize > MaxSize)
return false; return false;
continue; continue;
Context not available.
// offsets those indices implied. // offsets those indices implied.
static bool canReplaceGEPIdxWithZero(InstCombiner &IC, GetElementPtrInst *GEPI, static bool canReplaceGEPIdxWithZero(InstCombiner &IC, GetElementPtrInst *GEPI,
Instruction *MemI, unsigned &Idx) { Instruction *MemI, unsigned &Idx) {
const DataLayout *DL = IC.getDataLayout(); if (GEPI->getNumOperands() < 2)
if (GEPI->getNumOperands() < 2 || !DL)
return false; return false;
// Find the first non-zero index of a GEP. If all indices are zero, return // Find the first non-zero index of a GEP. If all indices are zero, return
Context not available.
GetElementPtrInst::getIndexedType(GEPI->getOperand(0)->getType(), Ops); GetElementPtrInst::getIndexedType(GEPI->getOperand(0)->getType(), Ops);
if (!AllocTy || !AllocTy->isSized()) if (!AllocTy || !AllocTy->isSized())
return false; return false;
uint64_t TyAllocSize = DL->getTypeAllocSize(AllocTy); const DataLayout &DL = IC.getDataLayout();
uint64_t TyAllocSize = DL.getTypeAllocSize(AllocTy);
// If there are more indices after the one we might replace with a zero, make // If there are more indices after the one we might replace with a zero, make
// sure they're all non-negative. If any of them are negative, the overall // sure they're all non-negative. If any of them are negative, the overall
Context not available.
return Res; return Res;
// Attempt to improve the alignment. // Attempt to improve the alignment.
if (DL) { unsigned KnownAlign = getOrEnforceKnownAlignment(
unsigned KnownAlign = getOrEnforceKnownAlignment( Op, DL.getPrefTypeAlignment(LI.getType()), LI, AC, DT);
Op, DL->getPrefTypeAlignment(LI.getType()), DL, AC, &LI, DT); unsigned LoadAlign = LI.getAlignment();
unsigned LoadAlign = LI.getAlignment(); unsigned EffectiveLoadAlign =
unsigned EffectiveLoadAlign = LoadAlign != 0 ? LoadAlign : LoadAlign != 0 ? LoadAlign : DL.getABITypeAlignment(LI.getType());
DL->getABITypeAlignment(LI.getType());
if (KnownAlign > EffectiveLoadAlign)
if (KnownAlign > EffectiveLoadAlign) LI.setAlignment(KnownAlign);
LI.setAlignment(KnownAlign); else if (LoadAlign == 0)
else if (LoadAlign == 0) LI.setAlignment(EffectiveLoadAlign);
LI.setAlignment(EffectiveLoadAlign);
}
// Replace GEP indices if possible. // Replace GEP indices if possible.
if (Instruction *NewGEPI = replaceGEPIdxWithZero(*this, Op, LI)) { if (Instruction *NewGEPI = replaceGEPIdxWithZero(*this, Op, LI)) {
Context not available.
if (SelectInst *SI = dyn_cast<SelectInst>(Op)) { if (SelectInst *SI = dyn_cast<SelectInst>(Op)) {
// load (select (Cond, &V1, &V2)) --> select(Cond, load &V1, load &V2). // load (select (Cond, &V1, &V2)) --> select(Cond, load &V1, load &V2).
unsigned Align = LI.getAlignment(); unsigned Align = LI.getAlignment();
if (isSafeToLoadUnconditionally(SI->getOperand(1), SI, Align, DL) && if (isSafeToLoadUnconditionally(SI->getOperand(1), SI, Align) &&
isSafeToLoadUnconditionally(SI->getOperand(2), SI, Align, DL)) { isSafeToLoadUnconditionally(SI->getOperand(2), SI, Align)) {
LoadInst *V1 = Builder->CreateLoad(SI->getOperand(1), LoadInst *V1 = Builder->CreateLoad(SI->getOperand(1),
SI->getOperand(1)->getName()+".val"); SI->getOperand(1)->getName()+".val");
LoadInst *V2 = Builder->CreateLoad(SI->getOperand(2), LoadInst *V2 = Builder->CreateLoad(SI->getOperand(2),
Context not available.
return EraseInstFromFunction(SI); return EraseInstFromFunction(SI);
// Attempt to improve the alignment. // Attempt to improve the alignment.
if (DL) { unsigned KnownAlign = getOrEnforceKnownAlignment(
unsigned KnownAlign = getOrEnforceKnownAlignment( Ptr, DL.getPrefTypeAlignment(Val->getType()), SI, AC, DT);
Ptr, DL->getPrefTypeAlignment(Val->getType()), DL, AC, &SI, DT); unsigned StoreAlign = SI.getAlignment();
unsigned StoreAlign = SI.getAlignment(); unsigned EffectiveStoreAlign =
unsigned EffectiveStoreAlign = StoreAlign != 0 ? StoreAlign : StoreAlign != 0 ? StoreAlign : DL.getABITypeAlignment(Val->getType());
DL->getABITypeAlignment(Val->getType());
if (KnownAlign > EffectiveStoreAlign)
if (KnownAlign > EffectiveStoreAlign) SI.setAlignment(KnownAlign);
SI.setAlignment(KnownAlign); else if (StoreAlign == 0)
else if (StoreAlign == 0) SI.setAlignment(EffectiveStoreAlign);
SI.setAlignment(EffectiveStoreAlign);
}
// Replace GEP indices if possible. // Replace GEP indices if possible.
if (Instruction *NewGEPI = replaceGEPIdxWithZero(*this, Ptr, SI)) { if (Instruction *NewGEPI = replaceGEPIdxWithZero(*this, Ptr, SI)) {
Context not available.

lib/Transforms/InstCombine/InstCombineMulDivRem.cpp

Context not available.
/// where it is known to be non-zero. If this allows us to simplify the /// where it is known to be non-zero. If this allows us to simplify the
/// computation, do so and return the new operand, otherwise return null. /// computation, do so and return the new operand, otherwise return null.
static Value *simplifyValueKnownNonZero(Value *V, InstCombiner &IC, static Value *simplifyValueKnownNonZero(Value *V, InstCombiner &IC,
Instruction *CxtI) { Instruction &CxtI) {
// If V has multiple uses, then we would have to do more analysis to determine // If V has multiple uses, then we would have to do more analysis to determine
// if this is safe. For example, the use could be in dynamically unreached // if this is safe. For example, the use could be in dynamically unreached
// code. // code.
Context not available.
// inexact. Similarly for <<. // inexact. Similarly for <<.
if (BinaryOperator *I = dyn_cast<BinaryOperator>(V)) if (BinaryOperator *I = dyn_cast<BinaryOperator>(V))
if (I->isLogicalShift() && if (I->isLogicalShift() &&
isKnownToBeAPowerOfTwo(I->getOperand(0), false, 0, isKnownToBeAPowerOfTwo(I->getOperand(0), IC.getDataLayout(), false, 0,
IC.getAssumptionCache(), CxtI, IC.getAssumptionCache(), &CxtI,
IC.getDominatorTree())) { IC.getDominatorTree())) {
// We know that this is an exact/nuw shift and that the input is a // We know that this is an exact/nuw shift and that the input is a
// non-zero context as well. // non-zero context as well.
Context not available.
/// \brief Return true if we can prove that: /// \brief Return true if we can prove that:
/// (mul LHS, RHS) === (mul nsw LHS, RHS) /// (mul LHS, RHS) === (mul nsw LHS, RHS)
bool InstCombiner::WillNotOverflowSignedMul(Value *LHS, Value *RHS, bool InstCombiner::WillNotOverflowSignedMul(Value *LHS, Value *RHS,
Instruction *CxtI) { Instruction &CxtI) {
// Multiplying n * m significant bits yields a result of n + m significant // Multiplying n * m significant bits yields a result of n + m significant
// bits. If the total number of significant bits does not exceed the // bits. If the total number of significant bits does not exceed the
// result bit width (minus 1), there is no overflow. // result bit width (minus 1), there is no overflow.
Context not available.
// Note that underestimating the number of sign bits gives a more // Note that underestimating the number of sign bits gives a more
// conservative answer. // conservative answer.
unsigned SignBits = ComputeNumSignBits(LHS, 0, CxtI) + unsigned SignBits =
ComputeNumSignBits(RHS, 0, CxtI); ComputeNumSignBits(LHS, 0, &CxtI) + ComputeNumSignBits(RHS, 0, &CxtI);
// First handle the easy case: if we have enough sign bits there's // First handle the easy case: if we have enough sign bits there's
// definitely no overflow. // definitely no overflow.
Context not available.
// For simplicity we just check if at least one side is not negative. // For simplicity we just check if at least one side is not negative.
bool LHSNonNegative, LHSNegative; bool LHSNonNegative, LHSNegative;
bool RHSNonNegative, RHSNegative; bool RHSNonNegative, RHSNegative;
ComputeSignBit(LHS, LHSNonNegative, LHSNegative, /*Depth=*/0, CxtI); ComputeSignBit(LHS, LHSNonNegative, LHSNegative, /*Depth=*/0, &CxtI);
ComputeSignBit(RHS, RHSNonNegative, RHSNegative, /*Depth=*/0, CxtI); ComputeSignBit(RHS, RHSNonNegative, RHSNegative, /*Depth=*/0, &CxtI);
if (LHSNonNegative || RHSNonNegative) if (LHSNonNegative || RHSNonNegative)
return true; return true;
} }
Context not available.
} }
} }
if (!I.hasNoSignedWrap() && WillNotOverflowSignedMul(Op0, Op1, &I)) { if (!I.hasNoSignedWrap() && WillNotOverflowSignedMul(Op0, Op1, I)) {
Changed = true; Changed = true;
I.setHasNoSignedWrap(true); I.setHasNoSignedWrap(true);
} }
Context not available.
Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1); Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
// The RHS is known non-zero. // The RHS is known non-zero.
if (Value *V = simplifyValueKnownNonZero(I.getOperand(1), *this, &I)) { if (Value *V = simplifyValueKnownNonZero(I.getOperand(1), *this, I)) {
I.setOperand(1, V); I.setOperand(1, V);
return &I; return &I;
} }
Context not available.
return BO; return BO;
} }
if (isKnownToBeAPowerOfTwo(Op1, /*OrZero*/ true, 0, AC, &I, DT)) { if (isKnownToBeAPowerOfTwo(Op1, DL, /*OrZero*/ true, 0, AC, &I, DT)) {
// X sdiv (1 << Y) -> X udiv (1 << Y) ( -> X u>> Y) // X sdiv (1 << Y) -> X udiv (1 << Y) ( -> X u>> Y)
// Safe because the only negative value (1 << Y) can take on is // Safe because the only negative value (1 << Y) can take on is
// INT_MIN, and X sdiv INT_MIN == X udiv INT_MIN == 0 if X doesn't have // INT_MIN, and X sdiv INT_MIN == X udiv INT_MIN == 0 if X doesn't have
Context not available.
Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1); Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
// The RHS is known non-zero. // The RHS is known non-zero.
if (Value *V = simplifyValueKnownNonZero(I.getOperand(1), *this, &I)) { if (Value *V = simplifyValueKnownNonZero(I.getOperand(1), *this, I)) {
I.setOperand(1, V); I.setOperand(1, V);
return &I; return &I;
} }
Context not available.
I.getType()); I.getType());
// X urem Y -> X and Y-1, where Y is a power of 2, // X urem Y -> X and Y-1, where Y is a power of 2,
if (isKnownToBeAPowerOfTwo(Op1, /*OrZero*/ true, 0, AC, &I, DT)) { if (isKnownToBeAPowerOfTwo(Op1, DL, /*OrZero*/ true, 0, AC, &I, DT)) {
Constant *N1 = Constant::getAllOnesValue(I.getType()); Constant *N1 = Constant::getAllOnesValue(I.getType());
Value *Add = Builder->CreateAdd(Op1, N1); Value *Add = Builder->CreateAdd(Op1, N1);
return BinaryOperator::CreateAnd(Op0, Add); return BinaryOperator::CreateAnd(Op0, Add);
Context not available.

lib/Transforms/InstCombine/InstCombinePHI.cpp

Context not available.
#include "llvm/ADT/STLExtras.h" #include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/SmallPtrSet.h" #include "llvm/ADT/SmallPtrSet.h"
#include "llvm/Analysis/InstructionSimplify.h" #include "llvm/Analysis/InstructionSimplify.h"
#include "llvm/IR/DataLayout.h"
using namespace llvm; using namespace llvm;
#define DEBUG_TYPE "instcombine" #define DEBUG_TYPE "instcombine"
Context not available.
// it is only used by trunc or trunc(lshr) operations. If so, we split the // it is only used by trunc or trunc(lshr) operations. If so, we split the
// PHI into the various pieces being extracted. This sort of thing is // PHI into the various pieces being extracted. This sort of thing is
// introduced when SROA promotes an aggregate to a single large integer type. // introduced when SROA promotes an aggregate to a single large integer type.
if (PN.getType()->isIntegerTy() && DL && if (PN.getType()->isIntegerTy() &&
!DL->isLegalInteger(PN.getType()->getPrimitiveSizeInBits())) !DL.isLegalInteger(PN.getType()->getPrimitiveSizeInBits()))
if (Instruction *Res = SliceUpIllegalIntegerPHI(PN)) if (Instruction *Res = SliceUpIllegalIntegerPHI(PN))
return Res; return Res;
Context not available.

lib/Transforms/InstCombine/InstCombineSelect.cpp

Context not available.
/// SimplifyWithOpReplaced - See if V simplifies when its operand Op is /// SimplifyWithOpReplaced - See if V simplifies when its operand Op is
/// replaced with RepOp. /// replaced with RepOp.
static Value *SimplifyWithOpReplaced(Value *V, Value *Op, Value *RepOp, static Value *SimplifyWithOpReplaced(Value *V, Value *Op, Value *RepOp,
const DataLayout *TD,
const TargetLibraryInfo *TLI, const TargetLibraryInfo *TLI,
DominatorTree *DT, AssumptionCache *AC) { const DataLayout &DL, DominatorTree *DT,
AssumptionCache *AC) {
// Trivial replacement. // Trivial replacement.
if (V == Op) if (V == Op)
return RepOp; return RepOp;
Context not available.
// If this is a binary operator, try to simplify it with the replaced op. // If this is a binary operator, try to simplify it with the replaced op.
if (BinaryOperator *B = dyn_cast<BinaryOperator>(I)) { if (BinaryOperator *B = dyn_cast<BinaryOperator>(I)) {
if (B->getOperand(0) == Op) if (B->getOperand(0) == Op)
return SimplifyBinOp(B->getOpcode(), RepOp, B->getOperand(1), TD, TLI); return SimplifyBinOp(B->getOpcode(), RepOp, B->getOperand(1), DL, TLI);
if (B->getOperand(1) == Op) if (B->getOperand(1) == Op)
return SimplifyBinOp(B->getOpcode(), B->getOperand(0), RepOp, TD, TLI); return SimplifyBinOp(B->getOpcode(), B->getOperand(0), RepOp, DL, TLI);
} }
// Same for CmpInsts. // Same for CmpInsts.
if (CmpInst *C = dyn_cast<CmpInst>(I)) { if (CmpInst *C = dyn_cast<CmpInst>(I)) {
if (C->getOperand(0) == Op) if (C->getOperand(0) == Op)
return SimplifyCmpInst(C->getPredicate(), RepOp, C->getOperand(1), TD, return SimplifyCmpInst(C->getPredicate(), RepOp, C->getOperand(1), DL,
TLI, DT, AC); TLI, DT, AC);
if (C->getOperand(1) == Op) if (C->getOperand(1) == Op)
return SimplifyCmpInst(C->getPredicate(), C->getOperand(0), RepOp, TD, return SimplifyCmpInst(C->getPredicate(), C->getOperand(0), RepOp, DL,
TLI, DT, AC); TLI, DT, AC);
} }
Context not available.
if (ConstOps.size() == I->getNumOperands()) { if (ConstOps.size() == I->getNumOperands()) {
if (CmpInst *C = dyn_cast<CmpInst>(I)) if (CmpInst *C = dyn_cast<CmpInst>(I))
return ConstantFoldCompareInstOperands(C->getPredicate(), ConstOps[0], return ConstantFoldCompareInstOperands(C->getPredicate(), ConstOps[0],
ConstOps[1], TD, TLI); ConstOps[1], DL, TLI);
if (LoadInst *LI = dyn_cast<LoadInst>(I)) if (LoadInst *LI = dyn_cast<LoadInst>(I))
if (!LI->isVolatile()) if (!LI->isVolatile())
return ConstantFoldLoadFromConstPtr(ConstOps[0], TD); return ConstantFoldLoadFromConstPtr(ConstOps[0], DL);
return ConstantFoldInstOperands(I->getOpcode(), I->getType(), return ConstantFoldInstOperands(I->getOpcode(), I->getType(), ConstOps,
ConstOps, TD, TLI); DL, TLI);
} }
} }
Context not available.
// arms of the select. See if substituting this value into the arm and // arms of the select. See if substituting this value into the arm and
// simplifying the result yields the same value as the other arm. // simplifying the result yields the same value as the other arm.
if (Pred == ICmpInst::ICMP_EQ) { if (Pred == ICmpInst::ICMP_EQ) {
if (SimplifyWithOpReplaced(FalseVal, CmpLHS, CmpRHS, DL, TLI, DT, AC) == if (SimplifyWithOpReplaced(FalseVal, CmpLHS, CmpRHS, TLI, DL, DT, AC) ==
TrueVal || TrueVal ||
SimplifyWithOpReplaced(FalseVal, CmpRHS, CmpLHS, DL, TLI, DT, AC) == SimplifyWithOpReplaced(FalseVal, CmpRHS, CmpLHS, TLI, DL, DT, AC) ==
TrueVal) TrueVal)
return ReplaceInstUsesWith(SI, FalseVal); return ReplaceInstUsesWith(SI, FalseVal);
if (SimplifyWithOpReplaced(TrueVal, CmpLHS, CmpRHS, DL, TLI, DT, AC) == if (SimplifyWithOpReplaced(TrueVal, CmpLHS, CmpRHS, TLI, DL, DT, AC) ==
FalseVal || FalseVal ||
SimplifyWithOpReplaced(TrueVal, CmpRHS, CmpLHS, DL, TLI, DT, AC) == SimplifyWithOpReplaced(TrueVal, CmpRHS, CmpLHS, TLI, DL, DT, AC) ==
FalseVal) FalseVal)
return ReplaceInstUsesWith(SI, FalseVal); return ReplaceInstUsesWith(SI, FalseVal);
} else if (Pred == ICmpInst::ICMP_NE) { } else if (Pred == ICmpInst::ICMP_NE) {
if (SimplifyWithOpReplaced(TrueVal, CmpLHS, CmpRHS, DL, TLI, DT, AC) == if (SimplifyWithOpReplaced(TrueVal, CmpLHS, CmpRHS, TLI, DL, DT, AC) ==
FalseVal || FalseVal ||
SimplifyWithOpReplaced(TrueVal, CmpRHS, CmpLHS, DL, TLI, DT, AC) == SimplifyWithOpReplaced(TrueVal, CmpRHS, CmpLHS, TLI, DL, DT, AC) ==
FalseVal) FalseVal)
return ReplaceInstUsesWith(SI, TrueVal); return ReplaceInstUsesWith(SI, TrueVal);
if (SimplifyWithOpReplaced(FalseVal, CmpLHS, CmpRHS, DL, TLI, DT, AC) == if (SimplifyWithOpReplaced(FalseVal, CmpLHS, CmpRHS, TLI, DL, DT, AC) ==
TrueVal || TrueVal ||
SimplifyWithOpReplaced(FalseVal, CmpRHS, CmpLHS, DL, TLI, DT, AC) == SimplifyWithOpReplaced(FalseVal, CmpRHS, CmpLHS, TLI, DL, DT, AC) ==
TrueVal) TrueVal)
return ReplaceInstUsesWith(SI, TrueVal); return ReplaceInstUsesWith(SI, TrueVal);
} }
Context not available.

lib/Transforms/InstCombine/InstCombineShifts.cpp

Context not available.
/// GetShiftedValue - When CanEvaluateShifted returned true for an expression, /// GetShiftedValue - When CanEvaluateShifted returned true for an expression,
/// this value inserts the new computation that produces the shifted value. /// this value inserts the new computation that produces the shifted value.
static Value *GetShiftedValue(Value *V, unsigned NumBits, bool isLeftShift, static Value *GetShiftedValue(Value *V, unsigned NumBits, bool isLeftShift,
InstCombiner &IC) { InstCombiner &IC, const DataLayout &DL) {
// We can always evaluate constants shifted. // We can always evaluate constants shifted.
if (Constant *C = dyn_cast<Constant>(V)) { if (Constant *C = dyn_cast<Constant>(V)) {
if (isLeftShift) if (isLeftShift)
Context not available.
V = IC.Builder->CreateLShr(C, NumBits); V = IC.Builder->CreateLShr(C, NumBits);
// If we got a constantexpr back, try to simplify it with TD info. // If we got a constantexpr back, try to simplify it with TD info.
if (ConstantExpr *CE = dyn_cast<ConstantExpr>(V)) if (ConstantExpr *CE = dyn_cast<ConstantExpr>(V))
V = ConstantFoldConstantExpression(CE, IC.getDataLayout(), V = ConstantFoldConstantExpression(CE, DL, IC.getTargetLibraryInfo());
IC.getTargetLibraryInfo());
return V; return V;
} }
Context not available.
case Instruction::Or: case Instruction::Or:
case Instruction::Xor: case Instruction::Xor:
// Bitwise operators can all arbitrarily be arbitrarily evaluated shifted. // Bitwise operators can all arbitrarily be arbitrarily evaluated shifted.
I->setOperand(0, GetShiftedValue(I->getOperand(0), NumBits,isLeftShift,IC)); I->setOperand(
I->setOperand(1, GetShiftedValue(I->getOperand(1), NumBits,isLeftShift,IC)); 0, GetShiftedValue(I->getOperand(0), NumBits, isLeftShift, IC, DL));
I->setOperand(
1, GetShiftedValue(I->getOperand(1), NumBits, isLeftShift, IC, DL));
return I; return I;
case Instruction::Shl: { case Instruction::Shl: {
Context not available.
} }
case Instruction::Select: case Instruction::Select:
I->setOperand(1, GetShiftedValue(I->getOperand(1), NumBits,isLeftShift,IC)); I->setOperand(
I->setOperand(2, GetShiftedValue(I->getOperand(2), NumBits,isLeftShift,IC)); 1, GetShiftedValue(I->getOperand(1), NumBits, isLeftShift, IC, DL));
I->setOperand(
2, GetShiftedValue(I->getOperand(2), NumBits, isLeftShift, IC, DL));
return I; return I;
case Instruction::PHI: { case Instruction::PHI: {
// We can change a phi if we can change all operands. Note that we never // We can change a phi if we can change all operands. Note that we never
Context not available.
// instructions with a single use. // instructions with a single use.
PHINode *PN = cast<PHINode>(I); PHINode *PN = cast<PHINode>(I);
for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i)
PN->setIncomingValue(i, GetShiftedValue(PN->getIncomingValue(i), PN->setIncomingValue(i, GetShiftedValue(PN->getIncomingValue(i), NumBits,
NumBits, isLeftShift, IC)); isLeftShift, IC, DL));
return PN; return PN;
} }
} }
Context not available.
DEBUG(dbgs() << "ICE: GetShiftedValue propagating shift through expression" DEBUG(dbgs() << "ICE: GetShiftedValue propagating shift through expression"
" to eliminate shift:\n IN: " << *Op0 << "\n SH: " << I <<"\n"); " to eliminate shift:\n IN: " << *Op0 << "\n SH: " << I <<"\n");
return ReplaceInstUsesWith(I, return ReplaceInstUsesWith(
GetShiftedValue(Op0, COp1->getZExtValue(), isLeftShift, *this)); I, GetShiftedValue(Op0, COp1->getZExtValue(), isLeftShift, *this, DL));
} }
// See if we can simplify any instructions used by the instruction whose sole // See if we can simplify any instructions used by the instruction whose sole
Context not available.

lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp

Context not available.
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "InstCombineInternal.h" #include "InstCombineInternal.h"
#include "llvm/IR/DataLayout.h"
#include "llvm/IR/IntrinsicInst.h" #include "llvm/IR/IntrinsicInst.h"
#include "llvm/IR/PatternMatch.h" #include "llvm/IR/PatternMatch.h"
Context not available.
APInt KnownZero(BitWidth, 0), KnownOne(BitWidth, 0); APInt KnownZero(BitWidth, 0), KnownOne(BitWidth, 0);
APInt DemandedMask(APInt::getAllOnesValue(BitWidth)); APInt DemandedMask(APInt::getAllOnesValue(BitWidth));
Value *V = SimplifyDemandedUseBits(&Inst, DemandedMask, Value *V = SimplifyDemandedUseBits(&Inst, DemandedMask, KnownZero, KnownOne,
KnownZero, KnownOne, 0, &Inst); 0, &Inst);
if (!V) return false; if (!V) return false;
if (V == &Inst) return true; if (V == &Inst) return true;
ReplaceInstUsesWith(Inst, V); ReplaceInstUsesWith(Inst, V);
Context not available.
bool InstCombiner::SimplifyDemandedBits(Use &U, APInt DemandedMask, bool InstCombiner::SimplifyDemandedBits(Use &U, APInt DemandedMask,
APInt &KnownZero, APInt &KnownOne, APInt &KnownZero, APInt &KnownOne,
unsigned Depth) { unsigned Depth) {
Value *NewVal = SimplifyDemandedUseBits(U.get(), DemandedMask, Value *NewVal =
KnownZero, KnownOne, Depth, SimplifyDemandedUseBits(U.get(), DemandedMask, KnownZero, KnownOne, Depth,
dyn_cast<Instruction>(U.getUser())); dyn_cast<Instruction>(U.getUser()));
if (!NewVal) return false; if (!NewVal) return false;
U = NewVal; U = NewVal;
return true; return true;
Context not available.
assert(Depth <= 6 && "Limit Search Depth"); assert(Depth <= 6 && "Limit Search Depth");
uint32_t BitWidth = DemandedMask.getBitWidth(); uint32_t BitWidth = DemandedMask.getBitWidth();
Type *VTy = V->getType(); Type *VTy = V->getType();
assert((DL || !VTy->isPointerTy()) && assert(
"SimplifyDemandedBits needs to know bit widths!"); (!VTy->isIntOrIntVectorTy() || VTy->getScalarSizeInBits() == BitWidth) &&
assert((!DL || DL->getTypeSizeInBits(VTy->getScalarType()) == BitWidth) && KnownZero.getBitWidth() == BitWidth &&
(!VTy->isIntOrIntVectorTy() || KnownOne.getBitWidth() == BitWidth &&
VTy->getScalarSizeInBits() == BitWidth) && "Value *V, DemandedMask, KnownZero and KnownOne "
KnownZero.getBitWidth() == BitWidth && "must have same BitWidth");
KnownOne.getBitWidth() == BitWidth &&
"Value *V, DemandedMask, KnownZero and KnownOne "
"must have same BitWidth");
if (ConstantInt *CI = dyn_cast<ConstantInt>(V)) { if (ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
// We know all of the bits for a constant! // We know all of the bits for a constant!
KnownOne = CI->getValue() & DemandedMask; KnownOne = CI->getValue() & DemandedMask;
Context not available.
// this instruction has a simpler value in that context. // this instruction has a simpler value in that context.
if (I->getOpcode() == Instruction::And) { if (I->getOpcode() == Instruction::And) {
// If either the LHS or the RHS are Zero, the result is zero. // If either the LHS or the RHS are Zero, the result is zero.
computeKnownBits(I->getOperand(1), RHSKnownZero, RHSKnownOne, Depth+1, computeKnownBits(I->getOperand(1), RHSKnownZero, RHSKnownOne, Depth + 1,
CxtI); CxtI);
computeKnownBits(I->getOperand(0), LHSKnownZero, LHSKnownOne, Depth+1, computeKnownBits(I->getOperand(0), LHSKnownZero, LHSKnownOne, Depth + 1,
CxtI); CxtI);
// If all of the demanded bits are known 1 on one side, return the other. // If all of the demanded bits are known 1 on one side, return the other.
Context not available.
// only bits from X or Y are demanded. // only bits from X or Y are demanded.
// If either the LHS or the RHS are One, the result is One. // If either the LHS or the RHS are One, the result is One.
computeKnownBits(I->getOperand(1), RHSKnownZero, RHSKnownOne, Depth+1, computeKnownBits(I->getOperand(1), RHSKnownZero, RHSKnownOne, Depth + 1,
CxtI); CxtI);
computeKnownBits(I->getOperand(0), LHSKnownZero, LHSKnownOne, Depth+1, computeKnownBits(I->getOperand(0), LHSKnownZero, LHSKnownOne, Depth + 1,
CxtI); CxtI);
// If all of the demanded bits are known zero on one side, return the // If all of the demanded bits are known zero on one side, return the
Context not available.
// We can simplify (X^Y) -> X or Y in the user's context if we know that // We can simplify (X^Y) -> X or Y in the user's context if we know that
// only bits from X or Y are demanded. // only bits from X or Y are demanded.
computeKnownBits(I->getOperand(1), RHSKnownZero, RHSKnownOne, Depth+1, computeKnownBits(I->getOperand(1), RHSKnownZero, RHSKnownOne, Depth + 1,
CxtI); CxtI);
computeKnownBits(I->getOperand(0), LHSKnownZero, LHSKnownOne, Depth+1, computeKnownBits(I->getOperand(0), LHSKnownZero, LHSKnownOne, Depth + 1,
CxtI); CxtI);
// If all of the demanded bits are known zero on one side, return the // If all of the demanded bits are known zero on one side, return the
Context not available.
break; break;
case Instruction::And: case Instruction::And:
// If either the LHS or the RHS are Zero, the result is zero. // If either the LHS or the RHS are Zero, the result is zero.
if (SimplifyDemandedBits(I->getOperandUse(1), DemandedMask, if (SimplifyDemandedBits(I->getOperandUse(1), DemandedMask, RHSKnownZero,
RHSKnownZero, RHSKnownOne, Depth+1) || RHSKnownOne, Depth + 1) ||
SimplifyDemandedBits(I->getOperandUse(0), DemandedMask & ~RHSKnownZero, SimplifyDemandedBits(I->getOperandUse(0), DemandedMask & ~RHSKnownZero,
LHSKnownZero, LHSKnownOne, Depth+1)) LHSKnownZero, LHSKnownOne, Depth + 1))
return I; return I;
assert(!(RHSKnownZero & RHSKnownOne) && "Bits known to be one AND zero?"); assert(!(RHSKnownZero & RHSKnownOne) && "Bits known to be one AND zero?");
assert(!(LHSKnownZero & LHSKnownOne) && "Bits known to be one AND zero?"); assert(!(LHSKnownZero & LHSKnownOne) && "Bits known to be one AND zero?");
Context not available.
break; break;
case Instruction::Or: case Instruction::Or:
// If either the LHS or the RHS are One, the result is One. // If either the LHS or the RHS are One, the result is One.
if (SimplifyDemandedBits(I->getOperandUse(1), DemandedMask, if (SimplifyDemandedBits(I->getOperandUse(1), DemandedMask, RHSKnownZero,
RHSKnownZero, RHSKnownOne, Depth+1) || RHSKnownOne, Depth + 1) ||
SimplifyDemandedBits(I->getOperandUse(0), DemandedMask & ~RHSKnownOne, SimplifyDemandedBits(I->getOperandUse(0), DemandedMask & ~RHSKnownOne,
LHSKnownZero, LHSKnownOne, Depth+1)) LHSKnownZero, LHSKnownOne, Depth + 1))
return I; return I;
assert(!(RHSKnownZero & RHSKnownOne) && "Bits known to be one AND zero?"); assert(!(RHSKnownZero & RHSKnownOne) && "Bits known to be one AND zero?");
assert(!(LHSKnownZero & LHSKnownOne) && "Bits known to be one AND zero?"); assert(!(LHSKnownZero & LHSKnownOne) && "Bits known to be one AND zero?");
Context not available.
KnownOne = RHSKnownOne | LHSKnownOne; KnownOne = RHSKnownOne | LHSKnownOne;
break; break;
case Instruction::Xor: { case Instruction::Xor: {
if (SimplifyDemandedBits(I->getOperandUse(1), DemandedMask, if (SimplifyDemandedBits(I->getOperandUse(1), DemandedMask, RHSKnownZero,
RHSKnownZero, RHSKnownOne, Depth+1) || RHSKnownOne, Depth + 1) ||
SimplifyDemandedBits(I->getOperandUse(0), DemandedMask, SimplifyDemandedBits(I->getOperandUse(0), DemandedMask, LHSKnownZero,
LHSKnownZero, LHSKnownOne, Depth+1)) LHSKnownOne, Depth + 1))
return I; return I;
assert(!(RHSKnownZero & RHSKnownOne) && "Bits known to be one AND zero?"); assert(!(RHSKnownZero & RHSKnownOne) && "Bits known to be one AND zero?");
assert(!(LHSKnownZero & LHSKnownOne) && "Bits known to be one AND zero?"); assert(!(LHSKnownZero & LHSKnownOne) && "Bits known to be one AND zero?");
Context not available.
break; break;
} }
case Instruction::Select: case Instruction::Select:
if (SimplifyDemandedBits(I->getOperandUse(2), DemandedMask, if (SimplifyDemandedBits(I->getOperandUse(2), DemandedMask, RHSKnownZero,
RHSKnownZero, RHSKnownOne, Depth+1) || RHSKnownOne, Depth + 1) ||
SimplifyDemandedBits(I->getOperandUse(1), DemandedMask, SimplifyDemandedBits(I->getOperandUse(1), DemandedMask, LHSKnownZero,
LHSKnownZero, LHSKnownOne, Depth+1)) LHSKnownOne, Depth + 1))
return I; return I;
assert(!(RHSKnownZero & RHSKnownOne) && "Bits known to be one AND zero?"); assert(!(RHSKnownZero & RHSKnownOne) && "Bits known to be one AND zero?");
assert(!(LHSKnownZero & LHSKnownOne) && "Bits known to be one AND zero?"); assert(!(LHSKnownZero & LHSKnownOne) && "Bits known to be one AND zero?");
Context not available.
DemandedMask = DemandedMask.zext(truncBf); DemandedMask = DemandedMask.zext(truncBf);
KnownZero = KnownZero.zext(truncBf); KnownZero = KnownZero.zext(truncBf);
KnownOne = KnownOne.zext(truncBf); KnownOne = KnownOne.zext(truncBf);
if (SimplifyDemandedBits(I->getOperandUse(0), DemandedMask, if (SimplifyDemandedBits(I->getOperandUse(0), DemandedMask, KnownZero,
KnownZero, KnownOne, Depth+1)) KnownOne, Depth + 1))
return I; return I;
DemandedMask = DemandedMask.trunc(BitWidth); DemandedMask = DemandedMask.trunc(BitWidth);
KnownZero = KnownZero.trunc(BitWidth); KnownZero = KnownZero.trunc(BitWidth);
Context not available.
// Don't touch a vector-to-scalar bitcast. // Don't touch a vector-to-scalar bitcast.
return nullptr; return nullptr;
if (SimplifyDemandedBits(I->getOperandUse(0), DemandedMask, if (SimplifyDemandedBits(I->getOperandUse(0), DemandedMask, KnownZero,
KnownZero, KnownOne, Depth+1)) KnownOne, Depth + 1))
return I; return I;
assert(!(KnownZero & KnownOne) && "Bits known to be one AND zero?"); assert(!(KnownZero & KnownOne) && "Bits known to be one AND zero?");
break; break;
Context not available.
DemandedMask = DemandedMask.trunc(SrcBitWidth); DemandedMask = DemandedMask.trunc(SrcBitWidth);
KnownZero = KnownZero.trunc(SrcBitWidth); KnownZero = KnownZero.trunc(SrcBitWidth);
KnownOne = KnownOne.trunc(SrcBitWidth); KnownOne = KnownOne.trunc(SrcBitWidth);
if (SimplifyDemandedBits(I->getOperandUse(0), DemandedMask, if (SimplifyDemandedBits(I->getOperandUse(0), DemandedMask, KnownZero,
KnownZero, KnownOne, Depth+1)) KnownOne, Depth + 1))
return I; return I;
DemandedMask = DemandedMask.zext(BitWidth); DemandedMask = DemandedMask.zext(BitWidth);
KnownZero = KnownZero.zext(BitWidth); KnownZero = KnownZero.zext(BitWidth);
Context not available.
InputDemandedBits = InputDemandedBits.trunc(SrcBitWidth); InputDemandedBits = InputDemandedBits.trunc(SrcBitWidth);
KnownZero = KnownZero.trunc(SrcBitWidth); KnownZero = KnownZero.trunc(SrcBitWidth);
KnownOne = KnownOne.trunc(SrcBitWidth); KnownOne = KnownOne.trunc(SrcBitWidth);
if (SimplifyDemandedBits(I->getOperandUse(0), InputDemandedBits, if (SimplifyDemandedBits(I->getOperandUse(0), InputDemandedBits, KnownZero,
KnownZero, KnownOne, Depth+1)) KnownOne, Depth + 1))
return I; return I;
InputDemandedBits = InputDemandedBits.zext(BitWidth); InputDemandedBits = InputDemandedBits.zext(BitWidth);
KnownZero = KnownZero.zext(BitWidth); KnownZero = KnownZero.zext(BitWidth);
Context not available.
// Find information about known zero/one bits in the input. // Find information about known zero/one bits in the input.
if (SimplifyDemandedBits(I->getOperandUse(0), InDemandedBits, if (SimplifyDemandedBits(I->getOperandUse(0), InDemandedBits,
LHSKnownZero, LHSKnownOne, Depth+1)) LHSKnownZero, LHSKnownOne, Depth + 1))
return I; return I;
// If the RHS of the add has bits set that can't affect the input, reduce // If the RHS of the add has bits set that can't affect the input, reduce
Context not available.
// significant bit and all those below it. // significant bit and all those below it.
APInt DemandedFromOps(APInt::getLowBitsSet(BitWidth, BitWidth-NLZ)); APInt DemandedFromOps(APInt::getLowBitsSet(BitWidth, BitWidth-NLZ));
if (SimplifyDemandedBits(I->getOperandUse(0), DemandedFromOps, if (SimplifyDemandedBits(I->getOperandUse(0), DemandedFromOps,
LHSKnownZero, LHSKnownOne, Depth+1) || LHSKnownZero, LHSKnownOne, Depth + 1) ||
SimplifyDemandedBits(I->getOperandUse(1), DemandedFromOps, SimplifyDemandedBits(I->getOperandUse(1), DemandedFromOps,
LHSKnownZero, LHSKnownOne, Depth+1)) LHSKnownZero, LHSKnownOne, Depth + 1))
return I; return I;
} }
} }
Context not available.
uint32_t NLZ = DemandedMask.countLeadingZeros(); uint32_t NLZ = DemandedMask.countLeadingZeros();
APInt DemandedFromOps(APInt::getLowBitsSet(BitWidth, BitWidth-NLZ)); APInt DemandedFromOps(APInt::getLowBitsSet(BitWidth, BitWidth-NLZ));
if (SimplifyDemandedBits(I->getOperandUse(0), DemandedFromOps, if (SimplifyDemandedBits(I->getOperandUse(0), DemandedFromOps,
LHSKnownZero, LHSKnownOne, Depth+1) || LHSKnownZero, LHSKnownOne, Depth + 1) ||
SimplifyDemandedBits(I->getOperandUse(1), DemandedFromOps, SimplifyDemandedBits(I->getOperandUse(1), DemandedFromOps,
LHSKnownZero, LHSKnownOne, Depth+1)) LHSKnownZero, LHSKnownOne, Depth + 1))
return I; return I;
} }
Context not available.
else if (IOp->hasNoUnsignedWrap()) else if (IOp->hasNoUnsignedWrap())
DemandedMaskIn |= APInt::getHighBitsSet(BitWidth, ShiftAmt); DemandedMaskIn |= APInt::getHighBitsSet(BitWidth, ShiftAmt);
if (SimplifyDemandedBits(I->getOperandUse(0), DemandedMaskIn, if (SimplifyDemandedBits(I->getOperandUse(0), DemandedMaskIn, KnownZero,
KnownZero, KnownOne, Depth+1)) KnownOne, Depth + 1))
return I; return I;
assert(!(KnownZero & KnownOne) && "Bits known to be one AND zero?"); assert(!(KnownZero & KnownOne) && "Bits known to be one AND zero?");
KnownZero <<= ShiftAmt; KnownZero <<= ShiftAmt;
Context not available.
if (cast<LShrOperator>(I)->isExact()) if (cast<LShrOperator>(I)->isExact())
DemandedMaskIn |= APInt::getLowBitsSet(BitWidth, ShiftAmt); DemandedMaskIn |= APInt::getLowBitsSet(BitWidth, ShiftAmt);
if (SimplifyDemandedBits(I->getOperandUse(0), DemandedMaskIn, if (SimplifyDemandedBits(I->getOperandUse(0), DemandedMaskIn, KnownZero,
KnownZero, KnownOne, Depth+1)) KnownOne, Depth + 1))
return I; return I;
assert(!(KnownZero & KnownOne) && "Bits known to be one AND zero?"); assert(!(KnownZero & KnownOne) && "Bits known to be one AND zero?");
KnownZero = APIntOps::lshr(KnownZero, ShiftAmt); KnownZero = APIntOps::lshr(KnownZero, ShiftAmt);
Context not available.
if (cast<AShrOperator>(I)->isExact()) if (cast<AShrOperator>(I)->isExact())
DemandedMaskIn |= APInt::getLowBitsSet(BitWidth, ShiftAmt); DemandedMaskIn |= APInt::getLowBitsSet(BitWidth, ShiftAmt);
if (SimplifyDemandedBits(I->getOperandUse(0), DemandedMaskIn, if (SimplifyDemandedBits(I->getOperandUse(0), DemandedMaskIn, KnownZero,
KnownZero, KnownOne, Depth+1)) KnownOne, Depth + 1))
return I; return I;
assert(!(KnownZero & KnownOne) && "Bits known to be one AND zero?"); assert(!(KnownZero & KnownOne) && "Bits known to be one AND zero?");
// Compute the new bits that are at the top now. // Compute the new bits that are at the top now.
Context not available.
APInt LowBits = RA - 1; APInt LowBits = RA - 1;
APInt Mask2 = LowBits | APInt::getSignBit(BitWidth); APInt Mask2 = LowBits | APInt::getSignBit(BitWidth);
if (SimplifyDemandedBits(I->getOperandUse(0), Mask2, if (SimplifyDemandedBits(I->getOperandUse(0), Mask2, LHSKnownZero,
LHSKnownZero, LHSKnownOne, Depth+1)) LHSKnownOne, Depth + 1))
return I; return I;
// The low bits of LHS are unchanged by the srem. // The low bits of LHS are unchanged by the srem.
Context not available.
// remainder is zero. // remainder is zero.
if (DemandedMask.isNegative() && KnownZero.isNonNegative()) { if (DemandedMask.isNegative() && KnownZero.isNonNegative()) {
APInt LHSKnownZero(BitWidth, 0), LHSKnownOne(BitWidth, 0); APInt LHSKnownZero(BitWidth, 0), LHSKnownOne(BitWidth, 0);
computeKnownBits(I->getOperand(0), LHSKnownZero, LHSKnownOne, Depth+1, computeKnownBits(I->getOperand(0), LHSKnownZero, LHSKnownOne, Depth + 1,
CxtI); CxtI);
// If it's known zero, our sign bit is also zero. // If it's known zero, our sign bit is also zero.
if (LHSKnownZero.isNegative()) if (LHSKnownZero.isNegative())
Context not available.
case Instruction::URem: { case Instruction::URem: {
APInt KnownZero2(BitWidth, 0), KnownOne2(BitWidth, 0); APInt KnownZero2(BitWidth, 0), KnownOne2(BitWidth, 0);
APInt AllOnes = APInt::getAllOnesValue(BitWidth); APInt AllOnes = APInt::getAllOnesValue(BitWidth);
if (SimplifyDemandedBits(I->getOperandUse(0), AllOnes, if (SimplifyDemandedBits(I->getOperandUse(0), AllOnes, KnownZero2,
KnownZero2, KnownOne2, Depth+1) || KnownOne2, Depth + 1) ||
SimplifyDemandedBits(I->getOperandUse(1), AllOnes, SimplifyDemandedBits(I->getOperandUse(1), AllOnes, KnownZero2,
KnownZero2, KnownOne2, Depth+1)) KnownOne2, Depth + 1))
return I; return I;
unsigned Leaders = KnownZero2.countLeadingOnes(); unsigned Leaders = KnownZero2.countLeadingOnes();
Context not available.
// Note that we can't propagate undef elt info, because we don't know // Note that we can't propagate undef elt info, because we don't know
// which elt is getting updated. // which elt is getting updated.
TmpV = SimplifyDemandedVectorElts(I->getOperand(0), DemandedElts, TmpV = SimplifyDemandedVectorElts(I->getOperand(0), DemandedElts,
UndefElts2, Depth+1); UndefElts2, Depth + 1);
if (TmpV) { I->setOperand(0, TmpV); MadeChange = true; } if (TmpV) { I->setOperand(0, TmpV); MadeChange = true; }
break; break;
} }
Context not available.
APInt DemandedElts2 = DemandedElts; APInt DemandedElts2 = DemandedElts;
DemandedElts2.clearBit(IdxNo); DemandedElts2.clearBit(IdxNo);
TmpV = SimplifyDemandedVectorElts(I->getOperand(0), DemandedElts2, TmpV = SimplifyDemandedVectorElts(I->getOperand(0), DemandedElts2,
UndefElts, Depth+1); UndefElts, Depth + 1);
if (TmpV) { I->setOperand(0, TmpV); MadeChange = true; } if (TmpV) { I->setOperand(0, TmpV); MadeChange = true; }
// The inserted element is defined. // The inserted element is defined.
Context not available.
APInt UndefElts4(LHSVWidth, 0); APInt UndefElts4(LHSVWidth, 0);
TmpV = SimplifyDemandedVectorElts(I->getOperand(0), LeftDemanded, TmpV = SimplifyDemandedVectorElts(I->getOperand(0), LeftDemanded,
UndefElts4, Depth+1); UndefElts4, Depth + 1);
if (TmpV) { I->setOperand(0, TmpV); MadeChange = true; } if (TmpV) { I->setOperand(0, TmpV); MadeChange = true; }
APInt UndefElts3(LHSVWidth, 0); APInt UndefElts3(LHSVWidth, 0);
TmpV = SimplifyDemandedVectorElts(I->getOperand(1), RightDemanded, TmpV = SimplifyDemandedVectorElts(I->getOperand(1), RightDemanded,
UndefElts3, Depth+1); UndefElts3, Depth + 1);
if (TmpV) { I->setOperand(1, TmpV); MadeChange = true; } if (TmpV) { I->setOperand(1, TmpV); MadeChange = true; }
bool NewUndefElts = false; bool NewUndefElts = false;
Context not available.
} }
} }
TmpV = SimplifyDemandedVectorElts(I->getOperand(1), LeftDemanded, TmpV = SimplifyDemandedVectorElts(I->getOperand(1), LeftDemanded, UndefElts,
UndefElts, Depth+1); Depth + 1);
if (TmpV) { I->setOperand(1, TmpV); MadeChange = true; } if (TmpV) { I->setOperand(1, TmpV); MadeChange = true; }
TmpV = SimplifyDemandedVectorElts(I->getOperand(2), RightDemanded, TmpV = SimplifyDemandedVectorElts(I->getOperand(2), RightDemanded,
UndefElts2, Depth+1); UndefElts2, Depth + 1);
if (TmpV) { I->setOperand(2, TmpV); MadeChange = true; } if (TmpV) { I->setOperand(2, TmpV); MadeChange = true; }
// Output elements are undefined if both are undefined. // Output elements are undefined if both are undefined.
Context not available.
// div/rem demand all inputs, because they don't want divide by zero. // div/rem demand all inputs, because they don't want divide by zero.
TmpV = SimplifyDemandedVectorElts(I->getOperand(0), InputDemandedElts, TmpV = SimplifyDemandedVectorElts(I->getOperand(0), InputDemandedElts,
UndefElts2, Depth+1); UndefElts2, Depth + 1);
if (TmpV) { if (TmpV) {
I->setOperand(0, TmpV); I->setOperand(0, TmpV);
MadeChange = true; MadeChange = true;
Context not available.
case Instruction::Sub: case Instruction::Sub:
case Instruction::Mul: case Instruction::Mul:
// div/rem demand all inputs, because they don't want divide by zero. // div/rem demand all inputs, because they don't want divide by zero.
TmpV = SimplifyDemandedVectorElts(I->getOperand(0), DemandedElts, TmpV = SimplifyDemandedVectorElts(I->getOperand(0), DemandedElts, UndefElts,
UndefElts, Depth+1); Depth + 1);
if (TmpV) { I->setOperand(0, TmpV); MadeChange = true; } if (TmpV) { I->setOperand(0, TmpV); MadeChange = true; }
TmpV = SimplifyDemandedVectorElts(I->getOperand(1), DemandedElts, TmpV = SimplifyDemandedVectorElts(I->getOperand(1), DemandedElts,
UndefElts2, Depth+1); UndefElts2, Depth + 1);
if (TmpV) { I->setOperand(1, TmpV); MadeChange = true; } if (TmpV) { I->setOperand(1, TmpV); MadeChange = true; }
// Output elements are undefined if both are undefined. Consider things // Output elements are undefined if both are undefined. Consider things
Context not available.
break; break;
case Instruction::FPTrunc: case Instruction::FPTrunc:
case Instruction::FPExt: case Instruction::FPExt:
TmpV = SimplifyDemandedVectorElts(I->getOperand(0), DemandedElts, TmpV = SimplifyDemandedVectorElts(I->getOperand(0), DemandedElts, UndefElts,
UndefElts, Depth+1); Depth + 1);
if (TmpV) { I->setOperand(0, TmpV); MadeChange = true; } if (TmpV) { I->setOperand(0, TmpV); MadeChange = true; }
break; break;
Context not available.
case Intrinsic::x86_sse2_min_sd: case Intrinsic::x86_sse2_min_sd:
case Intrinsic::x86_sse2_max_sd: case Intrinsic::x86_sse2_max_sd:
TmpV = SimplifyDemandedVectorElts(II->getArgOperand(0), DemandedElts, TmpV = SimplifyDemandedVectorElts(II->getArgOperand(0), DemandedElts,
UndefElts, Depth+1); UndefElts, Depth + 1);
if (TmpV) { II->setArgOperand(0, TmpV); MadeChange = true; } if (TmpV) { II->setArgOperand(0, TmpV); MadeChange = true; }
TmpV = SimplifyDemandedVectorElts(II->getArgOperand(1), DemandedElts, TmpV = SimplifyDemandedVectorElts(II->getArgOperand(1), DemandedElts,
UndefElts2, Depth+1); UndefElts2, Depth + 1);
if (TmpV) { II->setArgOperand(1, TmpV); MadeChange = true; } if (TmpV) { II->setArgOperand(1, TmpV); MadeChange = true; }
// If only the low elt is demanded and this is a scalarizable intrinsic, // If only the low elt is demanded and this is a scalarizable intrinsic,
Context not available.

lib/Transforms/InstCombine/InstCombineVectorOps.cpp

Context not available.
APInt UndefElts(VectorWidth, 0); APInt UndefElts(VectorWidth, 0);
APInt DemandedMask(VectorWidth, 0); APInt DemandedMask(VectorWidth, 0);
DemandedMask.setBit(IndexVal); DemandedMask.setBit(IndexVal);
if (Value *V = SimplifyDemandedVectorElts(EI.getOperand(0), if (Value *V = SimplifyDemandedVectorElts(EI.getOperand(0), DemandedMask,
DemandedMask, UndefElts)) { UndefElts)) {
EI.setOperand(0, V); EI.setOperand(0, V);
return &EI; return &EI;
} }
Context not available.

lib/Transforms/InstCombine/InstructionCombining.cpp

Context not available.
STATISTIC(NumReassoc , "Number of reassociations"); STATISTIC(NumReassoc , "Number of reassociations");
Value *InstCombiner::EmitGEPOffset(User *GEP) { Value *InstCombiner::EmitGEPOffset(User *GEP) {
return llvm::EmitGEPOffset(Builder, *getDataLayout(), GEP); return llvm::EmitGEPOffset(Builder, DL, GEP);
} }
/// ShouldChangeType - Return true if it is desirable to convert a computation /// ShouldChangeType - Return true if it is desirable to convert a computation
Context not available.
bool InstCombiner::ShouldChangeType(Type *From, Type *To) const { bool InstCombiner::ShouldChangeType(Type *From, Type *To) const {
assert(From->isIntegerTy() && To->isIntegerTy()); assert(From->isIntegerTy() && To->isIntegerTy());
// If we don't have DL, we don't know if the source/dest are legal.
if (!DL) return false;
unsigned FromWidth = From->getPrimitiveSizeInBits(); unsigned FromWidth = From->getPrimitiveSizeInBits();
unsigned ToWidth = To->getPrimitiveSizeInBits(); unsigned ToWidth = To->getPrimitiveSizeInBits();
bool FromLegal = DL->isLegalInteger(FromWidth); bool FromLegal = DL.isLegalInteger(FromWidth);
bool ToLegal = DL->isLegalInteger(ToWidth); bool ToLegal = DL.isLegalInteger(ToWidth);
// If this is a legal integer from type, and the result would be an illegal // If this is a legal integer from type, and the result would be an illegal
// type, don't do the transformation. // type, don't do the transformation.
Context not available.
/// This tries to simplify binary operations by factorizing out common terms /// This tries to simplify binary operations by factorizing out common terms
/// (e. g. "(A*B)+(A*C)" -> "A*(B+C)"). /// (e. g. "(A*B)+(A*C)" -> "A*(B+C)").
static Value *tryFactorization(InstCombiner::BuilderTy *Builder, static Value *tryFactorization(InstCombiner::BuilderTy *Builder,
const DataLayout *DL, BinaryOperator &I, const DataLayout &DL, BinaryOperator &I,
Instruction::BinaryOps InnerOpcode, Value *A, Instruction::BinaryOps InnerOpcode, Value *A,
Value *B, Value *C, Value *D) { Value *B, Value *C, Value *D) {
Context not available.
/// will land us at the specified offset. If so, fill them into NewIndices and /// will land us at the specified offset. If so, fill them into NewIndices and
/// return the resultant element type, otherwise return null. /// return the resultant element type, otherwise return null.
Type *InstCombiner::FindElementAtOffset(Type *PtrTy, int64_t Offset, Type *InstCombiner::FindElementAtOffset(Type *PtrTy, int64_t Offset,
SmallVectorImpl<Value*> &NewIndices) { SmallVectorImpl<Value *> &NewIndices) {
assert(PtrTy->isPtrOrPtrVectorTy()); assert(PtrTy->isPtrOrPtrVectorTy());
if (!DL)
return nullptr;
Type *Ty = PtrTy->getPointerElementType(); Type *Ty = PtrTy->getPointerElementType();
if (!Ty->isSized()) if (!Ty->isSized())
return nullptr; return nullptr;
Context not available.
// Start with the index over the outer type. Note that the type size // Start with the index over the outer type. Note that the type size
// might be zero (even if the offset isn't zero) if the indexed type // might be zero (even if the offset isn't zero) if the indexed type
// is something like [0 x {int, int}] // is something like [0 x {int, int}]
Type *IntPtrTy = DL->getIntPtrType(PtrTy); Type *IntPtrTy = DL.getIntPtrType(PtrTy);
int64_t FirstIdx = 0; int64_t FirstIdx = 0;
if (int64_t TySize = DL->getTypeAllocSize(Ty)) { if (int64_t TySize = DL.getTypeAllocSize(Ty)) {
FirstIdx = Offset/TySize; FirstIdx = Offset/TySize;
Offset -= FirstIdx*TySize; Offset -= FirstIdx*TySize;
Context not available.
// Index into the types. If we fail, set OrigBase to null. // Index into the types. If we fail, set OrigBase to null.
while (Offset) { while (Offset) {
// Indexing into tail padding between struct/array elements. // Indexing into tail padding between struct/array elements.
if (uint64_t(Offset*8) >= DL->getTypeSizeInBits(Ty)) if (uint64_t(Offset * 8) >= DL.getTypeSizeInBits(Ty))
return nullptr; return nullptr;
if (StructType *STy = dyn_cast<StructType>(Ty)) { if (StructType *STy = dyn_cast<StructType>(Ty)) {
const StructLayout *SL = DL->getStructLayout(STy); const StructLayout *SL = DL.getStructLayout(STy);
assert(Offset < (int64_t)SL->getSizeInBytes() && assert(Offset < (int64_t)SL->getSizeInBytes() &&
"Offset must stay within the indexed type"); "Offset must stay within the indexed type");
Context not available.
Offset -= SL->getElementOffset(Elt); Offset -= SL->getElementOffset(Elt);
Ty = STy->getElementType(Elt); Ty = STy->getElementType(Elt);
} else if (ArrayType *AT = dyn_cast<ArrayType>(Ty)) { } else if (ArrayType *AT = dyn_cast<ArrayType>(Ty)) {
uint64_t EltSize = DL->getTypeAllocSize(AT->getElementType()); uint64_t EltSize = DL.getTypeAllocSize(AT->getElementType());
assert(EltSize && "Cannot index into a zero-sized array"); assert(EltSize && "Cannot index into a zero-sized array");
NewIndices.push_back(ConstantInt::get(IntPtrTy,Offset/EltSize)); NewIndices.push_back(ConstantInt::get(IntPtrTy,Offset/EltSize));
Offset %= EltSize; Offset %= EltSize;
Context not available.
// It may not be safe to reorder shuffles and things like div, urem, etc. // It may not be safe to reorder shuffles and things like div, urem, etc.
// because we may trap when executing those ops on unknown vector elements. // because we may trap when executing those ops on unknown vector elements.
// See PR20059. // See PR20059.
if (!isSafeToSpeculativelyExecute(&Inst, DL)) return nullptr; if (!isSafeToSpeculativelyExecute(&Inst))
return nullptr;
unsigned VWidth = cast<VectorType>(Inst.getType())->getNumElements(); unsigned VWidth = cast<VectorType>(Inst.getType())->getNumElements();
Value *LHS = Inst.getOperand(0), *RHS = Inst.getOperand(1); Value *LHS = Inst.getOperand(0), *RHS = Inst.getOperand(1);
Context not available.
// Eliminate unneeded casts for indices, and replace indices which displace // Eliminate unneeded casts for indices, and replace indices which displace
// by multiples of a zero size type with zero. // by multiples of a zero size type with zero.
if (DL) { bool MadeChange = false;
bool MadeChange = false; Type *IntPtrTy = DL.getIntPtrType(GEP.getPointerOperandType());
Type *IntPtrTy = DL->getIntPtrType(GEP.getPointerOperandType());
gep_type_iterator GTI = gep_type_begin(GEP);
gep_type_iterator GTI = gep_type_begin(GEP); for (User::op_iterator I = GEP.op_begin() + 1, E = GEP.op_end(); I != E;
for (User::op_iterator I = GEP.op_begin() + 1, E = GEP.op_end(); ++I, ++GTI) {
I != E; ++I, ++GTI) { // Skip indices into struct types.
// Skip indices into struct types. SequentialType *SeqTy = dyn_cast<SequentialType>(*GTI);
SequentialType *SeqTy = dyn_cast<SequentialType>(*GTI); if (!SeqTy)
if (!SeqTy) continue; continue;
// If the element type has zero size then any index over it is equivalent
// to an index of zero, so replace it with zero if it is not zero already.
if (SeqTy->getElementType()->isSized() &&
DL->getTypeAllocSize(SeqTy->getElementType()) == 0)
if (!isa<Constant>(*I) || !cast<Constant>(*I)->isNullValue()) {
*I = Constant::getNullValue(IntPtrTy);
MadeChange = true;
}
Type *IndexTy = (*I)->getType(); // If the element type has zero size then any index over it is equivalent
if (IndexTy != IntPtrTy) { // to an index of zero, so replace it with zero if it is not zero already.
// If we are using a wider index than needed for this platform, shrink if (SeqTy->getElementType()->isSized() &&
// it to what we need. If narrower, sign-extend it to what we need. DL.getTypeAllocSize(SeqTy->getElementType()) == 0)
// This explicit cast can make subsequent optimizations more obvious. if (!isa<Constant>(*I) || !cast<Constant>(*I)->isNullValue()) {
*I = Builder->CreateIntCast(*I, IntPtrTy, true); *I = Constant::getNullValue(IntPtrTy);
MadeChange = true; MadeChange = true;
} }
Type *IndexTy = (*I)->getType();
if (IndexTy != IntPtrTy) {
// If we are using a wider index than needed for this platform, shrink
// it to what we need. If narrower, sign-extend it to what we need.
// This explicit cast can make subsequent optimizations more obvious.
*I = Builder->CreateIntCast(*I, IntPtrTy, true);
MadeChange = true;
} }
if (MadeChange) return &GEP;
} }
if (MadeChange)
return &GEP;
// Check to see if the inputs to the PHI node are getelementptr instructions. // Check to see if the inputs to the PHI node are getelementptr instructions.
if (PHINode *PN = dyn_cast<PHINode>(PtrOp)) { if (PHINode *PN = dyn_cast<PHINode>(PtrOp)) {
Context not available.
GetElementPtrInst::Create(Src->getOperand(0), Indices, GEP.getName()); GetElementPtrInst::Create(Src->getOperand(0), Indices, GEP.getName());
} }
if (DL && GEP.getNumIndices() == 1) { if (GEP.getNumIndices() == 1) {
unsigned AS = GEP.getPointerAddressSpace(); unsigned AS = GEP.getPointerAddressSpace();
if (GEP.getOperand(1)->getType()->getScalarSizeInBits() == if (GEP.getOperand(1)->getType()->getScalarSizeInBits() ==
DL->getPointerSizeInBits(AS)) { DL.getPointerSizeInBits(AS)) {
Type *PtrTy = GEP.getPointerOperandType(); Type *PtrTy = GEP.getPointerOperandType();
Type *Ty = PtrTy->getPointerElementType(); Type *Ty = PtrTy->getPointerElementType();
uint64_t TyAllocSize = DL->getTypeAllocSize(Ty); uint64_t TyAllocSize = DL.getTypeAllocSize(Ty);
bool Matched = false; bool Matched = false;
uint64_t C; uint64_t C;
Context not available.
// into: %t1 = getelementptr [2 x i32]* %str, i32 0, i32 %V; bitcast // into: %t1 = getelementptr [2 x i32]* %str, i32 0, i32 %V; bitcast
Type *SrcElTy = StrippedPtrTy->getElementType(); Type *SrcElTy = StrippedPtrTy->getElementType();
Type *ResElTy = PtrOp->getType()->getPointerElementType(); Type *ResElTy = PtrOp->getType()->getPointerElementType();
if (DL && SrcElTy->isArrayTy() && if (SrcElTy->isArrayTy() &&
DL->getTypeAllocSize(SrcElTy->getArrayElementType()) == DL.getTypeAllocSize(SrcElTy->getArrayElementType()) ==
DL->getTypeAllocSize(ResElTy)) { DL.getTypeAllocSize(ResElTy)) {
Type *IdxType = DL->getIntPtrType(GEP.getType()); Type *IdxType = DL.getIntPtrType(GEP.getType());
Value *Idx[2] = { Constant::getNullValue(IdxType), GEP.getOperand(1) }; Value *Idx[2] = { Constant::getNullValue(IdxType), GEP.getOperand(1) };
Value *NewGEP = GEP.isInBounds() ? Value *NewGEP = GEP.isInBounds() ?
Builder->CreateInBoundsGEP(StrippedPtr, Idx, GEP.getName()) : Builder->CreateInBoundsGEP(StrippedPtr, Idx, GEP.getName()) :
Context not available.
// %V = mul i64 %N, 4 // %V = mul i64 %N, 4
// %t = getelementptr i8* bitcast (i32* %arr to i8*), i32 %V // %t = getelementptr i8* bitcast (i32* %arr to i8*), i32 %V
// into: %t1 = getelementptr i32* %arr, i32 %N; bitcast // into: %t1 = getelementptr i32* %arr, i32 %N; bitcast
if (DL && ResElTy->isSized() && SrcElTy->isSized()) { if (ResElTy->isSized() && SrcElTy->isSized()) {
// Check that changing the type amounts to dividing the index by a scale // Check that changing the type amounts to dividing the index by a scale
// factor. // factor.
uint64_t ResSize = DL->getTypeAllocSize(ResElTy); uint64_t ResSize = DL.getTypeAllocSize(ResElTy);
uint64_t SrcSize = DL->getTypeAllocSize(SrcElTy); uint64_t SrcSize = DL.getTypeAllocSize(SrcElTy);
if (ResSize && SrcSize % ResSize == 0) { if (ResSize && SrcSize % ResSize == 0) {
Value *Idx = GEP.getOperand(1); Value *Idx = GEP.getOperand(1);
unsigned BitWidth = Idx->getType()->getPrimitiveSizeInBits(); unsigned BitWidth = Idx->getType()->getPrimitiveSizeInBits();
Context not available.
// Earlier transforms ensure that the index has type IntPtrType, which // Earlier transforms ensure that the index has type IntPtrType, which
// considerably simplifies the logic by eliminating implicit casts. // considerably simplifies the logic by eliminating implicit casts.
assert(Idx->getType() == DL->getIntPtrType(GEP.getType()) && assert(Idx->getType() == DL.getIntPtrType(GEP.getType()) &&
"Index not cast to pointer width?"); "Index not cast to pointer width?");
bool NSW; bool NSW;
Context not available.
// getelementptr i8* bitcast ([100 x double]* X to i8*), i32 %tmp // getelementptr i8* bitcast ([100 x double]* X to i8*), i32 %tmp
// (where tmp = 8*tmp2) into: // (where tmp = 8*tmp2) into:
// getelementptr [100 x double]* %arr, i32 0, i32 %tmp2; bitcast // getelementptr [100 x double]* %arr, i32 0, i32 %tmp2; bitcast
if (DL && ResElTy->isSized() && SrcElTy->isSized() && if (ResElTy->isSized() && SrcElTy->isSized() && SrcElTy->isArrayTy()) {
SrcElTy->isArrayTy()) {
// Check that changing to the array element type amounts to dividing the // Check that changing to the array element type amounts to dividing the
// index by a scale factor. // index by a scale factor.
uint64_t ResSize = DL->getTypeAllocSize(ResElTy); uint64_t ResSize = DL.getTypeAllocSize(ResElTy);
uint64_t ArrayEltSize uint64_t ArrayEltSize =
= DL->getTypeAllocSize(SrcElTy->getArrayElementType()); DL.getTypeAllocSize(SrcElTy->getArrayElementType());
if (ResSize && ArrayEltSize % ResSize == 0) { if (ResSize && ArrayEltSize % ResSize == 0) {
Value *Idx = GEP.getOperand(1); Value *Idx = GEP.getOperand(1);
unsigned BitWidth = Idx->getType()->getPrimitiveSizeInBits(); unsigned BitWidth = Idx->getType()->getPrimitiveSizeInBits();
Context not available.
// Earlier transforms ensure that the index has type IntPtrType, which // Earlier transforms ensure that the index has type IntPtrType, which
// considerably simplifies the logic by eliminating implicit casts. // considerably simplifies the logic by eliminating implicit casts.
assert(Idx->getType() == DL->getIntPtrType(GEP.getType()) && assert(Idx->getType() == DL.getIntPtrType(GEP.getType()) &&
"Index not cast to pointer width?"); "Index not cast to pointer width?");
bool NSW; bool NSW;
Context not available.
// If the multiplication NewIdx * Scale may overflow then the new // If the multiplication NewIdx * Scale may overflow then the new
// GEP may not be "inbounds". // GEP may not be "inbounds".
Value *Off[2] = { Value *Off[2] = {
Constant::getNullValue(DL->getIntPtrType(GEP.getType())), Constant::getNullValue(DL.getIntPtrType(GEP.getType())),
NewIdx NewIdx};
};
Value *NewGEP = GEP.isInBounds() && NSW ? Value *NewGEP = GEP.isInBounds() && NSW ?
Builder->CreateInBoundsGEP(StrippedPtr, Off, GEP.getName()) : Builder->CreateInBoundsGEP(StrippedPtr, Off, GEP.getName()) :
Context not available.
} }
} }
if (!DL)
return nullptr;
// addrspacecast between types is canonicalized as a bitcast, then an // addrspacecast between types is canonicalized as a bitcast, then an
// addrspacecast. To take advantage of the below bitcast + struct GEP, look // addrspacecast. To take advantage of the below bitcast + struct GEP, look
// through the addrspacecast. // through the addrspacecast.
Context not available.
if (BitCastInst *BCI = dyn_cast<BitCastInst>(PtrOp)) { if (BitCastInst *BCI = dyn_cast<BitCastInst>(PtrOp)) {
Value *Operand = BCI->getOperand(0); Value *Operand = BCI->getOperand(0);
PointerType *OpType = cast<PointerType>(Operand->getType()); PointerType *OpType = cast<PointerType>(Operand->getType());
unsigned OffsetBits = DL->getPointerTypeSizeInBits(GEP.getType()); unsigned OffsetBits = DL.getPointerTypeSizeInBits(GEP.getType());
APInt Offset(OffsetBits, 0); APInt Offset(OffsetBits, 0);
if (!isa<BitCastInst>(Operand) && if (!isa<BitCastInst>(Operand) &&
GEP.accumulateConstantOffset(*DL, Offset)) { GEP.accumulateConstantOffset(DL, Offset)) {
// If this GEP instruction doesn't move the pointer, just replace the GEP // If this GEP instruction doesn't move the pointer, just replace the GEP
// with a bitcast of the real input to the dest type. // with a bitcast of the real input to the dest type.
Context not available.
Value *Cond = SI.getCondition(); Value *Cond = SI.getCondition();
unsigned BitWidth = cast<IntegerType>(Cond->getType())->getBitWidth(); unsigned BitWidth = cast<IntegerType>(Cond->getType())->getBitWidth();
APInt KnownZero(BitWidth, 0), KnownOne(BitWidth, 0); APInt KnownZero(BitWidth, 0), KnownOne(BitWidth, 0);
computeKnownBits(Cond, KnownZero, KnownOne); computeKnownBits(Cond, KnownZero, KnownOne, 0, &SI);
unsigned LeadingKnownZeros = KnownZero.countLeadingOnes(); unsigned LeadingKnownZeros = KnownZero.countLeadingOnes();
unsigned LeadingKnownOnes = KnownOne.countLeadingOnes(); unsigned LeadingKnownOnes = KnownOne.countLeadingOnes();
Context not available.
// x86 generates redundant zero-extenstion instructions if the operand is // x86 generates redundant zero-extenstion instructions if the operand is
// truncated to i8 or i16. // truncated to i8 or i16.
bool TruncCond = false; bool TruncCond = false;
if (DL && BitWidth > NewWidth && if (BitWidth > NewWidth && NewWidth >= DL.getLargestLegalIntTypeSize()) {
NewWidth >= DL->getLargestLegalIntTypeSize()) {
TruncCond = true; TruncCond = true;
IntegerType *Ty = IntegerType::get(SI.getContext(), NewWidth); IntegerType *Ty = IntegerType::get(SI.getContext(), NewWidth);
Builder->SetInsertPoint(&SI); Builder->SetInsertPoint(&SI);
Context not available.
} }
// Instruction isn't dead, see if we can constant propagate it. // Instruction isn't dead, see if we can constant propagate it.
if (!I->use_empty() && isa<Constant>(I->getOperand(0))) if (!I->use_empty() && isa<Constant>(I->getOperand(0))) {
if (Constant *C = ConstantFoldInstruction(I, DL, TLI)) { if (Constant *C = ConstantFoldInstruction(I, DL, TLI)) {
DEBUG(dbgs() << "IC: ConstFold to: " << *C << " from: " << *I << '\n'); DEBUG(dbgs() << "IC: ConstFold to: " << *C << " from: " << *I << '\n');
Context not available.
MadeIRChange = true; MadeIRChange = true;
continue; continue;
} }
}
// See if we can trivially sink this instruction to a successor basic block. // See if we can trivially sink this instruction to a successor basic block.
if (I->hasOneUse()) { if (I->hasOneUse()) {
Context not available.
/// many instructions are dead or constant). Additionally, if we find a branch /// many instructions are dead or constant). Additionally, if we find a branch
/// whose condition is a known constant, we only visit the reachable successors. /// whose condition is a known constant, we only visit the reachable successors.
/// ///
static bool AddReachableCodeToWorklist(BasicBlock *BB, static bool AddReachableCodeToWorklist(BasicBlock *BB, const DataLayout &DL,
SmallPtrSetImpl<BasicBlock*> &Visited, SmallPtrSetImpl<BasicBlock *> &Visited,
InstCombineWorklist &ICWorklist, InstCombineWorklist &ICWorklist,
const DataLayout *DL,
const TargetLibraryInfo *TLI) { const TargetLibraryInfo *TLI) {
bool MadeIRChange = false; bool MadeIRChange = false;
SmallVector<BasicBlock*, 256> Worklist; SmallVector<BasicBlock*, 256> Worklist;
Context not available.
continue; continue;
} }
if (DL) { // See if we can constant fold its operands.
// See if we can constant fold its operands. for (User::op_iterator i = Inst->op_begin(), e = Inst->op_end(); i != e;
for (User::op_iterator i = Inst->op_begin(), e = Inst->op_end(); ++i) {
i != e; ++i) { ConstantExpr *CE = dyn_cast<ConstantExpr>(i);
ConstantExpr *CE = dyn_cast<ConstantExpr>(i); if (CE == nullptr)
if (CE == nullptr) continue; continue;
Constant*& FoldRes = FoldedConstants[CE]; Constant *&FoldRes = FoldedConstants[CE];
if (!FoldRes) if (!FoldRes)
FoldRes = ConstantFoldConstantExpression(CE, DL, TLI); FoldRes = ConstantFoldConstantExpression(CE, DL, TLI);
if (!FoldRes) if (!FoldRes)
FoldRes = CE; FoldRes = CE;
if (FoldRes != CE) { if (FoldRes != CE) {
*i = FoldRes; *i = FoldRes;
MadeIRChange = true; MadeIRChange = true;
}
} }
} }
Context not available.
/// ///
/// This also does basic constant propagation and other forward fixing to make /// This also does basic constant propagation and other forward fixing to make
/// the combiner itself run much faster. /// the combiner itself run much faster.
static bool prepareICWorklistFromFunction(Function &F, const DataLayout *DL, static bool prepareICWorklistFromFunction(Function &F, const DataLayout &DL,
TargetLibraryInfo *TLI, TargetLibraryInfo *TLI,
InstCombineWorklist &ICWorklist) { InstCombineWorklist &ICWorklist) {
bool MadeIRChange = false; bool MadeIRChange = false;
Context not available.
// track of which blocks we visit. // track of which blocks we visit.
SmallPtrSet<BasicBlock *, 64> Visited; SmallPtrSet<BasicBlock *, 64> Visited;
MadeIRChange |= MadeIRChange |=
AddReachableCodeToWorklist(F.begin(), Visited, ICWorklist, DL, TLI); AddReachableCodeToWorklist(F.begin(), DL, Visited, ICWorklist, TLI);
// Do a quick scan over the function. If we find any blocks that are // Do a quick scan over the function. If we find any blocks that are
// unreachable, remove any instructions inside of them. This prevents // unreachable, remove any instructions inside of them. This prevents
Context not available.
DominatorTree &DT, LoopInfo *LI = nullptr) { DominatorTree &DT, LoopInfo *LI = nullptr) {
// Minimizing size? // Minimizing size?
bool MinimizeSize = F.hasFnAttribute(Attribute::MinSize); bool MinimizeSize = F.hasFnAttribute(Attribute::MinSize);
const DataLayout &DL = F.getParent()->getDataLayout(); auto &DL = F.getParent()->getDataLayout();
/// Builder - This is an IRBuilder that automatically inserts new /// Builder - This is an IRBuilder that automatically inserts new
/// instructions into the worklist when they are created. /// instructions into the worklist when they are created.
IRBuilder<true, TargetFolder, InstCombineIRInserter> Builder( IRBuilder<true, TargetFolder, InstCombineIRInserter> Builder(
F.getContext(), TargetFolder(&DL), InstCombineIRInserter(Worklist, &AC)); F.getContext(), TargetFolder(DL), InstCombineIRInserter(Worklist, &AC));
// Lower dbg.declare intrinsics otherwise their value may be clobbered // Lower dbg.declare intrinsics otherwise their value may be clobbered
// by instcombiner. // by instcombiner.
Context not available.
<< F.getName() << "\n"); << F.getName() << "\n");
bool Changed = false; bool Changed = false;
if (prepareICWorklistFromFunction(F, &DL, &TLI, Worklist)) if (prepareICWorklistFromFunction(F, DL, &TLI, Worklist))
Changed = true; Changed = true;
InstCombiner IC(Worklist, &Builder, MinimizeSize, &AC, &TLI, &DT, &DL, LI); InstCombiner IC(Worklist, &Builder, MinimizeSize, &AC, &TLI, &DT, DL, LI);
if (IC.run()) if (IC.run())
Changed = true; Changed = true;
Context not available.

lib/Transforms/Instrumentation/AddressSanitizer.cpp

Context not available.
} }
uint64_t getAllocaSizeInBytes(AllocaInst *AI) const { uint64_t getAllocaSizeInBytes(AllocaInst *AI) const {
Type *Ty = AI->getAllocatedType(); Type *Ty = AI->getAllocatedType();
uint64_t SizeInBytes = DL->getTypeAllocSize(Ty); uint64_t SizeInBytes =
AI->getModule()->getDataLayout().getTypeAllocSize(Ty);
return SizeInBytes; return SizeInBytes;
} }
/// Check if we want (and can) handle this alloca. /// Check if we want (and can) handle this alloca.
Context not available.
uint64_t *TypeSize, uint64_t *TypeSize,
unsigned *Alignment) const; unsigned *Alignment) const;
void instrumentMop(ObjectSizeOffsetVisitor &ObjSizeVis, Instruction *I, void instrumentMop(ObjectSizeOffsetVisitor &ObjSizeVis, Instruction *I,
bool UseCalls); bool UseCalls, const DataLayout &DL);
void instrumentPointerComparisonOrSubtraction(Instruction *I); void instrumentPointerComparisonOrSubtraction(Instruction *I);
void instrumentAddress(Instruction *OrigIns, Instruction *InsertBefore, void instrumentAddress(Instruction *OrigIns, Instruction *InsertBefore,
Value *Addr, uint32_t TypeSize, bool IsWrite, Value *Addr, uint32_t TypeSize, bool IsWrite,
Context not available.
uint64_t TypeSize) const; uint64_t TypeSize) const;
LLVMContext *C; LLVMContext *C;
const DataLayout *DL;
Triple TargetTriple; Triple TargetTriple;
int LongSize; int LongSize;
Type *IntptrTy; Type *IntptrTy;
Context not available.
GlobalsMetadata GlobalsMD; GlobalsMetadata GlobalsMD;
Type *IntptrTy; Type *IntptrTy;
LLVMContext *C; LLVMContext *C;
const DataLayout *DL;
Triple TargetTriple; Triple TargetTriple;
ShadowMapping Mapping; ShadowMapping Mapping;
Function *AsanPoisonGlobals; Function *AsanPoisonGlobals;
Context not available.
// Right shift for BigEndian and left shift for LittleEndian. // Right shift for BigEndian and left shift for LittleEndian.
Value *shiftAllocaMagic(Value *Val, IRBuilder<> &IRB, Value *Shift) { Value *shiftAllocaMagic(Value *Val, IRBuilder<> &IRB, Value *Shift) {
return ASan.DL->isLittleEndian() ? IRB.CreateShl(Val, Shift) auto &DL = F.getParent()->getDataLayout();
: IRB.CreateLShr(Val, Shift); return DL.isLittleEndian() ? IRB.CreateShl(Val, Shift)
: IRB.CreateLShr(Val, Shift);
} }
// Compute PartialRzMagic for dynamic alloca call. Since we don't know the // Compute PartialRzMagic for dynamic alloca call. Since we don't know the
Context not available.
if (I->getMetadata("nosanitize")) return nullptr; if (I->getMetadata("nosanitize")) return nullptr;
Value *PtrOperand = nullptr; Value *PtrOperand = nullptr;
const DataLayout &DL = I->getModule()->getDataLayout();
if (LoadInst *LI = dyn_cast<LoadInst>(I)) { if (LoadInst *LI = dyn_cast<LoadInst>(I)) {
if (!ClInstrumentReads) return nullptr; if (!ClInstrumentReads) return nullptr;
*IsWrite = false; *IsWrite = false;
*TypeSize = DL->getTypeStoreSizeInBits(LI->getType()); *TypeSize = DL.getTypeStoreSizeInBits(LI->getType());
*Alignment = LI->getAlignment(); *Alignment = LI->getAlignment();
PtrOperand = LI->getPointerOperand(); PtrOperand = LI->getPointerOperand();
} else if (StoreInst *SI = dyn_cast<StoreInst>(I)) { } else if (StoreInst *SI = dyn_cast<StoreInst>(I)) {
if (!ClInstrumentWrites) return nullptr; if (!ClInstrumentWrites) return nullptr;
*IsWrite = true; *IsWrite = true;
*TypeSize = DL->getTypeStoreSizeInBits(SI->getValueOperand()->getType()); *TypeSize = DL.getTypeStoreSizeInBits(SI->getValueOperand()->getType());
*Alignment = SI->getAlignment(); *Alignment = SI->getAlignment();
PtrOperand = SI->getPointerOperand(); PtrOperand = SI->getPointerOperand();
} else if (AtomicRMWInst *RMW = dyn_cast<AtomicRMWInst>(I)) { } else if (AtomicRMWInst *RMW = dyn_cast<AtomicRMWInst>(I)) {
if (!ClInstrumentAtomics) return nullptr; if (!ClInstrumentAtomics) return nullptr;
*IsWrite = true; *IsWrite = true;
*TypeSize = DL->getTypeStoreSizeInBits(RMW->getValOperand()->getType()); *TypeSize = DL.getTypeStoreSizeInBits(RMW->getValOperand()->getType());
*Alignment = 0; *Alignment = 0;
PtrOperand = RMW->getPointerOperand(); PtrOperand = RMW->getPointerOperand();
} else if (AtomicCmpXchgInst *XCHG = dyn_cast<AtomicCmpXchgInst>(I)) { } else if (AtomicCmpXchgInst *XCHG = dyn_cast<AtomicCmpXchgInst>(I)) {
if (!ClInstrumentAtomics) return nullptr; if (!ClInstrumentAtomics) return nullptr;
*IsWrite = true; *IsWrite = true;
*TypeSize = *TypeSize = DL.getTypeStoreSizeInBits(XCHG->getCompareOperand()->getType());
DL->getTypeStoreSizeInBits(XCHG->getCompareOperand()->getType());
*Alignment = 0; *Alignment = 0;
PtrOperand = XCHG->getPointerOperand(); PtrOperand = XCHG->getPointerOperand();
} }
Context not available.
} }
void AddressSanitizer::instrumentMop(ObjectSizeOffsetVisitor &ObjSizeVis, void AddressSanitizer::instrumentMop(ObjectSizeOffsetVisitor &ObjSizeVis,
Instruction *I, bool UseCalls) { Instruction *I, bool UseCalls,
const DataLayout &DL) {
bool IsWrite = false; bool IsWrite = false;
unsigned Alignment = 0; unsigned Alignment = 0;
uint64_t TypeSize = 0; uint64_t TypeSize = 0;
Context not available.
if (ClOpt && ClOptGlobals) { if (ClOpt && ClOptGlobals) {
// If initialization order checking is disabled, a simple access to a // If initialization order checking is disabled, a simple access to a
// dynamically initialized global is always valid. // dynamically initialized global is always valid.
GlobalVariable *G = GlobalVariable *G = dyn_cast<GlobalVariable>(GetUnderlyingObject(Addr, DL));
dyn_cast<GlobalVariable>(GetUnderlyingObject(Addr, nullptr));
if (G != NULL && (!ClInitializers || GlobalIsLinkerInitialized(G)) && if (G != NULL && (!ClInitializers || GlobalIsLinkerInitialized(G)) &&
isSafeAccess(ObjSizeVis, Addr, TypeSize)) { isSafeAccess(ObjSizeVis, Addr, TypeSize)) {
NumOptimizedAccessesToGlobalVar++; NumOptimizedAccessesToGlobalVar++;
Context not available.
if (ClOpt && ClOptStack) { if (ClOpt && ClOptStack) {
// A direct inbounds access to a stack variable is always valid. // A direct inbounds access to a stack variable is always valid.
if (isa<AllocaInst>(GetUnderlyingObject(Addr, nullptr)) && if (isa<AllocaInst>(GetUnderlyingObject(Addr, DL)) &&
isSafeAccess(ObjSizeVis, Addr, TypeSize)) { isSafeAccess(ObjSizeVis, Addr, TypeSize)) {
NumOptimizedAccessesToStackVar++; NumOptimizedAccessesToStackVar++;
return; return;
Context not available.
GlobalVariable *ModuleName = createPrivateGlobalForString( GlobalVariable *ModuleName = createPrivateGlobalForString(
M, M.getModuleIdentifier(), /*AllowMerging*/ false); M, M.getModuleIdentifier(), /*AllowMerging*/ false);
auto &DL = M.getDataLayout();
for (size_t i = 0; i < n; i++) { for (size_t i = 0; i < n; i++) {
static const uint64_t kMaxGlobalRedzone = 1 << 18; static const uint64_t kMaxGlobalRedzone = 1 << 18;
GlobalVariable *G = GlobalsToChange[i]; GlobalVariable *G = GlobalsToChange[i];
Context not available.
PointerType *PtrTy = cast<PointerType>(G->getType()); PointerType *PtrTy = cast<PointerType>(G->getType());
Type *Ty = PtrTy->getElementType(); Type *Ty = PtrTy->getElementType();
uint64_t SizeInBytes = DL->getTypeAllocSize(Ty); uint64_t SizeInBytes = DL.getTypeAllocSize(Ty);
uint64_t MinRZ = MinRedzoneSizeForGlobal(); uint64_t MinRZ = MinRedzoneSizeForGlobal();
// MinRZ <= RZ <= kMaxGlobalRedzone // MinRZ <= RZ <= kMaxGlobalRedzone
// and trying to make RZ to be ~ 1/4 of SizeInBytes. // and trying to make RZ to be ~ 1/4 of SizeInBytes.
Context not available.
} }
bool AddressSanitizerModule::runOnModule(Module &M) { bool AddressSanitizerModule::runOnModule(Module &M) {
DL = &M.getDataLayout();
C = &(M.getContext()); C = &(M.getContext());
int LongSize = DL->getPointerSizeInBits(); int LongSize = M.getDataLayout().getPointerSizeInBits();
IntptrTy = Type::getIntNTy(*C, LongSize); IntptrTy = Type::getIntNTy(*C, LongSize);
TargetTriple = Triple(M.getTargetTriple()); TargetTriple = Triple(M.getTargetTriple());
Mapping = getShadowMapping(TargetTriple, LongSize); Mapping = getShadowMapping(TargetTriple, LongSize);
Context not available.
// virtual // virtual
bool AddressSanitizer::doInitialization(Module &M) { bool AddressSanitizer::doInitialization(Module &M) {
// Initialize the private fields. No one has accessed them before. // Initialize the private fields. No one has accessed them before.
DL = &M.getDataLayout();
GlobalsMD.init(M); GlobalsMD.init(M);
C = &(M.getContext()); C = &(M.getContext());
LongSize = DL->getPointerSizeInBits(); LongSize = M.getDataLayout().getPointerSizeInBits();
IntptrTy = Type::getIntNTy(*C, LongSize); IntptrTy = Type::getIntNTy(*C, LongSize);
TargetTriple = Triple(M.getTargetTriple()); TargetTriple = Triple(M.getTargetTriple());
Context not available.
const TargetLibraryInfo *TLI = const TargetLibraryInfo *TLI =
&getAnalysis<TargetLibraryInfoWrapperPass>().getTLI(); &getAnalysis<TargetLibraryInfoWrapperPass>().getTLI();
const DataLayout &DL = F.getParent()->getDataLayout();
ObjectSizeOffsetVisitor ObjSizeVis(DL, TLI, F.getContext(), ObjectSizeOffsetVisitor ObjSizeVis(DL, TLI, F.getContext(),
/*RoundToAlign=*/true); /*RoundToAlign=*/true);
Context not available.
if (ClDebugMin < 0 || ClDebugMax < 0 || if (ClDebugMin < 0 || ClDebugMax < 0 ||
(NumInstrumented >= ClDebugMin && NumInstrumented <= ClDebugMax)) { (NumInstrumented >= ClDebugMin && NumInstrumented <= ClDebugMax)) {
if (isInterestingMemoryAccess(Inst, &IsWrite, &TypeSize, &Alignment)) if (isInterestingMemoryAccess(Inst, &IsWrite, &TypeSize, &Alignment))
instrumentMop(ObjSizeVis, Inst, UseCalls); instrumentMop(ObjSizeVis, Inst, UseCalls,
F.getParent()->getDataLayout());
else else
instrumentMemIntrinsic(cast<MemIntrinsic>(Inst)); instrumentMemIntrinsic(cast<MemIntrinsic>(Inst));
} }
Context not available.
for (; i + LargeStoreSizeInBytes - 1 < n; i += LargeStoreSizeInBytes) { for (; i + LargeStoreSizeInBytes - 1 < n; i += LargeStoreSizeInBytes) {
uint64_t Val = 0; uint64_t Val = 0;
for (size_t j = 0; j < LargeStoreSizeInBytes; j++) { for (size_t j = 0; j < LargeStoreSizeInBytes; j++) {
if (ASan.DL->isLittleEndian()) if (F.getParent()->getDataLayout().isLittleEndian())
Val |= (uint64_t)ShadowBytes[i + j] << (8 * j); Val |= (uint64_t)ShadowBytes[i + j] << (8 * j);
else else
Val = (Val << 8) | ShadowBytes[i + j]; Val = (Val << 8) | ShadowBytes[i + j];
Context not available.
Value *Shift = IRB.CreateAnd(PartialSize, IRB.getInt32(~7)); Value *Shift = IRB.CreateAnd(PartialSize, IRB.getInt32(~7));
unsigned Val1Int = kAsanAllocaPartialVal1; unsigned Val1Int = kAsanAllocaPartialVal1;
unsigned Val2Int = kAsanAllocaPartialVal2; unsigned Val2Int = kAsanAllocaPartialVal2;
if (!ASan.DL->isLittleEndian()) { if (!F.getParent()->getDataLayout().isLittleEndian()) {
Val1Int = sys::getSwappedBytes(Val1Int); Val1Int = sys::getSwappedBytes(Val1Int);
Val2Int = sys::getSwappedBytes(Val2Int); Val2Int = sys::getSwappedBytes(Val2Int);
} }
Value *Val1 = shiftAllocaMagic(IRB.getInt32(Val1Int), IRB, Shift); Value *Val1 = shiftAllocaMagic(IRB.getInt32(Val1Int), IRB, Shift);
Value *PartialBits = IRB.CreateAnd(PartialSize, IRB.getInt32(7)); Value *PartialBits = IRB.CreateAnd(PartialSize, IRB.getInt32(7));
// For BigEndian get 0x000000YZ -> 0xYZ000000. // For BigEndian get 0x000000YZ -> 0xYZ000000.
if (ASan.DL->isBigEndian()) if (F.getParent()->getDataLayout().isBigEndian())
PartialBits = IRB.CreateShl(PartialBits, IRB.getInt32(24)); PartialBits = IRB.CreateShl(PartialBits, IRB.getInt32(24));
Value *Val2 = IRB.getInt32(Val2Int); Value *Val2 = IRB.getInt32(Val2Int);
Value *Cond = Value *Cond =
Context not available.
// redzones, and OldSize is number of allocated blocks with // redzones, and OldSize is number of allocated blocks with
// ElementSize size, get allocated memory size in bytes by // ElementSize size, get allocated memory size in bytes by
// OldSize * ElementSize. // OldSize * ElementSize.
unsigned ElementSize = ASan.DL->getTypeAllocSize(AI->getAllocatedType()); unsigned ElementSize =
F.getParent()->getDataLayout().getTypeAllocSize(AI->getAllocatedType());
Value *OldSize = IRB.CreateMul(AI->getArraySize(), Value *OldSize = IRB.CreateMul(AI->getArraySize(),
ConstantInt::get(IntptrTy, ElementSize)); ConstantInt::get(IntptrTy, ElementSize));
Context not available.

lib/Transforms/Instrumentation/BoundsChecking.cpp

Context not available.
} }
private: private:
const DataLayout *DL;
const TargetLibraryInfo *TLI; const TargetLibraryInfo *TLI;
ObjectSizeOffsetEvaluator *ObjSizeEval; ObjectSizeOffsetEvaluator *ObjSizeEval;
BuilderTy *Builder; BuilderTy *Builder;
Context not available.
BasicBlock *getTrapBB(); BasicBlock *getTrapBB();
void emitBranchToTrap(Value *Cmp = nullptr); void emitBranchToTrap(Value *Cmp = nullptr);
bool instrument(Value *Ptr, Value *Val); bool instrument(Value *Ptr, Value *Val, const DataLayout &DL);
}; };
} }
Context not available.
/// result from the load or the value being stored. It is used to determine the /// result from the load or the value being stored. It is used to determine the
/// size of memory block that is touched. /// size of memory block that is touched.
/// Returns true if any change was made to the IR, false otherwise. /// Returns true if any change was made to the IR, false otherwise.
bool BoundsChecking::instrument(Value *Ptr, Value *InstVal) { bool BoundsChecking::instrument(Value *Ptr, Value *InstVal,
uint64_t NeededSize = DL->getTypeStoreSize(InstVal->getType()); const DataLayout &DL) {
uint64_t NeededSize = DL.getTypeStoreSize(InstVal->getType());
DEBUG(dbgs() << "Instrument " << *Ptr << " for " << Twine(NeededSize) DEBUG(dbgs() << "Instrument " << *Ptr << " for " << Twine(NeededSize)
<< " bytes\n"); << " bytes\n");
Context not available.
Value *Offset = SizeOffset.second; Value *Offset = SizeOffset.second;
ConstantInt *SizeCI = dyn_cast<ConstantInt>(Size); ConstantInt *SizeCI = dyn_cast<ConstantInt>(Size);
Type *IntTy = DL->getIntPtrType(Ptr->getType()); Type *IntTy = DL.getIntPtrType(Ptr->getType());
Value *NeededSizeVal = ConstantInt::get(IntTy, NeededSize); Value *NeededSizeVal = ConstantInt::get(IntTy, NeededSize);
// three checks are required to ensure safety: // three checks are required to ensure safety:
Context not available.
} }
bool BoundsChecking::runOnFunction(Function &F) { bool BoundsChecking::runOnFunction(Function &F) {
DL = &F.getParent()->getDataLayout(); const DataLayout &DL = F.getParent()->getDataLayout();
TLI = &getAnalysis<TargetLibraryInfoWrapperPass>().getTLI(); TLI = &getAnalysis<TargetLibraryInfoWrapperPass>().getTLI();
TrapBB = nullptr; TrapBB = nullptr;
Context not available.
Builder->SetInsertPoint(Inst); Builder->SetInsertPoint(Inst);
if (LoadInst *LI = dyn_cast<LoadInst>(Inst)) { if (LoadInst *LI = dyn_cast<LoadInst>(Inst)) {
MadeChange |= instrument(LI->getPointerOperand(), LI); MadeChange |= instrument(LI->getPointerOperand(), LI, DL);
} else if (StoreInst *SI = dyn_cast<StoreInst>(Inst)) { } else if (StoreInst *SI = dyn_cast<StoreInst>(Inst)) {
MadeChange |= instrument(SI->getPointerOperand(), SI->getValueOperand()); MadeChange |=
instrument(SI->getPointerOperand(), SI->getValueOperand(), DL);
} else if (AtomicCmpXchgInst *AI = dyn_cast<AtomicCmpXchgInst>(Inst)) { } else if (AtomicCmpXchgInst *AI = dyn_cast<AtomicCmpXchgInst>(Inst)) {
MadeChange |= instrument(AI->getPointerOperand(),AI->getCompareOperand()); MadeChange |=
instrument(AI->getPointerOperand(), AI->getCompareOperand(), DL);
} else if (AtomicRMWInst *AI = dyn_cast<AtomicRMWInst>(Inst)) { } else if (AtomicRMWInst *AI = dyn_cast<AtomicRMWInst>(Inst)) {
MadeChange |= instrument(AI->getPointerOperand(), AI->getValOperand()); MadeChange |=
instrument(AI->getPointerOperand(), AI->getValOperand(), DL);
} else { } else {
llvm_unreachable("unknown Instruction type"); llvm_unreachable("unknown Instruction type");
} }
Context not available.

lib/Transforms/Instrumentation/DataFlowSanitizer.cpp

Context not available.
WK_Custom WK_Custom
}; };
const DataLayout *DL;
Module *Mod; Module *Mod;
LLVMContext *Ctx; LLVMContext *Ctx;
IntegerType *ShadowTy; IntegerType *ShadowTy;
Context not available.
bool IsMIPS64 = TargetTriple.getArch() == llvm::Triple::mips64 || bool IsMIPS64 = TargetTriple.getArch() == llvm::Triple::mips64 ||
TargetTriple.getArch() == llvm::Triple::mips64el; TargetTriple.getArch() == llvm::Triple::mips64el;
DL = &M.getDataLayout(); const DataLayout &DL = M.getDataLayout();
Mod = &M; Mod = &M;
Ctx = &M.getContext(); Ctx = &M.getContext();
ShadowTy = IntegerType::get(*Ctx, ShadowWidth); ShadowTy = IntegerType::get(*Ctx, ShadowWidth);
ShadowPtrTy = PointerType::getUnqual(ShadowTy); ShadowPtrTy = PointerType::getUnqual(ShadowTy);
IntptrTy = DL->getIntPtrType(*Ctx); IntptrTy = DL.getIntPtrType(*Ctx);
ZeroShadow = ConstantInt::getSigned(ShadowTy, 0); ZeroShadow = ConstantInt::getSigned(ShadowTy, 0);
ShadowPtrMul = ConstantInt::getSigned(IntptrTy, ShadowWidth / 8); ShadowPtrMul = ConstantInt::getSigned(IntptrTy, ShadowWidth / 8);
if (IsX86_64) if (IsX86_64)
Context not available.
uint64_t ShadowAlign = Align * DFS.ShadowWidth / 8; uint64_t ShadowAlign = Align * DFS.ShadowWidth / 8;
SmallVector<Value *, 2> Objs; SmallVector<Value *, 2> Objs;
GetUnderlyingObjects(Addr, Objs, DFS.DL); GetUnderlyingObjects(Addr, Objs, Pos->getModule()->getDataLayout());
bool AllConstants = true; bool AllConstants = true;
for (SmallVector<Value *, 2>::iterator i = Objs.begin(), e = Objs.end(); for (SmallVector<Value *, 2>::iterator i = Objs.begin(), e = Objs.end();
i != e; ++i) { i != e; ++i) {
Context not available.
} }
void DFSanVisitor::visitLoadInst(LoadInst &LI) { void DFSanVisitor::visitLoadInst(LoadInst &LI) {
uint64_t Size = DFSF.DFS.DL->getTypeStoreSize(LI.getType()); auto &DL = LI.getModule()->getDataLayout();
uint64_t Size = DL.getTypeStoreSize(LI.getType());
if (Size == 0) { if (Size == 0) {
DFSF.setShadow(&LI, DFSF.DFS.ZeroShadow); DFSF.setShadow(&LI, DFSF.DFS.ZeroShadow);
return; return;
Context not available.
if (ClPreserveAlignment) { if (ClPreserveAlignment) {
Align = LI.getAlignment(); Align = LI.getAlignment();
if (Align == 0) if (Align == 0)
Align = DFSF.DFS.DL->getABITypeAlignment(LI.getType()); Align = DL.getABITypeAlignment(LI.getType());
} else { } else {
Align = 1; Align = 1;
} }
Context not available.
} }
void DFSanVisitor::visitStoreInst(StoreInst &SI) { void DFSanVisitor::visitStoreInst(StoreInst &SI) {
uint64_t Size = auto &DL = SI.getModule()->getDataLayout();
DFSF.DFS.DL->getTypeStoreSize(SI.getValueOperand()->getType()); uint64_t Size = DL.getTypeStoreSize(SI.getValueOperand()->getType());
if (Size == 0) if (Size == 0)
return; return;
Context not available.
if (ClPreserveAlignment) { if (ClPreserveAlignment) {
Align = SI.getAlignment(); Align = SI.getAlignment();
if (Align == 0) if (Align == 0)
Align = DFSF.DFS.DL->getABITypeAlignment(SI.getValueOperand()->getType()); Align = DL.getABITypeAlignment(SI.getValueOperand()->getType());
} else { } else {
Align = 1; Align = 1;
} }
Context not available.

lib/Transforms/Instrumentation/MemorySanitizer.cpp

Context not available.
MemorySanitizer(int TrackOrigins = 0) MemorySanitizer(int TrackOrigins = 0)
: FunctionPass(ID), : FunctionPass(ID),
TrackOrigins(std::max(TrackOrigins, (int)ClTrackOrigins)), TrackOrigins(std::max(TrackOrigins, (int)ClTrackOrigins)),
DL(nullptr),
WarningFn(nullptr) {} WarningFn(nullptr) {}
const char *getPassName() const override { return "MemorySanitizer"; } const char *getPassName() const override { return "MemorySanitizer"; }
bool runOnFunction(Function &F) override; bool runOnFunction(Function &F) override;
Context not available.
/// \brief Track origins (allocation points) of uninitialized values. /// \brief Track origins (allocation points) of uninitialized values.
int TrackOrigins; int TrackOrigins;
const DataLayout *DL;
LLVMContext *C; LLVMContext *C;
Type *IntptrTy; Type *IntptrTy;
Type *OriginTy; Type *OriginTy;
Context not available.
/// ///
/// inserts a call to __msan_init to the module's constructor list. /// inserts a call to __msan_init to the module's constructor list.
bool MemorySanitizer::doInitialization(Module &M) { bool MemorySanitizer::doInitialization(Module &M) {
DL = &M.getDataLayout(); auto &DL = M.getDataLayout();
Triple TargetTriple(M.getTargetTriple()); Triple TargetTriple(M.getTargetTriple());
switch (TargetTriple.getOS()) { switch (TargetTriple.getOS()) {
Context not available.
} }
Value *originToIntptr(IRBuilder<> &IRB, Value *Origin) { Value *originToIntptr(IRBuilder<> &IRB, Value *Origin) {
unsigned IntptrSize = MS.DL->getTypeStoreSize(MS.IntptrTy); const DataLayout &DL = F.getParent()->getDataLayout();
unsigned IntptrSize = DL.getTypeStoreSize(MS.IntptrTy);
if (IntptrSize == kOriginSize) return Origin; if (IntptrSize == kOriginSize) return Origin;
assert(IntptrSize == kOriginSize * 2); assert(IntptrSize == kOriginSize * 2);
Origin = IRB.CreateIntCast(Origin, MS.IntptrTy, /* isSigned */ false); Origin = IRB.CreateIntCast(Origin, MS.IntptrTy, /* isSigned */ false);
Context not available.
/// \brief Fill memory range with the given origin value. /// \brief Fill memory range with the given origin value.
void paintOrigin(IRBuilder<> &IRB, Value *Origin, Value *OriginPtr, void paintOrigin(IRBuilder<> &IRB, Value *Origin, Value *OriginPtr,
unsigned Size, unsigned Alignment) { unsigned Size, unsigned Alignment) {
unsigned IntptrAlignment = MS.DL->getABITypeAlignment(MS.IntptrTy); const DataLayout &DL = F.getParent()->getDataLayout();
unsigned IntptrSize = MS.DL->getTypeStoreSize(MS.IntptrTy); unsigned IntptrAlignment = DL.getABITypeAlignment(MS.IntptrTy);
unsigned IntptrSize = DL.getTypeStoreSize(MS.IntptrTy);
assert(IntptrAlignment >= kMinOriginAlignment); assert(IntptrAlignment >= kMinOriginAlignment);
assert(IntptrSize >= kOriginSize); assert(IntptrSize >= kOriginSize);
Context not available.
void storeOrigin(IRBuilder<> &IRB, Value *Addr, Value *Shadow, Value *Origin, void storeOrigin(IRBuilder<> &IRB, Value *Addr, Value *Shadow, Value *Origin,
unsigned Alignment, bool AsCall) { unsigned Alignment, bool AsCall) {
const DataLayout &DL = F.getParent()->getDataLayout();
unsigned OriginAlignment = std::max(kMinOriginAlignment, Alignment); unsigned OriginAlignment = std::max(kMinOriginAlignment, Alignment);
unsigned StoreSize = MS.DL->getTypeStoreSize(Shadow->getType()); unsigned StoreSize = DL.getTypeStoreSize(Shadow->getType());
if (isa<StructType>(Shadow->getType())) { if (isa<StructType>(Shadow->getType())) {
paintOrigin(IRB, updateOrigin(Origin, IRB), paintOrigin(IRB, updateOrigin(Origin, IRB),
getOriginPtr(Addr, IRB, Alignment), StoreSize, getOriginPtr(Addr, IRB, Alignment), StoreSize,
Context not available.
} }
unsigned TypeSizeInBits = unsigned TypeSizeInBits =
MS.DL->getTypeSizeInBits(ConvertedShadow->getType()); DL.getTypeSizeInBits(ConvertedShadow->getType());
unsigned SizeIndex = TypeSizeToSizeIndex(TypeSizeInBits); unsigned SizeIndex = TypeSizeToSizeIndex(TypeSizeInBits);
if (AsCall && SizeIndex < kNumberOfAccessSizes) { if (AsCall && SizeIndex < kNumberOfAccessSizes) {
Value *Fn = MS.MaybeStoreOriginFn[SizeIndex]; Value *Fn = MS.MaybeStoreOriginFn[SizeIndex];
Context not available.
return; return;
} }
unsigned TypeSizeInBits = const DataLayout &DL = OrigIns->getModule()->getDataLayout();
MS.DL->getTypeSizeInBits(ConvertedShadow->getType());
unsigned TypeSizeInBits = DL.getTypeSizeInBits(ConvertedShadow->getType());
unsigned SizeIndex = TypeSizeToSizeIndex(TypeSizeInBits); unsigned SizeIndex = TypeSizeToSizeIndex(TypeSizeInBits);
if (AsCall && SizeIndex < kNumberOfAccessSizes) { if (AsCall && SizeIndex < kNumberOfAccessSizes) {
Value *Fn = MS.MaybeWarningFn[SizeIndex]; Value *Fn = MS.MaybeWarningFn[SizeIndex];
Context not available.
/// \brief Add MemorySanitizer instrumentation to a function. /// \brief Add MemorySanitizer instrumentation to a function.
bool runOnFunction() { bool runOnFunction() {
MS.initializeCallbacks(*F.getParent()); MS.initializeCallbacks(*F.getParent());
if (!MS.DL) return false;
// In the presence of unreachable blocks, we may see Phi nodes with // In the presence of unreachable blocks, we may see Phi nodes with
// incoming nodes from such blocks. Since InstVisitor skips unreachable // incoming nodes from such blocks. Since InstVisitor skips unreachable
Context not available.
// This may return weird-sized types like i1. // This may return weird-sized types like i1.
if (IntegerType *IT = dyn_cast<IntegerType>(OrigTy)) if (IntegerType *IT = dyn_cast<IntegerType>(OrigTy))
return IT; return IT;
const DataLayout &DL = F.getParent()->getDataLayout();
if (VectorType *VT = dyn_cast<VectorType>(OrigTy)) { if (VectorType *VT = dyn_cast<VectorType>(OrigTy)) {
uint32_t EltSize = MS.DL->getTypeSizeInBits(VT->getElementType()); uint32_t EltSize = DL.getTypeSizeInBits(VT->getElementType());
return VectorType::get(IntegerType::get(*MS.C, EltSize), return VectorType::get(IntegerType::get(*MS.C, EltSize),
VT->getNumElements()); VT->getNumElements());
} }
Context not available.
DEBUG(dbgs() << "getShadowTy: " << *ST << " ===> " << *Res << "\n"); DEBUG(dbgs() << "getShadowTy: " << *ST << " ===> " << *Res << "\n");
return Res; return Res;
} }
uint32_t TypeSize = MS.DL->getTypeSizeInBits(OrigTy); uint32_t TypeSize = DL.getTypeSizeInBits(OrigTy);
return IntegerType::get(*MS.C, TypeSize); return IntegerType::get(*MS.C, TypeSize);
} }
Context not available.
Function *F = A->getParent(); Function *F = A->getParent();
IRBuilder<> EntryIRB(F->getEntryBlock().getFirstNonPHI()); IRBuilder<> EntryIRB(F->getEntryBlock().getFirstNonPHI());
unsigned ArgOffset = 0; unsigned ArgOffset = 0;
const DataLayout &DL = F->getParent()->getDataLayout();
for (auto &FArg : F->args()) { for (auto &FArg : F->args()) {
if (!FArg.getType()->isSized()) { if (!FArg.getType()->isSized()) {
DEBUG(dbgs() << "Arg is not sized\n"); DEBUG(dbgs() << "Arg is not sized\n");
continue; continue;
} }
unsigned Size = FArg.hasByValAttr() unsigned Size =
? MS.DL->getTypeAllocSize(FArg.getType()->getPointerElementType()) FArg.hasByValAttr()
: MS.DL->getTypeAllocSize(FArg.getType()); ? DL.getTypeAllocSize(FArg.getType()->getPointerElementType())
: DL.getTypeAllocSize(FArg.getType());
if (A == &FArg) { if (A == &FArg) {
bool Overflow = ArgOffset + Size > kParamTLSSize; bool Overflow = ArgOffset + Size > kParamTLSSize;
Value *Base = getShadowPtrForArgument(&FArg, EntryIRB, ArgOffset); Value *Base = getShadowPtrForArgument(&FArg, EntryIRB, ArgOffset);
Context not available.
unsigned ArgAlign = FArg.getParamAlignment(); unsigned ArgAlign = FArg.getParamAlignment();
if (ArgAlign == 0) { if (ArgAlign == 0) {
Type *EltType = A->getType()->getPointerElementType(); Type *EltType = A->getType()->getPointerElementType();
ArgAlign = MS.DL->getABITypeAlignment(EltType); ArgAlign = DL.getABITypeAlignment(EltType);
} }
if (Overflow) { if (Overflow) {
// ParamTLS overflow. // ParamTLS overflow.
Context not available.
DEBUG(dbgs() << " Arg#" << i << ": " << *A << DEBUG(dbgs() << " Arg#" << i << ": " << *A <<
" Shadow: " << *ArgShadow << "\n"); " Shadow: " << *ArgShadow << "\n");
bool ArgIsInitialized = false; bool ArgIsInitialized = false;
const DataLayout &DL = F.getParent()->getDataLayout();
if (CS.paramHasAttr(i + 1, Attribute::ByVal)) { if (CS.paramHasAttr(i + 1, Attribute::ByVal)) {
assert(A->getType()->isPointerTy() && assert(A->getType()->isPointerTy() &&
"ByVal argument is not a pointer!"); "ByVal argument is not a pointer!");
Size = MS.DL->getTypeAllocSize(A->getType()->getPointerElementType()); Size = DL.getTypeAllocSize(A->getType()->getPointerElementType());
if (ArgOffset + Size > kParamTLSSize) break; if (ArgOffset + Size > kParamTLSSize) break;
unsigned ParamAlignment = CS.getParamAlignment(i + 1); unsigned ParamAlignment = CS.getParamAlignment(i + 1);
unsigned Alignment = std::min(ParamAlignment, kShadowTLSAlignment); unsigned Alignment = std::min(ParamAlignment, kShadowTLSAlignment);
Context not available.
getShadowPtr(A, Type::getInt8Ty(*MS.C), IRB), getShadowPtr(A, Type::getInt8Ty(*MS.C), IRB),
Size, Alignment); Size, Alignment);
} else { } else {
Size = MS.DL->getTypeAllocSize(A->getType()); Size = DL.getTypeAllocSize(A->getType());
if (ArgOffset + Size > kParamTLSSize) break; if (ArgOffset + Size > kParamTLSSize) break;
Store = IRB.CreateAlignedStore(ArgShadow, ArgShadowBase, Store = IRB.CreateAlignedStore(ArgShadow, ArgShadowBase,
kShadowTLSAlignment); kShadowTLSAlignment);
Context not available.
setShadow(&I, getCleanShadow(&I)); setShadow(&I, getCleanShadow(&I));
setOrigin(&I, getCleanOrigin()); setOrigin(&I, getCleanOrigin());
IRBuilder<> IRB(I.getNextNode()); IRBuilder<> IRB(I.getNextNode());
uint64_t Size = MS.DL->getTypeAllocSize(I.getAllocatedType()); const DataLayout &DL = F.getParent()->getDataLayout();
uint64_t Size = DL.getTypeAllocSize(I.getAllocatedType());
if (PoisonStack && ClPoisonStackWithCall) { if (PoisonStack && ClPoisonStackWithCall) {
IRB.CreateCall2(MS.MsanPoisonStackFn, IRB.CreateCall2(MS.MsanPoisonStackFn,
IRB.CreatePointerCast(&I, IRB.getInt8PtrTy()), IRB.CreatePointerCast(&I, IRB.getInt8PtrTy()),
Context not available.
unsigned GpOffset = 0; unsigned GpOffset = 0;
unsigned FpOffset = AMD64GpEndOffset; unsigned FpOffset = AMD64GpEndOffset;
unsigned OverflowOffset = AMD64FpEndOffset; unsigned OverflowOffset = AMD64FpEndOffset;
const DataLayout &DL = F.getParent()->getDataLayout();
for (CallSite::arg_iterator ArgIt = CS.arg_begin(), End = CS.arg_end(); for (CallSite::arg_iterator ArgIt = CS.arg_begin(), End = CS.arg_end();
ArgIt != End; ++ArgIt) { ArgIt != End; ++ArgIt) {
Value *A = *ArgIt; Value *A = *ArgIt;
Context not available.
// ByVal arguments always go to the overflow area. // ByVal arguments always go to the overflow area.
assert(A->getType()->isPointerTy()); assert(A->getType()->isPointerTy());
Type *RealTy = A->getType()->getPointerElementType(); Type *RealTy = A->getType()->getPointerElementType();
uint64_t ArgSize = MS.DL->getTypeAllocSize(RealTy); uint64_t ArgSize = DL.getTypeAllocSize(RealTy);
Value *Base = getShadowPtrForVAArgument(RealTy, IRB, OverflowOffset); Value *Base = getShadowPtrForVAArgument(RealTy, IRB, OverflowOffset);
OverflowOffset += RoundUpToAlignment(ArgSize, 8); OverflowOffset += RoundUpToAlignment(ArgSize, 8);
IRB.CreateMemCpy(Base, MSV.getShadowPtr(A, IRB.getInt8Ty(), IRB), IRB.CreateMemCpy(Base, MSV.getShadowPtr(A, IRB.getInt8Ty(), IRB),
Context not available.
FpOffset += 16; FpOffset += 16;
break; break;
case AK_Memory: case AK_Memory:
uint64_t ArgSize = MS.DL->getTypeAllocSize(A->getType()); uint64_t ArgSize = DL.getTypeAllocSize(A->getType());
Base = getShadowPtrForVAArgument(A->getType(), IRB, OverflowOffset); Base = getShadowPtrForVAArgument(A->getType(), IRB, OverflowOffset);
OverflowOffset += RoundUpToAlignment(ArgSize, 8); OverflowOffset += RoundUpToAlignment(ArgSize, 8);
} }
Context not available.
void visitCallSite(CallSite &CS, IRBuilder<> &IRB) override { void visitCallSite(CallSite &CS, IRBuilder<> &IRB) override {
unsigned VAArgOffset = 0; unsigned VAArgOffset = 0;
const DataLayout &DL = F.getParent()->getDataLayout();
for (CallSite::arg_iterator ArgIt = CS.arg_begin() + 1, End = CS.arg_end(); for (CallSite::arg_iterator ArgIt = CS.arg_begin() + 1, End = CS.arg_end();
ArgIt != End; ++ArgIt) { ArgIt != End; ++ArgIt) {
Value *A = *ArgIt; Value *A = *ArgIt;
Value *Base; Value *Base;
uint64_t ArgSize = MS.DL->getTypeAllocSize(A->getType()); uint64_t ArgSize = DL.getTypeAllocSize(A->getType());
#if defined(__MIPSEB__) || defined(MIPSEB) #if defined(__MIPSEB__) || defined(MIPSEB)
// Adjusting the shadow for argument with size < 8 to match the placement // Adjusting the shadow for argument with size < 8 to match the placement
// of bits in big endian system // of bits in big endian system
Context not available.

lib/Transforms/Instrumentation/ThreadSanitizer.cpp

Context not available.
/// ThreadSanitizer: instrument the code in module to find races. /// ThreadSanitizer: instrument the code in module to find races.
struct ThreadSanitizer : public FunctionPass { struct ThreadSanitizer : public FunctionPass {
ThreadSanitizer() : FunctionPass(ID), DL(nullptr) {} ThreadSanitizer() : FunctionPass(ID) {}
const char *getPassName() const override; const char *getPassName() const override;
bool runOnFunction(Function &F) override; bool runOnFunction(Function &F) override;
bool doInitialization(Module &M) override; bool doInitialization(Module &M) override;
Context not available.
private: private:
void initializeCallbacks(Module &M); void initializeCallbacks(Module &M);
bool instrumentLoadOrStore(Instruction *I); bool instrumentLoadOrStore(Instruction *I, const DataLayout &DL);
bool instrumentAtomic(Instruction *I); bool instrumentAtomic(Instruction *I, const DataLayout &DL);
bool instrumentMemIntrinsic(Instruction *I); bool instrumentMemIntrinsic(Instruction *I);
void chooseInstructionsToInstrument(SmallVectorImpl<Instruction*> &Local, void chooseInstructionsToInstrument(SmallVectorImpl<Instruction *> &Local,
SmallVectorImpl<Instruction*> &All); SmallVectorImpl<Instruction *> &All,
const DataLayout &DL);
bool addrPointsToConstantData(Value *Addr); bool addrPointsToConstantData(Value *Addr);
int getMemoryAccessFuncIndex(Value *Addr); int getMemoryAccessFuncIndex(Value *Addr, const DataLayout &DL);
const DataLayout *DL;
Type *IntptrTy; Type *IntptrTy;
IntegerType *OrdTy; IntegerType *OrdTy;
// Callbacks to run-time library are computed in doInitialization. // Callbacks to run-time library are computed in doInitialization.
Context not available.
} }
bool ThreadSanitizer::doInitialization(Module &M) { bool ThreadSanitizer::doInitialization(Module &M) {
DL = &M.getDataLayout(); const DataLayout &DL = M.getDataLayout();
// Always insert a call to __tsan_init into the module's CTORs. // Always insert a call to __tsan_init into the module's CTORs.
IRBuilder<> IRB(M.getContext()); IRBuilder<> IRB(M.getContext());
Context not available.
// 'Local' is a vector of insns within the same BB (no calls between). // 'Local' is a vector of insns within the same BB (no calls between).
// 'All' is a vector of insns that will be instrumented. // 'All' is a vector of insns that will be instrumented.
void ThreadSanitizer::chooseInstructionsToInstrument( void ThreadSanitizer::chooseInstructionsToInstrument(
SmallVectorImpl<Instruction*> &Local, SmallVectorImpl<Instruction *> &Local, SmallVectorImpl<Instruction *> &All,
SmallVectorImpl<Instruction*> &All) { const DataLayout &DL) {
SmallSet<Value*, 8> WriteTargets; SmallSet<Value*, 8> WriteTargets;
// Iterate from the end. // Iterate from the end.
for (SmallVectorImpl<Instruction*>::reverse_iterator It = Local.rbegin(), for (SmallVectorImpl<Instruction*>::reverse_iterator It = Local.rbegin(),
Context not available.
Value *Addr = isa<StoreInst>(*I) Value *Addr = isa<StoreInst>(*I)
? cast<StoreInst>(I)->getPointerOperand() ? cast<StoreInst>(I)->getPointerOperand()
: cast<LoadInst>(I)->getPointerOperand(); : cast<LoadInst>(I)->getPointerOperand();
if (isa<AllocaInst>(GetUnderlyingObject(Addr, nullptr)) && if (isa<AllocaInst>(GetUnderlyingObject(Addr, DL)) &&
!PointerMayBeCaptured(Addr, true, true)) { !PointerMayBeCaptured(Addr, true, true)) {
// The variable is addressable but not captured, so it cannot be // The variable is addressable but not captured, so it cannot be
// referenced from a different thread and participate in a data race // referenced from a different thread and participate in a data race
Context not available.
} }
bool ThreadSanitizer::runOnFunction(Function &F) { bool ThreadSanitizer::runOnFunction(Function &F) {
if (!DL) return false;
initializeCallbacks(*F.getParent()); initializeCallbacks(*F.getParent());
SmallVector<Instruction*, 8> RetVec; SmallVector<Instruction*, 8> RetVec;
SmallVector<Instruction*, 8> AllLoadsAndStores; SmallVector<Instruction*, 8> AllLoadsAndStores;
Context not available.
bool Res = false; bool Res = false;
bool HasCalls = false; bool HasCalls = false;
bool SanitizeFunction = F.hasFnAttribute(Attribute::SanitizeThread); bool SanitizeFunction = F.hasFnAttribute(Attribute::SanitizeThread);
const DataLayout &DL = F.getParent()->getDataLayout();
// Traverse all instructions, collect loads/stores/returns, check for calls. // Traverse all instructions, collect loads/stores/returns, check for calls.
for (auto &BB : F) { for (auto &BB : F) {
Context not available.
if (isa<MemIntrinsic>(Inst)) if (isa<MemIntrinsic>(Inst))
MemIntrinCalls.push_back(&Inst); MemIntrinCalls.push_back(&Inst);
HasCalls = true; HasCalls = true;
chooseInstructionsToInstrument(LocalLoadsAndStores, AllLoadsAndStores); chooseInstructionsToInstrument(LocalLoadsAndStores, AllLoadsAndStores,
DL);
} }
} }
chooseInstructionsToInstrument(LocalLoadsAndStores, AllLoadsAndStores); chooseInstructionsToInstrument(LocalLoadsAndStores, AllLoadsAndStores, DL);
} }
// We have collected all loads and stores. // We have collected all loads and stores.
Context not available.
// Instrument memory accesses only if we want to report bugs in the function. // Instrument memory accesses only if we want to report bugs in the function.
if (ClInstrumentMemoryAccesses && SanitizeFunction) if (ClInstrumentMemoryAccesses && SanitizeFunction)
for (auto Inst : AllLoadsAndStores) { for (auto Inst : AllLoadsAndStores) {
Res |= instrumentLoadOrStore(Inst); Res |= instrumentLoadOrStore(Inst, DL);
} }
// Instrument atomic memory accesses in any case (they can be used to // Instrument atomic memory accesses in any case (they can be used to
// implement synchronization). // implement synchronization).
if (ClInstrumentAtomics) if (ClInstrumentAtomics)
for (auto Inst : AtomicAccesses) { for (auto Inst : AtomicAccesses) {
Res |= instrumentAtomic(Inst); Res |= instrumentAtomic(Inst, DL);
} }
if (ClInstrumentMemIntrinsics && SanitizeFunction) if (ClInstrumentMemIntrinsics && SanitizeFunction)
Context not available.
return Res; return Res;
} }
bool ThreadSanitizer::instrumentLoadOrStore(Instruction *I) { bool ThreadSanitizer::instrumentLoadOrStore(Instruction *I,
const DataLayout &DL) {
IRBuilder<> IRB(I); IRBuilder<> IRB(I);
bool IsWrite = isa<StoreInst>(*I); bool IsWrite = isa<StoreInst>(*I);
Value *Addr = IsWrite Value *Addr = IsWrite
? cast<StoreInst>(I)->getPointerOperand() ? cast<StoreInst>(I)->getPointerOperand()
: cast<LoadInst>(I)->getPointerOperand(); : cast<LoadInst>(I)->getPointerOperand();
int Idx = getMemoryAccessFuncIndex(Addr); int Idx = getMemoryAccessFuncIndex(Addr, DL);
if (Idx < 0) if (Idx < 0)
return false; return false;
if (IsWrite && isVtableAccess(I)) { if (IsWrite && isVtableAccess(I)) {
Context not available.
? cast<StoreInst>(I)->getAlignment() ? cast<StoreInst>(I)->getAlignment()
: cast<LoadInst>(I)->getAlignment(); : cast<LoadInst>(I)->getAlignment();
Type *OrigTy = cast<PointerType>(Addr->getType())->getElementType(); Type *OrigTy = cast<PointerType>(Addr->getType())->getElementType();
const uint32_t TypeSize = DL->getTypeStoreSizeInBits(OrigTy); const uint32_t TypeSize = DL.getTypeStoreSizeInBits(OrigTy);
Value *OnAccessFunc = nullptr; Value *OnAccessFunc = nullptr;
if (Alignment == 0 || Alignment >= 8 || (Alignment % (TypeSize / 8)) == 0) if (Alignment == 0 || Alignment >= 8 || (Alignment % (TypeSize / 8)) == 0)
OnAccessFunc = IsWrite ? TsanWrite[Idx] : TsanRead[Idx]; OnAccessFunc = IsWrite ? TsanWrite[Idx] : TsanRead[Idx];
Context not available.
// The following page contains more background information: // The following page contains more background information:
// http://www.hpl.hp.com/personal/Hans_Boehm/c++mm/ // http://www.hpl.hp.com/personal/Hans_Boehm/c++mm/
bool ThreadSanitizer::instrumentAtomic(Instruction *I) { bool ThreadSanitizer::instrumentAtomic(Instruction *I, const DataLayout &DL) {
IRBuilder<> IRB(I); IRBuilder<> IRB(I);
if (LoadInst *LI = dyn_cast<LoadInst>(I)) { if (LoadInst *LI = dyn_cast<LoadInst>(I)) {
Value *Addr = LI->getPointerOperand(); Value *Addr = LI->getPointerOperand();
int Idx = getMemoryAccessFuncIndex(Addr); int Idx = getMemoryAccessFuncIndex(Addr, DL);
if (Idx < 0) if (Idx < 0)
return false; return false;
const size_t ByteSize = 1 << Idx; const size_t ByteSize = 1 << Idx;
Context not available.
} else if (StoreInst *SI = dyn_cast<StoreInst>(I)) { } else if (StoreInst *SI = dyn_cast<StoreInst>(I)) {
Value *Addr = SI->getPointerOperand(); Value *Addr = SI->getPointerOperand();
int Idx = getMemoryAccessFuncIndex(Addr); int Idx = getMemoryAccessFuncIndex(Addr, DL);
if (Idx < 0) if (Idx < 0)
return false; return false;
const size_t ByteSize = 1 << Idx; const size_t ByteSize = 1 << Idx;
Context not available.
ReplaceInstWithInst(I, C); ReplaceInstWithInst(I, C);
} else if (AtomicRMWInst *RMWI = dyn_cast<AtomicRMWInst>(I)) { } else if (AtomicRMWInst *RMWI = dyn_cast<AtomicRMWInst>(I)) {
Value *Addr = RMWI->getPointerOperand(); Value *Addr = RMWI->getPointerOperand();
int Idx = getMemoryAccessFuncIndex(Addr); int Idx = getMemoryAccessFuncIndex(Addr, DL);
if (Idx < 0) if (Idx < 0)
return false; return false;
Function *F = TsanAtomicRMW[RMWI->getOperation()][Idx]; Function *F = TsanAtomicRMW[RMWI->getOperation()][Idx];
Context not available.
ReplaceInstWithInst(I, C); ReplaceInstWithInst(I, C);
} else if (AtomicCmpXchgInst *CASI = dyn_cast<AtomicCmpXchgInst>(I)) { } else if (AtomicCmpXchgInst *CASI = dyn_cast<AtomicCmpXchgInst>(I)) {
Value *Addr = CASI->getPointerOperand(); Value *Addr = CASI->getPointerOperand();
int Idx = getMemoryAccessFuncIndex(Addr); int Idx = getMemoryAccessFuncIndex(Addr, DL);
if (Idx < 0) if (Idx < 0)
return false; return false;
const size_t ByteSize = 1 << Idx; const size_t ByteSize = 1 << Idx;
Context not available.
return true; return true;
} }
int ThreadSanitizer::getMemoryAccessFuncIndex(Value *Addr) { int ThreadSanitizer::getMemoryAccessFuncIndex(Value *Addr,
const DataLayout &DL) {
Type *OrigPtrTy = Addr->getType(); Type *OrigPtrTy = Addr->getType();
Type *OrigTy = cast<PointerType>(OrigPtrTy)->getElementType(); Type *OrigTy = cast<PointerType>(OrigPtrTy)->getElementType();
assert(OrigTy->isSized()); assert(OrigTy->isSized());
uint32_t TypeSize = DL->getTypeStoreSizeInBits(OrigTy); uint32_t TypeSize = DL.getTypeStoreSizeInBits(OrigTy);
if (TypeSize != 8 && TypeSize != 16 && if (TypeSize != 8 && TypeSize != 16 &&
TypeSize != 32 && TypeSize != 64 && TypeSize != 128) { TypeSize != 32 && TypeSize != 64 && TypeSize != 128) {
NumAccessesWithBadSize++; NumAccessesWithBadSize++;
Context not available.

lib/Transforms/ObjCARC/DependencyAnalysis.cpp

Context not available.
if (AliasAnalysis::onlyReadsMemory(MRB)) if (AliasAnalysis::onlyReadsMemory(MRB))
return false; return false;
if (AliasAnalysis::onlyAccessesArgPointees(MRB)) { if (AliasAnalysis::onlyAccessesArgPointees(MRB)) {
const DataLayout &DL = Inst->getModule()->getDataLayout();
for (ImmutableCallSite::arg_iterator I = CS.arg_begin(), E = CS.arg_end(); for (ImmutableCallSite::arg_iterator I = CS.arg_begin(), E = CS.arg_end();
I != E; ++I) { I != E; ++I) {
const Value *Op = *I; const Value *Op = *I;
if (IsPotentialRetainableObjPtr(Op, *PA.getAA()) && PA.related(Ptr, Op)) if (IsPotentialRetainableObjPtr(Op, *PA.getAA()) &&
PA.related(Ptr, Op, DL))
return true; return true;
} }
return false; return false;
Context not available.
if (Class == ARCInstKind::Call) if (Class == ARCInstKind::Call)
return false; return false;
const DataLayout &DL = Inst->getModule()->getDataLayout();
// Consider various instructions which may have pointer arguments which are // Consider various instructions which may have pointer arguments which are
// not "uses". // not "uses".
if (const ICmpInst *ICI = dyn_cast<ICmpInst>(Inst)) { if (const ICmpInst *ICI = dyn_cast<ICmpInst>(Inst)) {
Context not available.
for (ImmutableCallSite::arg_iterator OI = CS.arg_begin(), for (ImmutableCallSite::arg_iterator OI = CS.arg_begin(),
OE = CS.arg_end(); OI != OE; ++OI) { OE = CS.arg_end(); OI != OE; ++OI) {
const Value *Op = *OI; const Value *Op = *OI;
if (IsPotentialRetainableObjPtr(Op, *PA.getAA()) && PA.related(Ptr, Op)) if (IsPotentialRetainableObjPtr(Op, *PA.getAA()) &&
PA.related(Ptr, Op, DL))
return true; return true;
} }
return false; return false;
} else if (const StoreInst *SI = dyn_cast<StoreInst>(Inst)) { } else if (const StoreInst *SI = dyn_cast<StoreInst>(Inst)) {
// Special-case stores, because we don't care about the stored value, just // Special-case stores, because we don't care about the stored value, just
// the store address. // the store address.
const Value *Op = GetUnderlyingObjCPtr(SI->getPointerOperand()); const Value *Op = GetUnderlyingObjCPtr(SI->getPointerOperand(), DL);
// If we can't tell what the underlying object was, assume there is a // If we can't tell what the underlying object was, assume there is a
// dependence. // dependence.
return IsPotentialRetainableObjPtr(Op, *PA.getAA()) && PA.related(Op, Ptr); return IsPotentialRetainableObjPtr(Op, *PA.getAA()) &&
PA.related(Op, Ptr, DL);
} }
// Check each operand for a match. // Check each operand for a match.
for (User::const_op_iterator OI = Inst->op_begin(), OE = Inst->op_end(); for (User::const_op_iterator OI = Inst->op_begin(), OE = Inst->op_end();
OI != OE; ++OI) { OI != OE; ++OI) {
const Value *Op = *OI; const Value *Op = *OI;
if (IsPotentialRetainableObjPtr(Op, *PA.getAA()) && PA.related(Ptr, Op)) if (IsPotentialRetainableObjPtr(Op, *PA.getAA()) && PA.related(Ptr, Op, DL))
return true; return true;
} }
return false; return false;
Context not available.

lib/Transforms/ObjCARC/ObjCARC.h

Context not available.
/// \brief This is a wrapper around getUnderlyingObject which also knows how to /// \brief This is a wrapper around getUnderlyingObject which also knows how to
/// look through objc_retain and objc_autorelease calls, which we know to return /// look through objc_retain and objc_autorelease calls, which we know to return
/// their argument verbatim. /// their argument verbatim.
static inline const Value *GetUnderlyingObjCPtr(const Value *V) { static inline const Value *GetUnderlyingObjCPtr(const Value *V,
const DataLayout &DL) {
for (;;) { for (;;) {
V = GetUnderlyingObject(V); V = GetUnderlyingObject(V, DL);
if (!IsForwarding(GetBasicARCInstKind(V))) if (!IsForwarding(GetBasicARCInstKind(V)))
break; break;
V = cast<CallInst>(V)->getArgOperand(0); V = cast<CallInst>(V)->getArgOperand(0);
Context not available.

lib/Transforms/ObjCARC/ObjCARCAliasAnalysis.cpp

Context not available.
// If that failed, climb to the underlying object, including climbing through // If that failed, climb to the underlying object, including climbing through
// ObjC-specific no-ops, and try making an imprecise alias query. // ObjC-specific no-ops, and try making an imprecise alias query.
const Value *UA = GetUnderlyingObjCPtr(SA); const Value *UA = GetUnderlyingObjCPtr(SA, *DL);
const Value *UB = GetUnderlyingObjCPtr(SB); const Value *UB = GetUnderlyingObjCPtr(SB, *DL);
if (UA != SA || UB != SB) { if (UA != SA || UB != SB) {
Result = AliasAnalysis::alias(Location(UA), Location(UB)); Result = AliasAnalysis::alias(Location(UA), Location(UB));
// We can't use MustAlias or PartialAlias results here because // We can't use MustAlias or PartialAlias results here because
Context not available.
// If that failed, climb to the underlying object, including climbing through // If that failed, climb to the underlying object, including climbing through
// ObjC-specific no-ops, and try making an imprecise alias query. // ObjC-specific no-ops, and try making an imprecise alias query.
const Value *U = GetUnderlyingObjCPtr(S); const Value *U = GetUnderlyingObjCPtr(S, *DL);
if (U != S) if (U != S)
return AliasAnalysis::pointsToConstantMemory(Location(U), OrLocal); return AliasAnalysis::pointsToConstantMemory(Location(U), OrLocal);
Context not available.

lib/Transforms/ObjCARC/ObjCARCOpts.cpp

Context not available.
/// This is a wrapper around getUnderlyingObjCPtr along the lines of /// This is a wrapper around getUnderlyingObjCPtr along the lines of
/// GetUnderlyingObjects except that it returns early when it sees the first /// GetUnderlyingObjects except that it returns early when it sees the first
/// alloca. /// alloca.
static inline bool AreAnyUnderlyingObjectsAnAlloca(const Value *V) { static inline bool AreAnyUnderlyingObjectsAnAlloca(const Value *V,
const DataLayout &DL) {
SmallPtrSet<const Value *, 4> Visited; SmallPtrSet<const Value *, 4> Visited;
SmallVector<const Value *, 4> Worklist; SmallVector<const Value *, 4> Worklist;
Worklist.push_back(V); Worklist.push_back(V);
do { do {
const Value *P = Worklist.pop_back_val(); const Value *P = Worklist.pop_back_val();
P = GetUnderlyingObjCPtr(P); P = GetUnderlyingObjCPtr(P, DL);
if (isa<AllocaInst>(P)) if (isa<AllocaInst>(P))
return true; return true;
Context not available.
// in the presence of allocas we only unconditionally remove pointers if // in the presence of allocas we only unconditionally remove pointers if
// both our retain and our release are KnownSafe. // both our retain and our release are KnownSafe.
if (StoreInst *SI = dyn_cast<StoreInst>(Inst)) { if (StoreInst *SI = dyn_cast<StoreInst>(Inst)) {
if (AreAnyUnderlyingObjectsAnAlloca(SI->getPointerOperand())) { const DataLayout &DL = BB->getModule()->getDataLayout();
if (AreAnyUnderlyingObjectsAnAlloca(SI->getPointerOperand(), DL)) {
auto I = MyStates.findPtrBottomUpState( auto I = MyStates.findPtrBottomUpState(
GetRCIdentityRoot(SI->getValueOperand())); GetRCIdentityRoot(SI->getValueOperand()));
if (I != MyStates.bottom_up_ptr_end()) if (I != MyStates.bottom_up_ptr_end())
MultiOwnersSet.insert(I->first); MultiOwnersSet.insert(I->first);
} }
Context not available.

lib/Transforms/ObjCARC/ProvenanceAnalysis.h

Context not available.
namespace llvm { namespace llvm {
class Value; class Value;
class AliasAnalysis; class AliasAnalysis;
class DataLayout;
class PHINode; class PHINode;
class SelectInst; class SelectInst;
} }
Context not available.
typedef DenseMap<ValuePairTy, bool> CachedResultsTy; typedef DenseMap<ValuePairTy, bool> CachedResultsTy;
CachedResultsTy CachedResults; CachedResultsTy CachedResults;
bool relatedCheck(const Value *A, const Value *B); bool relatedCheck(const Value *A, const Value *B, const DataLayout &DL);
bool relatedSelect(const SelectInst *A, const Value *B); bool relatedSelect(const SelectInst *A, const Value *B);
bool relatedPHI(const PHINode *A, const Value *B); bool relatedPHI(const PHINode *A, const Value *B);
Context not available.
AliasAnalysis *getAA() const { return AA; } AliasAnalysis *getAA() const { return AA; }
bool related(const Value *A, const Value *B); bool related(const Value *A, const Value *B, const DataLayout &DL);
void clear() { void clear() {
CachedResults.clear(); CachedResults.clear();
Context not available.

lib/Transforms/ObjCARC/ProvenanceAnalysis.cpp

Context not available.
bool ProvenanceAnalysis::relatedSelect(const SelectInst *A, bool ProvenanceAnalysis::relatedSelect(const SelectInst *A,
const Value *B) { const Value *B) {
const DataLayout &DL = A->getModule()->getDataLayout();
// If the values are Selects with the same condition, we can do a more precise // If the values are Selects with the same condition, we can do a more precise
// check: just check for relations between the values on corresponding arms. // check: just check for relations between the values on corresponding arms.
if (const SelectInst *SB = dyn_cast<SelectInst>(B)) if (const SelectInst *SB = dyn_cast<SelectInst>(B))
if (A->getCondition() == SB->getCondition()) if (A->getCondition() == SB->getCondition())
return related(A->getTrueValue(), SB->getTrueValue()) || return related(A->getTrueValue(), SB->getTrueValue(), DL) ||
related(A->getFalseValue(), SB->getFalseValue()); related(A->getFalseValue(), SB->getFalseValue(), DL);
// Check both arms of the Select node individually. // Check both arms of the Select node individually.
return related(A->getTrueValue(), B) || return related(A->getTrueValue(), B, DL) ||
related(A->getFalseValue(), B); related(A->getFalseValue(), B, DL);
} }
bool ProvenanceAnalysis::relatedPHI(const PHINode *A, bool ProvenanceAnalysis::relatedPHI(const PHINode *A,
const Value *B) { const Value *B) {
const DataLayout &DL = A->getModule()->getDataLayout();
// If the values are PHIs in the same block, we can do a more precise as well // If the values are PHIs in the same block, we can do a more precise as well
// as efficient check: just check for relations between the values on // as efficient check: just check for relations between the values on
// corresponding edges. // corresponding edges.
Context not available.
if (PNB->getParent() == A->getParent()) { if (PNB->getParent() == A->getParent()) {
for (unsigned i = 0, e = A->getNumIncomingValues(); i != e; ++i) for (unsigned i = 0, e = A->getNumIncomingValues(); i != e; ++i)
if (related(A->getIncomingValue(i), if (related(A->getIncomingValue(i),
PNB->getIncomingValueForBlock(A->getIncomingBlock(i)))) PNB->getIncomingValueForBlock(A->getIncomingBlock(i)), DL))
return true; return true;
return false; return false;
} }
Context not available.
SmallPtrSet<const Value *, 4> UniqueSrc; SmallPtrSet<const Value *, 4> UniqueSrc;
for (unsigned i = 0, e = A->getNumIncomingValues(); i != e; ++i) { for (unsigned i = 0, e = A->getNumIncomingValues(); i != e; ++i) {
const Value *PV1 = A->getIncomingValue(i); const Value *PV1 = A->getIncomingValue(i);
if (UniqueSrc.insert(PV1).second && related(PV1, B)) if (UniqueSrc.insert(PV1).second && related(PV1, B, DL))
return true; return true;
} }
Context not available.
return false; return false;
} }
bool ProvenanceAnalysis::relatedCheck(const Value *A, bool ProvenanceAnalysis::relatedCheck(const Value *A, const Value *B,
const Value *B) { const DataLayout &DL) {
// Skip past provenance pass-throughs. // Skip past provenance pass-throughs.
A = GetUnderlyingObjCPtr(A); A = GetUnderlyingObjCPtr(A, DL);
B = GetUnderlyingObjCPtr(B); B = GetUnderlyingObjCPtr(B, DL);
// Quick check. // Quick check.
if (A == B) if (A == B)
Context not available.
return true; return true;
} }
bool ProvenanceAnalysis::related(const Value *A, bool ProvenanceAnalysis::related(const Value *A, const Value *B,
const Value *B) { const DataLayout &DL) {
// Begin by inserting a conservative value into the map. If the insertion // Begin by inserting a conservative value into the map. If the insertion
// fails, we have the answer already. If it succeeds, leave it there until we // fails, we have the answer already. If it succeeds, leave it there until we
// compute the real answer to guard against recursive queries. // compute the real answer to guard against recursive queries.
Context not available.
if (!Pair.second) if (!Pair.second)
return Pair.first->second; return Pair.first->second;
bool Result = relatedCheck(A, B); bool Result = relatedCheck(A, B, DL);
CachedResults[ValuePairTy(A, B)] = Result; CachedResults[ValuePairTy(A, B)] = Result;
return Result; return Result;
} }
Context not available.

lib/Transforms/ObjCARC/ProvenanceAnalysisEvaluator.cpp

Context not available.
#include "llvm/Analysis/Passes.h" #include "llvm/Analysis/Passes.h"
#include "llvm/IR/InstIterator.h" #include "llvm/IR/InstIterator.h"
#include "llvm/IR/Function.h" #include "llvm/IR/Function.h"
#include "llvm/IR/Module.h"
#include "llvm/Support/raw_ostream.h" #include "llvm/Support/raw_ostream.h"
using namespace llvm; using namespace llvm;
Context not available.
ProvenanceAnalysis PA; ProvenanceAnalysis PA;
PA.setAA(&getAnalysis<AliasAnalysis>()); PA.setAA(&getAnalysis<AliasAnalysis>());
const DataLayout &DL = F.getParent()->getDataLayout();
for (Value *V1 : Values) { for (Value *V1 : Values) {
StringRef NameV1 = getName(V1); StringRef NameV1 = getName(V1);
Context not available.
if (NameV1 >= NameV2) if (NameV1 >= NameV2)
continue; continue;
errs() << NameV1 << " and " << NameV2; errs() << NameV1 << " and " << NameV2;
if (PA.related(V1, V2)) if (PA.related(V1, V2, DL))
errs() << " are related.\n"; errs() << " are related.\n";
else else
errs() << " are not related.\n"; errs() << " are not related.\n";
Context not available.

lib/Transforms/Scalar/AlignmentFromAssumptions.cpp

Context not available.
#include "llvm/IR/Instruction.h" #include "llvm/IR/Instruction.h"
#include "llvm/IR/IntrinsicInst.h" #include "llvm/IR/IntrinsicInst.h"
#include "llvm/IR/Intrinsics.h" #include "llvm/IR/Intrinsics.h"
#include "llvm/IR/DataLayout.h"
#include "llvm/IR/Module.h" #include "llvm/IR/Module.h"
#include "llvm/Support/Debug.h" #include "llvm/Support/Debug.h"
#include "llvm/Support/raw_ostream.h" #include "llvm/Support/raw_ostream.h"
Context not available.
ScalarEvolution *SE; ScalarEvolution *SE;
DominatorTree *DT; DominatorTree *DT;
const DataLayout *DL;
bool extractAlignmentInfo(CallInst *I, Value *&AAPtr, const SCEV *&AlignSCEV, bool extractAlignmentInfo(CallInst *I, Value *&AAPtr, const SCEV *&AlignSCEV,
const SCEV *&OffSCEV); const SCEV *&OffSCEV);
Context not available.
continue; continue;
if (Instruction *K = dyn_cast<Instruction>(J)) if (Instruction *K = dyn_cast<Instruction>(J))
if (isValidAssumeForContext(ACall, K, DL, DT)) if (isValidAssumeForContext(ACall, K, DT))
WorkList.push_back(K); WorkList.push_back(K);
} }
Context not available.
Visited.insert(J); Visited.insert(J);
for (User *UJ : J->users()) { for (User *UJ : J->users()) {
Instruction *K = cast<Instruction>(UJ); Instruction *K = cast<Instruction>(UJ);
if (!Visited.count(K) && isValidAssumeForContext(ACall, K, DL, DT)) if (!Visited.count(K) && isValidAssumeForContext(ACall, K, DT))
WorkList.push_back(K); WorkList.push_back(K);
} }
} }
Context not available.
auto &AC = getAnalysis<AssumptionCacheTracker>().getAssumptionCache(F); auto &AC = getAnalysis<AssumptionCacheTracker>().getAssumptionCache(F);
SE = &getAnalysis<ScalarEvolution>(); SE = &getAnalysis<ScalarEvolution>();
DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree(); DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
DL = &F.getParent()->getDataLayout();
NewDestAlignments.clear(); NewDestAlignments.clear();
NewSrcAlignments.clear(); NewSrcAlignments.clear();
Context not available.

lib/Transforms/Scalar/BDCE.cpp

Context not available.
APInt &KnownZero2, APInt &KnownOne2); APInt &KnownZero2, APInt &KnownOne2);
AssumptionCache *AC; AssumptionCache *AC;
const DataLayout *DL;
DominatorTree *DT; DominatorTree *DT;
}; };
} }
Context not available.
// however, want to do this twice, so we cache the result in APInts that live // however, want to do this twice, so we cache the result in APInts that live
// in the caller. For the two-relevant-operands case, both operand values are // in the caller. For the two-relevant-operands case, both operand values are
// provided here. // provided here.
auto ComputeKnownBits = [&](unsigned BitWidth, const Value *V1, auto ComputeKnownBits =
const Value *V2) { [&](unsigned BitWidth, const Value *V1, const Value *V2) {
KnownZero = APInt(BitWidth, 0); const DataLayout &DL = I->getModule()->getDataLayout();
KnownOne = APInt(BitWidth, 0); KnownZero = APInt(BitWidth, 0);
computeKnownBits(const_cast<Value*>(V1), KnownZero, KnownOne, DL, 0, AC, KnownOne = APInt(BitWidth, 0);
UserI, DT); computeKnownBits(const_cast<Value *>(V1), KnownZero, KnownOne, DL, 0,
AC, UserI, DT);
if (V2) {
KnownZero2 = APInt(BitWidth, 0); if (V2) {
KnownOne2 = APInt(BitWidth, 0); KnownZero2 = APInt(BitWidth, 0);
computeKnownBits(const_cast<Value*>(V2), KnownZero2, KnownOne2, DL, 0, AC, KnownOne2 = APInt(BitWidth, 0);
UserI, DT); computeKnownBits(const_cast<Value *>(V2), KnownZero2, KnownOne2, DL,
} 0, AC, UserI, DT);
}; }
};
switch (UserI->getOpcode()) { switch (UserI->getOpcode()) {
default: break; default: break;
Context not available.
return false; return false;
AC = &getAnalysis<AssumptionCacheTracker>().getAssumptionCache(F); AC = &getAnalysis<AssumptionCacheTracker>().getAssumptionCache(F);
DL = &F.getParent()->getDataLayout();
DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree(); DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
DenseMap<Instruction *, APInt> AliveBits; DenseMap<Instruction *, APInt> AliveBits;
Context not available.

lib/Transforms/Scalar/ConstantProp.cpp

Context not available.
#include "llvm/ADT/Statistic.h" #include "llvm/ADT/Statistic.h"
#include "llvm/Analysis/ConstantFolding.h" #include "llvm/Analysis/ConstantFolding.h"
#include "llvm/IR/Constant.h" #include "llvm/IR/Constant.h"
#include "llvm/IR/DataLayout.h"
#include "llvm/IR/InstIterator.h" #include "llvm/IR/InstIterator.h"
#include "llvm/IR/Instruction.h" #include "llvm/IR/Instruction.h"
#include "llvm/Pass.h" #include "llvm/Pass.h"
Context not available.
WorkList.erase(WorkList.begin()); // Get an element from the worklist... WorkList.erase(WorkList.begin()); // Get an element from the worklist...
if (!I->use_empty()) // Don't muck with dead instructions... if (!I->use_empty()) // Don't muck with dead instructions...
if (Constant *C = ConstantFoldInstruction(I, &DL, TLI)) { if (Constant *C = ConstantFoldInstruction(I, DL, TLI)) {
// Add all of the users of this instruction to the worklist, they might // Add all of the users of this instruction to the worklist, they might
// be constant propagatable now... // be constant propagatable now...
for (User *U : I->users()) for (User *U : I->users())
Context not available.

lib/Transforms/Scalar/CorrelatedValuePropagation.cpp

Context not available.
Changed = true; Changed = true;
} }
// FIXME: Provide DL, TLI, DT, AT to SimplifyInstruction. // FIXME: Provide TLI, DT, AT to SimplifyInstruction.
if (Value *V = SimplifyInstruction(P)) { const DataLayout &DL = BB->getModule()->getDataLayout();
if (Value *V = SimplifyInstruction(P, DL)) {
P->replaceAllUsesWith(V); P->replaceAllUsesWith(V);
P->eraseFromParent(); P->eraseFromParent();
Changed = true; Changed = true;
Context not available.

lib/Transforms/Scalar/DeadStoreElimination.cpp

Context not available.
bool HandleFree(CallInst *F); bool HandleFree(CallInst *F);
bool handleEndBlock(BasicBlock &BB); bool handleEndBlock(BasicBlock &BB);
void RemoveAccessedObjects(const AliasAnalysis::Location &LoadedLoc, void RemoveAccessedObjects(const AliasAnalysis::Location &LoadedLoc,
SmallSetVector<Value*, 16> &DeadStackObjects); SmallSetVector<Value *, 16> &DeadStackObjects,
const DataLayout &DL);
void getAnalysisUsage(AnalysisUsage &AU) const override { void getAnalysisUsage(AnalysisUsage &AU) const override {
AU.setPreservesCFG(); AU.setPreservesCFG();
Context not available.
/// describe the memory operations for this instruction. /// describe the memory operations for this instruction.
static AliasAnalysis::Location static AliasAnalysis::Location
getLocForWrite(Instruction *Inst, AliasAnalysis &AA) { getLocForWrite(Instruction *Inst, AliasAnalysis &AA) {
const DataLayout *DL = AA.getDataLayout();
if (StoreInst *SI = dyn_cast<StoreInst>(Inst)) if (StoreInst *SI = dyn_cast<StoreInst>(Inst))
return AA.getLocation(SI); return AA.getLocation(SI);
if (MemIntrinsic *MI = dyn_cast<MemIntrinsic>(Inst)) { if (MemIntrinsic *MI = dyn_cast<MemIntrinsic>(Inst)) {
// memcpy/memmove/memset. // memcpy/memmove/memset.
AliasAnalysis::Location Loc = AA.getLocationForDest(MI); AliasAnalysis::Location Loc = AA.getLocationForDest(MI);
// If we don't have target data around, an unknown size in Location means
// that we should use the size of the pointee type. This isn't valid for
// memset/memcpy, which writes more than an i8.
if (Loc.Size == AliasAnalysis::UnknownSize && DL == nullptr)
return AliasAnalysis::Location();
return Loc; return Loc;
} }
Context not available.
switch (II->getIntrinsicID()) { switch (II->getIntrinsicID()) {
default: return AliasAnalysis::Location(); // Unhandled intrinsic. default: return AliasAnalysis::Location(); // Unhandled intrinsic.
case Intrinsic::init_trampoline: case Intrinsic::init_trampoline:
// If we don't have target data around, an unknown size in Location means
// that we should use the size of the pointee type. This isn't valid for
// init.trampoline, which writes more than an i8.
if (!DL) return AliasAnalysis::Location();
// FIXME: We don't know the size of the trampoline, so we can't really // FIXME: We don't know the size of the trampoline, so we can't really
// handle it here. // handle it here.
return AliasAnalysis::Location(II->getArgOperand(0)); return AliasAnalysis::Location(II->getArgOperand(0));
Context not available.
return CS.getArgument(0); return CS.getArgument(0);
} }
static uint64_t getPointerSize(const Value *V, AliasAnalysis &AA) { static uint64_t getPointerSize(const Value *V, const DataLayout &DL,
const TargetLibraryInfo *TLI) {
uint64_t Size; uint64_t Size;
if (getObjectSize(V, Size, AA.getDataLayout(), AA.getTargetLibraryInfo())) if (getObjectSize(V, Size, DL, TLI))
return Size; return Size;
return AliasAnalysis::UnknownSize; return AliasAnalysis::UnknownSize;
} }
Context not available.
/// overwritten by 'Later', or 'OverwriteUnknown' if nothing can be determined /// overwritten by 'Later', or 'OverwriteUnknown' if nothing can be determined
static OverwriteResult isOverwrite(const AliasAnalysis::Location &Later, static OverwriteResult isOverwrite(const AliasAnalysis::Location &Later,
const AliasAnalysis::Location &Earlier, const AliasAnalysis::Location &Earlier,
AliasAnalysis &AA, const DataLayout &DL,
int64_t &EarlierOff, const TargetLibraryInfo *TLI,
int64_t &LaterOff) { int64_t &EarlierOff, int64_t &LaterOff) {
const DataLayout *DL = AA.getDataLayout();
const Value *P1 = Earlier.Ptr->stripPointerCasts(); const Value *P1 = Earlier.Ptr->stripPointerCasts();
const Value *P2 = Later.Ptr->stripPointerCasts(); const Value *P2 = Later.Ptr->stripPointerCasts();
Context not available.
// Otherwise, we have to have size information, and the later store has to be // Otherwise, we have to have size information, and the later store has to be
// larger than the earlier one. // larger than the earlier one.
if (Later.Size == AliasAnalysis::UnknownSize || if (Later.Size == AliasAnalysis::UnknownSize ||
Earlier.Size == AliasAnalysis::UnknownSize || DL == nullptr) Earlier.Size == AliasAnalysis::UnknownSize)
return OverwriteUnknown; return OverwriteUnknown;
// Check to see if the later store is to the entire object (either a global, // Check to see if the later store is to the entire object (either a global,
Context not available.
return OverwriteUnknown; return OverwriteUnknown;
// If the "Later" store is to a recognizable object, get its size. // If the "Later" store is to a recognizable object, get its size.
uint64_t ObjectSize = getPointerSize(UO2, AA); uint64_t ObjectSize = getPointerSize(UO2, DL, TLI);
if (ObjectSize != AliasAnalysis::UnknownSize) if (ObjectSize != AliasAnalysis::UnknownSize)
if (ObjectSize == Later.Size && ObjectSize >= Earlier.Size) if (ObjectSize == Later.Size && ObjectSize >= Earlier.Size)
return OverwriteComplete; return OverwriteComplete;
Context not available.
if (isRemovable(DepWrite) && if (isRemovable(DepWrite) &&
!isPossibleSelfRead(Inst, Loc, DepWrite, *AA)) { !isPossibleSelfRead(Inst, Loc, DepWrite, *AA)) {
int64_t InstWriteOffset, DepWriteOffset; int64_t InstWriteOffset, DepWriteOffset;
OverwriteResult OR = isOverwrite(Loc, DepLoc, *AA, const DataLayout &DL = BB.getModule()->getDataLayout();
DepWriteOffset, InstWriteOffset); OverwriteResult OR =
isOverwrite(Loc, DepLoc, DL, AA->getTargetLibraryInfo(),
DepWriteOffset, InstWriteOffset);
if (OR == OverwriteComplete) { if (OR == OverwriteComplete) {
DEBUG(dbgs() << "DSE: Remove Dead Store:\n DEAD: " DEBUG(dbgs() << "DSE: Remove Dead Store:\n DEAD: "
<< *DepWrite << "\n KILLER: " << *Inst << '\n'); << *DepWrite << "\n KILLER: " << *Inst << '\n');
Context not available.
AliasAnalysis::Location Loc = AliasAnalysis::Location(F->getOperand(0)); AliasAnalysis::Location Loc = AliasAnalysis::Location(F->getOperand(0));
SmallVector<BasicBlock *, 16> Blocks; SmallVector<BasicBlock *, 16> Blocks;
Blocks.push_back(F->getParent()); Blocks.push_back(F->getParent());
const DataLayout &DL = F->getModule()->getDataLayout();
while (!Blocks.empty()) { while (!Blocks.empty()) {
BasicBlock *BB = Blocks.pop_back_val(); BasicBlock *BB = Blocks.pop_back_val();
Context not available.
break; break;
Value *DepPointer = Value *DepPointer =
GetUnderlyingObject(getStoredPointerOperand(Dependency)); GetUnderlyingObject(getStoredPointerOperand(Dependency), DL);
// Check for aliasing. // Check for aliasing.
if (!AA->isMustAlias(F->getArgOperand(0), DepPointer)) if (!AA->isMustAlias(F->getArgOperand(0), DepPointer))
Context not available.
if (AI->hasByValOrInAllocaAttr()) if (AI->hasByValOrInAllocaAttr())
DeadStackObjects.insert(AI); DeadStackObjects.insert(AI);
const DataLayout &DL = BB.getModule()->getDataLayout();
// Scan the basic block backwards // Scan the basic block backwards
for (BasicBlock::iterator BBI = BB.end(); BBI != BB.begin(); ){ for (BasicBlock::iterator BBI = BB.end(); BBI != BB.begin(); ){
--BBI; --BBI;
Context not available.
if (hasMemoryWrite(BBI, TLI) && isRemovable(BBI)) { if (hasMemoryWrite(BBI, TLI) && isRemovable(BBI)) {
// See through pointer-to-pointer bitcasts // See through pointer-to-pointer bitcasts
SmallVector<Value *, 4> Pointers; SmallVector<Value *, 4> Pointers;
GetUnderlyingObjects(getStoredPointerOperand(BBI), Pointers); GetUnderlyingObjects(getStoredPointerOperand(BBI), Pointers, DL);
// Stores to stack values are valid candidates for removal. // Stores to stack values are valid candidates for removal.
bool AllDead = true; bool AllDead = true;
Context not available.
// the call is live. // the call is live.
DeadStackObjects.remove_if([&](Value *I) { DeadStackObjects.remove_if([&](Value *I) {
// See if the call site touches the value. // See if the call site touches the value.
AliasAnalysis::ModRefResult A = AliasAnalysis::ModRefResult A = AA->getModRefInfo(
AA->getModRefInfo(CS, I, getPointerSize(I, *AA)); CS, I, getPointerSize(I, DL, AA->getTargetLibraryInfo()));
return A == AliasAnalysis::ModRef || A == AliasAnalysis::Ref; return A == AliasAnalysis::ModRef || A == AliasAnalysis::Ref;
}); });
Context not available.
// Remove any allocas from the DeadPointer set that are loaded, as this // Remove any allocas from the DeadPointer set that are loaded, as this
// makes any stores above the access live. // makes any stores above the access live.
RemoveAccessedObjects(LoadedLoc, DeadStackObjects); RemoveAccessedObjects(LoadedLoc, DeadStackObjects, DL);
// If all of the allocas were clobbered by the access then we're not going // If all of the allocas were clobbered by the access then we're not going
// to find anything else to process. // to find anything else to process.
Context not available.
/// of the stack objects in the DeadStackObjects set. If so, they become live /// of the stack objects in the DeadStackObjects set. If so, they become live
/// because the location is being loaded. /// because the location is being loaded.
void DSE::RemoveAccessedObjects(const AliasAnalysis::Location &LoadedLoc, void DSE::RemoveAccessedObjects(const AliasAnalysis::Location &LoadedLoc,
SmallSetVector<Value*, 16> &DeadStackObjects) { SmallSetVector<Value *, 16> &DeadStackObjects,
const Value *UnderlyingPointer = GetUnderlyingObject(LoadedLoc.Ptr); const DataLayout &DL) {
const Value *UnderlyingPointer = GetUnderlyingObject(LoadedLoc.Ptr, DL);
// A constant can't be in the dead pointer set. // A constant can't be in the dead pointer set.
if (isa<Constant>(UnderlyingPointer)) if (isa<Constant>(UnderlyingPointer))
Context not available.
// Remove objects that could alias LoadedLoc. // Remove objects that could alias LoadedLoc.
DeadStackObjects.remove_if([&](Value *I) { DeadStackObjects.remove_if([&](Value *I) {
// See if the loaded location could alias the stack location. // See if the loaded location could alias the stack location.
AliasAnalysis::Location StackLoc(I, getPointerSize(I, *AA)); AliasAnalysis::Location StackLoc(
I, getPointerSize(I, DL, AA->getTargetLibraryInfo()));
return !AA->isNoAlias(StackLoc, LoadedLoc); return !AA->isNoAlias(StackLoc, LoadedLoc);
}); });
} }
Context not available.

lib/Transforms/Scalar/EarlyCSE.cpp

Context not available.
class EarlyCSE { class EarlyCSE {
public: public:
Function &F; Function &F;
const DataLayout *DL;
const TargetLibraryInfo &TLI; const TargetLibraryInfo &TLI;
const TargetTransformInfo &TTI; const TargetTransformInfo &TTI;
DominatorTree &DT; DominatorTree &DT;
Context not available.
unsigned CurrentGeneration; unsigned CurrentGeneration;
/// \brief Set up the EarlyCSE runner for a particular function. /// \brief Set up the EarlyCSE runner for a particular function.
EarlyCSE(Function &F, const DataLayout *DL, const TargetLibraryInfo &TLI, EarlyCSE(Function &F, const TargetLibraryInfo &TLI,
const TargetTransformInfo &TTI, DominatorTree &DT, const TargetTransformInfo &TTI, DominatorTree &DT,
AssumptionCache &AC) AssumptionCache &AC)
: F(F), DL(DL), TLI(TLI), TTI(TTI), DT(DT), AC(AC), CurrentGeneration(0) { : F(F), TLI(TLI), TTI(TTI), DT(DT), AC(AC), CurrentGeneration(0) {}
}
bool run(); bool run();
Context not available.
Instruction *LastStore = nullptr; Instruction *LastStore = nullptr;
bool Changed = false; bool Changed = false;
const DataLayout &DL = BB->getModule()->getDataLayout();
// See if any instructions in the block can be eliminated. If so, do it. If // See if any instructions in the block can be eliminated. If so, do it. If
// not, add them to AvailableValues. // not, add them to AvailableValues.
Context not available.
PreservedAnalyses EarlyCSEPass::run(Function &F, PreservedAnalyses EarlyCSEPass::run(Function &F,
AnalysisManager<Function> *AM) { AnalysisManager<Function> *AM) {
const DataLayout &DL = F.getParent()->getDataLayout();
auto &TLI = AM->getResult<TargetLibraryAnalysis>(F); auto &TLI = AM->getResult<TargetLibraryAnalysis>(F);
auto &TTI = AM->getResult<TargetIRAnalysis>(F); auto &TTI = AM->getResult<TargetIRAnalysis>(F);
auto &DT = AM->getResult<DominatorTreeAnalysis>(F); auto &DT = AM->getResult<DominatorTreeAnalysis>(F);
auto &AC = AM->getResult<AssumptionAnalysis>(F); auto &AC = AM->getResult<AssumptionAnalysis>(F);
EarlyCSE CSE(F, &DL, TLI, TTI, DT, AC); EarlyCSE CSE(F, TLI, TTI, DT, AC);
if (!CSE.run()) if (!CSE.run())
return PreservedAnalyses::all(); return PreservedAnalyses::all();
Context not available.
if (skipOptnoneFunction(F)) if (skipOptnoneFunction(F))
return false; return false;
auto &DL = F.getParent()->getDataLayout();
auto &TLI = getAnalysis<TargetLibraryInfoWrapperPass>().getTLI(); auto &TLI = getAnalysis<TargetLibraryInfoWrapperPass>().getTLI();
auto &TTI = getAnalysis<TargetTransformInfoWrapperPass>().getTTI(F); auto &TTI = getAnalysis<TargetTransformInfoWrapperPass>().getTTI(F);
auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree(); auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
auto &AC = getAnalysis<AssumptionCacheTracker>().getAssumptionCache(F); auto &AC = getAnalysis<AssumptionCacheTracker>().getAssumptionCache(F);
EarlyCSE CSE(F, &DL, TLI, TTI, DT, AC); EarlyCSE CSE(F, TLI, TTI, DT, AC);
return CSE.run(); return CSE.run();
} }
Context not available.

lib/Transforms/Scalar/GVN.cpp

Context not available.
/// Emit code into this block to adjust the value defined here to the /// Emit code into this block to adjust the value defined here to the
/// specified type. This handles various coercion cases. /// specified type. This handles various coercion cases.
Value *MaterializeAdjustedValue(Type *LoadTy, GVN &gvn) const; Value *MaterializeAdjustedValue(LoadInst *LI, GVN &gvn) const;
}; };
class GVN : public FunctionPass { class GVN : public FunctionPass {
bool NoLoads; bool NoLoads;
MemoryDependenceAnalysis *MD; MemoryDependenceAnalysis *MD;
DominatorTree *DT; DominatorTree *DT;
const DataLayout *DL;
const TargetLibraryInfo *TLI; const TargetLibraryInfo *TLI;
AssumptionCache *AC; AssumptionCache *AC;
SetVector<BasicBlock *> DeadBlocks; SetVector<BasicBlock *> DeadBlocks;
Context not available.
InstrsToErase.push_back(I); InstrsToErase.push_back(I);
} }
const DataLayout *getDataLayout() const { return DL; }
DominatorTree &getDominatorTree() const { return *DT; } DominatorTree &getDominatorTree() const { return *DT; }
AliasAnalysis *getAliasAnalysis() const { return VN.getAliasAnalysis(); } AliasAnalysis *getAliasAnalysis() const { return VN.getAliasAnalysis(); }
MemoryDependenceAnalysis &getMemDep() const { return *MD; } MemoryDependenceAnalysis &getMemDep() const { return *MD; }
Context not available.
return -1; return -1;
int64_t StoreOffset = 0, LoadOffset = 0; int64_t StoreOffset = 0, LoadOffset = 0;
Value *StoreBase = GetPointerBaseWithConstantOffset(WritePtr,StoreOffset,&DL); Value *StoreBase =
Value *LoadBase = GetPointerBaseWithConstantOffset(LoadPtr, LoadOffset, &DL); GetPointerBaseWithConstantOffset(WritePtr, StoreOffset, DL);
Value *LoadBase = GetPointerBaseWithConstantOffset(LoadPtr, LoadOffset, DL);
if (StoreBase != LoadBase) if (StoreBase != LoadBase)
return -1; return -1;
Context not available.
/// This function is called when we have a /// This function is called when we have a
/// memdep query of a load that ends up being a clobbering store. /// memdep query of a load that ends up being a clobbering store.
static int AnalyzeLoadFromClobberingStore(Type *LoadTy, Value *LoadPtr, static int AnalyzeLoadFromClobberingStore(Type *LoadTy, Value *LoadPtr,
StoreInst *DepSI, StoreInst *DepSI) {
const DataLayout &DL) {
// Cannot handle reading from store of first-class aggregate yet. // Cannot handle reading from store of first-class aggregate yet.
if (DepSI->getValueOperand()->getType()->isStructTy() || if (DepSI->getValueOperand()->getType()->isStructTy() ||
DepSI->getValueOperand()->getType()->isArrayTy()) DepSI->getValueOperand()->getType()->isArrayTy())
return -1; return -1;
const DataLayout &DL = DepSI->getModule()->getDataLayout();
Value *StorePtr = DepSI->getPointerOperand(); Value *StorePtr = DepSI->getPointerOperand();
uint64_t StoreSize =DL.getTypeSizeInBits(DepSI->getValueOperand()->getType()); uint64_t StoreSize =DL.getTypeSizeInBits(DepSI->getValueOperand()->getType());
return AnalyzeLoadFromClobberingWrite(LoadTy, LoadPtr, return AnalyzeLoadFromClobberingWrite(LoadTy, LoadPtr,
Context not available.
// then we should widen it! // then we should widen it!
int64_t LoadOffs = 0; int64_t LoadOffs = 0;
const Value *LoadBase = const Value *LoadBase =
GetPointerBaseWithConstantOffset(LoadPtr, LoadOffs, &DL); GetPointerBaseWithConstantOffset(LoadPtr, LoadOffs, DL);
unsigned LoadSize = DL.getTypeStoreSize(LoadTy); unsigned LoadSize = DL.getTypeStoreSize(LoadTy);
unsigned Size = MemoryDependenceAnalysis:: unsigned Size = MemoryDependenceAnalysis::getLoadLoadClobberFullWidthSize(
getLoadLoadClobberFullWidthSize(LoadBase, LoadOffs, LoadSize, DepLI, DL); LoadBase, LoadOffs, LoadSize, DepLI);
if (Size == 0) return -1; if (Size == 0) return -1;
return AnalyzeLoadFromClobberingWrite(LoadTy, LoadPtr, DepPtr, Size*8, DL); return AnalyzeLoadFromClobberingWrite(LoadTy, LoadPtr, DepPtr, Size*8, DL);
Context not available.
Constant *Src = dyn_cast<Constant>(MTI->getSource()); Constant *Src = dyn_cast<Constant>(MTI->getSource());
if (!Src) return -1; if (!Src) return -1;
GlobalVariable *GV = dyn_cast<GlobalVariable>(GetUnderlyingObject(Src, &DL)); GlobalVariable *GV = dyn_cast<GlobalVariable>(GetUnderlyingObject(Src, DL));
if (!GV || !GV->isConstant()) return -1; if (!GV || !GV->isConstant()) return -1;
// See if the access is within the bounds of the transfer. // See if the access is within the bounds of the transfer.
Context not available.
ConstantInt::get(Type::getInt64Ty(Src->getContext()), (unsigned)Offset); ConstantInt::get(Type::getInt64Ty(Src->getContext()), (unsigned)Offset);
Src = ConstantExpr::getGetElementPtr(Src, OffsetCst); Src = ConstantExpr::getGetElementPtr(Src, OffsetCst);
Src = ConstantExpr::getBitCast(Src, PointerType::get(LoadTy, AS)); Src = ConstantExpr::getBitCast(Src, PointerType::get(LoadTy, AS));
if (ConstantFoldLoadFromConstPtr(Src, &DL)) if (ConstantFoldLoadFromConstPtr(Src, DL))
return Offset; return Offset;
return -1; return -1;
} }
Context not available.
static Value *GetLoadValueForLoad(LoadInst *SrcVal, unsigned Offset, static Value *GetLoadValueForLoad(LoadInst *SrcVal, unsigned Offset,
Type *LoadTy, Instruction *InsertPt, Type *LoadTy, Instruction *InsertPt,
GVN &gvn) { GVN &gvn) {
const DataLayout &DL = *gvn.getDataLayout(); const DataLayout &DL = SrcVal->getModule()->getDataLayout();
// If Offset+LoadTy exceeds the size of SrcVal, then we must be wanting to // If Offset+LoadTy exceeds the size of SrcVal, then we must be wanting to
// widen SrcVal out to a larger load. // widen SrcVal out to a larger load.
unsigned SrcValSize = DL.getTypeStoreSize(SrcVal->getType()); unsigned SrcValSize = DL.getTypeStoreSize(SrcVal->getType());
Context not available.
ConstantInt::get(Type::getInt64Ty(Src->getContext()), (unsigned)Offset); ConstantInt::get(Type::getInt64Ty(Src->getContext()), (unsigned)Offset);
Src = ConstantExpr::getGetElementPtr(Src, OffsetCst); Src = ConstantExpr::getGetElementPtr(Src, OffsetCst);
Src = ConstantExpr::getBitCast(Src, PointerType::get(LoadTy, AS)); Src = ConstantExpr::getBitCast(Src, PointerType::get(LoadTy, AS));
return ConstantFoldLoadFromConstPtr(Src, &DL); return ConstantFoldLoadFromConstPtr(Src, DL);
} }
Context not available.
gvn.getDominatorTree().properlyDominates(ValuesPerBlock[0].BB, gvn.getDominatorTree().properlyDominates(ValuesPerBlock[0].BB,
LI->getParent())) { LI->getParent())) {
assert(!ValuesPerBlock[0].isUndefValue() && "Dead BB dominate this block"); assert(!ValuesPerBlock[0].isUndefValue() && "Dead BB dominate this block");
return ValuesPerBlock[0].MaterializeAdjustedValue(LI->getType(), gvn); return ValuesPerBlock[0].MaterializeAdjustedValue(LI, gvn);
} }
// Otherwise, we have to construct SSA form. // Otherwise, we have to construct SSA form.
Context not available.
SSAUpdater SSAUpdate(&NewPHIs); SSAUpdater SSAUpdate(&NewPHIs);
SSAUpdate.Initialize(LI->getType(), LI->getName()); SSAUpdate.Initialize(LI->getType(), LI->getName());
Type *LoadTy = LI->getType();
for (unsigned i = 0, e = ValuesPerBlock.size(); i != e; ++i) { for (unsigned i = 0, e = ValuesPerBlock.size(); i != e; ++i) {
const AvailableValueInBlock &AV = ValuesPerBlock[i]; const AvailableValueInBlock &AV = ValuesPerBlock[i];
BasicBlock *BB = AV.BB; BasicBlock *BB = AV.BB;
Context not available.
if (SSAUpdate.HasValueForBlock(BB)) if (SSAUpdate.HasValueForBlock(BB))
continue; continue;
SSAUpdate.AddAvailableValue(BB, AV.MaterializeAdjustedValue(LoadTy, gvn)); SSAUpdate.AddAvailableValue(BB, AV.MaterializeAdjustedValue(LI, gvn));
} }
// Perform PHI construction. // Perform PHI construction.
Context not available.
return V; return V;
} }
Value *AvailableValueInBlock::MaterializeAdjustedValue(Type *LoadTy, GVN &gvn) const { Value *AvailableValueInBlock::MaterializeAdjustedValue(LoadInst *LI,
GVN &gvn) const {
Value *Res; Value *Res;
Type *LoadTy = LI->getType();
const DataLayout &DL = LI->getModule()->getDataLayout();
if (isSimpleValue()) { if (isSimpleValue()) {
Res = getSimpleValue(); Res = getSimpleValue();
if (Res->getType() != LoadTy) { if (Res->getType() != LoadTy) {
const DataLayout *DL = gvn.getDataLayout(); Res = GetStoreValueForLoad(Res, Offset, LoadTy, BB->getTerminator(), DL);
assert(DL && "Need target data to handle type mismatch case");
Res = GetStoreValueForLoad(Res, Offset, LoadTy, BB->getTerminator(),
*DL);
DEBUG(dbgs() << "GVN COERCED NONLOCAL VAL:\nOffset: " << Offset << " " DEBUG(dbgs() << "GVN COERCED NONLOCAL VAL:\nOffset: " << Offset << " "
<< *getSimpleValue() << '\n' << *getSimpleValue() << '\n'
<< *Res << '\n' << "\n\n\n"); << *Res << '\n' << "\n\n\n");
Context not available.
<< *Res << '\n' << "\n\n\n"); << *Res << '\n' << "\n\n\n");
} }
} else if (isMemIntrinValue()) { } else if (isMemIntrinValue()) {
const DataLayout *DL = gvn.getDataLayout(); Res = GetMemInstValueForLoad(getMemIntrinValue(), Offset, LoadTy,
assert(DL && "Need target data to handle type mismatch case"); BB->getTerminator(), DL);
Res = GetMemInstValueForLoad(getMemIntrinValue(), Offset,
LoadTy, BB->getTerminator(), *DL);
DEBUG(dbgs() << "GVN COERCED NONLOCAL MEM INTRIN:\nOffset: " << Offset DEBUG(dbgs() << "GVN COERCED NONLOCAL MEM INTRIN:\nOffset: " << Offset
<< " " << *getMemIntrinValue() << '\n' << " " << *getMemIntrinValue() << '\n'
<< *Res << '\n' << "\n\n\n"); << *Res << '\n' << "\n\n\n");
Context not available.
// dependencies that produce an unknown value for the load (such as a call // dependencies that produce an unknown value for the load (such as a call
// that could potentially clobber the load). // that could potentially clobber the load).
unsigned NumDeps = Deps.size(); unsigned NumDeps = Deps.size();
const DataLayout &DL = LI->getModule()->getDataLayout();
for (unsigned i = 0, e = NumDeps; i != e; ++i) { for (unsigned i = 0, e = NumDeps; i != e; ++i) {
BasicBlock *DepBB = Deps[i].getBB(); BasicBlock *DepBB = Deps[i].getBB();
MemDepResult DepInfo = Deps[i].getResult(); MemDepResult DepInfo = Deps[i].getResult();
Context not available.
// read by the load, we can extract the bits we need for the load from the // read by the load, we can extract the bits we need for the load from the
// stored value. // stored value.
if (StoreInst *DepSI = dyn_cast<StoreInst>(DepInfo.getInst())) { if (StoreInst *DepSI = dyn_cast<StoreInst>(DepInfo.getInst())) {
if (DL && Address) { if (Address) {
int Offset = AnalyzeLoadFromClobberingStore(LI->getType(), Address, int Offset =
DepSI, *DL); AnalyzeLoadFromClobberingStore(LI->getType(), Address, DepSI);
if (Offset != -1) { if (Offset != -1) {
ValuesPerBlock.push_back(AvailableValueInBlock::get(DepBB, ValuesPerBlock.push_back(AvailableValueInBlock::get(DepBB,
DepSI->getValueOperand(), DepSI->getValueOperand(),
Context not available.
if (LoadInst *DepLI = dyn_cast<LoadInst>(DepInfo.getInst())) { if (LoadInst *DepLI = dyn_cast<LoadInst>(DepInfo.getInst())) {
// If this is a clobber and L is the first instruction in its block, then // If this is a clobber and L is the first instruction in its block, then
// we have the first instruction in the entry block. // we have the first instruction in the entry block.
if (DepLI != LI && Address && DL) { if (DepLI != LI && Address) {
int Offset = AnalyzeLoadFromClobberingLoad(LI->getType(), Address, int Offset =
DepLI, *DL); AnalyzeLoadFromClobberingLoad(LI->getType(), Address, DepLI, DL);
if (Offset != -1) { if (Offset != -1) {
ValuesPerBlock.push_back(AvailableValueInBlock::getLoad(DepBB,DepLI, ValuesPerBlock.push_back(AvailableValueInBlock::getLoad(DepBB,DepLI,
Context not available.
// If the clobbering value is a memset/memcpy/memmove, see if we can // If the clobbering value is a memset/memcpy/memmove, see if we can
// forward a value on from it. // forward a value on from it.
if (MemIntrinsic *DepMI = dyn_cast<MemIntrinsic>(DepInfo.getInst())) { if (MemIntrinsic *DepMI = dyn_cast<MemIntrinsic>(DepInfo.getInst())) {
if (DL && Address) { if (Address) {
int Offset = AnalyzeLoadFromClobberingMemInst(LI->getType(), Address, int Offset = AnalyzeLoadFromClobberingMemInst(LI->getType(), Address,
DepMI, *DL); DepMI, DL);
if (Offset != -1) { if (Offset != -1) {
ValuesPerBlock.push_back(AvailableValueInBlock::getMI(DepBB, DepMI, ValuesPerBlock.push_back(AvailableValueInBlock::getMI(DepBB, DepMI,
Offset)); Offset));
Context not available.
if (S->getValueOperand()->getType() != LI->getType()) { if (S->getValueOperand()->getType() != LI->getType()) {
// If the stored value is larger or equal to the loaded value, we can // If the stored value is larger or equal to the loaded value, we can
// reuse it. // reuse it.
if (!DL || !CanCoerceMustAliasedValueToLoad(S->getValueOperand(), if (!CanCoerceMustAliasedValueToLoad(S->getValueOperand(),
LI->getType(), *DL)) { LI->getType(), DL)) {
UnavailableBlocks.push_back(DepBB); UnavailableBlocks.push_back(DepBB);
continue; continue;
} }
Context not available.
if (LD->getType() != LI->getType()) { if (LD->getType() != LI->getType()) {
// If the stored value is larger or equal to the loaded value, we can // If the stored value is larger or equal to the loaded value, we can
// reuse it. // reuse it.
if (!DL || !CanCoerceMustAliasedValueToLoad(LD, LI->getType(),*DL)) { if (!CanCoerceMustAliasedValueToLoad(LD, LI->getType(), DL)) {
UnavailableBlocks.push_back(DepBB); UnavailableBlocks.push_back(DepBB);
continue; continue;
} }
Context not available.
// Check if the load can safely be moved to all the unavailable predecessors. // Check if the load can safely be moved to all the unavailable predecessors.
bool CanDoPRE = true; bool CanDoPRE = true;
const DataLayout &DL = LI->getModule()->getDataLayout();
SmallVector<Instruction*, 8> NewInsts; SmallVector<Instruction*, 8> NewInsts;
for (auto &PredLoad : PredLoads) { for (auto &PredLoad : PredLoads) {
BasicBlock *UnavailablePred = PredLoad.first; BasicBlock *UnavailablePred = PredLoad.first;
Context not available.
// ... to a pointer that has been loaded from before... // ... to a pointer that has been loaded from before...
MemDepResult Dep = MD->getDependency(L); MemDepResult Dep = MD->getDependency(L);
const DataLayout &DL = L->getModule()->getDataLayout();
// If we have a clobber and target data is around, see if this is a clobber // If we have a clobber and target data is around, see if this is a clobber
// that we can fix up through code synthesis. // that we can fix up through code synthesis.
if (Dep.isClobber() && DL) { if (Dep.isClobber()) {
// Check to see if we have something like this: // Check to see if we have something like this:
// store i32 123, i32* %P // store i32 123, i32* %P
// %A = bitcast i32* %P to i8* // %A = bitcast i32* %P to i8*
Context not available.
// access code. // access code.
Value *AvailVal = nullptr; Value *AvailVal = nullptr;
if (StoreInst *DepSI = dyn_cast<StoreInst>(Dep.getInst())) { if (StoreInst *DepSI = dyn_cast<StoreInst>(Dep.getInst())) {
int Offset = AnalyzeLoadFromClobberingStore(L->getType(), int Offset = AnalyzeLoadFromClobberingStore(
L->getPointerOperand(), L->getType(), L->getPointerOperand(), DepSI);
DepSI, *DL);
if (Offset != -1) if (Offset != -1)
AvailVal = GetStoreValueForLoad(DepSI->getValueOperand(), Offset, AvailVal = GetStoreValueForLoad(DepSI->getValueOperand(), Offset,
L->getType(), L, *DL); L->getType(), L, DL);
} }
// Check to see if we have something like this: // Check to see if we have something like this:
Context not available.
if (DepLI == L) if (DepLI == L)
return false; return false;
int Offset = AnalyzeLoadFromClobberingLoad(L->getType(), int Offset = AnalyzeLoadFromClobberingLoad(
L->getPointerOperand(), L->getType(), L->getPointerOperand(), DepLI, DL);
DepLI, *DL);
if (Offset != -1) if (Offset != -1)
AvailVal = GetLoadValueForLoad(DepLI, Offset, L->getType(), L, *this); AvailVal = GetLoadValueForLoad(DepLI, Offset, L->getType(), L, *this);
} }
Context not available.
// If the clobbering value is a memset/memcpy/memmove, see if we can forward // If the clobbering value is a memset/memcpy/memmove, see if we can forward
// a value on from it. // a value on from it.
if (MemIntrinsic *DepMI = dyn_cast<MemIntrinsic>(Dep.getInst())) { if (MemIntrinsic *DepMI = dyn_cast<MemIntrinsic>(Dep.getInst())) {
int Offset = AnalyzeLoadFromClobberingMemInst(L->getType(), int Offset = AnalyzeLoadFromClobberingMemInst(
L->getPointerOperand(), L->getType(), L->getPointerOperand(), DepMI, DL);
DepMI, *DL);
if (Offset != -1) if (Offset != -1)
AvailVal = GetMemInstValueForLoad(DepMI, Offset, L->getType(), L, *DL); AvailVal = GetMemInstValueForLoad(DepMI, Offset, L->getType(), L, DL);
} }
if (AvailVal) { if (AvailVal) {
Context not available.
// actually have the same type. See if we know how to reuse the stored // actually have the same type. See if we know how to reuse the stored
// value (depending on its type). // value (depending on its type).
if (StoredVal->getType() != L->getType()) { if (StoredVal->getType() != L->getType()) {
if (DL) { StoredVal =
StoredVal = CoerceAvailableValueToLoadType(StoredVal, L->getType(), CoerceAvailableValueToLoadType(StoredVal, L->getType(), L, DL);
L, *DL); if (!StoredVal)
if (!StoredVal)
return false;
DEBUG(dbgs() << "GVN COERCED STORE:\n" << *DepSI << '\n' << *StoredVal
<< '\n' << *L << "\n\n\n");
}
else
return false; return false;
DEBUG(dbgs() << "GVN COERCED STORE:\n" << *DepSI << '\n' << *StoredVal
<< '\n' << *L << "\n\n\n");
} }
// Remove it! // Remove it!
Context not available.
// the same type. See if we know how to reuse the previously loaded value // the same type. See if we know how to reuse the previously loaded value
// (depending on its type). // (depending on its type).
if (DepLI->getType() != L->getType()) { if (DepLI->getType() != L->getType()) {
if (DL) { AvailableVal = CoerceAvailableValueToLoadType(DepLI, L->getType(), L, DL);
AvailableVal = CoerceAvailableValueToLoadType(DepLI, L->getType(), if (!AvailableVal)
L, *DL);
if (!AvailableVal)
return false;
DEBUG(dbgs() << "GVN COERCED LOAD:\n" << *DepLI << "\n" << *AvailableVal
<< "\n" << *L << "\n\n\n");
}
else
return false; return false;
DEBUG(dbgs() << "GVN COERCED LOAD:\n" << *DepLI << "\n" << *AvailableVal
<< "\n" << *L << "\n\n\n");
} }
// Remove it! // Remove it!
Context not available.
// to value numbering it. Value numbering often exposes redundancies, for // to value numbering it. Value numbering often exposes redundancies, for
// example if it determines that %y is equal to %x then the instruction // example if it determines that %y is equal to %x then the instruction
// "%z = and i32 %x, %y" becomes "%z = and i32 %x, %x" which we now simplify. // "%z = and i32 %x, %y" becomes "%z = and i32 %x, %x" which we now simplify.
const DataLayout &DL = I->getModule()->getDataLayout();
if (Value *V = SimplifyInstruction(I, DL, TLI, DT, AC)) { if (Value *V = SimplifyInstruction(I, DL, TLI, DT, AC)) {
I->replaceAllUsesWith(V); I->replaceAllUsesWith(V);
if (MD && V->getType()->getScalarType()->isPointerTy()) if (MD && V->getType()->getScalarType()->isPointerTy())
Context not available.
if (!NoLoads) if (!NoLoads)
MD = &getAnalysis<MemoryDependenceAnalysis>(); MD = &getAnalysis<MemoryDependenceAnalysis>();
DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree(); DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
DL = &F.getParent()->getDataLayout();
AC = &getAnalysis<AssumptionCacheTracker>().getAssumptionCache(F); AC = &getAnalysis<AssumptionCacheTracker>().getAssumptionCache(F);
TLI = &getAnalysis<TargetLibraryInfoWrapperPass>().getTLI(); TLI = &getAnalysis<TargetLibraryInfoWrapperPass>().getTLI();
VN.setAliasAnalysis(&getAnalysis<AliasAnalysis>()); VN.setAliasAnalysis(&getAnalysis<AliasAnalysis>());
Context not available.

lib/Transforms/Scalar/IndVarSimplify.cpp

Context not available.
LoopInfo *LI; LoopInfo *LI;
ScalarEvolution *SE; ScalarEvolution *SE;
DominatorTree *DT; DominatorTree *DT;
const DataLayout *DL;
TargetLibraryInfo *TLI; TargetLibraryInfo *TLI;
const TargetTransformInfo *TTI; const TargetTransformInfo *TTI;
Context not available.
public: public:
static char ID; // Pass identification, replacement for typeid static char ID; // Pass identification, replacement for typeid
IndVarSimplify() : LoopPass(ID), LI(nullptr), SE(nullptr), DT(nullptr), IndVarSimplify()
DL(nullptr), Changed(false) { : LoopPass(ID), LI(nullptr), SE(nullptr), DT(nullptr), Changed(false) {
initializeIndVarSimplifyPass(*PassRegistry::getPassRegistry()); initializeIndVarSimplifyPass(*PassRegistry::getPassRegistry());
} }
Context not available.
/// extended by this sign or zero extend operation. This is used to determine /// extended by this sign or zero extend operation. This is used to determine
/// the final width of the IV before actually widening it. /// the final width of the IV before actually widening it.
static void visitIVCast(CastInst *Cast, WideIVInfo &WI, ScalarEvolution *SE, static void visitIVCast(CastInst *Cast, WideIVInfo &WI, ScalarEvolution *SE,
const DataLayout *DL, const TargetTransformInfo *TTI) { const TargetTransformInfo *TTI) {
bool IsSigned = Cast->getOpcode() == Instruction::SExt; bool IsSigned = Cast->getOpcode() == Instruction::SExt;
if (!IsSigned && Cast->getOpcode() != Instruction::ZExt) if (!IsSigned && Cast->getOpcode() != Instruction::ZExt)
return; return;
Type *Ty = Cast->getType(); Type *Ty = Cast->getType();
uint64_t Width = SE->getTypeSizeInBits(Ty); uint64_t Width = SE->getTypeSizeInBits(Ty);
if (DL && !DL->isLegalInteger(Width)) if (!Cast->getModule()->getDataLayout().isLegalInteger(Width))
return; return;
// Cast is either an sext or zext up to this point. // Cast is either an sext or zext up to this point.
Context not available.
namespace { namespace {
class IndVarSimplifyVisitor : public IVVisitor { class IndVarSimplifyVisitor : public IVVisitor {
ScalarEvolution *SE; ScalarEvolution *SE;
const DataLayout *DL;
const TargetTransformInfo *TTI; const TargetTransformInfo *TTI;
PHINode *IVPhi; PHINode *IVPhi;
Context not available.
WideIVInfo WI; WideIVInfo WI;
IndVarSimplifyVisitor(PHINode *IV, ScalarEvolution *SCEV, IndVarSimplifyVisitor(PHINode *IV, ScalarEvolution *SCEV,
const DataLayout *DL, const TargetTransformInfo *TTI, const TargetTransformInfo *TTI,
const DominatorTree *DTree) const DominatorTree *DTree)
: SE(SCEV), DL(DL), TTI(TTI), IVPhi(IV) { : SE(SCEV), TTI(TTI), IVPhi(IV) {
DT = DTree; DT = DTree;
WI.NarrowIV = IVPhi; WI.NarrowIV = IVPhi;
if (ReduceLiveIVs) if (ReduceLiveIVs)
Context not available.
} }
// Implement the interface used by simplifyUsersOfIV. // Implement the interface used by simplifyUsersOfIV.
void visitCast(CastInst *Cast) override { void visitCast(CastInst *Cast) override { visitIVCast(Cast, WI, SE, TTI); }
visitIVCast(Cast, WI, SE, DL, TTI);
}
}; };
} }
Context not available.
PHINode *CurrIV = LoopPhis.pop_back_val(); PHINode *CurrIV = LoopPhis.pop_back_val();
// Information about sign/zero extensions of CurrIV. // Information about sign/zero extensions of CurrIV.
IndVarSimplifyVisitor Visitor(CurrIV, SE, DL, TTI, DT); IndVarSimplifyVisitor Visitor(CurrIV, SE, TTI, DT);
Changed |= simplifyUsersOfIV(CurrIV, SE, &LPM, DeadInsts, &Visitor); Changed |= simplifyUsersOfIV(CurrIV, SE, &LPM, DeadInsts, &Visitor);
Context not available.
/// FIXME: Accept non-unit stride as long as SCEV can reduce BECount * Stride. /// FIXME: Accept non-unit stride as long as SCEV can reduce BECount * Stride.
/// This is difficult in general for SCEV because of potential overflow. But we /// This is difficult in general for SCEV because of potential overflow. But we
/// could at least handle constant BECounts. /// could at least handle constant BECounts.
static PHINode * static PHINode *FindLoopCounter(Loop *L, const SCEV *BECount,
FindLoopCounter(Loop *L, const SCEV *BECount, ScalarEvolution *SE, DominatorTree *DT) {
ScalarEvolution *SE, DominatorTree *DT, const DataLayout *DL) {
uint64_t BCWidth = SE->getTypeSizeInBits(BECount->getType()); uint64_t BCWidth = SE->getTypeSizeInBits(BECount->getType());
Value *Cond = Value *Cond =
Context not available.
// AR may be wider than BECount. With eq/ne tests overflow is immaterial. // AR may be wider than BECount. With eq/ne tests overflow is immaterial.
// AR may not be a narrower type, or we may never exit. // AR may not be a narrower type, or we may never exit.
uint64_t PhiWidth = SE->getTypeSizeInBits(AR->getType()); uint64_t PhiWidth = SE->getTypeSizeInBits(AR->getType());
if (PhiWidth < BCWidth || (DL && !DL->isLegalInteger(PhiWidth))) if (PhiWidth < BCWidth ||
!L->getHeader()->getModule()->getDataLayout().isLegalInteger(PhiWidth))
continue; continue;
const SCEV *Step = dyn_cast<SCEVConstant>(AR->getStepRecurrence(*SE)); const SCEV *Step = dyn_cast<SCEVConstant>(AR->getStepRecurrence(*SE));
Context not available.
LI = &getAnalysis<LoopInfoWrapperPass>().getLoopInfo(); LI = &getAnalysis<LoopInfoWrapperPass>().getLoopInfo();
SE = &getAnalysis<ScalarEvolution>(); SE = &getAnalysis<ScalarEvolution>();
DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree(); DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
DL = &L->getHeader()->getModule()->getDataLayout();
auto *TLIP = getAnalysisIfAvailable<TargetLibraryInfoWrapperPass>(); auto *TLIP = getAnalysisIfAvailable<TargetLibraryInfoWrapperPass>();
TLI = TLIP ? &TLIP->getTLI() : nullptr; TLI = TLIP ? &TLIP->getTLI() : nullptr;
auto *TTIP = getAnalysisIfAvailable<TargetTransformInfoWrapperPass>(); auto *TTIP = getAnalysisIfAvailable<TargetTransformInfoWrapperPass>();
TTI = TTIP ? &TTIP->getTTI(*L->getHeader()->getParent()) : nullptr; TTI = TTIP ? &TTIP->getTTI(*L->getHeader()->getParent()) : nullptr;
const DataLayout &DL = L->getHeader()->getModule()->getDataLayout();
DeadInsts.clear(); DeadInsts.clear();
Changed = false; Changed = false;
Context not available.
const SCEV *BackedgeTakenCount = SE->getBackedgeTakenCount(L); const SCEV *BackedgeTakenCount = SE->getBackedgeTakenCount(L);
// Create a rewriter object which we'll use to transform the code with. // Create a rewriter object which we'll use to transform the code with.
SCEVExpander Rewriter(*SE, "indvars"); SCEVExpander Rewriter(*SE, DL, "indvars");
#ifndef NDEBUG #ifndef NDEBUG
Rewriter.setDebugType(DEBUG_TYPE); Rewriter.setDebugType(DEBUG_TYPE);
#endif #endif
Context not available.
// If we have a trip count expression, rewrite the loop's exit condition // If we have a trip count expression, rewrite the loop's exit condition
// using it. We can currently only handle loops with a single exit. // using it. We can currently only handle loops with a single exit.
if (canExpandBackedgeTakenCount(L, SE) && needsLFTR(L, DT)) { if (canExpandBackedgeTakenCount(L, SE) && needsLFTR(L, DT)) {
PHINode *IndVar = FindLoopCounter(L, BackedgeTakenCount, SE, DT, DL); PHINode *IndVar = FindLoopCounter(L, BackedgeTakenCount, SE, DT);
if (IndVar) { if (IndVar) {
// Check preconditions for proper SCEVExpander operation. SCEV does not // Check preconditions for proper SCEVExpander operation. SCEV does not
// express SCEVExpander's dependencies, such as LoopSimplify. Instead any // express SCEVExpander's dependencies, such as LoopSimplify. Instead any
Context not available.

lib/Transforms/Scalar/InductiveRangeCheckElimination.cpp

Context not available.
"loop variant exit count doesn't make sense!"); "loop variant exit count doesn't make sense!");
assert(!L.contains(LatchExit) && "expected an exit block!"); assert(!L.contains(LatchExit) && "expected an exit block!");
const DataLayout &DL = Preheader->getModule()->getDataLayout();
Value *IndVarStartV = SCEVExpander(SE, "irce").expandCodeFor( Value *IndVarStartV =
IndVarStart, IndVarTy, &*Preheader->rbegin()); SCEVExpander(SE, DL, "irce")
.expandCodeFor(IndVarStart, IndVarTy, &*Preheader->rbegin());
IndVarStartV->setName("indvar.start"); IndVarStartV->setName("indvar.start");
LoopStructure Result; LoopStructure Result;
Context not available.
IntegerType *IVTy = IntegerType *IVTy =
cast<IntegerType>(MainLoopStructure.IndVarNext->getType()); cast<IntegerType>(MainLoopStructure.IndVarNext->getType());
SCEVExpander Expander(SE, "irce"); SCEVExpander Expander(SE, F.getParent()->getDataLayout(), "irce");
Instruction *InsertPt = OriginalPreheader->getTerminator(); Instruction *InsertPt = OriginalPreheader->getTerminator();
// It would have been better to make `PreLoop' and `PostLoop' // It would have been better to make `PreLoop' and `PostLoop'
Context not available.

lib/Transforms/Scalar/JumpThreading.cpp

Context not available.
/// revectored to the false side of the second if. /// revectored to the false side of the second if.
/// ///
class JumpThreading : public FunctionPass { class JumpThreading : public FunctionPass {
const DataLayout *DL;
TargetLibraryInfo *TLI; TargetLibraryInfo *TLI;
LazyValueInfo *LVI; LazyValueInfo *LVI;
#ifdef NDEBUG #ifdef NDEBUG
Context not available.
return false; return false;
DEBUG(dbgs() << "Jump threading on function '" << F.getName() << "'\n"); DEBUG(dbgs() << "Jump threading on function '" << F.getName() << "'\n");
DL = &F.getParent()->getDataLayout();
TLI = &getAnalysis<TargetLibraryInfoWrapperPass>().getTLI(); TLI = &getAnalysis<TargetLibraryInfoWrapperPass>().getTLI();
LVI = &getAnalysis<LazyValueInfo>(); LVI = &getAnalysis<LazyValueInfo>();
Context not available.
assert(Preference == WantInteger && "Compares only produce integers"); assert(Preference == WantInteger && "Compares only produce integers");
PHINode *PN = dyn_cast<PHINode>(Cmp->getOperand(0)); PHINode *PN = dyn_cast<PHINode>(Cmp->getOperand(0));
if (PN && PN->getParent() == BB) { if (PN && PN->getParent() == BB) {
const DataLayout &DL = PN->getModule()->getDataLayout();
// We can do this simplification if any comparisons fold to true or false. // We can do this simplification if any comparisons fold to true or false.
// See if any do. // See if any do.
for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) { for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) {
Context not available.
// Run constant folding to see if we can reduce the condition to a simple // Run constant folding to see if we can reduce the condition to a simple
// constant. // constant.
if (Instruction *I = dyn_cast<Instruction>(Condition)) { if (Instruction *I = dyn_cast<Instruction>(Condition)) {
Value *SimpleVal = ConstantFoldInstruction(I, DL, TLI); Value *SimpleVal =
ConstantFoldInstruction(I, BB->getModule()->getDataLayout(), TLI);
if (SimpleVal) { if (SimpleVal) {
I->replaceAllUsesWith(SimpleVal); I->replaceAllUsesWith(SimpleVal);
I->eraseFromParent(); I->eraseFromParent();
Context not available.
// At this point, the IR is fully up to date and consistent. Do a quick scan // At this point, the IR is fully up to date and consistent. Do a quick scan
// over the new instructions and zap any that are constants or dead. This // over the new instructions and zap any that are constants or dead. This
// frequently happens because of phi translation. // frequently happens because of phi translation.
SimplifyInstructionsInBlock(NewBB, DL, TLI); SimplifyInstructionsInBlock(NewBB, TLI);
// Threaded an edge! // Threaded an edge!
++NumThreads; ++NumThreads;
Context not available.
BasicBlock::iterator BI = BB->begin(); BasicBlock::iterator BI = BB->begin();
for (; PHINode *PN = dyn_cast<PHINode>(BI); ++BI) for (; PHINode *PN = dyn_cast<PHINode>(BI); ++BI)
ValueMapping[PN] = PN->getIncomingValueForBlock(PredBB); ValueMapping[PN] = PN->getIncomingValueForBlock(PredBB);
// Clone the non-phi instructions of BB into PredBB, keeping track of the // Clone the non-phi instructions of BB into PredBB, keeping track of the
// mapping and using it to remap operands in the cloned instructions. // mapping and using it to remap operands in the cloned instructions.
for (; BI != BB->end(); ++BI) { for (; BI != BB->end(); ++BI) {
Context not available.
// If this instruction can be simplified after the operands are updated, // If this instruction can be simplified after the operands are updated,
// just use the simplified value instead. This frequently happens due to // just use the simplified value instead. This frequently happens due to
// phi translation. // phi translation.
if (Value *IV = SimplifyInstruction(New, DL)) { if (Value *IV =
SimplifyInstruction(New, BB->getModule()->getDataLayout())) {
delete New; delete New;
ValueMapping[BI] = IV; ValueMapping[BI] = IV;
} else { } else {
Context not available.

lib/Transforms/Scalar/LICM.cpp

Context not available.
#include "llvm/IR/IntrinsicInst.h" #include "llvm/IR/IntrinsicInst.h"
#include "llvm/IR/LLVMContext.h" #include "llvm/IR/LLVMContext.h"
#include "llvm/IR/Metadata.h" #include "llvm/IR/Metadata.h"
#include "llvm/IR/Module.h"
#include "llvm/IR/PredIteratorCache.h" #include "llvm/IR/PredIteratorCache.h"
#include "llvm/Support/CommandLine.h" #include "llvm/Support/CommandLine.h"
#include "llvm/Support/Debug.h" #include "llvm/Support/Debug.h"
Context not available.
static bool hoist(Instruction &I, BasicBlock *Preheader); static bool hoist(Instruction &I, BasicBlock *Preheader);
static bool sink(Instruction &I, LoopInfo *LI, DominatorTree *DT, static bool sink(Instruction &I, LoopInfo *LI, DominatorTree *DT,
Loop *CurLoop, AliasSetTracker *CurAST ); Loop *CurLoop, AliasSetTracker *CurAST );
static bool isGuaranteedToExecute(Instruction &Inst, DominatorTree *DT, static bool isGuaranteedToExecute(Instruction &Inst, DominatorTree *DT,
Loop *CurLoop, LICMSafetyInfo * SafetyInfo); Loop *CurLoop, LICMSafetyInfo *SafetyInfo);
static bool isSafeToExecuteUnconditionally(Instruction &Inst,DominatorTree *DT, static bool isSafeToExecuteUnconditionally(Instruction &Inst, DominatorTree *DT,
const DataLayout *DL, Loop *CurLoop, Loop *CurLoop,
LICMSafetyInfo * SafetyInfo); LICMSafetyInfo *SafetyInfo);
static bool pointerInvalidatedByLoop(Value *V, uint64_t Size, static bool pointerInvalidatedByLoop(Value *V, uint64_t Size,
const AAMDNodes &AAInfo, const AAMDNodes &AAInfo,
AliasSetTracker *CurAST); AliasSetTracker *CurAST);
static Instruction *CloneInstructionInExitBlock(Instruction &I, static Instruction *CloneInstructionInExitBlock(Instruction &I,
BasicBlock &ExitBlock, BasicBlock &ExitBlock,
PHINode &PN, LoopInfo *LI); PHINode &PN, LoopInfo *LI);
static bool canSinkOrHoistInst(Instruction &I, AliasAnalysis *AA, static bool canSinkOrHoistInst(Instruction &I, AliasAnalysis *AA,
DominatorTree *DT, const DataLayout *DL, DominatorTree *DT, Loop *CurLoop,
Loop *CurLoop, AliasSetTracker *CurAST, AliasSetTracker *CurAST,
LICMSafetyInfo * SafetyInfo); LICMSafetyInfo *SafetyInfo);
namespace { namespace {
struct LICM : public LoopPass { struct LICM : public LoopPass {
Context not available.
LoopInfo *LI; // Current LoopInfo LoopInfo *LI; // Current LoopInfo
DominatorTree *DT; // Dominator Tree for the current Loop. DominatorTree *DT; // Dominator Tree for the current Loop.
const DataLayout *DL; // DataLayout for constant folding.
TargetLibraryInfo *TLI; // TargetLibraryInfo for constant folding. TargetLibraryInfo *TLI; // TargetLibraryInfo for constant folding.
// State that is updated as we process loops. // State that is updated as we process loops.
Context not available.
AA = &getAnalysis<AliasAnalysis>(); AA = &getAnalysis<AliasAnalysis>();
DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree(); DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
DL = &L->getHeader()->getModule()->getDataLayout();
TLI = &getAnalysis<TargetLibraryInfoWrapperPass>().getTLI(); TLI = &getAnalysis<TargetLibraryInfoWrapperPass>().getTLI();
assert(L->isLCSSAForm(*DT) && "Loop is not in LCSSA form."); assert(L->isLCSSAForm(*DT) && "Loop is not in LCSSA form.");
Context not available.
// instructions, we perform another pass to hoist them out of the loop. // instructions, we perform another pass to hoist them out of the loop.
// //
if (L->hasDedicatedExits()) if (L->hasDedicatedExits())
Changed |= sinkRegion(DT->getNode(L->getHeader()), AA, LI, DT, DL, TLI, Changed |= sinkRegion(DT->getNode(L->getHeader()), AA, LI, DT, TLI, CurLoop,
CurLoop, CurAST, &SafetyInfo); CurAST, &SafetyInfo);
if (Preheader) if (Preheader)
Changed |= hoistRegion(DT->getNode(L->getHeader()), AA, LI, DT, DL, TLI, Changed |= hoistRegion(DT->getNode(L->getHeader()), AA, LI, DT, TLI,
CurLoop, CurAST, &SafetyInfo); CurLoop, CurAST, &SafetyInfo);
// Now that all loop invariants have been removed from the loop, promote any // Now that all loop invariants have been removed from the loop, promote any
Context not available.
/// first order w.r.t the DominatorTree. This allows us to visit uses before /// first order w.r.t the DominatorTree. This allows us to visit uses before
/// definitions, allowing us to sink a loop body in one pass without iteration. /// definitions, allowing us to sink a loop body in one pass without iteration.
/// ///
bool llvm::sinkRegion(DomTreeNode *N, AliasAnalysis *AA, LoopInfo *LI, bool llvm::sinkRegion(DomTreeNode *N, AliasAnalysis *AA, LoopInfo *LI,
DominatorTree *DT, const DataLayout *DL, DominatorTree *DT, TargetLibraryInfo *TLI, Loop *CurLoop,
TargetLibraryInfo *TLI, Loop *CurLoop, AliasSetTracker *CurAST, LICMSafetyInfo *SafetyInfo) {
AliasSetTracker *CurAST, LICMSafetyInfo * SafetyInfo) {
// Verify inputs. // Verify inputs.
assert(N != nullptr && AA != nullptr && LI != nullptr && assert(N != nullptr && AA != nullptr && LI != nullptr &&
Context not available.
// We are processing blocks in reverse dfo, so process children first. // We are processing blocks in reverse dfo, so process children first.
const std::vector<DomTreeNode*> &Children = N->getChildren(); const std::vector<DomTreeNode*> &Children = N->getChildren();
for (unsigned i = 0, e = Children.size(); i != e; ++i) for (unsigned i = 0, e = Children.size(); i != e; ++i)
Changed |= sinkRegion(Children[i], AA, LI, DT, DL, TLI, CurLoop, Changed |=
CurAST, SafetyInfo); sinkRegion(Children[i], AA, LI, DT, TLI, CurLoop, CurAST, SafetyInfo);
// Only need to process the contents of this block if it is not part of a // Only need to process the contents of this block if it is not part of a
// subloop (which would already have been processed). // subloop (which would already have been processed).
if (inSubLoop(BB,CurLoop,LI)) return Changed; if (inSubLoop(BB,CurLoop,LI)) return Changed;
Context not available.
// outside of the loop. In this case, it doesn't even matter if the // outside of the loop. In this case, it doesn't even matter if the
// operands of the instruction are loop invariant. // operands of the instruction are loop invariant.
// //
if (isNotUsedInLoop(I, CurLoop) && if (isNotUsedInLoop(I, CurLoop) &&
canSinkOrHoistInst(I, AA, DT, DL, CurLoop, CurAST, SafetyInfo)) { canSinkOrHoistInst(I, AA, DT, CurLoop, CurAST, SafetyInfo)) {
++II; ++II;
Changed |= sink(I, LI, DT, CurLoop, CurAST); Changed |= sink(I, LI, DT, CurLoop, CurAST);
} }
Context not available.
/// order w.r.t the DominatorTree. This allows us to visit definitions before /// order w.r.t the DominatorTree. This allows us to visit definitions before
/// uses, allowing us to hoist a loop body in one pass without iteration. /// uses, allowing us to hoist a loop body in one pass without iteration.
/// ///
bool llvm::hoistRegion(DomTreeNode *N, AliasAnalysis *AA, LoopInfo *LI, bool llvm::hoistRegion(DomTreeNode *N, AliasAnalysis *AA, LoopInfo *LI,
DominatorTree *DT, const DataLayout *DL, DominatorTree *DT, TargetLibraryInfo *TLI, Loop *CurLoop,
TargetLibraryInfo *TLI, Loop *CurLoop, AliasSetTracker *CurAST, LICMSafetyInfo *SafetyInfo) {
AliasSetTracker *CurAST, LICMSafetyInfo *SafetyInfo) {
// Verify inputs. // Verify inputs.
assert(N != nullptr && AA != nullptr && LI != nullptr && assert(N != nullptr && AA != nullptr && LI != nullptr &&
DT != nullptr && CurLoop != nullptr && CurAST != nullptr && DT != nullptr && CurLoop != nullptr && CurAST != nullptr &&
Context not available.
// Try constant folding this instruction. If all the operands are // Try constant folding this instruction. If all the operands are
// constants, it is technically hoistable, but it would be better to just // constants, it is technically hoistable, but it would be better to just
// fold it. // fold it.
if (Constant *C = ConstantFoldInstruction(&I, DL, TLI)) { if (Constant *C = ConstantFoldInstruction(
&I, I.getModule()->getDataLayout(), TLI)) {
DEBUG(dbgs() << "LICM folding inst: " << I << " --> " << *C << '\n'); DEBUG(dbgs() << "LICM folding inst: " << I << " --> " << *C << '\n');
CurAST->copyValue(&I, C); CurAST->copyValue(&I, C);
CurAST->deleteValue(&I); CurAST->deleteValue(&I);
Context not available.
// if all of the operands of the instruction are loop invariant and if it // if all of the operands of the instruction are loop invariant and if it
// is safe to hoist the instruction. // is safe to hoist the instruction.
// //
if (CurLoop->hasLoopInvariantOperands(&I) && if (CurLoop->hasLoopInvariantOperands(&I) &&
canSinkOrHoistInst(I, AA, DT, DL, CurLoop, CurAST, SafetyInfo) && canSinkOrHoistInst(I, AA, DT, CurLoop, CurAST, SafetyInfo) &&
isSafeToExecuteUnconditionally(I, DT, DL, CurLoop, SafetyInfo)) isSafeToExecuteUnconditionally(I, DT, CurLoop, SafetyInfo))
Changed |= hoist(I, CurLoop->getLoopPreheader()); Changed |= hoist(I, CurLoop->getLoopPreheader());
} }
const std::vector<DomTreeNode*> &Children = N->getChildren(); const std::vector<DomTreeNode*> &Children = N->getChildren();
for (unsigned i = 0, e = Children.size(); i != e; ++i) for (unsigned i = 0, e = Children.size(); i != e; ++i)
Changed |= hoistRegion(Children[i], AA, LI, DT, DL, TLI, CurLoop, Changed |=
CurAST, SafetyInfo); hoistRegion(Children[i], AA, LI, DT, TLI, CurLoop, CurAST, SafetyInfo);
return Changed; return Changed;
} }
Context not available.
/// canSinkOrHoistInst - Return true if the hoister and sinker can handle this /// canSinkOrHoistInst - Return true if the hoister and sinker can handle this
/// instruction. /// instruction.
/// ///
bool canSinkOrHoistInst(Instruction &I, AliasAnalysis *AA, bool canSinkOrHoistInst(Instruction &I, AliasAnalysis *AA, DominatorTree *DT,
DominatorTree *DT, const DataLayout *DL, Loop *CurLoop, AliasSetTracker *CurAST,
Loop *CurLoop, AliasSetTracker *CurAST, LICMSafetyInfo *SafetyInfo) {
LICMSafetyInfo * SafetyInfo) {
// Loads have extra constraints we have to verify before we can hoist them. // Loads have extra constraints we have to verify before we can hoist them.
if (LoadInst *LI = dyn_cast<LoadInst>(&I)) { if (LoadInst *LI = dyn_cast<LoadInst>(&I)) {
if (!LI->isUnordered()) if (!LI->isUnordered())
Context not available.
!isa<InsertValueInst>(I)) !isa<InsertValueInst>(I))
return false; return false;
return isSafeToExecuteUnconditionally(I, DT, DL, CurLoop, SafetyInfo); return isSafeToExecuteUnconditionally(I, DT, CurLoop, SafetyInfo);
} }
/// Returns true if a PHINode is a trivially replaceable with an /// Returns true if a PHINode is a trivially replaceable with an
Context not available.
/// or if it is a trapping instruction and is guaranteed to execute. /// or if it is a trapping instruction and is guaranteed to execute.
/// ///
static bool isSafeToExecuteUnconditionally(Instruction &Inst, DominatorTree *DT, static bool isSafeToExecuteUnconditionally(Instruction &Inst, DominatorTree *DT,
const DataLayout *DL, Loop *CurLoop, Loop *CurLoop,
LICMSafetyInfo * SafetyInfo) { LICMSafetyInfo *SafetyInfo) {
// If it is not a trapping instruction, it is always safe to hoist. // If it is not a trapping instruction, it is always safe to hoist.
if (isSafeToSpeculativelyExecute(&Inst, DL)) if (isSafeToSpeculativelyExecute(&Inst))
return true; return true;
return isGuaranteedToExecute(Inst, DT, CurLoop, SafetyInfo); return isGuaranteedToExecute(Inst, DT, CurLoop, SafetyInfo);
Context not available.

lib/Transforms/Scalar/LoadCombine.cpp

Context not available.
class LoadCombine : public BasicBlockPass { class LoadCombine : public BasicBlockPass {
LLVMContext *C; LLVMContext *C;
const DataLayout *DL;
AliasAnalysis *AA; AliasAnalysis *AA;
public: public:
LoadCombine() LoadCombine() : BasicBlockPass(ID), C(nullptr), AA(nullptr) {
: BasicBlockPass(ID),
C(nullptr), DL(nullptr), AA(nullptr) {
initializeSROAPass(*PassRegistry::getPassRegistry()); initializeSROAPass(*PassRegistry::getPassRegistry());
} }
Context not available.
bool LoadCombine::doInitialization(Function &F) { bool LoadCombine::doInitialization(Function &F) {
DEBUG(dbgs() << "LoadCombine function: " << F.getName() << "\n"); DEBUG(dbgs() << "LoadCombine function: " << F.getName() << "\n");
C = &F.getContext(); C = &F.getContext();
DL = &F.getParent()->getDataLayout();
if (!DL) {
DEBUG(dbgs() << " Skipping LoadCombine -- no target data!\n");
return false;
}
return true; return true;
} }
Context not available.
POP.Offset = 0; POP.Offset = 0;
while (isa<BitCastInst>(POP.Pointer) || isa<GetElementPtrInst>(POP.Pointer)) { while (isa<BitCastInst>(POP.Pointer) || isa<GetElementPtrInst>(POP.Pointer)) {
if (auto *GEP = dyn_cast<GetElementPtrInst>(POP.Pointer)) { if (auto *GEP = dyn_cast<GetElementPtrInst>(POP.Pointer)) {
unsigned BitWidth = DL->getPointerTypeSizeInBits(GEP->getType()); auto &DL = LI.getModule()->getDataLayout();
unsigned BitWidth = DL.getPointerTypeSizeInBits(GEP->getType());
APInt Offset(BitWidth, 0); APInt Offset(BitWidth, 0);
if (GEP->accumulateConstantOffset(*DL, Offset)) if (GEP->accumulateConstantOffset(DL, Offset))
POP.Offset += Offset.getZExtValue(); POP.Offset += Offset.getZExtValue();
else else
// Can't handle GEPs with variable indices. // Can't handle GEPs with variable indices.
Context not available.
if (PrevOffset == -1ull) { if (PrevOffset == -1ull) {
BaseLoad = L.Load; BaseLoad = L.Load;
PrevOffset = L.POP.Offset; PrevOffset = L.POP.Offset;
PrevSize = DL->getTypeStoreSize(L.Load->getType()); PrevSize = L.Load->getModule()->getDataLayout().getTypeStoreSize(
L.Load->getType());
AggregateLoads.push_back(L); AggregateLoads.push_back(L);
continue; continue;
} }
Context not available.
// FIXME: We may want to handle this case. // FIXME: We may want to handle this case.
continue; continue;
PrevOffset = L.POP.Offset; PrevOffset = L.POP.Offset;
PrevSize = DL->getTypeStoreSize(L.Load->getType()); PrevSize = L.Load->getModule()->getDataLayout().getTypeStoreSize(
L.Load->getType());
AggregateLoads.push_back(L); AggregateLoads.push_back(L);
} }
if (combineLoads(AggregateLoads)) if (combineLoads(AggregateLoads))
Context not available.
for (const auto &L : Loads) { for (const auto &L : Loads) {
Builder->SetInsertPoint(L.Load); Builder->SetInsertPoint(L.Load);
Value *V = Builder->CreateExtractInteger( Value *V = Builder->CreateExtractInteger(
*DL, NewLoad, cast<IntegerType>(L.Load->getType()), L.Load->getModule()->getDataLayout(), NewLoad,
cast<IntegerType>(L.Load->getType()),
L.POP.Offset - Loads[0].POP.Offset, "combine.extract"); L.POP.Offset - Loads[0].POP.Offset, "combine.extract");
L.Load->replaceAllUsesWith(V); L.Load->replaceAllUsesWith(V);
} }
Context not available.
} }
bool LoadCombine::runOnBasicBlock(BasicBlock &BB) { bool LoadCombine::runOnBasicBlock(BasicBlock &BB) {
if (skipOptnoneFunction(BB) || !DL) if (skipOptnoneFunction(BB))
return false; return false;
AA = &getAnalysis<AliasAnalysis>(); AA = &getAnalysis<AliasAnalysis>();
IRBuilder<true, TargetFolder> IRBuilder<true, TargetFolder> TheBuilder(
TheBuilder(BB.getContext(), TargetFolder(DL)); BB.getContext(), TargetFolder(BB.getModule()->getDataLayout()));
Builder = &TheBuilder; Builder = &TheBuilder;
DenseMap<const Value *, SmallVector<LoadPOPPair, 8>> LoadMap; DenseMap<const Value *, SmallVector<LoadPOPPair, 8>> LoadMap;
Context not available.

lib/Transforms/Scalar/LoopIdiomRecognize.cpp

Context not available.
// header. This allows us to insert code for it in the preheader. // header. This allows us to insert code for it in the preheader.
BasicBlock *Preheader = CurLoop->getLoopPreheader(); BasicBlock *Preheader = CurLoop->getLoopPreheader();
IRBuilder<> Builder(Preheader->getTerminator()); IRBuilder<> Builder(Preheader->getTerminator());
SCEVExpander Expander(*SE, "loop-idiom"); SCEVExpander Expander(*SE, DL, "loop-idiom");
Type *DestInt8PtrTy = Builder.getInt8PtrTy(DestAS); Type *DestInt8PtrTy = Builder.getInt8PtrTy(DestAS);
Context not available.
// The # stored bytes is (BECount+1)*Size. Expand the trip count out to // The # stored bytes is (BECount+1)*Size. Expand the trip count out to
// pointer size if it isn't already. // pointer size if it isn't already.
Type *IntPtr = Builder.getIntPtrTy(&DL, DestAS); Type *IntPtr = Builder.getIntPtrTy(DL, DestAS);
BECount = SE->getTruncateOrZeroExtend(BECount, IntPtr); BECount = SE->getTruncateOrZeroExtend(BECount, IntPtr);
const SCEV *NumBytesS = SE->getAddExpr(BECount, SE->getConstant(IntPtr, 1), const SCEV *NumBytesS = SE->getAddExpr(BECount, SE->getConstant(IntPtr, 1),
Context not available.
// header. This allows us to insert code for it in the preheader. // header. This allows us to insert code for it in the preheader.
BasicBlock *Preheader = CurLoop->getLoopPreheader(); BasicBlock *Preheader = CurLoop->getLoopPreheader();
IRBuilder<> Builder(Preheader->getTerminator()); IRBuilder<> Builder(Preheader->getTerminator());
SCEVExpander Expander(*SE, "loop-idiom"); const DataLayout &DL = Preheader->getModule()->getDataLayout();
SCEVExpander Expander(*SE, DL, "loop-idiom");
// Okay, we have a strided store "p[i]" of a loaded value. We can turn // Okay, we have a strided store "p[i]" of a loaded value. We can turn
// this into a memcpy in the loop preheader now if we want. However, this // this into a memcpy in the loop preheader now if we want. However, this
Context not available.
// The # stored bytes is (BECount+1)*Size. Expand the trip count out to // The # stored bytes is (BECount+1)*Size. Expand the trip count out to
// pointer size if it isn't already. // pointer size if it isn't already.
auto &DL = CurLoop->getHeader()->getModule()->getDataLayout(); Type *IntPtrTy = Builder.getIntPtrTy(DL, SI->getPointerAddressSpace());
Type *IntPtrTy = Builder.getIntPtrTy(&DL, SI->getPointerAddressSpace());
BECount = SE->getTruncateOrZeroExtend(BECount, IntPtrTy); BECount = SE->getTruncateOrZeroExtend(BECount, IntPtrTy);
const SCEV *NumBytesS = SE->getAddExpr(BECount, SE->getConstant(IntPtrTy, 1), const SCEV *NumBytesS = SE->getAddExpr(BECount, SE->getConstant(IntPtrTy, 1),
Context not available.

lib/Transforms/Scalar/LoopInstSimplify.cpp

Context not available.
getAnalysisIfAvailable<DominatorTreeWrapperPass>(); getAnalysisIfAvailable<DominatorTreeWrapperPass>();
DominatorTree *DT = DTWP ? &DTWP->getDomTree() : nullptr; DominatorTree *DT = DTWP ? &DTWP->getDomTree() : nullptr;
LoopInfo *LI = &getAnalysis<LoopInfoWrapperPass>().getLoopInfo(); LoopInfo *LI = &getAnalysis<LoopInfoWrapperPass>().getLoopInfo();
const DataLayout *DL = &L->getHeader()->getModule()->getDataLayout();
const TargetLibraryInfo *TLI = const TargetLibraryInfo *TLI =
&getAnalysis<TargetLibraryInfoWrapperPass>().getTLI(); &getAnalysis<TargetLibraryInfoWrapperPass>().getTLI();
auto &AC = getAnalysis<AssumptionCacheTracker>().getAssumptionCache( auto &AC = getAnalysis<AssumptionCacheTracker>().getAssumptionCache(
Context not available.
WorklistItem Item = VisitStack.pop_back_val(); WorklistItem Item = VisitStack.pop_back_val();
BasicBlock *BB = Item.getPointer(); BasicBlock *BB = Item.getPointer();
bool IsSubloopHeader = Item.getInt(); bool IsSubloopHeader = Item.getInt();
const DataLayout &DL = L->getHeader()->getModule()->getDataLayout();
// Simplify instructions in the current basic block. // Simplify instructions in the current basic block.
for (BasicBlock::iterator BI = BB->begin(), BE = BB->end(); BI != BE;) { for (BasicBlock::iterator BI = BB->begin(), BE = BB->end(); BI != BE;) {
Context not available.

lib/Transforms/Scalar/LoopRerollPass.cpp

Context not available.
AliasAnalysis *AA; AliasAnalysis *AA;
LoopInfo *LI; LoopInfo *LI;
ScalarEvolution *SE; ScalarEvolution *SE;
const DataLayout *DL;
TargetLibraryInfo *TLI; TargetLibraryInfo *TLI;
DominatorTree *DT; DominatorTree *DT;
Context not available.
struct DAGRootTracker { struct DAGRootTracker {
DAGRootTracker(LoopReroll *Parent, Loop *L, Instruction *IV, DAGRootTracker(LoopReroll *Parent, Loop *L, Instruction *IV,
ScalarEvolution *SE, AliasAnalysis *AA, ScalarEvolution *SE, AliasAnalysis *AA,
TargetLibraryInfo *TLI, const DataLayout *DL) TargetLibraryInfo *TLI)
: Parent(Parent), L(L), SE(SE), AA(AA), TLI(TLI), : Parent(Parent), L(L), SE(SE), AA(AA), TLI(TLI), IV(IV) {}
DL(DL), IV(IV) {
}
/// Stage 1: Find all the DAG roots for the induction variable. /// Stage 1: Find all the DAG roots for the induction variable.
bool findRoots(); bool findRoots();
Context not available.
ScalarEvolution *SE; ScalarEvolution *SE;
AliasAnalysis *AA; AliasAnalysis *AA;
TargetLibraryInfo *TLI; TargetLibraryInfo *TLI;
const DataLayout *DL;
// The loop induction variable. // The loop induction variable.
Instruction *IV; Instruction *IV;
Context not available.
// needed because otherwise isSafeToSpeculativelyExecute returns // needed because otherwise isSafeToSpeculativelyExecute returns
// false on PHI nodes. // false on PHI nodes.
if (!isa<PHINode>(I) && !isSimpleLoadStore(I) && if (!isa<PHINode>(I) && !isSimpleLoadStore(I) &&
!isSafeToSpeculativelyExecute(I, DL)) !isSafeToSpeculativelyExecute(I))
// Intervening instructions cause side effects. // Intervening instructions cause side effects.
FutureSideEffects = true; FutureSideEffects = true;
} }
Context not available.
// side effects, and this instruction might also, then we can't reorder // side effects, and this instruction might also, then we can't reorder
// them, and this matching fails. As an exception, we allow the alias // them, and this matching fails. As an exception, we allow the alias
// set tracker to handle regular (simple) load/store dependencies. // set tracker to handle regular (simple) load/store dependencies.
if (FutureSideEffects && if (FutureSideEffects && ((!isSimpleLoadStore(BaseInst) &&
((!isSimpleLoadStore(BaseInst) && !isSafeToSpeculativelyExecute(BaseInst)) ||
!isSafeToSpeculativelyExecute(BaseInst, DL)) || (!isSimpleLoadStore(RootInst) &&
(!isSimpleLoadStore(RootInst) && !isSafeToSpeculativelyExecute(RootInst)))) {
!isSafeToSpeculativelyExecute(RootInst, DL)))) {
DEBUG(dbgs() << "LRR: iteration root match failed at " << *BaseInst << DEBUG(dbgs() << "LRR: iteration root match failed at " << *BaseInst <<
" vs. " << *RootInst << " vs. " << *RootInst <<
" (side effects prevent reordering)\n"); " (side effects prevent reordering)\n");
Context not available.
++J; ++J;
} }
const DataLayout &DL = Header->getModule()->getDataLayout();
// We need to create a new induction variable for each different BaseInst. // We need to create a new induction variable for each different BaseInst.
for (auto &DRS : RootSets) { for (auto &DRS : RootSets) {
Context not available.
SE->getConstant(RealIVSCEV->getType(), 1), SE->getConstant(RealIVSCEV->getType(), 1),
L, SCEV::FlagAnyWrap)); L, SCEV::FlagAnyWrap));
{ // Limit the lifetime of SCEVExpander. { // Limit the lifetime of SCEVExpander.
SCEVExpander Expander(*SE, "reroll"); SCEVExpander Expander(*SE, DL, "reroll");
Value *NewIV = Expander.expandCodeFor(H, IV->getType(), Header->begin()); Value *NewIV = Expander.expandCodeFor(H, IV->getType(), Header->begin());
for (auto &KV : Uses) { for (auto &KV : Uses) {
Context not available.
} }
} }
SimplifyInstructionsInBlock(Header, DL, TLI); SimplifyInstructionsInBlock(Header, TLI);
DeleteDeadPHIs(Header, TLI); DeleteDeadPHIs(Header, TLI);
} }
Context not available.
bool LoopReroll::reroll(Instruction *IV, Loop *L, BasicBlock *Header, bool LoopReroll::reroll(Instruction *IV, Loop *L, BasicBlock *Header,
const SCEV *IterCount, const SCEV *IterCount,
ReductionTracker &Reductions) { ReductionTracker &Reductions) {
DAGRootTracker DAGRoots(this, L, IV, SE, AA, TLI, DL); DAGRootTracker DAGRoots(this, L, IV, SE, AA, TLI);
if (!DAGRoots.findRoots()) if (!DAGRoots.findRoots())
return false; return false;
Context not available.
LI = &getAnalysis<LoopInfoWrapperPass>().getLoopInfo(); LI = &getAnalysis<LoopInfoWrapperPass>().getLoopInfo();
SE = &getAnalysis<ScalarEvolution>(); SE = &getAnalysis<ScalarEvolution>();
TLI = &getAnalysis<TargetLibraryInfoWrapperPass>().getTLI(); TLI = &getAnalysis<TargetLibraryInfoWrapperPass>().getTLI();
DL = &L->getHeader()->getModule()->getDataLayout();
DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree(); DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
BasicBlock *Header = L->getHeader(); BasicBlock *Header = L->getHeader();
Context not available.

lib/Transforms/Scalar/LoopRotation.cpp

Context not available.
for (; PHINode *PN = dyn_cast<PHINode>(I); ++I) for (; PHINode *PN = dyn_cast<PHINode>(I); ++I)
ValueMap[PN] = PN->getIncomingValueForBlock(OrigPreheader); ValueMap[PN] = PN->getIncomingValueForBlock(OrigPreheader);
const DataLayout &DL = L->getHeader()->getModule()->getDataLayout();
// For the rest of the instructions, either hoist to the OrigPreheader if // For the rest of the instructions, either hoist to the OrigPreheader if
// possible or create a clone in the OldPreHeader if not. // possible or create a clone in the OldPreHeader if not.
TerminatorInst *LoopEntryBranch = OrigPreheader->getTerminator(); TerminatorInst *LoopEntryBranch = OrigPreheader->getTerminator();
Context not available.
// otherwise simplifyable. This commonly occurs because the entry from PHI // otherwise simplifyable. This commonly occurs because the entry from PHI
// nodes allows icmps and other instructions to fold. // nodes allows icmps and other instructions to fold.
// FIXME: Provide DL, TLI, DT, AC to SimplifyInstruction. // FIXME: Provide DL, TLI, DT, AC to SimplifyInstruction.
Value *V = SimplifyInstruction(C); Value *V = SimplifyInstruction(C, DL);
if (V && LI->replacementPreservesLCSSAForm(C, V)) { if (V && LI->replacementPreservesLCSSAForm(C, V)) {
// If so, then delete the temporary instruction and stick the folded value // If so, then delete the temporary instruction and stick the folded value
// in the map. // in the map.
Context not available.

lib/Transforms/Scalar/LoopStrengthReduce.cpp

Context not available.
// we can remove them after we are done working. // we can remove them after we are done working.
SmallVector<WeakVH, 16> DeadInsts; SmallVector<WeakVH, 16> DeadInsts;
SCEVExpander Rewriter(SE, "lsr"); SCEVExpander Rewriter(SE, L->getHeader()->getModule()->getDataLayout(),
"lsr");
#ifndef NDEBUG #ifndef NDEBUG
Rewriter.setDebugType(DEBUG_TYPE); Rewriter.setDebugType(DEBUG_TYPE);
#endif #endif
Context not available.
Changed |= DeleteDeadPHIs(L->getHeader()); Changed |= DeleteDeadPHIs(L->getHeader());
if (EnablePhiElim && L->isLoopSimplifyForm()) { if (EnablePhiElim && L->isLoopSimplifyForm()) {
SmallVector<WeakVH, 16> DeadInsts; SmallVector<WeakVH, 16> DeadInsts;
SCEVExpander Rewriter(getAnalysis<ScalarEvolution>(), "lsr"); const DataLayout &DL = L->getHeader()->getModule()->getDataLayout();
SCEVExpander Rewriter(getAnalysis<ScalarEvolution>(), DL, "lsr");
#ifndef NDEBUG #ifndef NDEBUG
Rewriter.setDebugType(DEBUG_TYPE); Rewriter.setDebugType(DEBUG_TYPE);
#endif #endif
Context not available.

lib/Transforms/Scalar/LoopUnrollPass.cpp

Context not available.
if (Constant *SimpleRHS = SimplifiedValues.lookup(RHS)) if (Constant *SimpleRHS = SimplifiedValues.lookup(RHS))
RHS = SimpleRHS; RHS = SimpleRHS;
Value *SimpleV = nullptr; Value *SimpleV = nullptr;
const DataLayout &DL = I.getModule()->getDataLayout();
if (auto FI = dyn_cast<FPMathOperator>(&I)) if (auto FI = dyn_cast<FPMathOperator>(&I))
SimpleV = SimpleV =
SimplifyFPBinOp(I.getOpcode(), LHS, RHS, FI->getFastMathFlags()); SimplifyFPBinOp(I.getOpcode(), LHS, RHS, FI->getFastMathFlags(), DL);
else else
SimpleV = SimplifyBinOp(I.getOpcode(), LHS, RHS); SimpleV = SimplifyBinOp(I.getOpcode(), LHS, RHS, DL);
if (SimpleV && CountedInstructions.insert(&I).second) if (SimpleV && CountedInstructions.insert(&I).second)
NumberOfOptimizedInstructions += TTI.getUserCost(&I); NumberOfOptimizedInstructions += TTI.getUserCost(&I);
Context not available.

lib/Transforms/Scalar/LoopUnswitch.cpp

Context not available.
/// pass. /// pass.
/// ///
void LoopUnswitch::SimplifyCode(std::vector<Instruction*> &Worklist, Loop *L) { void LoopUnswitch::SimplifyCode(std::vector<Instruction*> &Worklist, Loop *L) {
const DataLayout &DL = L->getHeader()->getModule()->getDataLayout();
while (!Worklist.empty()) { while (!Worklist.empty()) {
Instruction *I = Worklist.back(); Instruction *I = Worklist.back();
Worklist.pop_back(); Worklist.pop_back();
Context not available.
// See if instruction simplification can hack this up. This is common for // See if instruction simplification can hack this up. This is common for
// things like "select false, X, Y" after unswitching made the condition be // things like "select false, X, Y" after unswitching made the condition be
// 'false'. TODO: update the domtree properly so we can pass it here. // 'false'. TODO: update the domtree properly so we can pass it here.
if (Value *V = SimplifyInstruction(I)) if (Value *V = SimplifyInstruction(I, DL))
if (LI->replacementPreservesLCSSAForm(I, V)) { if (LI->replacementPreservesLCSSAForm(I, V)) {
ReplaceUsesOfWith(I, V, Worklist, L, LPM); ReplaceUsesOfWith(I, V, Worklist, L, LPM);
continue; continue;
Context not available.

lib/Transforms/Scalar/MemCpyOptimizer.cpp

Context not available.
class MemCpyOpt : public FunctionPass { class MemCpyOpt : public FunctionPass {
MemoryDependenceAnalysis *MD; MemoryDependenceAnalysis *MD;
TargetLibraryInfo *TLI; TargetLibraryInfo *TLI;
const DataLayout *DL;
public: public:
static char ID; // Pass identification, replacement for typeid static char ID; // Pass identification, replacement for typeid
MemCpyOpt() : FunctionPass(ID) { MemCpyOpt() : FunctionPass(ID) {
initializeMemCpyOptPass(*PassRegistry::getPassRegistry()); initializeMemCpyOptPass(*PassRegistry::getPassRegistry());
MD = nullptr; MD = nullptr;
TLI = nullptr; TLI = nullptr;
DL = nullptr;
} }
bool runOnFunction(Function &F) override; bool runOnFunction(Function &F) override;
Context not available.
/// attempts to merge them together into a memcpy/memset. /// attempts to merge them together into a memcpy/memset.
Instruction *MemCpyOpt::tryMergingIntoMemset(Instruction *StartInst, Instruction *MemCpyOpt::tryMergingIntoMemset(Instruction *StartInst,
Value *StartPtr, Value *ByteVal) { Value *StartPtr, Value *ByteVal) {
if (!DL) return nullptr; const DataLayout &DL = StartInst->getModule()->getDataLayout();
// Okay, so we now have a single store that can be splatable. Scan to find // Okay, so we now have a single store that can be splatable. Scan to find
// all subsequent stores of the same value to offset from the same pointer. // all subsequent stores of the same value to offset from the same pointer.
// Join these together into ranges, so we can decide whether contiguous blocks // Join these together into ranges, so we can decide whether contiguous blocks
// are stored. // are stored.
MemsetRanges Ranges(*DL); MemsetRanges Ranges(DL);
BasicBlock::iterator BI = StartInst; BasicBlock::iterator BI = StartInst;
for (++BI; !isa<TerminatorInst>(BI); ++BI) { for (++BI; !isa<TerminatorInst>(BI); ++BI) {
Context not available.
// Check to see if this store is to a constant offset from the start ptr. // Check to see if this store is to a constant offset from the start ptr.
int64_t Offset; int64_t Offset;
if (!IsPointerOffset(StartPtr, NextStore->getPointerOperand(), if (!IsPointerOffset(StartPtr, NextStore->getPointerOperand(), Offset,
Offset, *DL)) DL))
break; break;
Ranges.addStore(Offset, NextStore); Ranges.addStore(Offset, NextStore);
Context not available.
// Check to see if this store is to a constant offset from the start ptr. // Check to see if this store is to a constant offset from the start ptr.
int64_t Offset; int64_t Offset;
if (!IsPointerOffset(StartPtr, MSI->getDest(), Offset, *DL)) if (!IsPointerOffset(StartPtr, MSI->getDest(), Offset, DL))
break; break;
Ranges.addMemSet(Offset, MSI); Ranges.addMemSet(Offset, MSI);
Context not available.
if (Range.TheStores.size() == 1) continue; if (Range.TheStores.size() == 1) continue;
// If it is profitable to lower this range to memset, do so now. // If it is profitable to lower this range to memset, do so now.
if (!Range.isProfitableToUseMemset(*DL)) if (!Range.isProfitableToUseMemset(DL))
continue; continue;
// Otherwise, we do want to transform this! Create a new memset. // Otherwise, we do want to transform this! Create a new memset.
Context not available.
if (Alignment == 0) { if (Alignment == 0) {
Type *EltType = Type *EltType =
cast<PointerType>(StartPtr->getType())->getElementType(); cast<PointerType>(StartPtr->getType())->getElementType();
Alignment = DL->getABITypeAlignment(EltType); Alignment = DL.getABITypeAlignment(EltType);
} }
AMemSet = AMemSet =
Context not available.
bool MemCpyOpt::processStore(StoreInst *SI, BasicBlock::iterator &BBI) { bool MemCpyOpt::processStore(StoreInst *SI, BasicBlock::iterator &BBI) {
if (!SI->isSimple()) return false; if (!SI->isSimple()) return false;
const DataLayout &DL = SI->getModule()->getDataLayout();
if (!DL) return false;
// Detect cases where we're performing call slot forwarding, but // Detect cases where we're performing call slot forwarding, but
// happen to be using a load-store pair to implement it, rather than // happen to be using a load-store pair to implement it, rather than
Context not available.
if (C) { if (C) {
unsigned storeAlign = SI->getAlignment(); unsigned storeAlign = SI->getAlignment();
if (!storeAlign) if (!storeAlign)
storeAlign = DL->getABITypeAlignment(SI->getOperand(0)->getType()); storeAlign = DL.getABITypeAlignment(SI->getOperand(0)->getType());
unsigned loadAlign = LI->getAlignment(); unsigned loadAlign = LI->getAlignment();
if (!loadAlign) if (!loadAlign)
loadAlign = DL->getABITypeAlignment(LI->getType()); loadAlign = DL.getABITypeAlignment(LI->getType());
bool changed = performCallSlotOptzn(LI, bool changed = performCallSlotOptzn(
SI->getPointerOperand()->stripPointerCasts(), LI, SI->getPointerOperand()->stripPointerCasts(),
LI->getPointerOperand()->stripPointerCasts(), LI->getPointerOperand()->stripPointerCasts(),
DL->getTypeStoreSize(SI->getOperand(0)->getType()), DL.getTypeStoreSize(SI->getOperand(0)->getType()),
std::min(storeAlign, loadAlign), C); std::min(storeAlign, loadAlign), C);
if (changed) { if (changed) {
MD->removeInstruction(SI); MD->removeInstruction(SI);
SI->eraseFromParent(); SI->eraseFromParent();
Context not available.
if (!srcAlloca) if (!srcAlloca)
return false; return false;
// Check that all of src is copied to dest.
if (!DL) return false;
ConstantInt *srcArraySize = dyn_cast<ConstantInt>(srcAlloca->getArraySize()); ConstantInt *srcArraySize = dyn_cast<ConstantInt>(srcAlloca->getArraySize());
if (!srcArraySize) if (!srcArraySize)
return false; return false;
uint64_t srcSize = DL->getTypeAllocSize(srcAlloca->getAllocatedType()) * const DataLayout &DL = cpy->getModule()->getDataLayout();
srcArraySize->getZExtValue(); uint64_t srcSize = DL.getTypeAllocSize(srcAlloca->getAllocatedType()) *
srcArraySize->getZExtValue();
if (cpyLen < srcSize) if (cpyLen < srcSize)
return false; return false;
Context not available.
if (!destArraySize) if (!destArraySize)
return false; return false;
uint64_t destSize = DL->getTypeAllocSize(A->getAllocatedType()) * uint64_t destSize = DL.getTypeAllocSize(A->getAllocatedType()) *
destArraySize->getZExtValue(); destArraySize->getZExtValue();
if (destSize < srcSize) if (destSize < srcSize)
return false; return false;
Context not available.
return false; return false;
} }
uint64_t destSize = DL->getTypeAllocSize(StructTy); uint64_t destSize = DL.getTypeAllocSize(StructTy);
if (destSize < srcSize) if (destSize < srcSize)
return false; return false;
} }
Context not available.
// Check that dest points to memory that is at least as aligned as src. // Check that dest points to memory that is at least as aligned as src.
unsigned srcAlign = srcAlloca->getAlignment(); unsigned srcAlign = srcAlloca->getAlignment();
if (!srcAlign) if (!srcAlign)
srcAlign = DL->getABITypeAlignment(srcAlloca->getAllocatedType()); srcAlign = DL.getABITypeAlignment(srcAlloca->getAllocatedType());
bool isDestSufficientlyAligned = srcAlign <= cpyAlign; bool isDestSufficientlyAligned = srcAlign <= cpyAlign;
// If dest is not aligned enough and we can't increase its alignment then // If dest is not aligned enough and we can't increase its alignment then
// bail out. // bail out.
Context not available.
/// processByValArgument - This is called on every byval argument in call sites. /// processByValArgument - This is called on every byval argument in call sites.
bool MemCpyOpt::processByValArgument(CallSite CS, unsigned ArgNo) { bool MemCpyOpt::processByValArgument(CallSite CS, unsigned ArgNo) {
if (!DL) return false; const DataLayout &DL = CS.getCaller()->getParent()->getDataLayout();
// Find out what feeds this byval argument. // Find out what feeds this byval argument.
Value *ByValArg = CS.getArgument(ArgNo); Value *ByValArg = CS.getArgument(ArgNo);
Type *ByValTy = cast<PointerType>(ByValArg->getType())->getElementType(); Type *ByValTy = cast<PointerType>(ByValArg->getType())->getElementType();
uint64_t ByValSize = DL->getTypeAllocSize(ByValTy); uint64_t ByValSize = DL.getTypeAllocSize(ByValTy);
MemDepResult DepInfo = MemDepResult DepInfo =
MD->getPointerDependencyFrom(AliasAnalysis::Location(ByValArg, ByValSize), MD->getPointerDependencyFrom(AliasAnalysis::Location(ByValArg, ByValSize),
true, CS.getInstruction(), true, CS.getInstruction(),
Context not available.
*CS->getParent()->getParent()); *CS->getParent()->getParent());
DominatorTree &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree(); DominatorTree &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
if (MDep->getAlignment() < ByValAlign && if (MDep->getAlignment() < ByValAlign &&
getOrEnforceKnownAlignment(MDep->getSource(), ByValAlign, DL, &AC, getOrEnforceKnownAlignment(MDep->getSource(), ByValAlign,
CS.getInstruction(), &DT) < ByValAlign) *CS.getInstruction(), &AC, &DT) < ByValAlign)
return false; return false;
// Verify that the copied-from memory doesn't change in between the memcpy and // Verify that the copied-from memory doesn't change in between the memcpy and
Context not available.
bool MadeChange = false; bool MadeChange = false;
MD = &getAnalysis<MemoryDependenceAnalysis>(); MD = &getAnalysis<MemoryDependenceAnalysis>();
DL = &F.getParent()->getDataLayout();
TLI = &getAnalysis<TargetLibraryInfoWrapperPass>().getTLI(); TLI = &getAnalysis<TargetLibraryInfoWrapperPass>().getTLI();
// If we don't have at least memset and memcpy, there is little point of doing // If we don't have at least memset and memcpy, there is little point of doing
Context not available.

lib/Transforms/Scalar/SCCP.cpp

Context not available.
} }
// Transform load from a constant into a constant if possible. // Transform load from a constant into a constant if possible.
if (Constant *C = ConstantFoldLoadFromConstPtr(Ptr, &DL)) if (Constant *C = ConstantFoldLoadFromConstPtr(Ptr, DL))
return markConstant(IV, &I, C); return markConstant(IV, &I, C);
// Otherwise we cannot say for certain what value this load will produce. // Otherwise we cannot say for certain what value this load will produce.
Context not available.

lib/Transforms/Scalar/SROA.cpp

Context not available.
// by writing out the code here where we have tho underlying allocation // by writing out the code here where we have tho underlying allocation
// size readily available. // size readily available.
APInt GEPOffset = Offset; APInt GEPOffset = Offset;
const DataLayout &DL = GEPI.getModule()->getDataLayout();
for (gep_type_iterator GTI = gep_type_begin(GEPI), for (gep_type_iterator GTI = gep_type_begin(GEPI),
GTE = gep_type_end(GEPI); GTE = gep_type_end(GEPI);
GTI != GTE; ++GTI) { GTI != GTE; ++GTI) {
Context not available.
if (!IsOffsetKnown) if (!IsOffsetKnown)
return PI.setAborted(&LI); return PI.setAborted(&LI);
const DataLayout &DL = LI.getModule()->getDataLayout();
uint64_t Size = DL.getTypeStoreSize(LI.getType()); uint64_t Size = DL.getTypeStoreSize(LI.getType());
return handleLoadOrStore(LI.getType(), LI, Offset, Size, LI.isVolatile()); return handleLoadOrStore(LI.getType(), LI, Offset, Size, LI.isVolatile());
} }
Context not available.
if (!IsOffsetKnown) if (!IsOffsetKnown)
return PI.setAborted(&SI); return PI.setAborted(&SI);
const DataLayout &DL = SI.getModule()->getDataLayout();
uint64_t Size = DL.getTypeStoreSize(ValOp->getType()); uint64_t Size = DL.getTypeStoreSize(ValOp->getType());
// If this memory access can be shown to *statically* extend outside the // If this memory access can be shown to *statically* extend outside the
Context not available.
SmallVector<std::pair<Instruction *, Instruction *>, 4> Uses; SmallVector<std::pair<Instruction *, Instruction *>, 4> Uses;
Visited.insert(Root); Visited.insert(Root);
Uses.push_back(std::make_pair(cast<Instruction>(*U), Root)); Uses.push_back(std::make_pair(cast<Instruction>(*U), Root));
const DataLayout &DL = Root->getModule()->getDataLayout();
// If there are no loads or stores, the access is dead. We mark that as // If there are no loads or stores, the access is dead. We mark that as
// a size zero access. // a size zero access.
Size = 0; Size = 0;
Context not available.
const bool RequiresDomTree; const bool RequiresDomTree;
LLVMContext *C; LLVMContext *C;
const DataLayout *DL;
DominatorTree *DT; DominatorTree *DT;
AssumptionCache *AC; AssumptionCache *AC;
Context not available.
public: public:
SROA(bool RequiresDomTree = true) SROA(bool RequiresDomTree = true)
: FunctionPass(ID), RequiresDomTree(RequiresDomTree), C(nullptr), : FunctionPass(ID), RequiresDomTree(RequiresDomTree), C(nullptr),
DL(nullptr), DT(nullptr) { DT(nullptr) {
initializeSROAPass(*PassRegistry::getPassRegistry()); initializeSROAPass(*PassRegistry::getPassRegistry());
} }
bool runOnFunction(Function &F) override; bool runOnFunction(Function &F) override;
Context not available.
/// ///
/// FIXME: This should be hoisted into a generic utility, likely in /// FIXME: This should be hoisted into a generic utility, likely in
/// Transforms/Util/Local.h /// Transforms/Util/Local.h
static bool isSafePHIToSpeculate(PHINode &PN, const DataLayout *DL = nullptr) { static bool isSafePHIToSpeculate(PHINode &PN) {
// For now, we can only do this promotion if the load is in the same block // For now, we can only do this promotion if the load is in the same block
// as the PHI, and if there are no stores between the phi and load. // as the PHI, and if there are no stores between the phi and load.
// TODO: Allow recursive phi users. // TODO: Allow recursive phi users.
Context not available.
if (!HaveLoad) if (!HaveLoad)
return false; return false;
const DataLayout &DL = PN.getModule()->getDataLayout();
// We can only transform this if it is safe to push the loads into the // We can only transform this if it is safe to push the loads into the
// predecessor blocks. The only thing to watch out for is that we can't put // predecessor blocks. The only thing to watch out for is that we can't put
// a possibly trapping load in the predecessor if it is a critical edge. // a possibly trapping load in the predecessor if it is a critical edge.
Context not available.
// is already a load in the block, then we can move the load to the pred // is already a load in the block, then we can move the load to the pred
// block. // block.
if (InVal->isDereferenceablePointer(DL) || if (InVal->isDereferenceablePointer(DL) ||
isSafeToLoadUnconditionally(InVal, TI, MaxAlign, DL)) isSafeToLoadUnconditionally(InVal, TI, MaxAlign))
continue; continue;
return false; return false;
Context not available.
/// ///
/// We can do this to a select if its only uses are loads and if the operand /// We can do this to a select if its only uses are loads and if the operand
/// to the select can be loaded unconditionally. /// to the select can be loaded unconditionally.
static bool isSafeSelectToSpeculate(SelectInst &SI, static bool isSafeSelectToSpeculate(SelectInst &SI) {
const DataLayout *DL = nullptr) {
Value *TValue = SI.getTrueValue(); Value *TValue = SI.getTrueValue();
Value *FValue = SI.getFalseValue(); Value *FValue = SI.getFalseValue();
const DataLayout &DL = SI.getModule()->getDataLayout();
bool TDerefable = TValue->isDereferenceablePointer(DL); bool TDerefable = TValue->isDereferenceablePointer(DL);
bool FDerefable = FValue->isDereferenceablePointer(DL); bool FDerefable = FValue->isDereferenceablePointer(DL);
Context not available.
// absolutely (e.g. allocas) or at this point because we can see other // absolutely (e.g. allocas) or at this point because we can see other
// accesses to it. // accesses to it.
if (!TDerefable && if (!TDerefable &&
!isSafeToLoadUnconditionally(TValue, LI, LI->getAlignment(), DL)) !isSafeToLoadUnconditionally(TValue, LI, LI->getAlignment()))
return false; return false;
if (!FDerefable && if (!FDerefable &&
!isSafeToLoadUnconditionally(FValue, LI, LI->getAlignment(), DL)) !isSafeToLoadUnconditionally(FValue, LI, LI->getAlignment()))
return false; return false;
} }
Context not available.
// them to the alloca slices. // them to the alloca slices.
SmallDenseMap<LoadInst *, std::vector<LoadInst *>, 1> SplitLoadsMap; SmallDenseMap<LoadInst *, std::vector<LoadInst *>, 1> SplitLoadsMap;
std::vector<LoadInst *> SplitLoads; std::vector<LoadInst *> SplitLoads;
const DataLayout &DL = AI.getModule()->getDataLayout();
for (LoadInst *LI : Loads) { for (LoadInst *LI : Loads) {
SplitLoads.clear(); SplitLoads.clear();
Context not available.
auto *PartTy = Type::getIntNTy(Ty->getContext(), PartSize * 8); auto *PartTy = Type::getIntNTy(Ty->getContext(), PartSize * 8);
auto *PartPtrTy = PartTy->getPointerTo(LI->getPointerAddressSpace()); auto *PartPtrTy = PartTy->getPointerTo(LI->getPointerAddressSpace());
LoadInst *PLoad = IRB.CreateAlignedLoad( LoadInst *PLoad = IRB.CreateAlignedLoad(
getAdjustedPtr(IRB, *DL, BasePtr, getAdjustedPtr(IRB, DL, BasePtr,
APInt(DL->getPointerSizeInBits(), PartOffset), APInt(DL.getPointerSizeInBits(), PartOffset),
PartPtrTy, BasePtr->getName() + "."), PartPtrTy, BasePtr->getName() + "."),
getAdjustedAlignment(LI, PartOffset, *DL), /*IsVolatile*/ false, getAdjustedAlignment(LI, PartOffset, DL), /*IsVolatile*/ false,
LI->getName()); LI->getName());
// Append this load onto the list of split loads so we can find it later // Append this load onto the list of split loads so we can find it later
Context not available.
PLoad->getType()->getPointerTo(SI->getPointerAddressSpace()); PLoad->getType()->getPointerTo(SI->getPointerAddressSpace());
StoreInst *PStore = IRB.CreateAlignedStore( StoreInst *PStore = IRB.CreateAlignedStore(
PLoad, getAdjustedPtr(IRB, *DL, StoreBasePtr, PLoad, getAdjustedPtr(IRB, DL, StoreBasePtr,
APInt(DL->getPointerSizeInBits(), PartOffset), APInt(DL.getPointerSizeInBits(), PartOffset),
PartPtrTy, StoreBasePtr->getName() + "."), PartPtrTy, StoreBasePtr->getName() + "."),
getAdjustedAlignment(SI, PartOffset, *DL), /*IsVolatile*/ false); getAdjustedAlignment(SI, PartOffset, DL), /*IsVolatile*/ false);
(void)PStore; (void)PStore;
DEBUG(dbgs() << " +" << PartOffset << ":" << *PStore << "\n"); DEBUG(dbgs() << " +" << PartOffset << ":" << *PStore << "\n");
} }
Context not available.
} else { } else {
IRB.SetInsertPoint(BasicBlock::iterator(LI)); IRB.SetInsertPoint(BasicBlock::iterator(LI));
PLoad = IRB.CreateAlignedLoad( PLoad = IRB.CreateAlignedLoad(
getAdjustedPtr(IRB, *DL, LoadBasePtr, getAdjustedPtr(IRB, DL, LoadBasePtr,
APInt(DL->getPointerSizeInBits(), PartOffset), APInt(DL.getPointerSizeInBits(), PartOffset),
PartPtrTy, LoadBasePtr->getName() + "."), PartPtrTy, LoadBasePtr->getName() + "."),
getAdjustedAlignment(LI, PartOffset, *DL), /*IsVolatile*/ false, getAdjustedAlignment(LI, PartOffset, DL), /*IsVolatile*/ false,
LI->getName()); LI->getName());
} }
// And store this partition. // And store this partition.
IRB.SetInsertPoint(BasicBlock::iterator(SI)); IRB.SetInsertPoint(BasicBlock::iterator(SI));
StoreInst *PStore = IRB.CreateAlignedStore( StoreInst *PStore = IRB.CreateAlignedStore(
PLoad, getAdjustedPtr(IRB, *DL, StoreBasePtr, PLoad, getAdjustedPtr(IRB, DL, StoreBasePtr,
APInt(DL->getPointerSizeInBits(), PartOffset), APInt(DL.getPointerSizeInBits(), PartOffset),
PartPtrTy, StoreBasePtr->getName() + "."), PartPtrTy, StoreBasePtr->getName() + "."),
getAdjustedAlignment(SI, PartOffset, *DL), /*IsVolatile*/ false); getAdjustedAlignment(SI, PartOffset, DL), /*IsVolatile*/ false);
// Now build a new slice for the alloca. // Now build a new slice for the alloca.
NewSlices.push_back( NewSlices.push_back(
Context not available.
// won't always succeed, in which case we fall back to a legal integer type // won't always succeed, in which case we fall back to a legal integer type
// or an i8 array of an appropriate size. // or an i8 array of an appropriate size.
Type *SliceTy = nullptr; Type *SliceTy = nullptr;
const DataLayout &DL = AI.getModule()->getDataLayout();
if (Type *CommonUseTy = findCommonType(P.begin(), P.end(), P.endOffset())) if (Type *CommonUseTy = findCommonType(P.begin(), P.end(), P.endOffset()))
if (DL->getTypeAllocSize(CommonUseTy) >= P.size()) if (DL.getTypeAllocSize(CommonUseTy) >= P.size())
SliceTy = CommonUseTy; SliceTy = CommonUseTy;
if (!SliceTy) if (!SliceTy)
if (Type *TypePartitionTy = getTypePartition(*DL, AI.getAllocatedType(), if (Type *TypePartitionTy = getTypePartition(DL, AI.getAllocatedType(),
P.beginOffset(), P.size())) P.beginOffset(), P.size()))
SliceTy = TypePartitionTy; SliceTy = TypePartitionTy;
if ((!SliceTy || (SliceTy->isArrayTy() && if ((!SliceTy || (SliceTy->isArrayTy() &&
SliceTy->getArrayElementType()->isIntegerTy())) && SliceTy->getArrayElementType()->isIntegerTy())) &&
DL->isLegalInteger(P.size() * 8)) DL.isLegalInteger(P.size() * 8))
SliceTy = Type::getIntNTy(*C, P.size() * 8); SliceTy = Type::getIntNTy(*C, P.size() * 8);
if (!SliceTy) if (!SliceTy)
SliceTy = ArrayType::get(Type::getInt8Ty(*C), P.size()); SliceTy = ArrayType::get(Type::getInt8Ty(*C), P.size());
assert(DL->getTypeAllocSize(SliceTy) >= P.size()); assert(DL.getTypeAllocSize(SliceTy) >= P.size());
bool IsIntegerPromotable = isIntegerWideningViable(P, SliceTy, *DL); bool IsIntegerPromotable = isIntegerWideningViable(P, SliceTy, DL);
VectorType *VecTy = VectorType *VecTy =
IsIntegerPromotable ? nullptr : isVectorPromotionViable(P, *DL); IsIntegerPromotable ? nullptr : isVectorPromotionViable(P, DL);
if (VecTy) if (VecTy)
SliceTy = VecTy; SliceTy = VecTy;
Context not available.
// The minimum alignment which users can rely on when the explicit // The minimum alignment which users can rely on when the explicit
// alignment is omitted or zero is that required by the ABI for this // alignment is omitted or zero is that required by the ABI for this
// type. // type.
Alignment = DL->getABITypeAlignment(AI.getAllocatedType()); Alignment = DL.getABITypeAlignment(AI.getAllocatedType());
} }
Alignment = MinAlign(Alignment, P.beginOffset()); Alignment = MinAlign(Alignment, P.beginOffset());
// If we will get at least this much alignment from the type alone, leave // If we will get at least this much alignment from the type alone, leave
// the alloca's alignment unconstrained. // the alloca's alignment unconstrained.
if (Alignment <= DL->getABITypeAlignment(SliceTy)) if (Alignment <= DL.getABITypeAlignment(SliceTy))
Alignment = 0; Alignment = 0;
NewAI = new AllocaInst( NewAI = new AllocaInst(
SliceTy, nullptr, Alignment, SliceTy, nullptr, Alignment,
Context not available.
SmallPtrSet<PHINode *, 8> PHIUsers; SmallPtrSet<PHINode *, 8> PHIUsers;
SmallPtrSet<SelectInst *, 8> SelectUsers; SmallPtrSet<SelectInst *, 8> SelectUsers;
AllocaSliceRewriter Rewriter(*DL, AS, *this, AI, *NewAI, P.beginOffset(), AllocaSliceRewriter Rewriter(DL, AS, *this, AI, *NewAI, P.beginOffset(),
P.endOffset(), IsIntegerPromotable, VecTy, P.endOffset(), IsIntegerPromotable, VecTy,
PHIUsers, SelectUsers); PHIUsers, SelectUsers);
bool Promotable = true; bool Promotable = true;
Context not available.
for (SmallPtrSetImpl<PHINode *>::iterator I = PHIUsers.begin(), for (SmallPtrSetImpl<PHINode *>::iterator I = PHIUsers.begin(),
E = PHIUsers.end(); E = PHIUsers.end();
I != E; ++I) I != E; ++I)
if (!isSafePHIToSpeculate(**I, DL)) { if (!isSafePHIToSpeculate(**I)) {
Promotable = false; Promotable = false;
PHIUsers.clear(); PHIUsers.clear();
SelectUsers.clear(); SelectUsers.clear();
Context not available.
for (SmallPtrSetImpl<SelectInst *>::iterator I = SelectUsers.begin(), for (SmallPtrSetImpl<SelectInst *>::iterator I = SelectUsers.begin(),
E = SelectUsers.end(); E = SelectUsers.end();
I != E; ++I) I != E; ++I)
if (!isSafeSelectToSpeculate(**I, DL)) { if (!isSafeSelectToSpeculate(**I)) {
Promotable = false; Promotable = false;
PHIUsers.clear(); PHIUsers.clear();
SelectUsers.clear(); SelectUsers.clear();
Context not available.
unsigned NumPartitions = 0; unsigned NumPartitions = 0;
bool Changed = false; bool Changed = false;
const DataLayout &DL = AI.getModule()->getDataLayout();
// First try to pre-split loads and stores. // First try to pre-split loads and stores.
Changed |= presplitLoadsAndStores(AI, AS); Changed |= presplitLoadsAndStores(AI, AS);
Context not available.
// confident that the above handling of splittable loads and stores is // confident that the above handling of splittable loads and stores is
// completely sufficient before we forcibly disable the remaining handling. // completely sufficient before we forcibly disable the remaining handling.
if (S.beginOffset() == 0 && if (S.beginOffset() == 0 &&
S.endOffset() >= DL->getTypeAllocSize(AI.getAllocatedType())) S.endOffset() >= DL.getTypeAllocSize(AI.getAllocatedType()))
continue; continue;
if (isa<LoadInst>(S.getUse()->getUser()) || if (isa<LoadInst>(S.getUse()->getUser()) ||
isa<StoreInst>(S.getUse()->getUser())) { isa<StoreInst>(S.getUse()->getUser())) {
Context not available.
Changed = true; Changed = true;
if (NewAI != &AI) { if (NewAI != &AI) {
uint64_t SizeOfByte = 8; uint64_t SizeOfByte = 8;
uint64_t AllocaSize = DL->getTypeSizeInBits(NewAI->getAllocatedType()); uint64_t AllocaSize = DL.getTypeSizeInBits(NewAI->getAllocatedType());
// Don't include any padding. // Don't include any padding.
uint64_t Size = std::min(AllocaSize, P.size() * SizeOfByte); uint64_t Size = std::min(AllocaSize, P.size() * SizeOfByte);
Pieces.push_back(Piece(NewAI, P.beginOffset() * SizeOfByte, Size)); Pieces.push_back(Piece(NewAI, P.beginOffset() * SizeOfByte, Size));
Context not available.
AI.eraseFromParent(); AI.eraseFromParent();
return true; return true;
} }
const DataLayout &DL = AI.getModule()->getDataLayout();
// Skip alloca forms that this analysis can't handle. // Skip alloca forms that this analysis can't handle.
if (AI.isArrayAllocation() || !AI.getAllocatedType()->isSized() || if (AI.isArrayAllocation() || !AI.getAllocatedType()->isSized() ||
DL->getTypeAllocSize(AI.getAllocatedType()) == 0) DL.getTypeAllocSize(AI.getAllocatedType()) == 0)
return false; return false;
bool Changed = false; bool Changed = false;
// First, split any FCA loads and stores touching this alloca to promote // First, split any FCA loads and stores touching this alloca to promote
// better splitting and promotion opportunities. // better splitting and promotion opportunities.
AggLoadStoreRewriter AggRewriter(*DL); AggLoadStoreRewriter AggRewriter(DL);
Changed |= AggRewriter.rewrite(AI); Changed |= AggRewriter.rewrite(AI);
// Build the slices using a recursive instruction-visiting builder. // Build the slices using a recursive instruction-visiting builder.
AllocaSlices AS(*DL, AI); AllocaSlices AS(DL, AI);
DEBUG(AS.print(dbgs())); DEBUG(AS.print(dbgs()));
if (AS.isEscaped()) if (AS.isEscaped())
return Changed; return Changed;
Context not available.
DEBUG(dbgs() << "SROA function: " << F.getName() << "\n"); DEBUG(dbgs() << "SROA function: " << F.getName() << "\n");
C = &F.getContext(); C = &F.getContext();
DL = &F.getParent()->getDataLayout();
DominatorTreeWrapperPass *DTWP = DominatorTreeWrapperPass *DTWP =
getAnalysisIfAvailable<DominatorTreeWrapperPass>(); getAnalysisIfAvailable<DominatorTreeWrapperPass>();
DT = DTWP ? &DTWP->getDomTree() : nullptr; DT = DTWP ? &DTWP->getDomTree() : nullptr;
Context not available.

lib/Transforms/Scalar/ScalarReplAggregates.cpp

Context not available.
private: private:
bool HasDomTree; bool HasDomTree;
const DataLayout *DL;
/// DeadInsts - Keep track of instructions we have made dead, so that /// DeadInsts - Keep track of instructions we have made dead, so that
/// we can remove them after we are done working. /// we can remove them after we are done working.
Context not available.
void isSafeMemAccess(uint64_t Offset, uint64_t MemSize, void isSafeMemAccess(uint64_t Offset, uint64_t MemSize,
Type *MemOpType, bool isStore, AllocaInfo &Info, Type *MemOpType, bool isStore, AllocaInfo &Info,
Instruction *TheAccess, bool AllowWholeAccess); Instruction *TheAccess, bool AllowWholeAccess);
bool TypeHasComponent(Type *T, uint64_t Offset, uint64_t Size); bool TypeHasComponent(Type *T, uint64_t Offset, uint64_t Size,
uint64_t FindElementAndOffset(Type *&T, uint64_t &Offset, const DataLayout &DL);
Type *&IdxTy); uint64_t FindElementAndOffset(Type *&T, uint64_t &Offset, Type *&IdxTy,
const DataLayout &DL);
void DoScalarReplacement(AllocaInst *AI, void DoScalarReplacement(AllocaInst *AI,
std::vector<AllocaInst*> &WorkList); std::vector<AllocaInst*> &WorkList);
Context not available.
// If the source and destination are both to the same alloca, then this is // If the source and destination are both to the same alloca, then this is
// a noop copy-to-self, just delete it. Otherwise, emit a load and store // a noop copy-to-self, just delete it. Otherwise, emit a load and store
// as appropriate. // as appropriate.
AllocaInst *OrigAI = cast<AllocaInst>(GetUnderlyingObject(Ptr, &DL, 0)); AllocaInst *OrigAI = cast<AllocaInst>(GetUnderlyingObject(Ptr, DL, 0));
if (GetUnderlyingObject(MTI->getSource(), &DL, 0) != OrigAI) { if (GetUnderlyingObject(MTI->getSource(), DL, 0) != OrigAI) {
// Dest must be OrigAI, change this to be a load from the original // Dest must be OrigAI, change this to be a load from the original
// pointer (bitcasted), then a store to our new alloca. // pointer (bitcasted), then a store to our new alloca.
assert(MTI->getRawDest() == Ptr && "Neither use is of pointer?"); assert(MTI->getRawDest() == Ptr && "Neither use is of pointer?");
Context not available.
LoadInst *SrcVal = Builder.CreateLoad(SrcPtr, "srcval"); LoadInst *SrcVal = Builder.CreateLoad(SrcPtr, "srcval");
SrcVal->setAlignment(MTI->getAlignment()); SrcVal->setAlignment(MTI->getAlignment());
Builder.CreateStore(SrcVal, NewAI); Builder.CreateStore(SrcVal, NewAI);
} else if (GetUnderlyingObject(MTI->getDest(), &DL, 0) != OrigAI) { } else if (GetUnderlyingObject(MTI->getDest(), DL, 0) != OrigAI) {
// Src must be OrigAI, change this to be a load from NewAI then a store // Src must be OrigAI, change this to be a load from NewAI then a store
// through the original dest pointer (bitcasted). // through the original dest pointer (bitcasted).
assert(MTI->getRawSource() == Ptr && "Neither use is of pointer?"); assert(MTI->getRawSource() == Ptr && "Neither use is of pointer?");
Context not available.
if (skipOptnoneFunction(F)) if (skipOptnoneFunction(F))
return false; return false;
DL = &F.getParent()->getDataLayout();
bool Changed = performPromotion(F); bool Changed = performPromotion(F);
// FIXME: ScalarRepl currently depends on DataLayout more than it
// theoretically needs to. It should be refactored in order to support
// target-independent IR. Until this is done, just skip the actual
// scalar-replacement portion of this pass.
if (!DL) return Changed;
while (1) { while (1) {
bool LocalChange = performScalarRepl(F); bool LocalChange = performScalarRepl(F);
if (!LocalChange) break; // No need to repromote if no scalarrepl if (!LocalChange) break; // No need to repromote if no scalarrepl
Context not available.
/// ///
/// We can do this to a select if its only uses are loads and if the operand to /// We can do this to a select if its only uses are loads and if the operand to
/// the select can be loaded unconditionally. /// the select can be loaded unconditionally.
static bool isSafeSelectToSpeculate(SelectInst *SI, const DataLayout *DL) { static bool isSafeSelectToSpeculate(SelectInst *SI) {
const DataLayout &DL = SI->getModule()->getDataLayout();
bool TDerefable = SI->getTrueValue()->isDereferenceablePointer(DL); bool TDerefable = SI->getTrueValue()->isDereferenceablePointer(DL);
bool FDerefable = SI->getFalseValue()->isDereferenceablePointer(DL); bool FDerefable = SI->getFalseValue()->isDereferenceablePointer(DL);
Context not available.
// Both operands to the select need to be dereferencable, either absolutely // Both operands to the select need to be dereferencable, either absolutely
// (e.g. allocas) or at this point because we can see other accesses to it. // (e.g. allocas) or at this point because we can see other accesses to it.
if (!TDerefable && !isSafeToLoadUnconditionally(SI->getTrueValue(), LI, if (!TDerefable &&
LI->getAlignment(), DL)) !isSafeToLoadUnconditionally(SI->getTrueValue(), LI,
LI->getAlignment()))
return false; return false;
if (!FDerefable && !isSafeToLoadUnconditionally(SI->getFalseValue(), LI, if (!FDerefable &&
LI->getAlignment(), DL)) !isSafeToLoadUnconditionally(SI->getFalseValue(), LI,
LI->getAlignment()))
return false; return false;
} }
Context not available.
/// ///
/// We can do this to a select if its only uses are loads and if the operand to /// We can do this to a select if its only uses are loads and if the operand to
/// the select can be loaded unconditionally. /// the select can be loaded unconditionally.
static bool isSafePHIToSpeculate(PHINode *PN, const DataLayout *DL) { static bool isSafePHIToSpeculate(PHINode *PN) {
// For now, we can only do this promotion if the load is in the same block as // For now, we can only do this promotion if the load is in the same block as
// the PHI, and if there are no stores between the phi and load. // the PHI, and if there are no stores between the phi and load.
// TODO: Allow recursive phi users. // TODO: Allow recursive phi users.
Context not available.
MaxAlign = std::max(MaxAlign, LI->getAlignment()); MaxAlign = std::max(MaxAlign, LI->getAlignment());
} }
const DataLayout &DL = PN->getModule()->getDataLayout();
// Okay, we know that we have one or more loads in the same block as the PHI. // Okay, we know that we have one or more loads in the same block as the PHI.
// We can transform this if it is safe to push the loads into the predecessor // We can transform this if it is safe to push the loads into the predecessor
// blocks. The only thing to watch out for is that we can't put a possibly // blocks. The only thing to watch out for is that we can't put a possibly
Context not available.
// If this pointer is always safe to load, or if we can prove that there is // If this pointer is always safe to load, or if we can prove that there is
// already a load in the block, then we can move the load to the pred block. // already a load in the block, then we can move the load to the pred block.
if (InVal->isDereferenceablePointer(DL) || if (InVal->isDereferenceablePointer(DL) ||
isSafeToLoadUnconditionally(InVal, Pred->getTerminator(), MaxAlign, DL)) isSafeToLoadUnconditionally(InVal, Pred->getTerminator(), MaxAlign))
continue; continue;
return false; return false;
Context not available.
/// direct (non-volatile) loads and stores to it. If the alloca is close but /// direct (non-volatile) loads and stores to it. If the alloca is close but
/// not quite there, this will transform the code to allow promotion. As such, /// not quite there, this will transform the code to allow promotion. As such,
/// it is a non-pure predicate. /// it is a non-pure predicate.
static bool tryToMakeAllocaBePromotable(AllocaInst *AI, const DataLayout *DL) { static bool tryToMakeAllocaBePromotable(AllocaInst *AI, const DataLayout &DL) {
SetVector<Instruction*, SmallVector<Instruction*, 4>, SetVector<Instruction*, SmallVector<Instruction*, 4>,
SmallPtrSet<Instruction*, 4> > InstsToRewrite; SmallPtrSet<Instruction*, 4> > InstsToRewrite;
for (User *U : AI->users()) { for (User *U : AI->users()) {
Context not available.
// If it is safe to turn "load (select c, AI, ptr)" into a select of two // If it is safe to turn "load (select c, AI, ptr)" into a select of two
// loads, then we can transform this by rewriting the select. // loads, then we can transform this by rewriting the select.
if (!isSafeSelectToSpeculate(SI, DL)) if (!isSafeSelectToSpeculate(SI))
return false; return false;
InstsToRewrite.insert(SI); InstsToRewrite.insert(SI);
Context not available.
// If it is safe to turn "load (phi [AI, ptr, ...])" into a PHI of loads // If it is safe to turn "load (phi [AI, ptr, ...])" into a PHI of loads
// in the pred blocks, then we can transform this by rewriting the PHI. // in the pred blocks, then we can transform this by rewriting the PHI.
if (!isSafePHIToSpeculate(PN, DL)) if (!isSafePHIToSpeculate(PN))
return false; return false;
InstsToRewrite.insert(PN); InstsToRewrite.insert(PN);
Context not available.
bool SROA::performPromotion(Function &F) { bool SROA::performPromotion(Function &F) {
std::vector<AllocaInst*> Allocas; std::vector<AllocaInst*> Allocas;
const DataLayout &DL = F.getParent()->getDataLayout();
DominatorTree *DT = nullptr; DominatorTree *DT = nullptr;
if (HasDomTree) if (HasDomTree)
DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree(); DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
Context not available.
// //
bool SROA::performScalarRepl(Function &F) { bool SROA::performScalarRepl(Function &F) {
std::vector<AllocaInst*> WorkList; std::vector<AllocaInst*> WorkList;
const DataLayout &DL = F.getParent()->getDataLayout();
// Scan the entry basic block, adding allocas to the worklist. // Scan the entry basic block, adding allocas to the worklist.
BasicBlock &BB = F.getEntryBlock(); BasicBlock &BB = F.getEntryBlock();
Context not available.
// transform the allocation instruction if it is an array allocation // transform the allocation instruction if it is an array allocation
// (allocations OF arrays are ok though), and an allocation of a scalar // (allocations OF arrays are ok though), and an allocation of a scalar
// value cannot be decomposed at all. // value cannot be decomposed at all.
uint64_t AllocaSize = DL->getTypeAllocSize(AI->getAllocatedType()); uint64_t AllocaSize = DL.getTypeAllocSize(AI->getAllocatedType());
// Do not promote [0 x %struct]. // Do not promote [0 x %struct].
if (AllocaSize == 0) continue; if (AllocaSize == 0) continue;
Context not available.
// promoted itself. If so, we don't want to transform it needlessly. Note // promoted itself. If so, we don't want to transform it needlessly. Note
// that we can't just check based on the type: the alloca may be of an i32 // that we can't just check based on the type: the alloca may be of an i32
// but that has pointer arithmetic to set byte 3 of it or something. // but that has pointer arithmetic to set byte 3 of it or something.
if (AllocaInst *NewAI = ConvertToScalarInfo( if (AllocaInst *NewAI =
(unsigned)AllocaSize, *DL, ScalarLoadThreshold).TryConvert(AI)) { ConvertToScalarInfo((unsigned)AllocaSize, DL, ScalarLoadThreshold)
.TryConvert(AI)) {
NewAI->takeName(AI); NewAI->takeName(AI);
AI->eraseFromParent(); AI->eraseFromParent();
++NumConverted; ++NumConverted;
Context not available.
/// referenced by this instruction. /// referenced by this instruction.
void SROA::isSafeForScalarRepl(Instruction *I, uint64_t Offset, void SROA::isSafeForScalarRepl(Instruction *I, uint64_t Offset,
AllocaInfo &Info) { AllocaInfo &Info) {
const DataLayout &DL = I->getModule()->getDataLayout();
for (Use &U : I->uses()) { for (Use &U : I->uses()) {
Instruction *User = cast<Instruction>(U.getUser()); Instruction *User = cast<Instruction>(U.getUser());
Context not available.
if (!LI->isSimple()) if (!LI->isSimple())
return MarkUnsafe(Info, User); return MarkUnsafe(Info, User);
Type *LIType = LI->getType(); Type *LIType = LI->getType();
isSafeMemAccess(Offset, DL->getTypeAllocSize(LIType), isSafeMemAccess(Offset, DL.getTypeAllocSize(LIType), LIType, false, Info,
LIType, false, Info, LI, true /*AllowWholeAccess*/); LI, true /*AllowWholeAccess*/);
Info.hasALoadOrStore = true; Info.hasALoadOrStore = true;
} else if (StoreInst *SI = dyn_cast<StoreInst>(User)) { } else if (StoreInst *SI = dyn_cast<StoreInst>(User)) {
Context not available.
return MarkUnsafe(Info, User); return MarkUnsafe(Info, User);
Type *SIType = SI->getOperand(0)->getType(); Type *SIType = SI->getOperand(0)->getType();
isSafeMemAccess(Offset, DL->getTypeAllocSize(SIType), isSafeMemAccess(Offset, DL.getTypeAllocSize(SIType), SIType, true, Info,
SIType, true, Info, SI, true /*AllowWholeAccess*/); SI, true /*AllowWholeAccess*/);
Info.hasALoadOrStore = true; Info.hasALoadOrStore = true;
} else if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(User)) { } else if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(User)) {
if (II->getIntrinsicID() != Intrinsic::lifetime_start && if (II->getIntrinsicID() != Intrinsic::lifetime_start &&
Context not available.
if (!Info.CheckedPHIs.insert(PN).second) if (!Info.CheckedPHIs.insert(PN).second)
return; return;
const DataLayout &DL = I->getModule()->getDataLayout();
for (User *U : I->users()) { for (User *U : I->users()) {
Instruction *UI = cast<Instruction>(U); Instruction *UI = cast<Instruction>(U);
Context not available.
if (!LI->isSimple()) if (!LI->isSimple())
return MarkUnsafe(Info, UI); return MarkUnsafe(Info, UI);
Type *LIType = LI->getType(); Type *LIType = LI->getType();
isSafeMemAccess(Offset, DL->getTypeAllocSize(LIType), isSafeMemAccess(Offset, DL.getTypeAllocSize(LIType), LIType, false, Info,
LIType, false, Info, LI, false /*AllowWholeAccess*/); LI, false /*AllowWholeAccess*/);
Info.hasALoadOrStore = true; Info.hasALoadOrStore = true;
} else if (StoreInst *SI = dyn_cast<StoreInst>(UI)) { } else if (StoreInst *SI = dyn_cast<StoreInst>(UI)) {
Context not available.
return MarkUnsafe(Info, UI); return MarkUnsafe(Info, UI);
Type *SIType = SI->getOperand(0)->getType(); Type *SIType = SI->getOperand(0)->getType();
isSafeMemAccess(Offset, DL->getTypeAllocSize(SIType), isSafeMemAccess(Offset, DL.getTypeAllocSize(SIType), SIType, true, Info,
SIType, true, Info, SI, false /*AllowWholeAccess*/); SI, false /*AllowWholeAccess*/);
Info.hasALoadOrStore = true; Info.hasALoadOrStore = true;
} else if (isa<PHINode>(UI) || isa<SelectInst>(UI)) { } else if (isa<PHINode>(UI) || isa<SelectInst>(UI)) {
isSafePHISelectUseForScalarRepl(UI, Offset, Info); isSafePHISelectUseForScalarRepl(UI, Offset, Info);
Context not available.
// constant part of the offset. // constant part of the offset.
if (NonConstant) if (NonConstant)
Indices.pop_back(); Indices.pop_back();
Offset += DL->getIndexedOffset(GEPI->getPointerOperandType(), Indices);
if (!TypeHasComponent(Info.AI->getAllocatedType(), Offset, const DataLayout &DL = GEPI->getModule()->getDataLayout();
NonConstantIdxSize)) Offset += DL.getIndexedOffset(GEPI->getPointerOperandType(), Indices);
if (!TypeHasComponent(Info.AI->getAllocatedType(), Offset, NonConstantIdxSize,
DL))
MarkUnsafe(Info, GEPI); MarkUnsafe(Info, GEPI);
} }
Context not available.
Type *MemOpType, bool isStore, Type *MemOpType, bool isStore,
AllocaInfo &Info, Instruction *TheAccess, AllocaInfo &Info, Instruction *TheAccess,
bool AllowWholeAccess) { bool AllowWholeAccess) {
const DataLayout &DL = TheAccess->getModule()->getDataLayout();
// Check if this is a load/store of the entire alloca. // Check if this is a load/store of the entire alloca.
if (Offset == 0 && AllowWholeAccess && if (Offset == 0 && AllowWholeAccess &&
MemSize == DL->getTypeAllocSize(Info.AI->getAllocatedType())) { MemSize == DL.getTypeAllocSize(Info.AI->getAllocatedType())) {
// This can be safe for MemIntrinsics (where MemOpType is 0) and integer // This can be safe for MemIntrinsics (where MemOpType is 0) and integer
// loads/stores (which are essentially the same as the MemIntrinsics with // loads/stores (which are essentially the same as the MemIntrinsics with
// regard to copying padding between elements). But, if an alloca is // regard to copying padding between elements). But, if an alloca is
Context not available.
} }
// Check if the offset/size correspond to a component within the alloca type. // Check if the offset/size correspond to a component within the alloca type.
Type *T = Info.AI->getAllocatedType(); Type *T = Info.AI->getAllocatedType();
if (TypeHasComponent(T, Offset, MemSize)) { if (TypeHasComponent(T, Offset, MemSize, DL)) {
Info.hasSubelementAccess = true; Info.hasSubelementAccess = true;
return; return;
} }
Context not available.
/// TypeHasComponent - Return true if T has a component type with the /// TypeHasComponent - Return true if T has a component type with the
/// specified offset and size. If Size is zero, do not check the size. /// specified offset and size. If Size is zero, do not check the size.
bool SROA::TypeHasComponent(Type *T, uint64_t Offset, uint64_t Size) { bool SROA::TypeHasComponent(Type *T, uint64_t Offset, uint64_t Size,
const DataLayout &DL) {
Type *EltTy; Type *EltTy;
uint64_t EltSize; uint64_t EltSize;
if (StructType *ST = dyn_cast<StructType>(T)) { if (StructType *ST = dyn_cast<StructType>(T)) {
const StructLayout *Layout = DL->getStructLayout(ST); const StructLayout *Layout = DL.getStructLayout(ST);
unsigned EltIdx = Layout->getElementContainingOffset(Offset); unsigned EltIdx = Layout->getElementContainingOffset(Offset);
EltTy = ST->getContainedType(EltIdx); EltTy = ST->getContainedType(EltIdx);
EltSize = DL->getTypeAllocSize(EltTy); EltSize = DL.getTypeAllocSize(EltTy);
Offset -= Layout->getElementOffset(EltIdx); Offset -= Layout->getElementOffset(EltIdx);
} else if (ArrayType *AT = dyn_cast<ArrayType>(T)) { } else if (ArrayType *AT = dyn_cast<ArrayType>(T)) {
EltTy = AT->getElementType(); EltTy = AT->getElementType();
EltSize = DL->getTypeAllocSize(EltTy); EltSize = DL.getTypeAllocSize(EltTy);
if (Offset >= AT->getNumElements() * EltSize) if (Offset >= AT->getNumElements() * EltSize)
return false; return false;
Offset %= EltSize; Offset %= EltSize;
} else if (VectorType *VT = dyn_cast<VectorType>(T)) { } else if (VectorType *VT = dyn_cast<VectorType>(T)) {
EltTy = VT->getElementType(); EltTy = VT->getElementType();
EltSize = DL->getTypeAllocSize(EltTy); EltSize = DL.getTypeAllocSize(EltTy);
if (Offset >= VT->getNumElements() * EltSize) if (Offset >= VT->getNumElements() * EltSize)
return false; return false;
Offset %= EltSize; Offset %= EltSize;
Context not available.
// Check if the component spans multiple elements. // Check if the component spans multiple elements.
if (Offset + Size > EltSize) if (Offset + Size > EltSize)
return false; return false;
return TypeHasComponent(EltTy, Offset, Size); return TypeHasComponent(EltTy, Offset, Size, DL);
} }
/// RewriteForScalarRepl - Alloca AI is being split into NewElts, so rewrite /// RewriteForScalarRepl - Alloca AI is being split into NewElts, so rewrite
Context not available.
/// instruction. /// instruction.
void SROA::RewriteForScalarRepl(Instruction *I, AllocaInst *AI, uint64_t Offset, void SROA::RewriteForScalarRepl(Instruction *I, AllocaInst *AI, uint64_t Offset,
SmallVectorImpl<AllocaInst *> &NewElts) { SmallVectorImpl<AllocaInst *> &NewElts) {
const DataLayout &DL = I->getModule()->getDataLayout();
for (Value::use_iterator UI = I->use_begin(), E = I->use_end(); UI!=E;) { for (Value::use_iterator UI = I->use_begin(), E = I->use_end(); UI!=E;) {
Use &TheUse = *UI++; Use &TheUse = *UI++;
Instruction *User = cast<Instruction>(TheUse.getUser()); Instruction *User = cast<Instruction>(TheUse.getUser());
Context not available.
if (MemIntrinsic *MI = dyn_cast<MemIntrinsic>(User)) { if (MemIntrinsic *MI = dyn_cast<MemIntrinsic>(User)) {
ConstantInt *Length = dyn_cast<ConstantInt>(MI->getLength()); ConstantInt *Length = dyn_cast<ConstantInt>(MI->getLength());
uint64_t MemSize = Length->getZExtValue(); uint64_t MemSize = Length->getZExtValue();
if (Offset == 0 && if (Offset == 0 && MemSize == DL.getTypeAllocSize(AI->getAllocatedType()))
MemSize == DL->getTypeAllocSize(AI->getAllocatedType()))
RewriteMemIntrinUserOfAlloca(MI, I, AI, NewElts); RewriteMemIntrinUserOfAlloca(MI, I, AI, NewElts);
// Otherwise the intrinsic can only touch a single element and the // Otherwise the intrinsic can only touch a single element and the
// address operand will be updated, so nothing else needs to be done. // address operand will be updated, so nothing else needs to be done.
Context not available.
LI->replaceAllUsesWith(Insert); LI->replaceAllUsesWith(Insert);
DeadInsts.push_back(LI); DeadInsts.push_back(LI);
} else if (LIType->isIntegerTy() && } else if (LIType->isIntegerTy() &&
DL->getTypeAllocSize(LIType) == DL.getTypeAllocSize(LIType) ==
DL->getTypeAllocSize(AI->getAllocatedType())) { DL.getTypeAllocSize(AI->getAllocatedType())) {
// If this is a load of the entire alloca to an integer, rewrite it. // If this is a load of the entire alloca to an integer, rewrite it.
RewriteLoadUserOfWholeAlloca(LI, AI, NewElts); RewriteLoadUserOfWholeAlloca(LI, AI, NewElts);
} }
Context not available.
} }
DeadInsts.push_back(SI); DeadInsts.push_back(SI);
} else if (SIType->isIntegerTy() && } else if (SIType->isIntegerTy() &&
DL->getTypeAllocSize(SIType) == DL.getTypeAllocSize(SIType) ==
DL->getTypeAllocSize(AI->getAllocatedType())) { DL.getTypeAllocSize(AI->getAllocatedType())) {
// If this is a store of the entire alloca from an integer, rewrite it. // If this is a store of the entire alloca from an integer, rewrite it.
RewriteStoreUserOfWholeAlloca(SI, AI, NewElts); RewriteStoreUserOfWholeAlloca(SI, AI, NewElts);
} }
Context not available.
Type *T = AI->getAllocatedType(); Type *T = AI->getAllocatedType();
uint64_t EltOffset = 0; uint64_t EltOffset = 0;
Type *IdxTy; Type *IdxTy;
uint64_t Idx = FindElementAndOffset(T, EltOffset, IdxTy); uint64_t Idx = FindElementAndOffset(T, EltOffset, IdxTy,
BC->getModule()->getDataLayout());
Instruction *Val = NewElts[Idx]; Instruction *Val = NewElts[Idx];
if (Val->getType() != BC->getDestTy()) { if (Val->getType() != BC->getDestTy()) {
Val = new BitCastInst(Val, BC->getDestTy(), "", BC); Val = new BitCastInst(Val, BC->getDestTy(), "", BC);
Context not available.
/// Sets T to the type of the element and Offset to the offset within that /// Sets T to the type of the element and Offset to the offset within that
/// element. IdxTy is set to the type of the index result to be used in a /// element. IdxTy is set to the type of the index result to be used in a
/// GEP instruction. /// GEP instruction.
uint64_t SROA::FindElementAndOffset(Type *&T, uint64_t &Offset, uint64_t SROA::FindElementAndOffset(Type *&T, uint64_t &Offset, Type *&IdxTy,
Type *&IdxTy) { const DataLayout &DL) {
uint64_t Idx = 0; uint64_t Idx = 0;
if (StructType *ST = dyn_cast<StructType>(T)) { if (StructType *ST = dyn_cast<StructType>(T)) {
const StructLayout *Layout = DL->getStructLayout(ST); const StructLayout *Layout = DL.getStructLayout(ST);
Idx = Layout->getElementContainingOffset(Offset); Idx = Layout->getElementContainingOffset(Offset);
T = ST->getContainedType(Idx); T = ST->getContainedType(Idx);
Offset -= Layout->getElementOffset(Idx); Offset -= Layout->getElementOffset(Idx);
Context not available.
return Idx; return Idx;
} else if (ArrayType *AT = dyn_cast<ArrayType>(T)) { } else if (ArrayType *AT = dyn_cast<ArrayType>(T)) {
T = AT->getElementType(); T = AT->getElementType();
uint64_t EltSize = DL->getTypeAllocSize(T); uint64_t EltSize = DL.getTypeAllocSize(T);
Idx = Offset / EltSize; Idx = Offset / EltSize;
Offset -= Idx * EltSize; Offset -= Idx * EltSize;
IdxTy = Type::getInt64Ty(T->getContext()); IdxTy = Type::getInt64Ty(T->getContext());
Context not available.
} }
VectorType *VT = cast<VectorType>(T); VectorType *VT = cast<VectorType>(T);
T = VT->getElementType(); T = VT->getElementType();
uint64_t EltSize = DL->getTypeAllocSize(T); uint64_t EltSize = DL.getTypeAllocSize(T);
Idx = Offset / EltSize; Idx = Offset / EltSize;
Offset -= Idx * EltSize; Offset -= Idx * EltSize;
IdxTy = Type::getInt64Ty(T->getContext()); IdxTy = Type::getInt64Ty(T->getContext());
Context not available.
void SROA::RewriteGEP(GetElementPtrInst *GEPI, AllocaInst *AI, uint64_t Offset, void SROA::RewriteGEP(GetElementPtrInst *GEPI, AllocaInst *AI, uint64_t Offset,
SmallVectorImpl<AllocaInst *> &NewElts) { SmallVectorImpl<AllocaInst *> &NewElts) {
uint64_t OldOffset = Offset; uint64_t OldOffset = Offset;
const DataLayout &DL = GEPI->getModule()->getDataLayout();
SmallVector<Value*, 8> Indices(GEPI->op_begin() + 1, GEPI->op_end()); SmallVector<Value*, 8> Indices(GEPI->op_begin() + 1, GEPI->op_end());
// If the GEP was dynamic then it must have been a dynamic vector lookup. // If the GEP was dynamic then it must have been a dynamic vector lookup.
// In this case, it must be the last GEP operand which is dynamic so keep that // In this case, it must be the last GEP operand which is dynamic so keep that
Context not available.
Value* NonConstantIdx = nullptr; Value* NonConstantIdx = nullptr;
if (!GEPI->hasAllConstantIndices()) if (!GEPI->hasAllConstantIndices())
NonConstantIdx = Indices.pop_back_val(); NonConstantIdx = Indices.pop_back_val();
Offset += DL->getIndexedOffset(GEPI->getPointerOperandType(), Indices); Offset += DL.getIndexedOffset(GEPI->getPointerOperandType(), Indices);
RewriteForScalarRepl(GEPI, AI, Offset, NewElts); RewriteForScalarRepl(GEPI, AI, Offset, NewElts);
Type *T = AI->getAllocatedType(); Type *T = AI->getAllocatedType();
Type *IdxTy; Type *IdxTy;
uint64_t OldIdx = FindElementAndOffset(T, OldOffset, IdxTy); uint64_t OldIdx = FindElementAndOffset(T, OldOffset, IdxTy, DL);
if (GEPI->getOperand(0) == AI) if (GEPI->getOperand(0) == AI)
OldIdx = ~0ULL; // Force the GEP to be rewritten. OldIdx = ~0ULL; // Force the GEP to be rewritten.
T = AI->getAllocatedType(); T = AI->getAllocatedType();
uint64_t EltOffset = Offset; uint64_t EltOffset = Offset;
uint64_t Idx = FindElementAndOffset(T, EltOffset, IdxTy); uint64_t Idx = FindElementAndOffset(T, EltOffset, IdxTy, DL);
// If this GEP does not move the pointer across elements of the alloca // If this GEP does not move the pointer across elements of the alloca
// being split, then it does not needs to be rewritten. // being split, then it does not needs to be rewritten.
Context not available.
SmallVector<Value*, 8> NewArgs; SmallVector<Value*, 8> NewArgs;
NewArgs.push_back(Constant::getNullValue(i32Ty)); NewArgs.push_back(Constant::getNullValue(i32Ty));
while (EltOffset != 0) { while (EltOffset != 0) {
uint64_t EltIdx = FindElementAndOffset(T, EltOffset, IdxTy); uint64_t EltIdx = FindElementAndOffset(T, EltOffset, IdxTy, DL);
NewArgs.push_back(ConstantInt::get(IdxTy, EltIdx)); NewArgs.push_back(ConstantInt::get(IdxTy, EltIdx));
} }
if (NonConstantIdx) { if (NonConstantIdx) {
Context not available.
// Put matching lifetime markers on everything from Offset up to // Put matching lifetime markers on everything from Offset up to
// Offset+OldSize. // Offset+OldSize.
Type *AIType = AI->getAllocatedType(); Type *AIType = AI->getAllocatedType();
const DataLayout &DL = II->getModule()->getDataLayout();
uint64_t NewOffset = Offset; uint64_t NewOffset = Offset;
Type *IdxTy; Type *IdxTy;
uint64_t Idx = FindElementAndOffset(AIType, NewOffset, IdxTy); uint64_t Idx = FindElementAndOffset(AIType, NewOffset, IdxTy, DL);
IRBuilder<> Builder(II); IRBuilder<> Builder(II);
uint64_t Size = OldSize->getLimitedValue(); uint64_t Size = OldSize->getLimitedValue();
Context not available.
V = Builder.CreateGEP(V, Builder.getInt64(NewOffset)); V = Builder.CreateGEP(V, Builder.getInt64(NewOffset));
IdxTy = NewElts[Idx]->getAllocatedType(); IdxTy = NewElts[Idx]->getAllocatedType();
uint64_t EltSize = DL->getTypeAllocSize(IdxTy) - NewOffset; uint64_t EltSize = DL.getTypeAllocSize(IdxTy) - NewOffset;
if (EltSize > Size) { if (EltSize > Size) {
EltSize = Size; EltSize = Size;
Size = 0; Size = 0;
Context not available.
for (; Idx != NewElts.size() && Size; ++Idx) { for (; Idx != NewElts.size() && Size; ++Idx) {
IdxTy = NewElts[Idx]->getAllocatedType(); IdxTy = NewElts[Idx]->getAllocatedType();
uint64_t EltSize = DL->getTypeAllocSize(IdxTy); uint64_t EltSize = DL.getTypeAllocSize(IdxTy);
if (EltSize > Size) { if (EltSize > Size) {
EltSize = Size; EltSize = Size;
Size = 0; Size = 0;
Context not available.
bool SROADest = MI->getRawDest() == Inst; bool SROADest = MI->getRawDest() == Inst;
Constant *Zero = Constant::getNullValue(Type::getInt32Ty(MI->getContext())); Constant *Zero = Constant::getNullValue(Type::getInt32Ty(MI->getContext()));
const DataLayout &DL = MI->getModule()->getDataLayout();
for (unsigned i = 0, e = NewElts.size(); i != e; ++i) { for (unsigned i = 0, e = NewElts.size(); i != e; ++i) {
// If this is a memcpy/memmove, emit a GEP of the other element address. // If this is a memcpy/memmove, emit a GEP of the other element address.
Context not available.
PointerType *OtherPtrTy = cast<PointerType>(OtherPtr->getType()); PointerType *OtherPtrTy = cast<PointerType>(OtherPtr->getType());
Type *OtherTy = OtherPtrTy->getElementType(); Type *OtherTy = OtherPtrTy->getElementType();
if (StructType *ST = dyn_cast<StructType>(OtherTy)) { if (StructType *ST = dyn_cast<StructType>(OtherTy)) {
EltOffset = DL->getStructLayout(ST)->getElementOffset(i); EltOffset = DL.getStructLayout(ST)->getElementOffset(i);
} else { } else {
Type *EltTy = cast<SequentialType>(OtherTy)->getElementType(); Type *EltTy = cast<SequentialType>(OtherTy)->getElementType();
EltOffset = DL->getTypeAllocSize(EltTy)*i; EltOffset = DL.getTypeAllocSize(EltTy) * i;
} }
// The alignment of the other pointer is the guaranteed alignment of the // The alignment of the other pointer is the guaranteed alignment of the
Context not available.
Type *ValTy = EltTy->getScalarType(); Type *ValTy = EltTy->getScalarType();
// Construct an integer with the right value. // Construct an integer with the right value.
unsigned EltSize = DL->getTypeSizeInBits(ValTy); unsigned EltSize = DL.getTypeSizeInBits(ValTy);
APInt OneVal(EltSize, CI->getZExtValue()); APInt OneVal(EltSize, CI->getZExtValue());
APInt TotalVal(OneVal); APInt TotalVal(OneVal);
// Set each byte. // Set each byte.
Context not available.
// this element. // this element.
} }
unsigned EltSize = DL->getTypeAllocSize(EltTy); unsigned EltSize = DL.getTypeAllocSize(EltTy);
if (!EltSize) if (!EltSize)
continue; continue;
Context not available.
// and store the element value to the individual alloca. // and store the element value to the individual alloca.
Value *SrcVal = SI->getOperand(0); Value *SrcVal = SI->getOperand(0);
Type *AllocaEltTy = AI->getAllocatedType(); Type *AllocaEltTy = AI->getAllocatedType();
uint64_t AllocaSizeBits = DL->getTypeAllocSizeInBits(AllocaEltTy); const DataLayout &DL = SI->getModule()->getDataLayout();
uint64_t AllocaSizeBits = DL.getTypeAllocSizeInBits(AllocaEltTy);
IRBuilder<> Builder(SI); IRBuilder<> Builder(SI);
// Handle tail padding by extending the operand // Handle tail padding by extending the operand
if (DL->getTypeSizeInBits(SrcVal->getType()) != AllocaSizeBits) if (DL.getTypeSizeInBits(SrcVal->getType()) != AllocaSizeBits)
SrcVal = Builder.CreateZExt(SrcVal, SrcVal = Builder.CreateZExt(SrcVal,
IntegerType::get(SI->getContext(), AllocaSizeBits)); IntegerType::get(SI->getContext(), AllocaSizeBits));
Context not available.
// There are two forms here: AI could be an array or struct. Both cases // There are two forms here: AI could be an array or struct. Both cases
// have different ways to compute the element offset. // have different ways to compute the element offset.
if (StructType *EltSTy = dyn_cast<StructType>(AllocaEltTy)) { if (StructType *EltSTy = dyn_cast<StructType>(AllocaEltTy)) {
const StructLayout *Layout = DL->getStructLayout(EltSTy); const StructLayout *Layout = DL.getStructLayout(EltSTy);
for (unsigned i = 0, e = NewElts.size(); i != e; ++i) { for (unsigned i = 0, e = NewElts.size(); i != e; ++i) {
// Get the number of bits to shift SrcVal to get the value. // Get the number of bits to shift SrcVal to get the value.
Type *FieldTy = EltSTy->getElementType(i); Type *FieldTy = EltSTy->getElementType(i);
uint64_t Shift = Layout->getElementOffsetInBits(i); uint64_t Shift = Layout->getElementOffsetInBits(i);
if (DL->isBigEndian()) if (DL.isBigEndian())
Shift = AllocaSizeBits-Shift-DL->getTypeAllocSizeInBits(FieldTy); Shift = AllocaSizeBits - Shift - DL.getTypeAllocSizeInBits(FieldTy);
Value *EltVal = SrcVal; Value *EltVal = SrcVal;
if (Shift) { if (Shift) {
Context not available.
} }
// Truncate down to an integer of the right size. // Truncate down to an integer of the right size.
uint64_t FieldSizeBits = DL->getTypeSizeInBits(FieldTy); uint64_t FieldSizeBits = DL.getTypeSizeInBits(FieldTy);
// Ignore zero sized fields like {}, they obviously contain no data. // Ignore zero sized fields like {}, they obviously contain no data.
if (FieldSizeBits == 0) continue; if (FieldSizeBits == 0) continue;
Context not available.
} else { } else {
ArrayType *ATy = cast<ArrayType>(AllocaEltTy); ArrayType *ATy = cast<ArrayType>(AllocaEltTy);
Type *ArrayEltTy = ATy->getElementType(); Type *ArrayEltTy = ATy->getElementType();
uint64_t ElementOffset = DL->getTypeAllocSizeInBits(ArrayEltTy); uint64_t ElementOffset = DL.getTypeAllocSizeInBits(ArrayEltTy);
uint64_t ElementSizeBits = DL->getTypeSizeInBits(ArrayEltTy); uint64_t ElementSizeBits = DL.getTypeSizeInBits(ArrayEltTy);
uint64_t Shift; uint64_t Shift;
if (DL->isBigEndian()) if (DL.isBigEndian())
Shift = AllocaSizeBits-ElementOffset; Shift = AllocaSizeBits-ElementOffset;
else else
Shift = 0; Shift = 0;
Context not available.
} }
new StoreInst(EltVal, DestField, SI); new StoreInst(EltVal, DestField, SI);
if (DL->isBigEndian()) if (DL.isBigEndian())
Shift -= ElementOffset; Shift -= ElementOffset;
else else
Shift += ElementOffset; Shift += ElementOffset;
Context not available.
// Extract each element out of the NewElts according to its structure offset // Extract each element out of the NewElts according to its structure offset
// and form the result value. // and form the result value.
Type *AllocaEltTy = AI->getAllocatedType(); Type *AllocaEltTy = AI->getAllocatedType();
uint64_t AllocaSizeBits = DL->getTypeAllocSizeInBits(AllocaEltTy); const DataLayout &DL = LI->getModule()->getDataLayout();
uint64_t AllocaSizeBits = DL.getTypeAllocSizeInBits(AllocaEltTy);
DEBUG(dbgs() << "PROMOTING LOAD OF WHOLE ALLOCA: " << *AI << '\n' << *LI DEBUG(dbgs() << "PROMOTING LOAD OF WHOLE ALLOCA: " << *AI << '\n' << *LI
<< '\n'); << '\n');
Context not available.
const StructLayout *Layout = nullptr; const StructLayout *Layout = nullptr;
uint64_t ArrayEltBitOffset = 0; uint64_t ArrayEltBitOffset = 0;
if (StructType *EltSTy = dyn_cast<StructType>(AllocaEltTy)) { if (StructType *EltSTy = dyn_cast<StructType>(AllocaEltTy)) {
Layout = DL->getStructLayout(EltSTy); Layout = DL.getStructLayout(EltSTy);
} else { } else {
Type *ArrayEltTy = cast<ArrayType>(AllocaEltTy)->getElementType(); Type *ArrayEltTy = cast<ArrayType>(AllocaEltTy)->getElementType();
ArrayEltBitOffset = DL->getTypeAllocSizeInBits(ArrayEltTy); ArrayEltBitOffset = DL.getTypeAllocSizeInBits(ArrayEltTy);
} }
Value *ResultVal = Value *ResultVal =
Context not available.
Value *SrcField = NewElts[i]; Value *SrcField = NewElts[i];
Type *FieldTy = Type *FieldTy =
cast<PointerType>(SrcField->getType())->getElementType(); cast<PointerType>(SrcField->getType())->getElementType();
uint64_t FieldSizeBits = DL->getTypeSizeInBits(FieldTy); uint64_t FieldSizeBits = DL.getTypeSizeInBits(FieldTy);
// Ignore zero sized fields like {}, they obviously contain no data. // Ignore zero sized fields like {}, they obviously contain no data.
if (FieldSizeBits == 0) continue; if (FieldSizeBits == 0) continue;
Context not available.
else // Array case. else // Array case.
Shift = i*ArrayEltBitOffset; Shift = i*ArrayEltBitOffset;
if (DL->isBigEndian()) if (DL.isBigEndian())
Shift = AllocaSizeBits-Shift-FieldIntTy->getBitWidth(); Shift = AllocaSizeBits-Shift-FieldIntTy->getBitWidth();
if (Shift) { if (Shift) {
Context not available.
} }
// Handle tail padding by truncating the result // Handle tail padding by truncating the result
if (DL->getTypeSizeInBits(LI->getType()) != AllocaSizeBits) if (DL.getTypeSizeInBits(LI->getType()) != AllocaSizeBits)
ResultVal = new TruncInst(ResultVal, LI->getType(), "", LI); ResultVal = new TruncInst(ResultVal, LI->getType(), "", LI);
LI->replaceAllUsesWith(ResultVal); LI->replaceAllUsesWith(ResultVal);
Context not available.
return false; return false;
} }
const DataLayout &DL = AI->getModule()->getDataLayout();
// Okay, we know all the users are promotable. If the aggregate is a memcpy // Okay, we know all the users are promotable. If the aggregate is a memcpy
// source and destination, we have to be careful. In particular, the memcpy // source and destination, we have to be careful. In particular, the memcpy
// could be moving around elements that live in structure padding of the LLVM // could be moving around elements that live in structure padding of the LLVM
// types, but may actually be used. In these cases, we refuse to promote the // types, but may actually be used. In these cases, we refuse to promote the
// struct. // struct.
if (Info.isMemCpySrc && Info.isMemCpyDst && if (Info.isMemCpySrc && Info.isMemCpyDst &&
HasPadding(AI->getAllocatedType(), *DL)) HasPadding(AI->getAllocatedType(), DL))
return false; return false;
// If the alloca never has an access to just *part* of it, but is accessed // If the alloca never has an access to just *part* of it, but is accessed
Context not available.

lib/Transforms/Scalar/Scalarizer.cpp

Context not available.
void gather(Instruction *, const ValueVector &); void gather(Instruction *, const ValueVector &);
bool canTransferMetadata(unsigned Kind); bool canTransferMetadata(unsigned Kind);
void transferMetadata(Instruction *, const ValueVector &); void transferMetadata(Instruction *, const ValueVector &);
bool getVectorLayout(Type *, unsigned, VectorLayout &); bool getVectorLayout(Type *, unsigned, VectorLayout &, const DataLayout &);
bool finish(); bool finish();
template<typename T> bool splitBinary(Instruction &, const T &); template<typename T> bool splitBinary(Instruction &, const T &);
Context not available.
ScatterMap Scattered; ScatterMap Scattered;
GatherList Gathered; GatherList Gathered;
unsigned ParallelLoopAccessMDKind; unsigned ParallelLoopAccessMDKind;
const DataLayout *DL;
bool ScalarizeLoadStore; bool ScalarizeLoadStore;
}; };
Context not available.
} }
bool Scalarizer::runOnFunction(Function &F) { bool Scalarizer::runOnFunction(Function &F) {
DL = &F.getParent()->getDataLayout();
for (Function::iterator BBI = F.begin(), BBE = F.end(); BBI != BBE; ++BBI) { for (Function::iterator BBI = F.begin(), BBE = F.end(); BBI != BBE; ++BBI) {
BasicBlock *BB = BBI; BasicBlock *BB = BBI;
for (BasicBlock::iterator II = BB->begin(), IE = BB->end(); II != IE;) { for (BasicBlock::iterator II = BB->begin(), IE = BB->end(); II != IE;) {
Context not available.
// Try to fill in Layout from Ty, returning true on success. Alignment is // Try to fill in Layout from Ty, returning true on success. Alignment is
// the alignment of the vector, or 0 if the ABI default should be used. // the alignment of the vector, or 0 if the ABI default should be used.
bool Scalarizer::getVectorLayout(Type *Ty, unsigned Alignment, bool Scalarizer::getVectorLayout(Type *Ty, unsigned Alignment,
VectorLayout &Layout) { VectorLayout &Layout, const DataLayout &DL) {
if (!DL)
return false;
// Make sure we're dealing with a vector. // Make sure we're dealing with a vector.
Layout.VecTy = dyn_cast<VectorType>(Ty); Layout.VecTy = dyn_cast<VectorType>(Ty);
if (!Layout.VecTy) if (!Layout.VecTy)
Context not available.
// Check that we're dealing with full-byte elements. // Check that we're dealing with full-byte elements.
Layout.ElemTy = Layout.VecTy->getElementType(); Layout.ElemTy = Layout.VecTy->getElementType();
if (DL->getTypeSizeInBits(Layout.ElemTy) != if (DL.getTypeSizeInBits(Layout.ElemTy) !=
DL->getTypeStoreSizeInBits(Layout.ElemTy)) DL.getTypeStoreSizeInBits(Layout.ElemTy))
return false; return false;
if (Alignment) if (Alignment)
Layout.VecAlign = Alignment; Layout.VecAlign = Alignment;
else else
Layout.VecAlign = DL->getABITypeAlignment(Layout.VecTy); Layout.VecAlign = DL.getABITypeAlignment(Layout.VecTy);
Layout.ElemSize = DL->getTypeStoreSize(Layout.ElemTy); Layout.ElemSize = DL.getTypeStoreSize(Layout.ElemTy);
return true; return true;
} }
Context not available.
return false; return false;
VectorLayout Layout; VectorLayout Layout;
if (!getVectorLayout(LI.getType(), LI.getAlignment(), Layout)) if (!getVectorLayout(LI.getType(), LI.getAlignment(), Layout,
LI.getModule()->getDataLayout()))
return false; return false;
unsigned NumElems = Layout.VecTy->getNumElements(); unsigned NumElems = Layout.VecTy->getNumElements();
Context not available.
VectorLayout Layout; VectorLayout Layout;
Value *FullValue = SI.getValueOperand(); Value *FullValue = SI.getValueOperand();
if (!getVectorLayout(FullValue->getType(), SI.getAlignment(), Layout)) if (!getVectorLayout(FullValue->getType(), SI.getAlignment(), Layout,
SI.getModule()->getDataLayout()))
return false; return false;
unsigned NumElems = Layout.VecTy->getNumElements(); unsigned NumElems = Layout.VecTy->getNumElements();
Context not available.

lib/Transforms/Scalar/SeparateConstOffsetFromGEP.cpp

Context not available.
/// new index representing the remainder (equal to the original index minus /// new index representing the remainder (equal to the original index minus
/// the constant offset), or nullptr if we cannot extract a constant offset. /// the constant offset), or nullptr if we cannot extract a constant offset.
/// \p Idx The given GEP index /// \p Idx The given GEP index
/// \p DL The datalayout of the module
/// \p GEP The given GEP /// \p GEP The given GEP
static Value *Extract(Value *Idx, const DataLayout *DL, static Value *Extract(Value *Idx, GetElementPtrInst *GEP);
GetElementPtrInst *GEP);
/// Looks for a constant offset from the given GEP index without extracting /// Looks for a constant offset from the given GEP index without extracting
/// it. It returns the numeric value of the extracted constant offset (0 if /// it. It returns the numeric value of the extracted constant offset (0 if
/// failed). The meaning of the arguments are the same as Extract. /// failed). The meaning of the arguments are the same as Extract.
static int64_t Find(Value *Idx, const DataLayout *DL, GetElementPtrInst *GEP); static int64_t Find(Value *Idx, GetElementPtrInst *GEP);
private: private:
ConstantOffsetExtractor(const DataLayout *Layout, Instruction *InsertionPt) ConstantOffsetExtractor(Instruction *InsertionPt) : IP(InsertionPt) {}
: DL(Layout), IP(InsertionPt) {}
/// Searches the expression that computes V for a non-zero constant C s.t. /// Searches the expression that computes V for a non-zero constant C s.t.
/// V can be reassociated into the form V' + C. If the searching is /// V can be reassociated into the form V' + C. If the searching is
/// successful, returns C and update UserChain as a def-use chain from C to V; /// successful, returns C and update UserChain as a def-use chain from C to V;
Context not available.
/// A data structure used in rebuildWithoutConstOffset. Contains all /// A data structure used in rebuildWithoutConstOffset. Contains all
/// sext/zext instructions along UserChain. /// sext/zext instructions along UserChain.
SmallVector<CastInst *, 16> ExtInsts; SmallVector<CastInst *, 16> ExtInsts;
/// The data layout of the module. Used in ComputeKnownBits.
const DataLayout *DL;
Instruction *IP; /// Insertion position of cloned instructions. Instruction *IP; /// Insertion position of cloned instructions.
}; };
Context not available.
AU.setPreservesCFG(); AU.setPreservesCFG();
} }
bool doInitialization(Module &M) override {
DL = &M.getDataLayout();
return false;
}
bool runOnFunction(Function &F) override; bool runOnFunction(Function &F) override;
private: private:
Context not available.
/// Verified in @i32_add in split-gep.ll /// Verified in @i32_add in split-gep.ll
bool canonicalizeArrayIndicesToPointerSize(GetElementPtrInst *GEP); bool canonicalizeArrayIndicesToPointerSize(GetElementPtrInst *GEP);
const DataLayout *DL;
const TargetMachine *TM; const TargetMachine *TM;
/// Whether to lower a GEP with multiple indices into arithmetic operations or /// Whether to lower a GEP with multiple indices into arithmetic operations or
/// multiple GEPs with a single index. /// multiple GEPs with a single index.
Context not available.
return BO; return BO;
} }
Value *ConstantOffsetExtractor::Extract(Value *Idx, const DataLayout *DL, Value *ConstantOffsetExtractor::Extract(Value *Idx, GetElementPtrInst *GEP) {
GetElementPtrInst *GEP) { ConstantOffsetExtractor Extractor(GEP);
ConstantOffsetExtractor Extractor(DL, GEP);
// Find a non-zero constant offset first. // Find a non-zero constant offset first.
APInt ConstantOffset = APInt ConstantOffset =
Extractor.find(Idx, /* SignExtended */ false, /* ZeroExtended */ false, Extractor.find(Idx, /* SignExtended */ false, /* ZeroExtended */ false,
Context not available.
return Extractor.rebuildWithoutConstOffset(); return Extractor.rebuildWithoutConstOffset();
} }
int64_t ConstantOffsetExtractor::Find(Value *Idx, const DataLayout *DL, int64_t ConstantOffsetExtractor::Find(Value *Idx, GetElementPtrInst *GEP) {
GetElementPtrInst *GEP) {
// If Idx is an index of an inbound GEP, Idx is guaranteed to be non-negative. // If Idx is an index of an inbound GEP, Idx is guaranteed to be non-negative.
return ConstantOffsetExtractor(DL, GEP) return ConstantOffsetExtractor(GEP)
.find(Idx, /* SignExtended */ false, /* ZeroExtended */ false, .find(Idx, /* SignExtended */ false, /* ZeroExtended */ false,
GEP->isInBounds()) GEP->isInBounds())
.getSExtValue(); .getSExtValue();
Context not available.
IntegerType *IT = cast<IntegerType>(V->getType()); IntegerType *IT = cast<IntegerType>(V->getType());
KnownOne = APInt(IT->getBitWidth(), 0); KnownOne = APInt(IT->getBitWidth(), 0);
KnownZero = APInt(IT->getBitWidth(), 0); KnownZero = APInt(IT->getBitWidth(), 0);
const DataLayout &DL = IP->getModule()->getDataLayout();
llvm::computeKnownBits(V, KnownZero, KnownOne, DL, 0); llvm::computeKnownBits(V, KnownZero, KnownOne, DL, 0);
} }
Context not available.
bool SeparateConstOffsetFromGEP::canonicalizeArrayIndicesToPointerSize( bool SeparateConstOffsetFromGEP::canonicalizeArrayIndicesToPointerSize(
GetElementPtrInst *GEP) { GetElementPtrInst *GEP) {
bool Changed = false; bool Changed = false;
Type *IntPtrTy = DL->getIntPtrType(GEP->getType()); const DataLayout &DL = GEP->getModule()->getDataLayout();
Type *IntPtrTy = DL.getIntPtrType(GEP->getType());
gep_type_iterator GTI = gep_type_begin(*GEP); gep_type_iterator GTI = gep_type_begin(*GEP);
for (User::op_iterator I = GEP->op_begin() + 1, E = GEP->op_end(); for (User::op_iterator I = GEP->op_begin() + 1, E = GEP->op_end();
I != E; ++I, ++GTI) { I != E; ++I, ++GTI) {
Context not available.
NeedsExtraction = false; NeedsExtraction = false;
int64_t AccumulativeByteOffset = 0; int64_t AccumulativeByteOffset = 0;
gep_type_iterator GTI = gep_type_begin(*GEP); gep_type_iterator GTI = gep_type_begin(*GEP);
const DataLayout &DL = GEP->getModule()->getDataLayout();
for (unsigned I = 1, E = GEP->getNumOperands(); I != E; ++I, ++GTI) { for (unsigned I = 1, E = GEP->getNumOperands(); I != E; ++I, ++GTI) {
if (isa<SequentialType>(*GTI)) { if (isa<SequentialType>(*GTI)) {
// Tries to extract a constant offset from this GEP index. // Tries to extract a constant offset from this GEP index.
int64_t ConstantOffset = int64_t ConstantOffset =
ConstantOffsetExtractor::Find(GEP->getOperand(I), DL, GEP); ConstantOffsetExtractor::Find(GEP->getOperand(I), GEP);
if (ConstantOffset != 0) { if (ConstantOffset != 0) {
NeedsExtraction = true; NeedsExtraction = true;
// A GEP may have multiple indices. We accumulate the extracted // A GEP may have multiple indices. We accumulate the extracted
// constant offset to a byte offset, and later offset the remainder of // constant offset to a byte offset, and later offset the remainder of
// the original GEP with this byte offset. // the original GEP with this byte offset.
AccumulativeByteOffset += AccumulativeByteOffset +=
ConstantOffset * DL->getTypeAllocSize(GTI.getIndexedType()); ConstantOffset * DL.getTypeAllocSize(GTI.getIndexedType());
} }
} else if (LowerGEP) { } else if (LowerGEP) {
StructType *StTy = cast<StructType>(*GTI); StructType *StTy = cast<StructType>(*GTI);
Context not available.
if (Field != 0) { if (Field != 0) {
NeedsExtraction = true; NeedsExtraction = true;
AccumulativeByteOffset += AccumulativeByteOffset +=
DL->getStructLayout(StTy)->getElementOffset(Field); DL.getStructLayout(StTy)->getElementOffset(Field);
} }
} }
} }
Context not available.
void SeparateConstOffsetFromGEP::lowerToSingleIndexGEPs( void SeparateConstOffsetFromGEP::lowerToSingleIndexGEPs(
GetElementPtrInst *Variadic, int64_t AccumulativeByteOffset) { GetElementPtrInst *Variadic, int64_t AccumulativeByteOffset) {
IRBuilder<> Builder(Variadic); IRBuilder<> Builder(Variadic);
Type *IntPtrTy = DL->getIntPtrType(Variadic->getType()); const DataLayout &DL = Variadic->getModule()->getDataLayout();
Type *IntPtrTy = DL.getIntPtrType(Variadic->getType());
Type *I8PtrTy = Type *I8PtrTy =
Builder.getInt8PtrTy(Variadic->getType()->getPointerAddressSpace()); Builder.getInt8PtrTy(Variadic->getType()->getPointerAddressSpace());
Context not available.
continue; continue;
APInt ElementSize = APInt(IntPtrTy->getIntegerBitWidth(), APInt ElementSize = APInt(IntPtrTy->getIntegerBitWidth(),
DL->getTypeAllocSize(GTI.getIndexedType())); DL.getTypeAllocSize(GTI.getIndexedType()));
// Scale the index by element size. // Scale the index by element size.
if (ElementSize != 1) { if (ElementSize != 1) {
if (ElementSize.isPowerOf2()) { if (ElementSize.isPowerOf2()) {
Context not available.
SeparateConstOffsetFromGEP::lowerToArithmetics(GetElementPtrInst *Variadic, SeparateConstOffsetFromGEP::lowerToArithmetics(GetElementPtrInst *Variadic,
int64_t AccumulativeByteOffset) { int64_t AccumulativeByteOffset) {
IRBuilder<> Builder(Variadic); IRBuilder<> Builder(Variadic);
Type *IntPtrTy = DL->getIntPtrType(Variadic->getType()); const DataLayout &DL = Variadic->getModule()->getDataLayout();
Type *IntPtrTy = DL.getIntPtrType(Variadic->getType());
Value *ResultPtr = Builder.CreatePtrToInt(Variadic->getOperand(0), IntPtrTy); Value *ResultPtr = Builder.CreatePtrToInt(Variadic->getOperand(0), IntPtrTy);
gep_type_iterator GTI = gep_type_begin(*Variadic); gep_type_iterator GTI = gep_type_begin(*Variadic);
Context not available.
continue; continue;
APInt ElementSize = APInt(IntPtrTy->getIntegerBitWidth(), APInt ElementSize = APInt(IntPtrTy->getIntegerBitWidth(),
DL->getTypeAllocSize(GTI.getIndexedType())); DL.getTypeAllocSize(GTI.getIndexedType()));
// Scale the index by element size. // Scale the index by element size.
if (ElementSize != 1) { if (ElementSize != 1) {
if (ElementSize.isPowerOf2()) { if (ElementSize.isPowerOf2()) {
Context not available.
if (isa<SequentialType>(*GTI)) { if (isa<SequentialType>(*GTI)) {
// Splits this GEP index into a variadic part and a constant offset, and // Splits this GEP index into a variadic part and a constant offset, and
// uses the variadic part as the new index. // uses the variadic part as the new index.
Value *NewIdx = Value *NewIdx = ConstantOffsetExtractor::Extract(GEP->getOperand(I), GEP);
ConstantOffsetExtractor::Extract(GEP->getOperand(I), DL, GEP);
if (NewIdx != nullptr) { if (NewIdx != nullptr) {
GEP->setOperand(I, NewIdx); GEP->setOperand(I, NewIdx);
} }
Context not available.
// Per ANSI C standard, signed / unsigned = unsigned and signed % unsigned = // Per ANSI C standard, signed / unsigned = unsigned and signed % unsigned =
// unsigned.. Therefore, we cast ElementTypeSizeOfGEP to signed because it is // unsigned.. Therefore, we cast ElementTypeSizeOfGEP to signed because it is
// used with unsigned integers later. // used with unsigned integers later.
const DataLayout &DL = GEP->getModule()->getDataLayout();
int64_t ElementTypeSizeOfGEP = static_cast<int64_t>( int64_t ElementTypeSizeOfGEP = static_cast<int64_t>(
DL->getTypeAllocSize(GEP->getType()->getElementType())); DL.getTypeAllocSize(GEP->getType()->getElementType()));
Type *IntPtrTy = DL->getIntPtrType(GEP->getType()); Type *IntPtrTy = DL.getIntPtrType(GEP->getType());
if (AccumulativeByteOffset % ElementTypeSizeOfGEP == 0) { if (AccumulativeByteOffset % ElementTypeSizeOfGEP == 0) {
// Very likely. As long as %gep is natually aligned, the byte offset we // Very likely. As long as %gep is natually aligned, the byte offset we
// extracted should be a multiple of sizeof(*%gep). // extracted should be a multiple of sizeof(*%gep).
Context not available.

lib/Transforms/Scalar/SimplifyCFGPass.cpp

Context not available.
/// iterativelySimplifyCFG - Call SimplifyCFG on all the blocks in the function, /// iterativelySimplifyCFG - Call SimplifyCFG on all the blocks in the function,
/// iterating until no more changes are made. /// iterating until no more changes are made.
static bool iterativelySimplifyCFG(Function &F, const TargetTransformInfo &TTI, static bool iterativelySimplifyCFG(Function &F, const TargetTransformInfo &TTI,
const DataLayout *DL, AssumptionCache *AC, AssumptionCache *AC,
unsigned BonusInstThreshold) { unsigned BonusInstThreshold) {
bool Changed = false; bool Changed = false;
bool LocalChange = true; bool LocalChange = true;
Context not available.
// Loop over all of the basic blocks and remove them if they are unneeded... // Loop over all of the basic blocks and remove them if they are unneeded...
// //
for (Function::iterator BBIt = F.begin(); BBIt != F.end(); ) { for (Function::iterator BBIt = F.begin(); BBIt != F.end(); ) {
if (SimplifyCFG(BBIt++, TTI, BonusInstThreshold, DL, AC)) { if (SimplifyCFG(BBIt++, TTI, BonusInstThreshold, AC)) {
LocalChange = true; LocalChange = true;
++NumSimpl; ++NumSimpl;
} }
Context not available.
} }
static bool simplifyFunctionCFG(Function &F, const TargetTransformInfo &TTI, static bool simplifyFunctionCFG(Function &F, const TargetTransformInfo &TTI,
const DataLayout *DL, AssumptionCache *AC, AssumptionCache *AC, int BonusInstThreshold) {
int BonusInstThreshold) {
bool EverChanged = removeUnreachableBlocks(F); bool EverChanged = removeUnreachableBlocks(F);
EverChanged |= mergeEmptyReturnBlocks(F); EverChanged |= mergeEmptyReturnBlocks(F);
EverChanged |= iterativelySimplifyCFG(F, TTI, DL, AC, BonusInstThreshold); EverChanged |= iterativelySimplifyCFG(F, TTI, AC, BonusInstThreshold);
// If neither pass changed anything, we're done. // If neither pass changed anything, we're done.
if (!EverChanged) return false; if (!EverChanged) return false;
Context not available.
return true; return true;
do { do {
EverChanged = iterativelySimplifyCFG(F, TTI, DL, AC, BonusInstThreshold); EverChanged = iterativelySimplifyCFG(F, TTI, AC, BonusInstThreshold);
EverChanged |= removeUnreachableBlocks(F); EverChanged |= removeUnreachableBlocks(F);
} while (EverChanged); } while (EverChanged);
Context not available.
PreservedAnalyses SimplifyCFGPass::run(Function &F, PreservedAnalyses SimplifyCFGPass::run(Function &F,
AnalysisManager<Function> *AM) { AnalysisManager<Function> *AM) {
auto &DL = F.getParent()->getDataLayout();
auto &TTI = AM->getResult<TargetIRAnalysis>(F); auto &TTI = AM->getResult<TargetIRAnalysis>(F);
auto &AC = AM->getResult<AssumptionAnalysis>(F); auto &AC = AM->getResult<AssumptionAnalysis>(F);
if (!simplifyFunctionCFG(F, TTI, &DL, &AC, BonusInstThreshold)) if (!simplifyFunctionCFG(F, TTI, &AC, BonusInstThreshold))
return PreservedAnalyses::none(); return PreservedAnalyses::none();
return PreservedAnalyses::all(); return PreservedAnalyses::all();
Context not available.
&getAnalysis<AssumptionCacheTracker>().getAssumptionCache(F); &getAnalysis<AssumptionCacheTracker>().getAssumptionCache(F);
const TargetTransformInfo &TTI = const TargetTransformInfo &TTI =
getAnalysis<TargetTransformInfoWrapperPass>().getTTI(F); getAnalysis<TargetTransformInfoWrapperPass>().getTTI(F);
const DataLayout &DL = F.getParent()->getDataLayout(); return simplifyFunctionCFG(F, TTI, AC, BonusInstThreshold);
return simplifyFunctionCFG(F, TTI, &DL, AC, BonusInstThreshold);
} }
void getAnalysisUsage(AnalysisUsage &AU) const override { void getAnalysisUsage(AnalysisUsage &AU) const override {
Context not available.

lib/Transforms/Scalar/Sink.cpp

Context not available.
DominatorTree *DT; DominatorTree *DT;
LoopInfo *LI; LoopInfo *LI;
AliasAnalysis *AA; AliasAnalysis *AA;
const DataLayout *DL;
public: public:
static char ID; // Pass identification static char ID; // Pass identification
Context not available.
DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree(); DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
LI = &getAnalysis<LoopInfoWrapperPass>().getLoopInfo(); LI = &getAnalysis<LoopInfoWrapperPass>().getLoopInfo();
AA = &getAnalysis<AliasAnalysis>(); AA = &getAnalysis<AliasAnalysis>();
DL = &F.getParent()->getDataLayout();
bool MadeChange, EverMadeChange = false; bool MadeChange, EverMadeChange = false;
Context not available.
if (SuccToSinkTo->getUniquePredecessor() != Inst->getParent()) { if (SuccToSinkTo->getUniquePredecessor() != Inst->getParent()) {
// We cannot sink a load across a critical edge - there may be stores in // We cannot sink a load across a critical edge - there may be stores in
// other code paths. // other code paths.
if (!isSafeToSpeculativelyExecute(Inst, DL)) if (!isSafeToSpeculativelyExecute(Inst))
return false; return false;
// We don't want to sink across a critical edge if we don't dominate the // We don't want to sink across a critical edge if we don't dominate the
Context not available.

lib/Transforms/Scalar/TailRecursionElimination.cpp

Context not available.
namespace { namespace {
struct TailCallElim : public FunctionPass { struct TailCallElim : public FunctionPass {
const TargetTransformInfo *TTI; const TargetTransformInfo *TTI;
const DataLayout *DL;
static char ID; // Pass identification, replacement for typeid static char ID; // Pass identification, replacement for typeid
TailCallElim() : FunctionPass(ID) { TailCallElim() : FunctionPass(ID) {
Context not available.
if (skipOptnoneFunction(F)) if (skipOptnoneFunction(F))
return false; return false;
DL = &F.getParent()->getDataLayout();
bool AllCallsAreTailCalls = false; bool AllCallsAreTailCalls = false;
bool Modified = markTails(F, AllCallsAreTailCalls); bool Modified = markTails(F, AllCallsAreTailCalls);
if (AllCallsAreTailCalls) if (AllCallsAreTailCalls)
Context not available.
PHINode *PN = ArgumentPHIs[i]; PHINode *PN = ArgumentPHIs[i];
// If the PHI Node is a dynamic constant, replace it with the value it is. // If the PHI Node is a dynamic constant, replace it with the value it is.
if (Value *PNV = SimplifyInstruction(PN)) { if (Value *PNV = SimplifyInstruction(PN, F.getParent()->getDataLayout())) {
PN->replaceAllUsesWith(PNV); PN->replaceAllUsesWith(PNV);
PN->eraseFromParent(); PN->eraseFromParent();
} }
Context not available.
// being loaded from. // being loaded from.
if (CI->mayWriteToMemory() || if (CI->mayWriteToMemory() ||
!isSafeToLoadUnconditionally(L->getPointerOperand(), L, !isSafeToLoadUnconditionally(L->getPointerOperand(), L,
L->getAlignment(), DL)) L->getAlignment()))
return false; return false;
} }
} }
Context not available.

lib/Transforms/Utils/BuildLibCalls.cpp

Context not available.
/// EmitStrLen - Emit a call to the strlen function to the builder, for the /// EmitStrLen - Emit a call to the strlen function to the builder, for the
/// specified pointer. This always returns an integer value of size intptr_t. /// specified pointer. This always returns an integer value of size intptr_t.
Value *llvm::EmitStrLen(Value *Ptr, IRBuilder<> &B, const DataLayout *TD, Value *llvm::EmitStrLen(Value *Ptr, IRBuilder<> &B, const DataLayout &DL,
const TargetLibraryInfo *TLI) { const TargetLibraryInfo *TLI) {
if (!TLI->has(LibFunc::strlen)) if (!TLI->has(LibFunc::strlen))
return nullptr; return nullptr;
Context not available.
AS[1] = AttributeSet::get(M->getContext(), AttributeSet::FunctionIndex, AVs); AS[1] = AttributeSet::get(M->getContext(), AttributeSet::FunctionIndex, AVs);
LLVMContext &Context = B.GetInsertBlock()->getContext(); LLVMContext &Context = B.GetInsertBlock()->getContext();
Constant *StrLen = M->getOrInsertFunction("strlen", Constant *StrLen = M->getOrInsertFunction(
AttributeSet::get(M->getContext(), "strlen", AttributeSet::get(M->getContext(), AS),
AS), DL.getIntPtrType(Context), B.getInt8PtrTy(), nullptr);
TD->getIntPtrType(Context),
B.getInt8PtrTy(),
nullptr);
CallInst *CI = B.CreateCall(StrLen, CastToCStr(Ptr, B), "strlen"); CallInst *CI = B.CreateCall(StrLen, CastToCStr(Ptr, B), "strlen");
if (const Function *F = dyn_cast<Function>(StrLen->stripPointerCasts())) if (const Function *F = dyn_cast<Function>(StrLen->stripPointerCasts()))
CI->setCallingConv(F->getCallingConv()); CI->setCallingConv(F->getCallingConv());
Context not available.
/// specified pointer. Ptr is required to be some pointer type, MaxLen must /// specified pointer. Ptr is required to be some pointer type, MaxLen must
/// be of size_t type, and the return value has 'intptr_t' type. /// be of size_t type, and the return value has 'intptr_t' type.
Value *llvm::EmitStrNLen(Value *Ptr, Value *MaxLen, IRBuilder<> &B, Value *llvm::EmitStrNLen(Value *Ptr, Value *MaxLen, IRBuilder<> &B,
const DataLayout *TD, const TargetLibraryInfo *TLI) { const DataLayout &DL, const TargetLibraryInfo *TLI) {
if (!TLI->has(LibFunc::strnlen)) if (!TLI->has(LibFunc::strnlen))
return nullptr; return nullptr;
Context not available.
AS[1] = AttributeSet::get(M->getContext(), AttributeSet::FunctionIndex, AVs); AS[1] = AttributeSet::get(M->getContext(), AttributeSet::FunctionIndex, AVs);
LLVMContext &Context = B.GetInsertBlock()->getContext(); LLVMContext &Context = B.GetInsertBlock()->getContext();
Constant *StrNLen = M->getOrInsertFunction("strnlen", Constant *StrNLen =
AttributeSet::get(M->getContext(), M->getOrInsertFunction("strnlen", AttributeSet::get(M->getContext(), AS),
AS), DL.getIntPtrType(Context), B.getInt8PtrTy(),
TD->getIntPtrType(Context), DL.getIntPtrType(Context), nullptr);
B.getInt8PtrTy(),
TD->getIntPtrType(Context),
nullptr);
CallInst *CI = B.CreateCall2(StrNLen, CastToCStr(Ptr, B), MaxLen, "strnlen"); CallInst *CI = B.CreateCall2(StrNLen, CastToCStr(Ptr, B), MaxLen, "strnlen");
if (const Function *F = dyn_cast<Function>(StrNLen->stripPointerCasts())) if (const Function *F = dyn_cast<Function>(StrNLen->stripPointerCasts()))
CI->setCallingConv(F->getCallingConv()); CI->setCallingConv(F->getCallingConv());
Context not available.
/// specified pointer and character. Ptr is required to be some pointer type, /// specified pointer and character. Ptr is required to be some pointer type,
/// and the return value has 'i8*' type. /// and the return value has 'i8*' type.
Value *llvm::EmitStrChr(Value *Ptr, char C, IRBuilder<> &B, Value *llvm::EmitStrChr(Value *Ptr, char C, IRBuilder<> &B,
const DataLayout *TD, const TargetLibraryInfo *TLI) { const TargetLibraryInfo *TLI) {
if (!TLI->has(LibFunc::strchr)) if (!TLI->has(LibFunc::strchr))
return nullptr; return nullptr;
Context not available.
} }
/// EmitStrNCmp - Emit a call to the strncmp function to the builder. /// EmitStrNCmp - Emit a call to the strncmp function to the builder.
Value *llvm::EmitStrNCmp(Value *Ptr1, Value *Ptr2, Value *Len, Value *llvm::EmitStrNCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilder<> &B,
IRBuilder<> &B, const DataLayout *TD, const DataLayout &DL, const TargetLibraryInfo *TLI) {
const TargetLibraryInfo *TLI) {
if (!TLI->has(LibFunc::strncmp)) if (!TLI->has(LibFunc::strncmp))
return nullptr; return nullptr;
Context not available.
AS[2] = AttributeSet::get(M->getContext(), AttributeSet::FunctionIndex, AVs); AS[2] = AttributeSet::get(M->getContext(), AttributeSet::FunctionIndex, AVs);
LLVMContext &Context = B.GetInsertBlock()->getContext(); LLVMContext &Context = B.GetInsertBlock()->getContext();
Value *StrNCmp = M->getOrInsertFunction("strncmp", Value *StrNCmp = M->getOrInsertFunction(
AttributeSet::get(M->getContext(), "strncmp", AttributeSet::get(M->getContext(), AS), B.getInt32Ty(),
AS), B.getInt8PtrTy(), B.getInt8PtrTy(), DL.getIntPtrType(Context), nullptr);
B.getInt32Ty(),
B.getInt8PtrTy(),
B.getInt8PtrTy(),
TD->getIntPtrType(Context), nullptr);
CallInst *CI = B.CreateCall3(StrNCmp, CastToCStr(Ptr1, B), CallInst *CI = B.CreateCall3(StrNCmp, CastToCStr(Ptr1, B),
CastToCStr(Ptr2, B), Len, "strncmp"); CastToCStr(Ptr2, B), Len, "strncmp");
Context not available.
/// EmitStrCpy - Emit a call to the strcpy function to the builder, for the /// EmitStrCpy - Emit a call to the strcpy function to the builder, for the
/// specified pointer arguments. /// specified pointer arguments.
Value *llvm::EmitStrCpy(Value *Dst, Value *Src, IRBuilder<> &B, Value *llvm::EmitStrCpy(Value *Dst, Value *Src, IRBuilder<> &B,
const DataLayout *TD, const TargetLibraryInfo *TLI, const TargetLibraryInfo *TLI, StringRef Name) {
StringRef Name) {
if (!TLI->has(LibFunc::strcpy)) if (!TLI->has(LibFunc::strcpy))
return nullptr; return nullptr;
Context not available.
/// EmitStrNCpy - Emit a call to the strncpy function to the builder, for the /// EmitStrNCpy - Emit a call to the strncpy function to the builder, for the
/// specified pointer arguments. /// specified pointer arguments.
Value *llvm::EmitStrNCpy(Value *Dst, Value *Src, Value *Len, Value *llvm::EmitStrNCpy(Value *Dst, Value *Src, Value *Len, IRBuilder<> &B,
IRBuilder<> &B, const DataLayout *TD,
const TargetLibraryInfo *TLI, StringRef Name) { const TargetLibraryInfo *TLI, StringRef Name) {
if (!TLI->has(LibFunc::strncpy)) if (!TLI->has(LibFunc::strncpy))
return nullptr; return nullptr;
Context not available.
/// This expects that the Len and ObjSize have type 'intptr_t' and Dst/Src /// This expects that the Len and ObjSize have type 'intptr_t' and Dst/Src
/// are pointers. /// are pointers.
Value *llvm::EmitMemCpyChk(Value *Dst, Value *Src, Value *Len, Value *ObjSize, Value *llvm::EmitMemCpyChk(Value *Dst, Value *Src, Value *Len, Value *ObjSize,
IRBuilder<> &B, const DataLayout *TD, IRBuilder<> &B, const DataLayout &DL,
const TargetLibraryInfo *TLI) { const TargetLibraryInfo *TLI) {
if (!TLI->has(LibFunc::memcpy_chk)) if (!TLI->has(LibFunc::memcpy_chk))
return nullptr; return nullptr;
Context not available.
AS = AttributeSet::get(M->getContext(), AttributeSet::FunctionIndex, AS = AttributeSet::get(M->getContext(), AttributeSet::FunctionIndex,
Attribute::NoUnwind); Attribute::NoUnwind);
LLVMContext &Context = B.GetInsertBlock()->getContext(); LLVMContext &Context = B.GetInsertBlock()->getContext();
Value *MemCpy = M->getOrInsertFunction("__memcpy_chk", Value *MemCpy = M->getOrInsertFunction(
AttributeSet::get(M->getContext(), AS), "__memcpy_chk", AttributeSet::get(M->getContext(), AS), B.getInt8PtrTy(),
B.getInt8PtrTy(), B.getInt8PtrTy(), B.getInt8PtrTy(), DL.getIntPtrType(Context),
B.getInt8PtrTy(), DL.getIntPtrType(Context), nullptr);
B.getInt8PtrTy(),
TD->getIntPtrType(Context),
TD->getIntPtrType(Context), nullptr);
Dst = CastToCStr(Dst, B); Dst = CastToCStr(Dst, B);
Src = CastToCStr(Src, B); Src = CastToCStr(Src, B);
CallInst *CI = B.CreateCall4(MemCpy, Dst, Src, Len, ObjSize); CallInst *CI = B.CreateCall4(MemCpy, Dst, Src, Len, ObjSize);
Context not available.
/// EmitMemChr - Emit a call to the memchr function. This assumes that Ptr is /// EmitMemChr - Emit a call to the memchr function. This assumes that Ptr is
/// a pointer, Val is an i32 value, and Len is an 'intptr_t' value. /// a pointer, Val is an i32 value, and Len is an 'intptr_t' value.
Value *llvm::EmitMemChr(Value *Ptr, Value *Val, Value *llvm::EmitMemChr(Value *Ptr, Value *Val, Value *Len, IRBuilder<> &B,
Value *Len, IRBuilder<> &B, const DataLayout *TD, const DataLayout &DL, const TargetLibraryInfo *TLI) {
const TargetLibraryInfo *TLI) {
if (!TLI->has(LibFunc::memchr)) if (!TLI->has(LibFunc::memchr))
return nullptr; return nullptr;
Context not available.
Attribute::AttrKind AVs[2] = { Attribute::ReadOnly, Attribute::NoUnwind }; Attribute::AttrKind AVs[2] = { Attribute::ReadOnly, Attribute::NoUnwind };
AS = AttributeSet::get(M->getContext(), AttributeSet::FunctionIndex, AVs); AS = AttributeSet::get(M->getContext(), AttributeSet::FunctionIndex, AVs);
LLVMContext &Context = B.GetInsertBlock()->getContext(); LLVMContext &Context = B.GetInsertBlock()->getContext();
Value *MemChr = M->getOrInsertFunction("memchr", Value *MemChr = M->getOrInsertFunction(
AttributeSet::get(M->getContext(), AS), "memchr", AttributeSet::get(M->getContext(), AS), B.getInt8PtrTy(),
B.getInt8PtrTy(), B.getInt8PtrTy(), B.getInt32Ty(), DL.getIntPtrType(Context), nullptr);
B.getInt8PtrTy(),
B.getInt32Ty(),
TD->getIntPtrType(Context),
nullptr);
CallInst *CI = B.CreateCall3(MemChr, CastToCStr(Ptr, B), Val, Len, "memchr"); CallInst *CI = B.CreateCall3(MemChr, CastToCStr(Ptr, B), Val, Len, "memchr");
if (const Function *F = dyn_cast<Function>(MemChr->stripPointerCasts())) if (const Function *F = dyn_cast<Function>(MemChr->stripPointerCasts()))
Context not available.
} }
/// EmitMemCmp - Emit a call to the memcmp function. /// EmitMemCmp - Emit a call to the memcmp function.
Value *llvm::EmitMemCmp(Value *Ptr1, Value *Ptr2, Value *llvm::EmitMemCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilder<> &B,
Value *Len, IRBuilder<> &B, const DataLayout *TD, const DataLayout &DL, const TargetLibraryInfo *TLI) {
const TargetLibraryInfo *TLI) {
if (!TLI->has(LibFunc::memcmp)) if (!TLI->has(LibFunc::memcmp))
return nullptr; return nullptr;
Context not available.
AS[2] = AttributeSet::get(M->getContext(), AttributeSet::FunctionIndex, AVs); AS[2] = AttributeSet::get(M->getContext(), AttributeSet::FunctionIndex, AVs);
LLVMContext &Context = B.GetInsertBlock()->getContext(); LLVMContext &Context = B.GetInsertBlock()->getContext();
Value *MemCmp = M->getOrInsertFunction("memcmp", Value *MemCmp = M->getOrInsertFunction(
AttributeSet::get(M->getContext(), AS), "memcmp", AttributeSet::get(M->getContext(), AS), B.getInt32Ty(),
B.getInt32Ty(), B.getInt8PtrTy(), B.getInt8PtrTy(), DL.getIntPtrType(Context), nullptr);
B.getInt8PtrTy(),
B.getInt8PtrTy(),
TD->getIntPtrType(Context), nullptr);
CallInst *CI = B.CreateCall3(MemCmp, CastToCStr(Ptr1, B), CastToCStr(Ptr2, B), CallInst *CI = B.CreateCall3(MemCmp, CastToCStr(Ptr1, B), CastToCStr(Ptr2, B),
Len, "memcmp"); Len, "memcmp");
Context not available.
/// EmitPutChar - Emit a call to the putchar function. This assumes that Char /// EmitPutChar - Emit a call to the putchar function. This assumes that Char
/// is an integer. /// is an integer.
Value *llvm::EmitPutChar(Value *Char, IRBuilder<> &B, const DataLayout *TD, Value *llvm::EmitPutChar(Value *Char, IRBuilder<> &B,
const TargetLibraryInfo *TLI) { const TargetLibraryInfo *TLI) {
if (!TLI->has(LibFunc::putchar)) if (!TLI->has(LibFunc::putchar))
return nullptr; return nullptr;
Context not available.
/// EmitPutS - Emit a call to the puts function. This assumes that Str is /// EmitPutS - Emit a call to the puts function. This assumes that Str is
/// some pointer. /// some pointer.
Value *llvm::EmitPutS(Value *Str, IRBuilder<> &B, const DataLayout *TD, Value *llvm::EmitPutS(Value *Str, IRBuilder<> &B,
const TargetLibraryInfo *TLI) { const TargetLibraryInfo *TLI) {
if (!TLI->has(LibFunc::puts)) if (!TLI->has(LibFunc::puts))
return nullptr; return nullptr;
Context not available.
/// EmitFPutC - Emit a call to the fputc function. This assumes that Char is /// EmitFPutC - Emit a call to the fputc function. This assumes that Char is
/// an integer and File is a pointer to FILE. /// an integer and File is a pointer to FILE.
Value *llvm::EmitFPutC(Value *Char, Value *File, IRBuilder<> &B, Value *llvm::EmitFPutC(Value *Char, Value *File, IRBuilder<> &B,
const DataLayout *TD, const TargetLibraryInfo *TLI) { const TargetLibraryInfo *TLI) {
if (!TLI->has(LibFunc::fputc)) if (!TLI->has(LibFunc::fputc))
return nullptr; return nullptr;
Context not available.
/// EmitFPutS - Emit a call to the puts function. Str is required to be a /// EmitFPutS - Emit a call to the puts function. Str is required to be a
/// pointer and File is a pointer to FILE. /// pointer and File is a pointer to FILE.
Value *llvm::EmitFPutS(Value *Str, Value *File, IRBuilder<> &B, Value *llvm::EmitFPutS(Value *Str, Value *File, IRBuilder<> &B,
const DataLayout *TD, const TargetLibraryInfo *TLI) { const TargetLibraryInfo *TLI) {
if (!TLI->has(LibFunc::fputs)) if (!TLI->has(LibFunc::fputs))
return nullptr; return nullptr;
Context not available.
/// EmitFWrite - Emit a call to the fwrite function. This assumes that Ptr is /// EmitFWrite - Emit a call to the fwrite function. This assumes that Ptr is
/// a pointer, Size is an 'intptr_t', and File is a pointer to FILE. /// a pointer, Size is an 'intptr_t', and File is a pointer to FILE.
Value *llvm::EmitFWrite(Value *Ptr, Value *Size, Value *File, Value *llvm::EmitFWrite(Value *Ptr, Value *Size, Value *File, IRBuilder<> &B,
IRBuilder<> &B, const DataLayout *TD, const DataLayout &DL, const TargetLibraryInfo *TLI) {
const TargetLibraryInfo *TLI) {
if (!TLI->has(LibFunc::fwrite)) if (!TLI->has(LibFunc::fwrite))
return nullptr; return nullptr;
Context not available.
StringRef FWriteName = TLI->getName(LibFunc::fwrite); StringRef FWriteName = TLI->getName(LibFunc::fwrite);
Constant *F; Constant *F;
if (File->getType()->isPointerTy()) if (File->getType()->isPointerTy())
F = M->getOrInsertFunction(FWriteName, F = M->getOrInsertFunction(
AttributeSet::get(M->getContext(), AS), FWriteName, AttributeSet::get(M->getContext(), AS),
TD->getIntPtrType(Context), DL.getIntPtrType(Context), B.getInt8PtrTy(), DL.getIntPtrType(Context),
B.getInt8PtrTy(), DL.getIntPtrType(Context), File->getType(), nullptr);
TD->getIntPtrType(Context),
TD->getIntPtrType(Context),
File->getType(), nullptr);
else else
F = M->getOrInsertFunction(FWriteName, TD->getIntPtrType(Context), F = M->getOrInsertFunction(FWriteName, DL.getIntPtrType(Context),
B.getInt8PtrTy(), B.getInt8PtrTy(), DL.getIntPtrType(Context),
TD->getIntPtrType(Context), DL.getIntPtrType(Context), File->getType(),
TD->getIntPtrType(Context), nullptr);
File->getType(), nullptr); CallInst *CI =
CallInst *CI = B.CreateCall4(F, CastToCStr(Ptr, B), Size, B.CreateCall4(F, CastToCStr(Ptr, B), Size,
ConstantInt::get(TD->getIntPtrType(Context), 1), File); ConstantInt::get(DL.getIntPtrType(Context), 1), File);
if (const Function *Fn = dyn_cast<Function>(F->stripPointerCasts())) if (const Function *Fn = dyn_cast<Function>(F->stripPointerCasts()))
CI->setCallingConv(Fn->getCallingConv()); CI->setCallingConv(Fn->getCallingConv());
Context not available.

lib/Transforms/Utils/CloneFunction.cpp

Context not available.
bool ModuleLevelChanges; bool ModuleLevelChanges;
const char *NameSuffix; const char *NameSuffix;
ClonedCodeInfo *CodeInfo; ClonedCodeInfo *CodeInfo;
const DataLayout *DL;
CloningDirector *Director; CloningDirector *Director;
ValueMapTypeRemapper *TypeMapper; ValueMapTypeRemapper *TypeMapper;
ValueMaterializer *Materializer; ValueMaterializer *Materializer;
public: public:
PruningFunctionCloner(Function *newFunc, const Function *oldFunc, PruningFunctionCloner(Function *newFunc, const Function *oldFunc,
ValueToValueMapTy &valueMap, ValueToValueMapTy &valueMap, bool moduleLevelChanges,
bool moduleLevelChanges, const char *nameSuffix, ClonedCodeInfo *codeInfo,
const char *nameSuffix,
ClonedCodeInfo *codeInfo,
const DataLayout *DL,
CloningDirector *Director) CloningDirector *Director)
: NewFunc(newFunc), OldFunc(oldFunc), : NewFunc(newFunc), OldFunc(oldFunc), VMap(valueMap),
VMap(valueMap), ModuleLevelChanges(moduleLevelChanges), ModuleLevelChanges(moduleLevelChanges), NameSuffix(nameSuffix),
NameSuffix(nameSuffix), CodeInfo(codeInfo), DL(DL), CodeInfo(codeInfo), Director(Director) {
Director(Director) {
// These are optional components. The Director may return null. // These are optional components. The Director may return null.
if (Director) { if (Director) {
TypeMapper = Director->getTypeRemapper(); TypeMapper = Director->getTypeRemapper();
Context not available.
// If we can simplify this instruction to some other value, simply add // If we can simplify this instruction to some other value, simply add
// a mapping to that value rather than inserting a new instruction into // a mapping to that value rather than inserting a new instruction into
// the basic block. // the basic block.
if (Value *V = SimplifyInstruction(NewInst, DL)) { if (Value *V =
SimplifyInstruction(NewInst, BB->getModule()->getDataLayout())) {
// On the off-chance that this simplifies to an instruction in the old // On the off-chance that this simplifies to an instruction in the old
// function, map it back into the new function. // function, map it back into the new function.
if (Value *MappedV = VMap.lookup(V)) if (Value *MappedV = VMap.lookup(V))
Context not available.
SmallVectorImpl<ReturnInst *> &Returns, SmallVectorImpl<ReturnInst *> &Returns,
const char *NameSuffix, const char *NameSuffix,
ClonedCodeInfo *CodeInfo, ClonedCodeInfo *CodeInfo,
const DataLayout *DL,
CloningDirector *Director) { CloningDirector *Director) {
assert(NameSuffix && "NameSuffix cannot be null!"); assert(NameSuffix && "NameSuffix cannot be null!");
Context not available.
#endif #endif
PruningFunctionCloner PFC(NewFunc, OldFunc, VMap, ModuleLevelChanges, PruningFunctionCloner PFC(NewFunc, OldFunc, VMap, ModuleLevelChanges,
NameSuffix, CodeInfo, DL, Director); NameSuffix, CodeInfo, Director);
const BasicBlock *StartingBB; const BasicBlock *StartingBB;
if (StartingInst) if (StartingInst)
StartingBB = StartingInst->getParent(); StartingBB = StartingInst->getParent();
Context not available.
// node). // node).
for (unsigned Idx = 0, Size = PHIToResolve.size(); Idx != Size; ++Idx) for (unsigned Idx = 0, Size = PHIToResolve.size(); Idx != Size; ++Idx)
if (PHINode *PN = dyn_cast<PHINode>(VMap[PHIToResolve[Idx]])) if (PHINode *PN = dyn_cast<PHINode>(VMap[PHIToResolve[Idx]]))
recursivelySimplifyInstruction(PN, DL); recursivelySimplifyInstruction(PN);
// Now that the inlined function body has been fully constructed, go through // Now that the inlined function body has been fully constructed, go through
// and zap unconditional fall-through branches. This happen all the time when // and zap unconditional fall-through branches. This happen all the time when
Context not available.
SmallVectorImpl<ReturnInst*> &Returns, SmallVectorImpl<ReturnInst*> &Returns,
const char *NameSuffix, const char *NameSuffix,
ClonedCodeInfo *CodeInfo, ClonedCodeInfo *CodeInfo,
const DataLayout *DL,
Instruction *TheCall) { Instruction *TheCall) {
CloneAndPruneIntoFromInst(NewFunc, OldFunc, OldFunc->front().begin(), CloneAndPruneIntoFromInst(NewFunc, OldFunc, OldFunc->front().begin(), VMap,
VMap, ModuleLevelChanges, Returns, NameSuffix, ModuleLevelChanges, Returns, NameSuffix, CodeInfo,
CodeInfo, DL, nullptr); nullptr);
} }
Context not available.

lib/Transforms/Utils/InlineFunction.cpp

Context not available.
/// parameters with noalias metadata specifying the new scope, and tag all /// parameters with noalias metadata specifying the new scope, and tag all
/// non-derived loads, stores and memory intrinsics with the new alias scopes. /// non-derived loads, stores and memory intrinsics with the new alias scopes.
static void AddAliasScopeMetadata(CallSite CS, ValueToValueMapTy &VMap, static void AddAliasScopeMetadata(CallSite CS, ValueToValueMapTy &VMap,
const DataLayout *DL, AliasAnalysis *AA) { const DataLayout &DL, AliasAnalysis *AA) {
if (!EnableNoAliasConversion) if (!EnableNoAliasConversion)
return; return;
Context not available.
// If we can already prove the asserted alignment in the context of the // If we can already prove the asserted alignment in the context of the
// caller, then don't bother inserting the assumption. // caller, then don't bother inserting the assumption.
Value *Arg = CS.getArgument(I->getArgNo()); Value *Arg = CS.getArgument(I->getArgNo());
if (getKnownAlignment(Arg, &DL, &IFI.ACT->getAssumptionCache(*CalledFunc), if (getKnownAlignment(Arg, *CS.getInstruction(),
CS.getInstruction(), &DT) >= Align) &IFI.ACT->getAssumptionCache(*CalledFunc),
&DT) >= Align)
continue; continue;
IRBuilder<>(CS.getInstruction()) IRBuilder<>(CS.getInstruction())
Context not available.
// If the pointer is already known to be sufficiently aligned, or if we can // If the pointer is already known to be sufficiently aligned, or if we can
// round it up to a larger alignment, then we don't need a temporary. // round it up to a larger alignment, then we don't need a temporary.
auto &DL = Caller->getParent()->getDataLayout(); if (getOrEnforceKnownAlignment(Arg, ByValAlignment, *TheCall,
if (getOrEnforceKnownAlignment(Arg, ByValAlignment, &DL, &IFI.ACT->getAssumptionCache(*Caller)) >=
&IFI.ACT->getAssumptionCache(*Caller), ByValAlignment)
TheCall) >= ByValAlignment)
return Arg; return Arg;
// Otherwise, we have to make a memcpy to get a safe alignment. This is bad // Otherwise, we have to make a memcpy to get a safe alignment. This is bad
Context not available.
// happy with whatever the cloner can do. // happy with whatever the cloner can do.
CloneAndPruneFunctionInto(Caller, CalledFunc, VMap, CloneAndPruneFunctionInto(Caller, CalledFunc, VMap,
/*ModuleLevelChanges=*/false, Returns, ".i", /*ModuleLevelChanges=*/false, Returns, ".i",
&InlinedFunctionInfo, &DL, TheCall); &InlinedFunctionInfo, TheCall);
// Remember the first block that is newly cloned over. // Remember the first block that is newly cloned over.
FirstNewBlock = LastBlock; ++FirstNewBlock; FirstNewBlock = LastBlock; ++FirstNewBlock;
Context not available.
CloneAliasScopeMetadata(CS, VMap); CloneAliasScopeMetadata(CS, VMap);
// Add noalias metadata if necessary. // Add noalias metadata if necessary.
AddAliasScopeMetadata(CS, VMap, &DL, IFI.AA); AddAliasScopeMetadata(CS, VMap, DL, IFI.AA);
// FIXME: We could register any cloned assumptions instead of clearing the // FIXME: We could register any cloned assumptions instead of clearing the
// whole function's cache. // whole function's cache.
Context not available.
// block other optimizations. // block other optimizations.
if (PHI) { if (PHI) {
auto &DL = Caller->getParent()->getDataLayout(); auto &DL = Caller->getParent()->getDataLayout();
if (Value *V = SimplifyInstruction(PHI, &DL, nullptr, nullptr, if (Value *V = SimplifyInstruction(PHI, DL, nullptr, nullptr,
&IFI.ACT->getAssumptionCache(*Caller))) { &IFI.ACT->getAssumptionCache(*Caller))) {
PHI->replaceAllUsesWith(V); PHI->replaceAllUsesWith(V);
PHI->eraseFromParent(); PHI->eraseFromParent();
Context not available.

lib/Transforms/Utils/Local.cpp

Context not available.
/// ///
/// This returns true if it changed the code, note that it can delete /// This returns true if it changed the code, note that it can delete
/// instructions in other blocks as well in this block. /// instructions in other blocks as well in this block.
bool llvm::SimplifyInstructionsInBlock(BasicBlock *BB, const DataLayout *TD, bool llvm::SimplifyInstructionsInBlock(BasicBlock *BB,
const TargetLibraryInfo *TLI) { const TargetLibraryInfo *TLI) {
bool MadeChange = false; bool MadeChange = false;
Context not available.
Instruction *Inst = BI++; Instruction *Inst = BI++;
WeakVH BIHandle(BI); WeakVH BIHandle(BI);
if (recursivelySimplifyInstruction(Inst, TD, TLI)) { if (recursivelySimplifyInstruction(Inst, TLI)) {
MadeChange = true; MadeChange = true;
if (BIHandle != BI) if (BIHandle != BI)
BI = BB->begin(); BI = BB->begin();
Context not available.
/// ///
/// .. and delete the predecessor corresponding to the '1', this will attempt to /// .. and delete the predecessor corresponding to the '1', this will attempt to
/// recursively fold the and to 0. /// recursively fold the and to 0.
void llvm::RemovePredecessorAndSimplify(BasicBlock *BB, BasicBlock *Pred, void llvm::RemovePredecessorAndSimplify(BasicBlock *BB, BasicBlock *Pred) {
DataLayout *TD) {
// This only adjusts blocks with PHI nodes. // This only adjusts blocks with PHI nodes.
if (!isa<PHINode>(BB->begin())) if (!isa<PHINode>(BB->begin()))
return; return;
Context not available.
PhiIt = &*++BasicBlock::iterator(cast<Instruction>(PhiIt)); PhiIt = &*++BasicBlock::iterator(cast<Instruction>(PhiIt));
Value *OldPhiIt = PhiIt; Value *OldPhiIt = PhiIt;
if (!recursivelySimplifyInstruction(PN, TD)) if (!recursivelySimplifyInstruction(PN))
continue; continue;
// If recursive simplification ended up deleting the next PHI node we would // If recursive simplification ended up deleting the next PHI node we would
Context not available.
/// their preferred alignment from the beginning. /// their preferred alignment from the beginning.
/// ///
static unsigned enforceKnownAlignment(Value *V, unsigned Align, static unsigned enforceKnownAlignment(Value *V, unsigned Align,
unsigned PrefAlign, const DataLayout *TD) { unsigned PrefAlign,
const DataLayout &DL) {
V = V->stripPointerCasts(); V = V->stripPointerCasts();
if (AllocaInst *AI = dyn_cast<AllocaInst>(V)) { if (AllocaInst *AI = dyn_cast<AllocaInst>(V)) {
// If the preferred alignment is greater than the natural stack alignment // If the preferred alignment is greater than the natural stack alignment
// then don't round up. This avoids dynamic stack realignment. // then don't round up. This avoids dynamic stack realignment.
if (TD && TD->exceedsNaturalStackAlignment(PrefAlign)) if (DL.exceedsNaturalStackAlignment(PrefAlign))
return Align; return Align;
// If there is a requested alignment and if this is an alloca, round up. // If there is a requested alignment and if this is an alloca, round up.
if (AI->getAlignment() >= PrefAlign) if (AI->getAlignment() >= PrefAlign)
Context not available.
/// and it is more than the alignment of the ultimate object, see if we can /// and it is more than the alignment of the ultimate object, see if we can
/// increase the alignment of the ultimate object, making this check succeed. /// increase the alignment of the ultimate object, making this check succeed.
unsigned llvm::getOrEnforceKnownAlignment(Value *V, unsigned PrefAlign, unsigned llvm::getOrEnforceKnownAlignment(Value *V, unsigned PrefAlign,
const DataLayout *DL, const Instruction &CxtI,
AssumptionCache *AC, AssumptionCache *AC,
const Instruction *CxtI,
const DominatorTree *DT) { const DominatorTree *DT) {
assert(V->getType()->isPointerTy() && assert(V->getType()->isPointerTy() &&
"getOrEnforceKnownAlignment expects a pointer!"); "getOrEnforceKnownAlignment expects a pointer!");
unsigned BitWidth = DL ? DL->getPointerTypeSizeInBits(V->getType()) : 64; const DataLayout &DL = CxtI.getModule()->getDataLayout();
unsigned BitWidth = DL.getPointerTypeSizeInBits(V->getType());
APInt KnownZero(BitWidth, 0), KnownOne(BitWidth, 0); APInt KnownZero(BitWidth, 0), KnownOne(BitWidth, 0);
computeKnownBits(V, KnownZero, KnownOne, DL, 0, AC, CxtI, DT); computeKnownBits(V, KnownZero, KnownOne, DL, 0, AC, &CxtI, DT);
unsigned TrailZ = KnownZero.countTrailingOnes(); unsigned TrailZ = KnownZero.countTrailingOnes();
// Avoid trouble with ridiculously large TrailZ values, such as // Avoid trouble with ridiculously large TrailZ values, such as
Context not available.

lib/Transforms/Utils/LoopSimplify.cpp

Context not available.
#include "llvm/IR/Instructions.h" #include "llvm/IR/Instructions.h"
#include "llvm/IR/IntrinsicInst.h" #include "llvm/IR/IntrinsicInst.h"
#include "llvm/IR/LLVMContext.h" #include "llvm/IR/LLVMContext.h"
#include "llvm/IR/Module.h"
#include "llvm/IR/Type.h" #include "llvm/IR/Type.h"
#include "llvm/Support/Debug.h" #include "llvm/Support/Debug.h"
#include "llvm/Transforms/Utils/BasicBlockUtils.h" #include "llvm/Transforms/Utils/BasicBlockUtils.h"
Context not available.
static PHINode *findPHIToPartitionLoops(Loop *L, AliasAnalysis *AA, static PHINode *findPHIToPartitionLoops(Loop *L, AliasAnalysis *AA,
DominatorTree *DT, DominatorTree *DT,
AssumptionCache *AC) { AssumptionCache *AC) {
const DataLayout &DL = L->getHeader()->getModule()->getDataLayout();
for (BasicBlock::iterator I = L->getHeader()->begin(); isa<PHINode>(I); ) { for (BasicBlock::iterator I = L->getHeader()->begin(); isa<PHINode>(I); ) {
PHINode *PN = cast<PHINode>(I); PHINode *PN = cast<PHINode>(I);
++I; ++I;
if (Value *V = SimplifyInstruction(PN, nullptr, nullptr, DT, AC)) { if (Value *V = SimplifyInstruction(PN, DL, nullptr, DT, AC)) {
// This is a degenerate PHI already, don't modify it! // This is a degenerate PHI already, don't modify it!
PN->replaceAllUsesWith(V); PN->replaceAllUsesWith(V);
if (AA) AA->deleteValue(PN); if (AA) AA->deleteValue(PN);
Context not available.
/// explicit if they accepted the analysis directly and then updated it. /// explicit if they accepted the analysis directly and then updated it.
static bool simplifyOneLoop(Loop *L, SmallVectorImpl<Loop *> &Worklist, static bool simplifyOneLoop(Loop *L, SmallVectorImpl<Loop *> &Worklist,
AliasAnalysis *AA, DominatorTree *DT, LoopInfo *LI, AliasAnalysis *AA, DominatorTree *DT, LoopInfo *LI,
ScalarEvolution *SE, Pass *PP, const DataLayout *DL, ScalarEvolution *SE, Pass *PP,
AssumptionCache *AC) { AssumptionCache *AC) {
bool Changed = false; bool Changed = false;
ReprocessLoop: ReprocessLoop:
Context not available.
} }
} }
const DataLayout &DL = L->getHeader()->getModule()->getDataLayout();
// Scan over the PHI nodes in the loop header. Since they now have only two // Scan over the PHI nodes in the loop header. Since they now have only two
// incoming values (the loop is canonicalized), we may have simplified the PHI // incoming values (the loop is canonicalized), we may have simplified the PHI
// down to 'X = phi [X, Y]', which should be replaced with 'Y'. // down to 'X = phi [X, Y]', which should be replaced with 'Y'.
PHINode *PN; PHINode *PN;
for (BasicBlock::iterator I = L->getHeader()->begin(); for (BasicBlock::iterator I = L->getHeader()->begin();
(PN = dyn_cast<PHINode>(I++)); ) (PN = dyn_cast<PHINode>(I++)); )
if (Value *V = SimplifyInstruction(PN, nullptr, nullptr, DT, AC)) { if (Value *V = SimplifyInstruction(PN, DL, nullptr, DT, AC)) {
if (AA) AA->deleteValue(PN); if (AA) AA->deleteValue(PN);
if (SE) SE->forgetValue(PN); if (SE) SE->forgetValue(PN);
PN->replaceAllUsesWith(V); PN->replaceAllUsesWith(V);
Context not available.
// The block has now been cleared of all instructions except for // The block has now been cleared of all instructions except for
// a comparison and a conditional branch. SimplifyCFG may be able // a comparison and a conditional branch. SimplifyCFG may be able
// to fold it now. // to fold it now.
if (!FoldBranchToCommonDest(BI, DL)) continue; if (!FoldBranchToCommonDest(BI))
continue;
// Success. The block is now dead, so remove it from the loop, // Success. The block is now dead, so remove it from the loop,
// update the dominator tree and delete it. // update the dominator tree and delete it.
Context not available.
bool llvm::simplifyLoop(Loop *L, DominatorTree *DT, LoopInfo *LI, Pass *PP, bool llvm::simplifyLoop(Loop *L, DominatorTree *DT, LoopInfo *LI, Pass *PP,
AliasAnalysis *AA, ScalarEvolution *SE, AliasAnalysis *AA, ScalarEvolution *SE,
const DataLayout *DL, AssumptionCache *AC) { AssumptionCache *AC) {
bool Changed = false; bool Changed = false;
// Worklist maintains our depth-first queue of loops in this nest to process. // Worklist maintains our depth-first queue of loops in this nest to process.
Context not available.
while (!Worklist.empty()) while (!Worklist.empty())
Changed |= simplifyOneLoop(Worklist.pop_back_val(), Worklist, AA, DT, LI, Changed |= simplifyOneLoop(Worklist.pop_back_val(), Worklist, AA, DT, LI,
SE, PP, DL, AC); SE, PP, AC);
return Changed; return Changed;
} }
Context not available.
DominatorTree *DT; DominatorTree *DT;
LoopInfo *LI; LoopInfo *LI;
ScalarEvolution *SE; ScalarEvolution *SE;
const DataLayout *DL;
AssumptionCache *AC; AssumptionCache *AC;
bool runOnFunction(Function &F) override; bool runOnFunction(Function &F) override;
Context not available.
LI = &getAnalysis<LoopInfoWrapperPass>().getLoopInfo(); LI = &getAnalysis<LoopInfoWrapperPass>().getLoopInfo();
DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree(); DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
SE = getAnalysisIfAvailable<ScalarEvolution>(); SE = getAnalysisIfAvailable<ScalarEvolution>();
DL = &F.getParent()->getDataLayout();
AC = &getAnalysis<AssumptionCacheTracker>().getAssumptionCache(F); AC = &getAnalysis<AssumptionCacheTracker>().getAssumptionCache(F);
// Simplify each loop nest in the function. // Simplify each loop nest in the function.
for (LoopInfo::iterator I = LI->begin(), E = LI->end(); I != E; ++I) for (LoopInfo::iterator I = LI->begin(), E = LI->end(); I != E; ++I)
Changed |= simplifyLoop(*I, DT, LI, this, AA, SE, DL, AC); Changed |= simplifyLoop(*I, DT, LI, this, AA, SE, AC);
return Changed; return Changed;
} }
Context not available.

lib/Transforms/Utils/LoopUnroll.cpp

Context not available.
// At this point, the code is well formed. We now do a quick sweep over the // At this point, the code is well formed. We now do a quick sweep over the
// inserted code, doing constant propagation and dead code elimination as we // inserted code, doing constant propagation and dead code elimination as we
// go. // go.
const DataLayout &DL = Header->getModule()->getDataLayout();
const std::vector<BasicBlock*> &NewLoopBlocks = L->getBlocks(); const std::vector<BasicBlock*> &NewLoopBlocks = L->getBlocks();
for (std::vector<BasicBlock*>::const_iterator BB = NewLoopBlocks.begin(), for (std::vector<BasicBlock*>::const_iterator BB = NewLoopBlocks.begin(),
BBE = NewLoopBlocks.end(); BB != BBE; ++BB) BBE = NewLoopBlocks.end(); BB != BBE; ++BB)
Context not available.
if (isInstructionTriviallyDead(Inst)) if (isInstructionTriviallyDead(Inst))
(*BB)->getInstList().erase(Inst); (*BB)->getInstList().erase(Inst);
else if (Value *V = SimplifyInstruction(Inst)) else if (Value *V = SimplifyInstruction(Inst, DL))
if (LI->replacementPreservesLCSSAForm(Inst, V)) { if (LI->replacementPreservesLCSSAForm(Inst, V)) {
Inst->replaceAllUsesWith(V); Inst->replaceAllUsesWith(V);
(*BB)->getInstList().erase(Inst); (*BB)->getInstList().erase(Inst);
Context not available.
if (!OuterL && !CompletelyUnroll) if (!OuterL && !CompletelyUnroll)
OuterL = L; OuterL = L;
if (OuterL) { if (OuterL) {
const DataLayout &DL = F->getParent()->getDataLayout(); simplifyLoop(OuterL, DT, LI, PP, /*AliasAnalysis*/ nullptr, SE, AC);
simplifyLoop(OuterL, DT, LI, PP, /*AliasAnalysis*/ nullptr, SE, &DL, AC);
// LCSSA must be performed on the outermost affected loop. The unrolled // LCSSA must be performed on the outermost affected loop. The unrolled
// loop's last loop latch is guaranteed to be in the outermost loop after // loop's last loop latch is guaranteed to be in the outermost loop after
Context not available.

lib/Transforms/Utils/LoopUnrollRuntime.cpp

Context not available.
#include "llvm/IR/BasicBlock.h" #include "llvm/IR/BasicBlock.h"
#include "llvm/IR/Dominators.h" #include "llvm/IR/Dominators.h"
#include "llvm/IR/Metadata.h" #include "llvm/IR/Metadata.h"
#include "llvm/IR/Module.h"
#include "llvm/Support/Debug.h" #include "llvm/Support/Debug.h"
#include "llvm/Support/raw_ostream.h" #include "llvm/Support/raw_ostream.h"
#include "llvm/Transforms/Scalar.h" #include "llvm/Transforms/Scalar.h"
Context not available.
BasicBlock *PEnd = SplitEdge(PH, Header, DT, LI); BasicBlock *PEnd = SplitEdge(PH, Header, DT, LI);
BasicBlock *NewPH = SplitBlock(PEnd, PEnd->getTerminator(), DT, LI); BasicBlock *NewPH = SplitBlock(PEnd, PEnd->getTerminator(), DT, LI);
BranchInst *PreHeaderBR = cast<BranchInst>(PH->getTerminator()); BranchInst *PreHeaderBR = cast<BranchInst>(PH->getTerminator());
const DataLayout &DL = Header->getModule()->getDataLayout();
// Compute the number of extra iterations required, which is: // Compute the number of extra iterations required, which is:
// extra iterations = run-time trip count % (loop unroll factor + 1) // extra iterations = run-time trip count % (loop unroll factor + 1)
SCEVExpander Expander(*SE, "loop-unroll"); SCEVExpander Expander(*SE, DL, "loop-unroll");
Value *TripCount = Expander.expandCodeFor(TripCountSC, TripCountSC->getType(), Value *TripCount = Expander.expandCodeFor(TripCountSC, TripCountSC->getType(),
PreHeaderBR); PreHeaderBR);
Value *BECount = Expander.expandCodeFor(BECountSC, BECountSC->getType(), Value *BECount = Expander.expandCodeFor(BECountSC, BECountSC->getType(),
Context not available.

lib/Transforms/Utils/PromoteMemoryToRegister.cpp

Context not available.
A->eraseFromParent(); A->eraseFromParent();
} }
const DataLayout &DL = F.getParent()->getDataLayout();
// Remove alloca's dbg.declare instrinsics from the function. // Remove alloca's dbg.declare instrinsics from the function.
for (unsigned i = 0, e = AllocaDbgDeclares.size(); i != e; ++i) for (unsigned i = 0, e = AllocaDbgDeclares.size(); i != e; ++i)
if (DbgDeclareInst *DDI = AllocaDbgDeclares[i]) if (DbgDeclareInst *DDI = AllocaDbgDeclares[i])
Context not available.
PHINode *PN = I->second; PHINode *PN = I->second;
// If this PHI node merges one value and/or undefs, get the value. // If this PHI node merges one value and/or undefs, get the value.
if (Value *V = SimplifyInstruction(PN, nullptr, nullptr, &DT, AC)) { if (Value *V = SimplifyInstruction(PN, DL, nullptr, &DT, AC)) {
if (AST && PN->getType()->isPointerTy()) if (AST && PN->getType()->isPointerTy())
AST->deleteValue(PN); AST->deleteValue(PN);
PN->replaceAllUsesWith(V); PN->replaceAllUsesWith(V);
Context not available.

lib/Transforms/Utils/SSAUpdater.cpp

Context not available.
// See if the PHI node can be merged to a single value. This can happen in // See if the PHI node can be merged to a single value. This can happen in
// loop cases when we get a PHI of itself and one other value. // loop cases when we get a PHI of itself and one other value.
if (Value *V = SimplifyInstruction(InsertedPHI)) { if (Value *V =
SimplifyInstruction(InsertedPHI, BB->getModule()->getDataLayout())) {
InsertedPHI->eraseFromParent(); InsertedPHI->eraseFromParent();
return V; return V;
} }
Context not available.

lib/Transforms/Utils/SimplifyCFG.cpp

Context not available.
class SimplifyCFGOpt { class SimplifyCFGOpt {
const TargetTransformInfo &TTI; const TargetTransformInfo &TTI;
const DataLayout &DL;
unsigned BonusInstThreshold; unsigned BonusInstThreshold;
const DataLayout *const DL;
AssumptionCache *AC; AssumptionCache *AC;
Value *isValueEqualityComparison(TerminatorInst *TI); Value *isValueEqualityComparison(TerminatorInst *TI);
BasicBlock *GetValueEqualityComparisonCases(TerminatorInst *TI, BasicBlock *GetValueEqualityComparisonCases(TerminatorInst *TI,
Context not available.
bool SimplifyCondBranch(BranchInst *BI, IRBuilder <>&Builder); bool SimplifyCondBranch(BranchInst *BI, IRBuilder <>&Builder);
public: public:
SimplifyCFGOpt(const TargetTransformInfo &TTI, unsigned BonusInstThreshold, SimplifyCFGOpt(const TargetTransformInfo &TTI, const DataLayout &DL,
const DataLayout *DL, AssumptionCache *AC) unsigned BonusInstThreshold, AssumptionCache *AC)
: TTI(TTI), BonusInstThreshold(BonusInstThreshold), DL(DL), AC(AC) {} : TTI(TTI), DL(DL), BonusInstThreshold(BonusInstThreshold), AC(AC) {}
bool run(BasicBlock *BB); bool run(BasicBlock *BB);
}; };
} }
Context not available.
/// given instruction, which is assumed to be safe to speculate. TCC_Free means /// given instruction, which is assumed to be safe to speculate. TCC_Free means
/// cheap, TCC_Basic means less cheap, and TCC_Expensive means prohibitively /// cheap, TCC_Basic means less cheap, and TCC_Expensive means prohibitively
/// expensive. /// expensive.
static unsigned ComputeSpeculationCost(const User *I, const DataLayout *DL, static unsigned ComputeSpeculationCost(const User *I,
const TargetTransformInfo &TTI) { const TargetTransformInfo &TTI) {
assert(isSafeToSpeculativelyExecute(I, DL) && assert(isSafeToSpeculativelyExecute(I) &&
"Instruction is not safe to speculatively execute!"); "Instruction is not safe to speculatively execute!");
return TTI.getUserCost(I); return TTI.getUserCost(I);
} }
Context not available.
static bool DominatesMergePoint(Value *V, BasicBlock *BB, static bool DominatesMergePoint(Value *V, BasicBlock *BB,
SmallPtrSetImpl<Instruction*> *AggressiveInsts, SmallPtrSetImpl<Instruction*> *AggressiveInsts,
unsigned &CostRemaining, unsigned &CostRemaining,
const DataLayout *DL,
const TargetTransformInfo &TTI) { const TargetTransformInfo &TTI) {
Instruction *I = dyn_cast<Instruction>(V); Instruction *I = dyn_cast<Instruction>(V);
if (!I) { if (!I) {
Context not available.
// Okay, it looks like the instruction IS in the "condition". Check to // Okay, it looks like the instruction IS in the "condition". Check to
// see if it's a cheap instruction to unconditionally compute, and if it // see if it's a cheap instruction to unconditionally compute, and if it
// only uses stuff defined outside of the condition. If so, hoist it out. // only uses stuff defined outside of the condition. If so, hoist it out.
if (!isSafeToSpeculativelyExecute(I, DL)) if (!isSafeToSpeculativelyExecute(I))
return false; return false;
unsigned Cost = ComputeSpeculationCost(I, DL, TTI); unsigned Cost = ComputeSpeculationCost(I, TTI);
if (Cost > CostRemaining) if (Cost > CostRemaining)
return false; return false;
Context not available.
// Okay, we can only really hoist these out if their operands do // Okay, we can only really hoist these out if their operands do
// not take us over the cost threshold. // not take us over the cost threshold.
for (User::op_iterator i = I->op_begin(), e = I->op_end(); i != e; ++i) for (User::op_iterator i = I->op_begin(), e = I->op_end(); i != e; ++i)
if (!DominatesMergePoint(*i, BB, AggressiveInsts, CostRemaining, DL, TTI)) if (!DominatesMergePoint(*i, BB, AggressiveInsts, CostRemaining, TTI))
return false; return false;
// Okay, it's safe to do this! Remember this instruction. // Okay, it's safe to do this! Remember this instruction.
AggressiveInsts->insert(I); AggressiveInsts->insert(I);
Context not available.
/// GetConstantInt - Extract ConstantInt from value, looking through IntToPtr /// GetConstantInt - Extract ConstantInt from value, looking through IntToPtr
/// and PointerNullValue. Return NULL if value is not a constant int. /// and PointerNullValue. Return NULL if value is not a constant int.
static ConstantInt *GetConstantInt(Value *V, const DataLayout *DL) { static ConstantInt *GetConstantInt(Value *V, const DataLayout &DL) {
// Normal constant int. // Normal constant int.
ConstantInt *CI = dyn_cast<ConstantInt>(V); ConstantInt *CI = dyn_cast<ConstantInt>(V);
if (CI || !DL || !isa<Constant>(V) || !V->getType()->isPointerTy()) if (CI || !isa<Constant>(V) || !V->getType()->isPointerTy())
return CI; return CI;
// This is some kind of pointer constant. Turn it into a pointer-sized // This is some kind of pointer constant. Turn it into a pointer-sized
// ConstantInt if possible. // ConstantInt if possible.
IntegerType *PtrTy = cast<IntegerType>(DL->getIntPtrType(V->getType())); IntegerType *PtrTy = cast<IntegerType>(DL.getIntPtrType(V->getType()));
// Null pointer means 0, see SelectionDAGBuilder::getValue(const Value*). // Null pointer means 0, see SelectionDAGBuilder::getValue(const Value*).
if (isa<ConstantPointerNull>(V)) if (isa<ConstantPointerNull>(V))
Context not available.
/// while for a chain of '&&' it will build the set elements that make the test /// while for a chain of '&&' it will build the set elements that make the test
/// fail. /// fail.
struct ConstantComparesGatherer { struct ConstantComparesGatherer {
const DataLayout &DL;
Value *CompValue; /// Value found for the switch comparison Value *CompValue; /// Value found for the switch comparison
Value *Extra; /// Extra clause to be checked before the switch Value *Extra; /// Extra clause to be checked before the switch
SmallVector<ConstantInt *, 8> Vals; /// Set of integers to match in switch SmallVector<ConstantInt *, 8> Vals; /// Set of integers to match in switch
unsigned UsedICmps; /// Number of comparisons matched in the and/or chain unsigned UsedICmps; /// Number of comparisons matched in the and/or chain
/// Construct and compute the result for the comparison instruction Cond /// Construct and compute the result for the comparison instruction Cond
ConstantComparesGatherer(Instruction *Cond, const DataLayout *DL) ConstantComparesGatherer(Instruction *Cond, const DataLayout &DL)
: CompValue(nullptr), Extra(nullptr), UsedICmps(0) { : DL(DL), CompValue(nullptr), Extra(nullptr), UsedICmps(0) {
gather(Cond, DL); gather(Cond);
} }
/// Prevent copy /// Prevent copy
Context not available.
/// against is placed in CompValue. /// against is placed in CompValue.
/// If CompValue is already set, the function is expected to fail if a match /// If CompValue is already set, the function is expected to fail if a match
/// is found but the value compared to is different. /// is found but the value compared to is different.
bool matchInstruction(Instruction *I, const DataLayout *DL, bool isEQ) { bool matchInstruction(Instruction *I, bool isEQ) {
// If this is an icmp against a constant, handle this as one of the cases. // If this is an icmp against a constant, handle this as one of the cases.
ICmpInst *ICI; ICmpInst *ICI;
ConstantInt *C; ConstantInt *C;
Context not available.
/// the value being compared, and stick the list constants into the Vals /// the value being compared, and stick the list constants into the Vals
/// vector. /// vector.
/// One "Extra" case is allowed to differ from the other. /// One "Extra" case is allowed to differ from the other.
void gather(Value *V, const DataLayout *DL) { void gather(Value *V) {
Instruction *I = dyn_cast<Instruction>(V); Instruction *I = dyn_cast<Instruction>(V);
bool isEQ = (I->getOpcode() == Instruction::Or); bool isEQ = (I->getOpcode() == Instruction::Or);
Context not available.
} }
// Try to match the current instruction // Try to match the current instruction
if (matchInstruction(I, DL, isEQ)) if (matchInstruction(I, isEQ))
// Match succeed, continue the loop // Match succeed, continue the loop
continue; continue;
} }
Context not available.
CV = SI->getCondition(); CV = SI->getCondition();
} else if (BranchInst *BI = dyn_cast<BranchInst>(TI)) } else if (BranchInst *BI = dyn_cast<BranchInst>(TI))
if (BI->isConditional() && BI->getCondition()->hasOneUse()) if (BI->isConditional() && BI->getCondition()->hasOneUse())
if (ICmpInst *ICI = dyn_cast<ICmpInst>(BI->getCondition())) if (ICmpInst *ICI = dyn_cast<ICmpInst>(BI->getCondition())) {
if (ICI->isEquality() && GetConstantInt(ICI->getOperand(1), DL)) if (ICI->isEquality() && GetConstantInt(ICI->getOperand(1), DL))
CV = ICI->getOperand(0); CV = ICI->getOperand(0);
}
// Unwrap any lossless ptrtoint cast. // Unwrap any lossless ptrtoint cast.
if (DL && CV) { if (CV) {
if (PtrToIntInst *PTII = dyn_cast<PtrToIntInst>(CV)) { if (PtrToIntInst *PTII = dyn_cast<PtrToIntInst>(CV)) {
Value *Ptr = PTII->getPointerOperand(); Value *Ptr = PTII->getPointerOperand();
if (PTII->getType() == DL->getIntPtrType(Ptr->getType())) if (PTII->getType() == DL.getIntPtrType(Ptr->getType()))
CV = Ptr; CV = Ptr;
} }
} }
Context not available.
Builder.SetInsertPoint(PTI); Builder.SetInsertPoint(PTI);
// Convert pointer to int before we switch. // Convert pointer to int before we switch.
if (CV->getType()->isPointerTy()) { if (CV->getType()->isPointerTy()) {
assert(DL && "Cannot switch on pointer without DataLayout"); CV = Builder.CreatePtrToInt(CV, DL.getIntPtrType(CV->getType()),
CV = Builder.CreatePtrToInt(CV, DL->getIntPtrType(CV->getType()),
"magicptr"); "magicptr");
} }
Context not available.
/// HoistThenElseCodeToIf - Given a conditional branch that goes to BB1 and /// HoistThenElseCodeToIf - Given a conditional branch that goes to BB1 and
/// BB2, hoist any common code in the two blocks up into the branch block. The /// BB2, hoist any common code in the two blocks up into the branch block. The
/// caller of this function guarantees that BI's block dominates BB1 and BB2. /// caller of this function guarantees that BI's block dominates BB1 and BB2.
static bool HoistThenElseCodeToIf(BranchInst *BI, const DataLayout *DL, static bool HoistThenElseCodeToIf(BranchInst *BI,
const TargetTransformInfo &TTI) { const TargetTransformInfo &TTI) {
// This does very trivial matching, with limited scanning, to find identical // This does very trivial matching, with limited scanning, to find identical
// instructions in the two blocks. In particular, we don't want to get into // instructions in the two blocks. In particular, we don't want to get into
Context not available.
passingValueIsAlwaysUndefined(BB2V, PN)) passingValueIsAlwaysUndefined(BB2V, PN))
return Changed; return Changed;
if (isa<ConstantExpr>(BB1V) && !isSafeToSpeculativelyExecute(BB1V, DL)) if (isa<ConstantExpr>(BB1V) && !isSafeToSpeculativelyExecute(BB1V))
return Changed; return Changed;
if (isa<ConstantExpr>(BB2V) && !isSafeToSpeculativelyExecute(BB2V, DL)) if (isa<ConstantExpr>(BB2V) && !isSafeToSpeculativelyExecute(BB2V))
return Changed; return Changed;
} }
} }
Context not available.
/// ///
/// \returns true if the conditional block is removed. /// \returns true if the conditional block is removed.
static bool SpeculativelyExecuteBB(BranchInst *BI, BasicBlock *ThenBB, static bool SpeculativelyExecuteBB(BranchInst *BI, BasicBlock *ThenBB,
const DataLayout *DL,
const TargetTransformInfo &TTI) { const TargetTransformInfo &TTI) {
// Be conservative for now. FP select instruction can often be expensive. // Be conservative for now. FP select instruction can often be expensive.
Value *BrCond = BI->getCondition(); Value *BrCond = BI->getCondition();
Context not available.
return false; return false;
// Don't hoist the instruction if it's unsafe or expensive. // Don't hoist the instruction if it's unsafe or expensive.
if (!isSafeToSpeculativelyExecute(I, DL) && if (!isSafeToSpeculativelyExecute(I) &&
!(HoistCondStores && !(HoistCondStores && (SpeculatedStoreValue = isSafeToSpeculateStore(
(SpeculatedStoreValue = isSafeToSpeculateStore(I, BB, ThenBB, I, BB, ThenBB, EndBB))))
EndBB))))
return false; return false;
if (!SpeculatedStoreValue && if (!SpeculatedStoreValue &&
ComputeSpeculationCost(I, DL, TTI) > PHINodeFoldingThreshold * ComputeSpeculationCost(I, TTI) >
TargetTransformInfo::TCC_Basic) PHINodeFoldingThreshold * TargetTransformInfo::TCC_Basic)
return false; return false;
// Store the store speculation candidate. // Store the store speculation candidate.
Context not available.
if (!OrigCE && !ThenCE) if (!OrigCE && !ThenCE)
continue; // Known safe and cheap. continue; // Known safe and cheap.
if ((ThenCE && !isSafeToSpeculativelyExecute(ThenCE, DL)) || if ((ThenCE && !isSafeToSpeculativelyExecute(ThenCE)) ||
(OrigCE && !isSafeToSpeculativelyExecute(OrigCE, DL))) (OrigCE && !isSafeToSpeculativelyExecute(OrigCE)))
return false; return false;
unsigned OrigCost = OrigCE ? ComputeSpeculationCost(OrigCE, DL, TTI) : 0; unsigned OrigCost = OrigCE ? ComputeSpeculationCost(OrigCE, TTI) : 0;
unsigned ThenCost = ThenCE ? ComputeSpeculationCost(ThenCE, DL, TTI) : 0; unsigned ThenCost = ThenCE ? ComputeSpeculationCost(ThenCE, TTI) : 0;
unsigned MaxCost = 2 * PHINodeFoldingThreshold * unsigned MaxCost = 2 * PHINodeFoldingThreshold *
TargetTransformInfo::TCC_Basic; TargetTransformInfo::TCC_Basic;
if (OrigCost + ThenCost > MaxCost) if (OrigCost + ThenCost > MaxCost)
Context not available.
/// that is defined in the same block as the branch and if any PHI entries are /// that is defined in the same block as the branch and if any PHI entries are
/// constants, thread edges corresponding to that entry to be branches to their /// constants, thread edges corresponding to that entry to be branches to their
/// ultimate destination. /// ultimate destination.
static bool FoldCondBranchOnPHI(BranchInst *BI, const DataLayout *DL) { static bool FoldCondBranchOnPHI(BranchInst *BI, const DataLayout &DL) {
BasicBlock *BB = BI->getParent(); BasicBlock *BB = BI->getParent();
PHINode *PN = dyn_cast<PHINode>(BI->getCondition()); PHINode *PN = dyn_cast<PHINode>(BI->getCondition());
// NOTE: we currently cannot transform this case if the PHI node is used // NOTE: we currently cannot transform this case if the PHI node is used
Context not available.
/// FoldTwoEntryPHINode - Given a BB that starts with the specified two-entry /// FoldTwoEntryPHINode - Given a BB that starts with the specified two-entry
/// PHI node, see if we can eliminate it. /// PHI node, see if we can eliminate it.
static bool FoldTwoEntryPHINode(PHINode *PN, const DataLayout *DL, static bool FoldTwoEntryPHINode(PHINode *PN, const TargetTransformInfo &TTI,
const TargetTransformInfo &TTI) { const DataLayout &DL) {
// Ok, this is a two entry PHI node. Check to see if this is a simple "if // Ok, this is a two entry PHI node. Check to see if this is a simple "if
// statement", which has a very simple dominance structure. Basically, we // statement", which has a very simple dominance structure. Basically, we
// are trying to find the condition that is being branched on, which // are trying to find the condition that is being branched on, which
Context not available.
} }
if (!DominatesMergePoint(PN->getIncomingValue(0), BB, &AggressiveInsts, if (!DominatesMergePoint(PN->getIncomingValue(0), BB, &AggressiveInsts,
MaxCostVal0, DL, TTI) || MaxCostVal0, TTI) ||
!DominatesMergePoint(PN->getIncomingValue(1), BB, &AggressiveInsts, !DominatesMergePoint(PN->getIncomingValue(1), BB, &AggressiveInsts,
MaxCostVal1, DL, TTI)) MaxCostVal1, TTI))
return false; return false;
} }
Context not available.
/// FoldBranchToCommonDest - If this basic block is simple enough, and if a /// FoldBranchToCommonDest - If this basic block is simple enough, and if a
/// predecessor branches to us and one of our successors, fold the block into /// predecessor branches to us and one of our successors, fold the block into
/// the predecessor and use logical operations to pick the right destination. /// the predecessor and use logical operations to pick the right destination.
bool llvm::FoldBranchToCommonDest(BranchInst *BI, const DataLayout *DL, bool llvm::FoldBranchToCommonDest(BranchInst *BI, unsigned BonusInstThreshold) {
unsigned BonusInstThreshold) {
BasicBlock *BB = BI->getParent(); BasicBlock *BB = BI->getParent();
Instruction *Cond = nullptr; Instruction *Cond = nullptr;
Context not available.
// Ignore dbg intrinsics. // Ignore dbg intrinsics.
if (isa<DbgInfoIntrinsic>(I)) if (isa<DbgInfoIntrinsic>(I))
continue; continue;
if (!I->hasOneUse() || !isSafeToSpeculativelyExecute(I, DL)) if (!I->hasOneUse() || !isSafeToSpeculativelyExecute(I))
return false; return false;
// I has only one use and can be executed unconditionally. // I has only one use and can be executed unconditionally.
Instruction *User = dyn_cast<Instruction>(I->user_back()); Instruction *User = dyn_cast<Instruction>(I->user_back());
Context not available.
/// We prefer to split the edge to 'end' so that there is a true/false entry to /// We prefer to split the edge to 'end' so that there is a true/false entry to
/// the PHI, merging the third icmp into the switch. /// the PHI, merging the third icmp into the switch.
static bool TryToSimplifyUncondBranchWithICmpInIt( static bool TryToSimplifyUncondBranchWithICmpInIt(
ICmpInst *ICI, IRBuilder<> &Builder, const TargetTransformInfo &TTI, ICmpInst *ICI, IRBuilder<> &Builder, const DataLayout &DL,
unsigned BonusInstThreshold, const DataLayout *DL, AssumptionCache *AC) { const TargetTransformInfo &TTI, unsigned BonusInstThreshold,
AssumptionCache *AC) {
BasicBlock *BB = ICI->getParent(); BasicBlock *BB = ICI->getParent();
// If the block has any PHIs in it or the icmp has multiple uses, it is too // If the block has any PHIs in it or the icmp has multiple uses, it is too
Context not available.
ICI->eraseFromParent(); ICI->eraseFromParent();
} }
// BB is now empty, so it is likely to simplify away. // BB is now empty, so it is likely to simplify away.
return SimplifyCFG(BB, TTI, BonusInstThreshold, DL, AC) | true; return SimplifyCFG(BB, TTI, BonusInstThreshold, AC) | true;
} }
// Ok, the block is reachable from the default dest. If the constant we're // Ok, the block is reachable from the default dest. If the constant we're
Context not available.
ICI->replaceAllUsesWith(V); ICI->replaceAllUsesWith(V);
ICI->eraseFromParent(); ICI->eraseFromParent();
// BB is now empty, so it is likely to simplify away. // BB is now empty, so it is likely to simplify away.
return SimplifyCFG(BB, TTI, BonusInstThreshold, DL, AC) | true; return SimplifyCFG(BB, TTI, BonusInstThreshold, AC) | true;
} }
// The use of the icmp has to be in the 'end' block, by the only PHI node in // The use of the icmp has to be in the 'end' block, by the only PHI node in
Context not available.
/// SimplifyBranchOnICmpChain - The specified branch is a conditional branch. /// SimplifyBranchOnICmpChain - The specified branch is a conditional branch.
/// Check to see if it is branching on an or/and chain of icmp instructions, and /// Check to see if it is branching on an or/and chain of icmp instructions, and
/// fold it into a switch instruction if so. /// fold it into a switch instruction if so.
static bool SimplifyBranchOnICmpChain(BranchInst *BI, const DataLayout *DL, static bool SimplifyBranchOnICmpChain(BranchInst *BI, IRBuilder<> &Builder,
IRBuilder<> &Builder) { const DataLayout &DL) {
Instruction *Cond = dyn_cast<Instruction>(BI->getCondition()); Instruction *Cond = dyn_cast<Instruction>(BI->getCondition());
if (!Cond) return false; if (!Cond) return false;
Context not available.
Builder.SetInsertPoint(BI); Builder.SetInsertPoint(BI);
// Convert pointer to int before we switch. // Convert pointer to int before we switch.
if (CompVal->getType()->isPointerTy()) { if (CompVal->getType()->isPointerTy()) {
assert(DL && "Cannot switch on pointer without DataLayout"); CompVal = Builder.CreatePtrToInt(
CompVal = Builder.CreatePtrToInt(CompVal, CompVal, DL.getIntPtrType(CompVal->getType()), "magicptr");
DL->getIntPtrType(CompVal->getType()),
"magicptr");
} }
// Create the new switch instruction now. // Create the new switch instruction now.
Context not available.
/// EliminateDeadSwitchCases - Compute masked bits for the condition of a switch /// EliminateDeadSwitchCases - Compute masked bits for the condition of a switch
/// and use it to remove dead cases. /// and use it to remove dead cases.
static bool EliminateDeadSwitchCases(SwitchInst *SI, const DataLayout *DL, static bool EliminateDeadSwitchCases(SwitchInst *SI, AssumptionCache *AC,
AssumptionCache *AC) { const DataLayout &DL) {
Value *Cond = SI->getCondition(); Value *Cond = SI->getCondition();
unsigned Bits = Cond->getType()->getIntegerBitWidth(); unsigned Bits = Cond->getType()->getIntegerBitWidth();
APInt KnownZero(Bits, 0), KnownOne(Bits, 0); APInt KnownZero(Bits, 0), KnownOne(Bits, 0);
Context not available.
/// constant or can be replaced by constants from the ConstantPool. Returns the /// constant or can be replaced by constants from the ConstantPool. Returns the
/// resulting constant on success, 0 otherwise. /// resulting constant on success, 0 otherwise.
static Constant * static Constant *
ConstantFold(Instruction *I, ConstantFold(Instruction *I, const DataLayout &DL,
const SmallDenseMap<Value *, Constant *> &ConstantPool, const SmallDenseMap<Value *, Constant *> &ConstantPool) {
const DataLayout *DL) {
if (SelectInst *Select = dyn_cast<SelectInst>(I)) { if (SelectInst *Select = dyn_cast<SelectInst>(I)) {
Constant *A = LookupConstant(Select->getCondition(), ConstantPool); Constant *A = LookupConstant(Select->getCondition(), ConstantPool);
if (!A) if (!A)
Context not available.
return nullptr; return nullptr;
} }
if (CmpInst *Cmp = dyn_cast<CmpInst>(I)) if (CmpInst *Cmp = dyn_cast<CmpInst>(I)) {
return ConstantFoldCompareInstOperands(Cmp->getPredicate(), COps[0], return ConstantFoldCompareInstOperands(Cmp->getPredicate(), COps[0],
COps[1], DL); COps[1], DL);
}
return ConstantFoldInstOperands(I->getOpcode(), I->getType(), COps, DL); return ConstantFoldInstOperands(I->getOpcode(), I->getType(), COps, DL);
} }
Context not available.
/// destionations CaseDest corresponding to value CaseVal (0 for the default /// destionations CaseDest corresponding to value CaseVal (0 for the default
/// case), of a switch instruction SI. /// case), of a switch instruction SI.
static bool static bool
GetCaseResults(SwitchInst *SI, GetCaseResults(SwitchInst *SI, ConstantInt *CaseVal, BasicBlock *CaseDest,
ConstantInt *CaseVal,
BasicBlock *CaseDest,
BasicBlock **CommonDest, BasicBlock **CommonDest,
SmallVectorImpl<std::pair<PHINode *, Constant *> > &Res, SmallVectorImpl<std::pair<PHINode *, Constant *>> &Res,
const DataLayout *DL) { const DataLayout &DL) {
// The block from which we enter the common destination. // The block from which we enter the common destination.
BasicBlock *Pred = SI->getParent(); BasicBlock *Pred = SI->getParent();
Context not available.
} else if (isa<DbgInfoIntrinsic>(I)) { } else if (isa<DbgInfoIntrinsic>(I)) {
// Skip debug intrinsic. // Skip debug intrinsic.
continue; continue;
} else if (Constant *C = ConstantFold(I, ConstantPool, DL)) { } else if (Constant *C = ConstantFold(I, DL, ConstantPool)) {
// Instruction is side-effect free and constant. // Instruction is side-effect free and constant.
// If the instruction has uses outside this block or a phi node slot for // If the instruction has uses outside this block or a phi node slot for
Context not available.
// results for the PHI node of the common destination block for a switch // results for the PHI node of the common destination block for a switch
// instruction. Returns false if multiple PHI nodes have been found or if // instruction. Returns false if multiple PHI nodes have been found or if
// there is not a common destination block for the switch. // there is not a common destination block for the switch.
static bool InitializeUniqueCases( static bool InitializeUniqueCases(SwitchInst *SI, PHINode *&PHI,
SwitchInst *SI, const DataLayout *DL, PHINode *&PHI, BasicBlock *&CommonDest,
BasicBlock *&CommonDest, SwitchCaseResultVectorTy &UniqueResults,
SwitchCaseResultVectorTy &UniqueResults, Constant *&DefaultResult,
Constant *&DefaultResult) { const DataLayout &DL) {
for (auto &I : SI->cases()) { for (auto &I : SI->cases()) {
ConstantInt *CaseVal = I.getCaseValue(); ConstantInt *CaseVal = I.getCaseValue();
Context not available.
/// phi nodes in a common successor block with only two different /// phi nodes in a common successor block with only two different
/// constant values, replace the switch with select. /// constant values, replace the switch with select.
static bool SwitchToSelect(SwitchInst *SI, IRBuilder<> &Builder, static bool SwitchToSelect(SwitchInst *SI, IRBuilder<> &Builder,
const DataLayout *DL, AssumptionCache *AC) { AssumptionCache *AC, const DataLayout &DL) {
Value *const Cond = SI->getCondition(); Value *const Cond = SI->getCondition();
PHINode *PHI = nullptr; PHINode *PHI = nullptr;
BasicBlock *CommonDest = nullptr; BasicBlock *CommonDest = nullptr;
Constant *DefaultResult; Constant *DefaultResult;
SwitchCaseResultVectorTy UniqueResults; SwitchCaseResultVectorTy UniqueResults;
// Collect all the cases that will deliver the same value from the switch. // Collect all the cases that will deliver the same value from the switch.
if (!InitializeUniqueCases(SI, DL, PHI, CommonDest, UniqueResults, if (!InitializeUniqueCases(SI, PHI, CommonDest, UniqueResults, DefaultResult,
DefaultResult)) DL))
return false; return false;
// Selects choose between maximum two values. // Selects choose between maximum two values.
if (UniqueResults.size() != 2) if (UniqueResults.size() != 2)
Context not available.
/// SwitchLookupTable - Create a lookup table to use as a switch replacement /// SwitchLookupTable - Create a lookup table to use as a switch replacement
/// with the contents of Values, using DefaultValue to fill any holes in the /// with the contents of Values, using DefaultValue to fill any holes in the
/// table. /// table.
SwitchLookupTable(Module &M, SwitchLookupTable(
uint64_t TableSize, Module &M, uint64_t TableSize, ConstantInt *Offset,
ConstantInt *Offset, const SmallVectorImpl<std::pair<ConstantInt *, Constant *>> &Values,
const SmallVectorImpl<std::pair<ConstantInt*, Constant*> >& Values, Constant *DefaultValue, const DataLayout &DL);
Constant *DefaultValue,
const DataLayout *DL);
/// BuildLookup - Build instructions with Builder to retrieve the value at /// BuildLookup - Build instructions with Builder to retrieve the value at
/// the position given by Index in the lookup table. /// the position given by Index in the lookup table.
Context not available.
/// WouldFitInRegister - Return true if a table with TableSize elements of /// WouldFitInRegister - Return true if a table with TableSize elements of
/// type ElementType would fit in a target-legal register. /// type ElementType would fit in a target-legal register.
static bool WouldFitInRegister(const DataLayout *DL, static bool WouldFitInRegister(const DataLayout &DL, uint64_t TableSize,
uint64_t TableSize,
const Type *ElementType); const Type *ElementType);
private: private:
Context not available.
}; };
} }
SwitchLookupTable::SwitchLookupTable(Module &M, SwitchLookupTable::SwitchLookupTable(
uint64_t TableSize, Module &M, uint64_t TableSize, ConstantInt *Offset,
ConstantInt *Offset, const SmallVectorImpl<std::pair<ConstantInt *, Constant *>> &Values,
const SmallVectorImpl<std::pair<ConstantInt*, Constant*> >& Values, Constant *DefaultValue, const DataLayout &DL)
Constant *DefaultValue,
const DataLayout *DL)
: SingleValue(nullptr), BitMap(nullptr), BitMapElementTy(nullptr), : SingleValue(nullptr), BitMap(nullptr), BitMapElementTy(nullptr),
LinearOffset(nullptr), LinearMultiplier(nullptr), Array(nullptr) { LinearOffset(nullptr), LinearMultiplier(nullptr), Array(nullptr) {
assert(Values.size() && "Can't build lookup table without values!"); assert(Values.size() && "Can't build lookup table without values!");
Context not available.
llvm_unreachable("Unknown lookup table kind!"); llvm_unreachable("Unknown lookup table kind!");
} }
bool SwitchLookupTable::WouldFitInRegister(const DataLayout *DL, bool SwitchLookupTable::WouldFitInRegister(const DataLayout &DL,
uint64_t TableSize, uint64_t TableSize,
const Type *ElementType) { const Type *ElementType) {
if (!DL)
return false;
const IntegerType *IT = dyn_cast<IntegerType>(ElementType); const IntegerType *IT = dyn_cast<IntegerType>(ElementType);
if (!IT) if (!IT)
return false; return false;
Context not available.
// Avoid overflow, fitsInLegalInteger uses unsigned int for the width. // Avoid overflow, fitsInLegalInteger uses unsigned int for the width.
if (TableSize >= UINT_MAX/IT->getBitWidth()) if (TableSize >= UINT_MAX/IT->getBitWidth())
return false; return false;
return DL->fitsInLegalInteger(TableSize * IT->getBitWidth()); return DL.fitsInLegalInteger(TableSize * IT->getBitWidth());
} }
/// ShouldBuildLookupTable - Determine whether a lookup table should be built /// ShouldBuildLookupTable - Determine whether a lookup table should be built
/// for this switch, based on the number of cases, size of the table and the /// for this switch, based on the number of cases, size of the table and the
/// types of the results. /// types of the results.
static bool ShouldBuildLookupTable(SwitchInst *SI, static bool
uint64_t TableSize, ShouldBuildLookupTable(SwitchInst *SI, uint64_t TableSize,
const TargetTransformInfo &TTI, const TargetTransformInfo &TTI, const DataLayout &DL,
const DataLayout *DL, const SmallDenseMap<PHINode *, Type *> &ResultTypes) {
const SmallDenseMap<PHINode*, Type*>& ResultTypes) {
if (SI->getNumCases() > TableSize || TableSize >= UINT64_MAX / 10) if (SI->getNumCases() > TableSize || TableSize >= UINT64_MAX / 10)
return false; // TableSize overflowed, or mul below might overflow. return false; // TableSize overflowed, or mul below might overflow.
Context not available.
/// SwitchToLookupTable - If the switch is only used to initialize one or more /// SwitchToLookupTable - If the switch is only used to initialize one or more
/// phi nodes in a common successor block with different constant values, /// phi nodes in a common successor block with different constant values,
/// replace the switch with lookup tables. /// replace the switch with lookup tables.
static bool SwitchToLookupTable(SwitchInst *SI, static bool SwitchToLookupTable(SwitchInst *SI, IRBuilder<> &Builder,
IRBuilder<> &Builder, const DataLayout &DL,
const TargetTransformInfo &TTI, const TargetTransformInfo &TTI) {
const DataLayout* DL) {
assert(SI->getNumCases() > 1 && "Degenerate switch?"); assert(SI->getNumCases() > 1 && "Degenerate switch?");
// Only build lookup table when we have a target that supports it. // Only build lookup table when we have a target that supports it.
Context not available.
// or a bitmask that fits in a register. // or a bitmask that fits in a register.
SmallVector<std::pair<PHINode*, Constant*>, 4> DefaultResultsList; SmallVector<std::pair<PHINode*, Constant*>, 4> DefaultResultsList;
bool HasDefaultResults = GetCaseResults(SI, nullptr, SI->getDefaultDest(), bool HasDefaultResults = GetCaseResults(SI, nullptr, SI->getDefaultDest(),
&CommonDest, DefaultResultsList, DL); &CommonDest, DefaultResultsList, DL);
bool NeedMask = (TableHasHoles && !HasDefaultResults); bool NeedMask = (TableHasHoles && !HasDefaultResults);
if (NeedMask) { if (NeedMask) {
// As an extra penalty for the validity test we require more cases. // As an extra penalty for the validity test we require more cases.
if (SI->getNumCases() < 4) // FIXME: Find best threshold value (benchmark). if (SI->getNumCases() < 4) // FIXME: Find best threshold value (benchmark).
return false; return false;
if (!(DL && DL->fitsInLegalInteger(TableSize))) if (!DL.fitsInLegalInteger(TableSize))
return false; return false;
} }
Context not available.
// see if that predecessor totally determines the outcome of this switch. // see if that predecessor totally determines the outcome of this switch.
if (BasicBlock *OnlyPred = BB->getSinglePredecessor()) if (BasicBlock *OnlyPred = BB->getSinglePredecessor())
if (SimplifyEqualityComparisonWithOnlyPredecessor(SI, OnlyPred, Builder)) if (SimplifyEqualityComparisonWithOnlyPredecessor(SI, OnlyPred, Builder))
return SimplifyCFG(BB, TTI, BonusInstThreshold, DL, AC) | true; return SimplifyCFG(BB, TTI, BonusInstThreshold, AC) | true;
Value *Cond = SI->getCondition(); Value *Cond = SI->getCondition();
if (SelectInst *Select = dyn_cast<SelectInst>(Cond)) if (SelectInst *Select = dyn_cast<SelectInst>(Cond))
if (SimplifySwitchOnSelect(SI, Select)) if (SimplifySwitchOnSelect(SI, Select))
return SimplifyCFG(BB, TTI, BonusInstThreshold, DL, AC) | true; return SimplifyCFG(BB, TTI, BonusInstThreshold, AC) | true;
// If the block only contains the switch, see if we can fold the block // If the block only contains the switch, see if we can fold the block
// away into any preds. // away into any preds.
Context not available.
++BBI; ++BBI;
if (SI == &*BBI) if (SI == &*BBI)
if (FoldValueComparisonIntoPredecessors(SI, Builder)) if (FoldValueComparisonIntoPredecessors(SI, Builder))
return SimplifyCFG(BB, TTI, BonusInstThreshold, DL, AC) | true; return SimplifyCFG(BB, TTI, BonusInstThreshold, AC) | true;
} }
// Try to transform the switch into an icmp and a branch. // Try to transform the switch into an icmp and a branch.
if (TurnSwitchRangeIntoICmp(SI, Builder)) if (TurnSwitchRangeIntoICmp(SI, Builder))
return SimplifyCFG(BB, TTI, BonusInstThreshold, DL, AC) | true; return SimplifyCFG(BB, TTI, BonusInstThreshold, AC) | true;
// Remove unreachable cases. // Remove unreachable cases.
if (EliminateDeadSwitchCases(SI, DL, AC)) if (EliminateDeadSwitchCases(SI, AC, DL))
return SimplifyCFG(BB, TTI, BonusInstThreshold, DL, AC) | true; return SimplifyCFG(BB, TTI, BonusInstThreshold, AC) | true;
if (SwitchToSelect(SI, Builder, DL, AC)) if (SwitchToSelect(SI, Builder, AC, DL))
return SimplifyCFG(BB, TTI, BonusInstThreshold, DL, AC) | true; return SimplifyCFG(BB, TTI, BonusInstThreshold, AC) | true;
if (ForwardSwitchConditionToPHI(SI)) if (ForwardSwitchConditionToPHI(SI))
return SimplifyCFG(BB, TTI, BonusInstThreshold, DL, AC) | true; return SimplifyCFG(BB, TTI, BonusInstThreshold, AC) | true;
if (SwitchToLookupTable(SI, Builder, TTI, DL)) if (SwitchToLookupTable(SI, Builder, DL, TTI))
return SimplifyCFG(BB, TTI, BonusInstThreshold, DL, AC) | true; return SimplifyCFG(BB, TTI, BonusInstThreshold, AC) | true;
return false; return false;
} }
Context not available.
if (SelectInst *SI = dyn_cast<SelectInst>(IBI->getAddress())) { if (SelectInst *SI = dyn_cast<SelectInst>(IBI->getAddress())) {
if (SimplifyIndirectBrOnSelect(IBI, SI)) if (SimplifyIndirectBrOnSelect(IBI, SI))
return SimplifyCFG(BB, TTI, BonusInstThreshold, DL, AC) | true; return SimplifyCFG(BB, TTI, BonusInstThreshold, AC) | true;
} }
return Changed; return Changed;
} }
Context not available.
for (++I; isa<DbgInfoIntrinsic>(I); ++I) for (++I; isa<DbgInfoIntrinsic>(I); ++I)
; ;
if (I->isTerminator() && if (I->isTerminator() &&
TryToSimplifyUncondBranchWithICmpInIt(ICI, Builder, TTI, TryToSimplifyUncondBranchWithICmpInIt(ICI, Builder, DL, TTI,
BonusInstThreshold, DL, AC)) BonusInstThreshold, AC))
return true; return true;
} }
Context not available.
// branches to us and our successor, fold the comparison into the // branches to us and our successor, fold the comparison into the
// predecessor and use logical operations to update the incoming value // predecessor and use logical operations to update the incoming value
// for PHI nodes in common successor. // for PHI nodes in common successor.
if (FoldBranchToCommonDest(BI, DL, BonusInstThreshold)) if (FoldBranchToCommonDest(BI, BonusInstThreshold))
return SimplifyCFG(BB, TTI, BonusInstThreshold, DL, AC) | true; return SimplifyCFG(BB, TTI, BonusInstThreshold, AC) | true;
return false; return false;
} }
Context not available.
// switch. // switch.
if (BasicBlock *OnlyPred = BB->getSinglePredecessor()) if (BasicBlock *OnlyPred = BB->getSinglePredecessor())
if (SimplifyEqualityComparisonWithOnlyPredecessor(BI, OnlyPred, Builder)) if (SimplifyEqualityComparisonWithOnlyPredecessor(BI, OnlyPred, Builder))
return SimplifyCFG(BB, TTI, BonusInstThreshold, DL, AC) | true; return SimplifyCFG(BB, TTI, BonusInstThreshold, AC) | true;
// This block must be empty, except for the setcond inst, if it exists. // This block must be empty, except for the setcond inst, if it exists.
// Ignore dbg intrinsics. // Ignore dbg intrinsics.
Context not available.
++I; ++I;
if (&*I == BI) { if (&*I == BI) {
if (FoldValueComparisonIntoPredecessors(BI, Builder)) if (FoldValueComparisonIntoPredecessors(BI, Builder))
return SimplifyCFG(BB, TTI, BonusInstThreshold, DL, AC) | true; return SimplifyCFG(BB, TTI, BonusInstThreshold, AC) | true;
} else if (&*I == cast<Instruction>(BI->getCondition())){ } else if (&*I == cast<Instruction>(BI->getCondition())){
++I; ++I;
// Ignore dbg intrinsics. // Ignore dbg intrinsics.
while (isa<DbgInfoIntrinsic>(I)) while (isa<DbgInfoIntrinsic>(I))
++I; ++I;
if (&*I == BI && FoldValueComparisonIntoPredecessors(BI, Builder)) if (&*I == BI && FoldValueComparisonIntoPredecessors(BI, Builder))
return SimplifyCFG(BB, TTI, BonusInstThreshold, DL, AC) | true; return SimplifyCFG(BB, TTI, BonusInstThreshold, AC) | true;
} }
} }
// Try to turn "br (X == 0 | X == 1), T, F" into a switch instruction. // Try to turn "br (X == 0 | X == 1), T, F" into a switch instruction.
if (SimplifyBranchOnICmpChain(BI, DL, Builder)) if (SimplifyBranchOnICmpChain(BI, Builder, DL))
return true; return true;
// If this basic block is ONLY a compare and a branch, and if a predecessor // If this basic block is ONLY a compare and a branch, and if a predecessor
// branches to us and one of our successors, fold the comparison into the // branches to us and one of our successors, fold the comparison into the
// predecessor and use logical operations to pick the right destination. // predecessor and use logical operations to pick the right destination.
if (FoldBranchToCommonDest(BI, DL, BonusInstThreshold)) if (FoldBranchToCommonDest(BI, BonusInstThreshold))
return SimplifyCFG(BB, TTI, BonusInstThreshold, DL, AC) | true; return SimplifyCFG(BB, TTI, BonusInstThreshold, AC) | true;
// We have a conditional branch to two blocks that are only reachable // We have a conditional branch to two blocks that are only reachable
// from BI. We know that the condbr dominates the two blocks, so see if // from BI. We know that the condbr dominates the two blocks, so see if
Context not available.
// can hoist it up to the branching block. // can hoist it up to the branching block.
if (BI->getSuccessor(0)->getSinglePredecessor()) { if (BI->getSuccessor(0)->getSinglePredecessor()) {
if (BI->getSuccessor(1)->getSinglePredecessor()) { if (BI->getSuccessor(1)->getSinglePredecessor()) {
if (HoistThenElseCodeToIf(BI, DL, TTI)) if (HoistThenElseCodeToIf(BI, TTI))
return SimplifyCFG(BB, TTI, BonusInstThreshold, DL, AC) | true; return SimplifyCFG(BB, TTI, BonusInstThreshold, AC) | true;
} else { } else {
// If Successor #1 has multiple preds, we may be able to conditionally // If Successor #1 has multiple preds, we may be able to conditionally
// execute Successor #0 if it branches to Successor #1. // execute Successor #0 if it branches to Successor #1.
TerminatorInst *Succ0TI = BI->getSuccessor(0)->getTerminator(); TerminatorInst *Succ0TI = BI->getSuccessor(0)->getTerminator();
if (Succ0TI->getNumSuccessors() == 1 && if (Succ0TI->getNumSuccessors() == 1 &&
Succ0TI->getSuccessor(0) == BI->getSuccessor(1)) Succ0TI->getSuccessor(0) == BI->getSuccessor(1))
if (SpeculativelyExecuteBB(BI, BI->getSuccessor(0), DL, TTI)) if (SpeculativelyExecuteBB(BI, BI->getSuccessor(0), TTI))
return SimplifyCFG(BB, TTI, BonusInstThreshold, DL, AC) | true; return SimplifyCFG(BB, TTI, BonusInstThreshold, AC) | true;
} }
} else if (BI->getSuccessor(1)->getSinglePredecessor()) { } else if (BI->getSuccessor(1)->getSinglePredecessor()) {
// If Successor #0 has multiple preds, we may be able to conditionally // If Successor #0 has multiple preds, we may be able to conditionally
Context not available.
TerminatorInst *Succ1TI = BI->getSuccessor(1)->getTerminator(); TerminatorInst *Succ1TI = BI->getSuccessor(1)->getTerminator();
if (Succ1TI->getNumSuccessors() == 1 && if (Succ1TI->getNumSuccessors() == 1 &&
Succ1TI->getSuccessor(0) == BI->getSuccessor(0)) Succ1TI->getSuccessor(0) == BI->getSuccessor(0))
if (SpeculativelyExecuteBB(BI, BI->getSuccessor(1), DL, TTI)) if (SpeculativelyExecuteBB(BI, BI->getSuccessor(1), TTI))
return SimplifyCFG(BB, TTI, BonusInstThreshold, DL, AC) | true; return SimplifyCFG(BB, TTI, BonusInstThreshold, AC) | true;
} }
// If this is a branch on a phi node in the current block, thread control // If this is a branch on a phi node in the current block, thread control
Context not available.
if (PHINode *PN = dyn_cast<PHINode>(BI->getCondition())) if (PHINode *PN = dyn_cast<PHINode>(BI->getCondition()))
if (PN->getParent() == BI->getParent()) if (PN->getParent() == BI->getParent())
if (FoldCondBranchOnPHI(BI, DL)) if (FoldCondBranchOnPHI(BI, DL))
return SimplifyCFG(BB, TTI, BonusInstThreshold, DL, AC) | true; return SimplifyCFG(BB, TTI, BonusInstThreshold, AC) | true;
// Scan predecessor blocks for conditional branches. // Scan predecessor blocks for conditional branches.
for (pred_iterator PI = pred_begin(BB), E = pred_end(BB); PI != E; ++PI) for (pred_iterator PI = pred_begin(BB), E = pred_end(BB); PI != E; ++PI)
if (BranchInst *PBI = dyn_cast<BranchInst>((*PI)->getTerminator())) if (BranchInst *PBI = dyn_cast<BranchInst>((*PI)->getTerminator()))
if (PBI != BI && PBI->isConditional()) if (PBI != BI && PBI->isConditional())
if (SimplifyCondBranchToCondBranch(PBI, BI)) if (SimplifyCondBranchToCondBranch(PBI, BI))
return SimplifyCFG(BB, TTI, BonusInstThreshold, DL, AC) | true; return SimplifyCFG(BB, TTI, BonusInstThreshold, AC) | true;
return false; return false;
} }
Context not available.
// eliminate it, do so now. // eliminate it, do so now.
if (PHINode *PN = dyn_cast<PHINode>(BB->begin())) if (PHINode *PN = dyn_cast<PHINode>(BB->begin()))
if (PN->getNumIncomingValues() == 2) if (PN->getNumIncomingValues() == 2)
Changed |= FoldTwoEntryPHINode(PN, DL, TTI); Changed |= FoldTwoEntryPHINode(PN, TTI, DL);
Builder.SetInsertPoint(BB->getTerminator()); Builder.SetInsertPoint(BB->getTerminator());
if (BranchInst *BI = dyn_cast<BranchInst>(BB->getTerminator())) { if (BranchInst *BI = dyn_cast<BranchInst>(BB->getTerminator())) {
Context not available.
/// of the CFG. It returns true if a modification was made. /// of the CFG. It returns true if a modification was made.
/// ///
bool llvm::SimplifyCFG(BasicBlock *BB, const TargetTransformInfo &TTI, bool llvm::SimplifyCFG(BasicBlock *BB, const TargetTransformInfo &TTI,
unsigned BonusInstThreshold, const DataLayout *DL, unsigned BonusInstThreshold, AssumptionCache *AC) {
AssumptionCache *AC) { return SimplifyCFGOpt(TTI, BB->getModule()->getDataLayout(),
return SimplifyCFGOpt(TTI, BonusInstThreshold, DL, AC).run(BB); BonusInstThreshold, AC).run(BB);
} }
Context not available.

lib/Transforms/Utils/SimplifyInstructions.cpp

Context not available.
continue; continue;
// Don't waste time simplifying unused instructions. // Don't waste time simplifying unused instructions.
if (!I->use_empty()) if (!I->use_empty())
if (Value *V = SimplifyInstruction(I, &DL, TLI, DT, AC)) { if (Value *V = SimplifyInstruction(I, DL, TLI, DT, AC)) {
// Mark all uses for resimplification next time round the loop. // Mark all uses for resimplification next time round the loop.
for (User *U : I->users()) for (User *U : I->users())
Next->insert(cast<Instruction>(U)); Next->insert(cast<Instruction>(U));
Context not available.

lib/Transforms/Utils/SimplifyLibCalls.cpp

Context not available.
/// string/memory copying library function \p Func. /// string/memory copying library function \p Func.
/// Acceptable functions are st[rp][n]?cpy, memove, memcpy, and memset. /// Acceptable functions are st[rp][n]?cpy, memove, memcpy, and memset.
/// Their fortified (_chk) counterparts are also accepted. /// Their fortified (_chk) counterparts are also accepted.
static bool checkStringCopyLibFuncSignature(Function *F, LibFunc::Func Func, static bool checkStringCopyLibFuncSignature(Function *F, LibFunc::Func Func) {
const DataLayout *DL) { const DataLayout &DL = F->getParent()->getDataLayout();
FunctionType *FT = F->getFunctionType(); FunctionType *FT = F->getFunctionType();
LLVMContext &Context = F->getContext(); LLVMContext &Context = F->getContext();
Type *PCharTy = Type::getInt8PtrTy(Context); Type *PCharTy = Type::getInt8PtrTy(Context);
Type *SizeTTy = DL ? DL->getIntPtrType(Context) : nullptr; Type *SizeTTy = DL.getIntPtrType(Context);
unsigned NumParams = FT->getNumParams(); unsigned NumParams = FT->getNumParams();
// All string libfuncs return the same type as the first parameter. // All string libfuncs return the same type as the first parameter.
Context not available.
if (Len == 0) if (Len == 0)
return Dst; return Dst;
// These optimizations require DataLayout.
if (!DL)
return nullptr;
return emitStrLenMemCpy(Src, Dst, Len, B); return emitStrLenMemCpy(Src, Dst, Len, B);
} }
Context not available.
// We have enough information to now generate the memcpy call to do the // We have enough information to now generate the memcpy call to do the
// concatenation for us. Make a memcpy to copy the nul byte with align = 1. // concatenation for us. Make a memcpy to copy the nul byte with align = 1.
B.CreateMemCpy( B.CreateMemCpy(CpyDst, Src,
CpyDst, Src, ConstantInt::get(DL.getIntPtrType(Src->getContext()), Len + 1),
ConstantInt::get(DL->getIntPtrType(Src->getContext()), Len + 1), 1); 1);
return Dst; return Dst;
} }
Context not available.
if (SrcLen == 0 || Len == 0) if (SrcLen == 0 || Len == 0)
return Dst; return Dst;
// These optimizations require DataLayout.
if (!DL)
return nullptr;
// We don't optimize this case // We don't optimize this case
if (Len < SrcLen) if (Len < SrcLen)
return nullptr; return nullptr;
Context not available.
// of the input string and turn this into memchr. // of the input string and turn this into memchr.
ConstantInt *CharC = dyn_cast<ConstantInt>(CI->getArgOperand(1)); ConstantInt *CharC = dyn_cast<ConstantInt>(CI->getArgOperand(1));
if (!CharC) { if (!CharC) {
// These optimizations require DataLayout.
if (!DL)
return nullptr;
uint64_t Len = GetStringLength(SrcStr); uint64_t Len = GetStringLength(SrcStr);
if (Len == 0 || !FT->getParamType(1)->isIntegerTy(32)) // memchr needs i32. if (Len == 0 || !FT->getParamType(1)->isIntegerTy(32)) // memchr needs i32.
return nullptr; return nullptr;
return EmitMemChr( return EmitMemChr(SrcStr, CI->getArgOperand(1), // include nul.
SrcStr, CI->getArgOperand(1), // include nul. ConstantInt::get(DL.getIntPtrType(CI->getContext()), Len),
ConstantInt::get(DL->getIntPtrType(CI->getContext()), Len), B, DL, TLI); B, DL, TLI);
} }
// Otherwise, the character is a constant, see if the first argument is // Otherwise, the character is a constant, see if the first argument is
// a string literal. If so, we can constant fold. // a string literal. If so, we can constant fold.
StringRef Str; StringRef Str;
if (!getConstantStringInfo(SrcStr, Str)) { if (!getConstantStringInfo(SrcStr, Str)) {
if (DL && CharC->isZero()) // strchr(p, 0) -> p + strlen(p) if (CharC->isZero()) // strchr(p, 0) -> p + strlen(p)
return B.CreateGEP(SrcStr, EmitStrLen(SrcStr, B, DL, TLI), "strchr"); return B.CreateGEP(SrcStr, EmitStrLen(SrcStr, B, DL, TLI), "strchr");
return nullptr; return nullptr;
} }
Context not available.
StringRef Str; StringRef Str;
if (!getConstantStringInfo(SrcStr, Str)) { if (!getConstantStringInfo(SrcStr, Str)) {
// strrchr(s, 0) -> strchr(s, 0) // strrchr(s, 0) -> strchr(s, 0)
if (DL && CharC->isZero()) if (CharC->isZero())
return EmitStrChr(SrcStr, '\0', B, DL, TLI); return EmitStrChr(SrcStr, '\0', B, TLI);
return nullptr; return nullptr;
} }
Context not available.
uint64_t Len1 = GetStringLength(Str1P); uint64_t Len1 = GetStringLength(Str1P);
uint64_t Len2 = GetStringLength(Str2P); uint64_t Len2 = GetStringLength(Str2P);
if (Len1 && Len2) { if (Len1 && Len2) {
// These optimizations require DataLayout.
if (!DL)
return nullptr;
return EmitMemCmp(Str1P, Str2P, return EmitMemCmp(Str1P, Str2P,
ConstantInt::get(DL->getIntPtrType(CI->getContext()), ConstantInt::get(DL.getIntPtrType(CI->getContext()),
std::min(Len1, Len2)), std::min(Len1, Len2)),
B, DL, TLI); B, DL, TLI);
} }
Context not available.
if (Length == 0) // strncmp(x,y,0) -> 0 if (Length == 0) // strncmp(x,y,0) -> 0
return ConstantInt::get(CI->getType(), 0); return ConstantInt::get(CI->getType(), 0);
if (DL && Length == 1) // strncmp(x,y,1) -> memcmp(x,y,1) if (Length == 1) // strncmp(x,y,1) -> memcmp(x,y,1)
return EmitMemCmp(Str1P, Str2P, CI->getArgOperand(2), B, DL, TLI); return EmitMemCmp(Str1P, Str2P, CI->getArgOperand(2), B, DL, TLI);
StringRef Str1, Str2; StringRef Str1, Str2;
Context not available.
Value *LibCallSimplifier::optimizeStrCpy(CallInst *CI, IRBuilder<> &B) { Value *LibCallSimplifier::optimizeStrCpy(CallInst *CI, IRBuilder<> &B) {
Function *Callee = CI->getCalledFunction(); Function *Callee = CI->getCalledFunction();
if (!checkStringCopyLibFuncSignature(Callee, LibFunc::strcpy, DL)) if (!checkStringCopyLibFuncSignature(Callee, LibFunc::strcpy))
return nullptr; return nullptr;
Value *Dst = CI->getArgOperand(0), *Src = CI->getArgOperand(1); Value *Dst = CI->getArgOperand(0), *Src = CI->getArgOperand(1);
if (Dst == Src) // strcpy(x,x) -> x if (Dst == Src) // strcpy(x,x) -> x
return Src; return Src;
// These optimizations require DataLayout.
if (!DL)
return nullptr;
// See if we can get the length of the input string. // See if we can get the length of the input string.
uint64_t Len = GetStringLength(Src); uint64_t Len = GetStringLength(Src);
if (Len == 0) if (Len == 0)
Context not available.
// We have enough information to now generate the memcpy call to do the // We have enough information to now generate the memcpy call to do the
// copy for us. Make a memcpy to copy the nul byte with align = 1. // copy for us. Make a memcpy to copy the nul byte with align = 1.
B.CreateMemCpy(Dst, Src, B.CreateMemCpy(Dst, Src,
ConstantInt::get(DL->getIntPtrType(CI->getContext()), Len), 1); ConstantInt::get(DL.getIntPtrType(CI->getContext()), Len), 1);
return Dst; return Dst;
} }
Context not available.
// Verify the "stpcpy" function prototype. // Verify the "stpcpy" function prototype.
FunctionType *FT = Callee->getFunctionType(); FunctionType *FT = Callee->getFunctionType();
if (!checkStringCopyLibFuncSignature(Callee, LibFunc::stpcpy, DL)) if (!checkStringCopyLibFuncSignature(Callee, LibFunc::stpcpy))
return nullptr;
// These optimizations require DataLayout.
if (!DL)
return nullptr; return nullptr;
Value *Dst = CI->getArgOperand(0), *Src = CI->getArgOperand(1); Value *Dst = CI->getArgOperand(0), *Src = CI->getArgOperand(1);
Context not available.
return nullptr; return nullptr;
Type *PT = FT->getParamType(0); Type *PT = FT->getParamType(0);
Value *LenV = ConstantInt::get(DL->getIntPtrType(PT), Len); Value *LenV = ConstantInt::get(DL.getIntPtrType(PT), Len);
Value *DstEnd = Value *DstEnd =
B.CreateGEP(Dst, ConstantInt::get(DL->getIntPtrType(PT), Len - 1)); B.CreateGEP(Dst, ConstantInt::get(DL.getIntPtrType(PT), Len - 1));
// We have enough information to now generate the memcpy call to do the // We have enough information to now generate the memcpy call to do the
// copy for us. Make a memcpy to copy the nul byte with align = 1. // copy for us. Make a memcpy to copy the nul byte with align = 1.
Context not available.
Function *Callee = CI->getCalledFunction(); Function *Callee = CI->getCalledFunction();
FunctionType *FT = Callee->getFunctionType(); FunctionType *FT = Callee->getFunctionType();
if (!checkStringCopyLibFuncSignature(Callee, LibFunc::strncpy, DL)) if (!checkStringCopyLibFuncSignature(Callee, LibFunc::strncpy))
return nullptr; return nullptr;
Value *Dst = CI->getArgOperand(0); Value *Dst = CI->getArgOperand(0);
Context not available.
if (Len == 0) if (Len == 0)
return Dst; // strncpy(x, y, 0) -> x return Dst; // strncpy(x, y, 0) -> x
// These optimizations require DataLayout.
if (!DL)
return nullptr;
// Let strncpy handle the zero padding // Let strncpy handle the zero padding
if (Len > SrcLen + 1) if (Len > SrcLen + 1)
return nullptr; return nullptr;
Type *PT = FT->getParamType(0); Type *PT = FT->getParamType(0);
// strncpy(x, s, c) -> memcpy(x, s, c, 1) [s and c are constant] // strncpy(x, s, c) -> memcpy(x, s, c, 1) [s and c are constant]
B.CreateMemCpy(Dst, Src, ConstantInt::get(DL->getIntPtrType(PT), Len), 1); B.CreateMemCpy(Dst, Src, ConstantInt::get(DL.getIntPtrType(PT), Len), 1);
return Dst; return Dst;
} }
Context not available.
} }
// strpbrk(s, "a") -> strchr(s, 'a') // strpbrk(s, "a") -> strchr(s, 'a')
if (DL && HasS2 && S2.size() == 1) if (HasS2 && S2.size() == 1)
return EmitStrChr(CI->getArgOperand(0), S2[0], B, DL, TLI); return EmitStrChr(CI->getArgOperand(0), S2[0], B, TLI);
return nullptr; return nullptr;
} }
Context not available.
} }
// strcspn(s, "") -> strlen(s) // strcspn(s, "") -> strlen(s)
if (DL && HasS2 && S2.empty()) if (HasS2 && S2.empty())
return EmitStrLen(CI->getArgOperand(0), B, DL, TLI); return EmitStrLen(CI->getArgOperand(0), B, DL, TLI);
return nullptr; return nullptr;
Context not available.
return B.CreateBitCast(CI->getArgOperand(0), CI->getType()); return B.CreateBitCast(CI->getArgOperand(0), CI->getType());
// fold strstr(a, b) == a -> strncmp(a, b, strlen(b)) == 0 // fold strstr(a, b) == a -> strncmp(a, b, strlen(b)) == 0
if (DL && isOnlyUsedInEqualityComparison(CI, CI->getArgOperand(0))) { if (isOnlyUsedInEqualityComparison(CI, CI->getArgOperand(0))) {
Value *StrLen = EmitStrLen(CI->getArgOperand(1), B, DL, TLI); Value *StrLen = EmitStrLen(CI->getArgOperand(1), B, DL, TLI);
if (!StrLen) if (!StrLen)
return nullptr; return nullptr;
Context not available.
// fold strstr(x, "y") -> strchr(x, 'y'). // fold strstr(x, "y") -> strchr(x, 'y').
if (HasStr2 && ToFindStr.size() == 1) { if (HasStr2 && ToFindStr.size() == 1) {
Value *StrChr = EmitStrChr(CI->getArgOperand(0), ToFindStr[0], B, DL, TLI); Value *StrChr = EmitStrChr(CI->getArgOperand(0), ToFindStr[0], B, TLI);
return StrChr ? B.CreateBitCast(StrChr, CI->getType()) : nullptr; return StrChr ? B.CreateBitCast(StrChr, CI->getType()) : nullptr;
} }
return nullptr; return nullptr;
Context not available.
Value *LibCallSimplifier::optimizeMemCpy(CallInst *CI, IRBuilder<> &B) { Value *LibCallSimplifier::optimizeMemCpy(CallInst *CI, IRBuilder<> &B) {
Function *Callee = CI->getCalledFunction(); Function *Callee = CI->getCalledFunction();
// These optimizations require DataLayout.
if (!DL)
return nullptr;
if (!checkStringCopyLibFuncSignature(Callee, LibFunc::memcpy, DL)) if (!checkStringCopyLibFuncSignature(Callee, LibFunc::memcpy))
return nullptr; return nullptr;
// memcpy(x, y, n) -> llvm.memcpy(x, y, n, 1) // memcpy(x, y, n) -> llvm.memcpy(x, y, n, 1)
Context not available.
Value *LibCallSimplifier::optimizeMemMove(CallInst *CI, IRBuilder<> &B) { Value *LibCallSimplifier::optimizeMemMove(CallInst *CI, IRBuilder<> &B) {
Function *Callee = CI->getCalledFunction(); Function *Callee = CI->getCalledFunction();
// These optimizations require DataLayout.
if (!DL)
return nullptr;
if (!checkStringCopyLibFuncSignature(Callee, LibFunc::memmove, DL)) if (!checkStringCopyLibFuncSignature(Callee, LibFunc::memmove))
return nullptr; return nullptr;
// memmove(x, y, n) -> llvm.memmove(x, y, n, 1) // memmove(x, y, n) -> llvm.memmove(x, y, n, 1)
Context not available.
Value *LibCallSimplifier::optimizeMemSet(CallInst *CI, IRBuilder<> &B) { Value *LibCallSimplifier::optimizeMemSet(CallInst *CI, IRBuilder<> &B) {
Function *Callee = CI->getCalledFunction(); Function *Callee = CI->getCalledFunction();
// These optimizations require DataLayout.
if (!DL)
return nullptr;
if (!checkStringCopyLibFuncSignature(Callee, LibFunc::memset, DL)) if (!checkStringCopyLibFuncSignature(Callee, LibFunc::memset))
return nullptr; return nullptr;
// memset(p, v, n) -> llvm.memset(p, v, n, 1) // memset(p, v, n) -> llvm.memset(p, v, n, 1)
Context not available.
// printf("x") -> putchar('x'), even for '%'. // printf("x") -> putchar('x'), even for '%'.
if (FormatStr.size() == 1) { if (FormatStr.size() == 1) {
Value *Res = EmitPutChar(B.getInt32(FormatStr[0]), B, DL, TLI); Value *Res = EmitPutChar(B.getInt32(FormatStr[0]), B, TLI);
if (CI->use_empty() || !Res) if (CI->use_empty() || !Res)
return Res; return Res;
return B.CreateIntCast(Res, CI->getType(), true); return B.CreateIntCast(Res, CI->getType(), true);
Context not available.
// pass to be run after this pass, to merge duplicate strings. // pass to be run after this pass, to merge duplicate strings.
FormatStr = FormatStr.drop_back(); FormatStr = FormatStr.drop_back();
Value *GV = B.CreateGlobalString(FormatStr, "str"); Value *GV = B.CreateGlobalString(FormatStr, "str");
Value *NewCI = EmitPutS(GV, B, DL, TLI); Value *NewCI = EmitPutS(GV, B, TLI);
return (CI->use_empty() || !NewCI) return (CI->use_empty() || !NewCI)
? NewCI ? NewCI
: ConstantInt::get(CI->getType(), FormatStr.size() + 1); : ConstantInt::get(CI->getType(), FormatStr.size() + 1);
Context not available.
// printf("%c", chr) --> putchar(chr) // printf("%c", chr) --> putchar(chr)
if (FormatStr == "%c" && CI->getNumArgOperands() > 1 && if (FormatStr == "%c" && CI->getNumArgOperands() > 1 &&
CI->getArgOperand(1)->getType()->isIntegerTy()) { CI->getArgOperand(1)->getType()->isIntegerTy()) {
Value *Res = EmitPutChar(CI->getArgOperand(1), B, DL, TLI); Value *Res = EmitPutChar(CI->getArgOperand(1), B, TLI);
if (CI->use_empty() || !Res) if (CI->use_empty() || !Res)
return Res; return Res;
Context not available.
// printf("%s\n", str) --> puts(str) // printf("%s\n", str) --> puts(str)
if (FormatStr == "%s\n" && CI->getNumArgOperands() > 1 && if (FormatStr == "%s\n" && CI->getNumArgOperands() > 1 &&
CI->getArgOperand(1)->getType()->isPointerTy()) { CI->getArgOperand(1)->getType()->isPointerTy()) {
return EmitPutS(CI->getArgOperand(1), B, DL, TLI); return EmitPutS(CI->getArgOperand(1), B, TLI);
} }
return nullptr; return nullptr;
} }
Context not available.
if (FormatStr[i] == '%') if (FormatStr[i] == '%')
return nullptr; // we found a format specifier, bail out. return nullptr; // we found a format specifier, bail out.
// These optimizations require DataLayout.
if (!DL)
return nullptr;
// sprintf(str, fmt) -> llvm.memcpy(str, fmt, strlen(fmt)+1, 1) // sprintf(str, fmt) -> llvm.memcpy(str, fmt, strlen(fmt)+1, 1)
B.CreateMemCpy( B.CreateMemCpy(CI->getArgOperand(0), CI->getArgOperand(1),
CI->getArgOperand(0), CI->getArgOperand(1), ConstantInt::get(DL.getIntPtrType(CI->getContext()),
ConstantInt::get(DL->getIntPtrType(CI->getContext()), FormatStr.size() + 1),
FormatStr.size() + 1), 1); // Copy the null byte.
1); // Copy the null byte.
return ConstantInt::get(CI->getType(), FormatStr.size()); return ConstantInt::get(CI->getType(), FormatStr.size());
} }
Context not available.
} }
if (FormatStr[1] == 's') { if (FormatStr[1] == 's') {
// These optimizations require DataLayout.
if (!DL)
return nullptr;
// sprintf(dest, "%s", str) -> llvm.memcpy(dest, str, strlen(str)+1, 1) // sprintf(dest, "%s", str) -> llvm.memcpy(dest, str, strlen(str)+1, 1)
if (!CI->getArgOperand(2)->getType()->isPointerTy()) if (!CI->getArgOperand(2)->getType()->isPointerTy())
return nullptr; return nullptr;
Context not available.
if (FormatStr[i] == '%') // Could handle %% -> % if we cared. if (FormatStr[i] == '%') // Could handle %% -> % if we cared.
return nullptr; // We found a format specifier. return nullptr; // We found a format specifier.
// These optimizations require DataLayout.
if (!DL)
return nullptr;
return EmitFWrite( return EmitFWrite(
CI->getArgOperand(1), CI->getArgOperand(1),
ConstantInt::get(DL->getIntPtrType(CI->getContext()), FormatStr.size()), ConstantInt::get(DL.getIntPtrType(CI->getContext()), FormatStr.size()),
CI->getArgOperand(0), B, DL, TLI); CI->getArgOperand(0), B, DL, TLI);
} }
Context not available.
// fprintf(F, "%c", chr) --> fputc(chr, F) // fprintf(F, "%c", chr) --> fputc(chr, F)
if (!CI->getArgOperand(2)->getType()->isIntegerTy()) if (!CI->getArgOperand(2)->getType()->isIntegerTy())
return nullptr; return nullptr;
return EmitFPutC(CI->getArgOperand(2), CI->getArgOperand(0), B, DL, TLI); return EmitFPutC(CI->getArgOperand(2), CI->getArgOperand(0), B, TLI);
} }
if (FormatStr[1] == 's') { if (FormatStr[1] == 's') {
// fprintf(F, "%s", str) --> fputs(str, F) // fprintf(F, "%s", str) --> fputs(str, F)
if (!CI->getArgOperand(2)->getType()->isPointerTy()) if (!CI->getArgOperand(2)->getType()->isPointerTy())
return nullptr; return nullptr;
return EmitFPutS(CI->getArgOperand(2), CI->getArgOperand(0), B, DL, TLI); return EmitFPutS(CI->getArgOperand(2), CI->getArgOperand(0), B, TLI);
} }
return nullptr; return nullptr;
} }
Context not available.
// This optimisation is only valid, if the return value is unused. // This optimisation is only valid, if the return value is unused.
if (Bytes == 1 && CI->use_empty()) { // fwrite(S,1,1,F) -> fputc(S[0],F) if (Bytes == 1 && CI->use_empty()) { // fwrite(S,1,1,F) -> fputc(S[0],F)
Value *Char = B.CreateLoad(CastToCStr(CI->getArgOperand(0), B), "char"); Value *Char = B.CreateLoad(CastToCStr(CI->getArgOperand(0), B), "char");
Value *NewCI = EmitFPutC(Char, CI->getArgOperand(3), B, DL, TLI); Value *NewCI = EmitFPutC(Char, CI->getArgOperand(3), B, TLI);
return NewCI ? ConstantInt::get(CI->getType(), 1) : nullptr; return NewCI ? ConstantInt::get(CI->getType(), 1) : nullptr;
} }
Context not available.
Function *Callee = CI->getCalledFunction(); Function *Callee = CI->getCalledFunction();
// These optimizations require DataLayout.
if (!DL)
return nullptr;
// Require two pointers. Also, we can't optimize if return value is used. // Require two pointers. Also, we can't optimize if return value is used.
FunctionType *FT = Callee->getFunctionType(); FunctionType *FT = Callee->getFunctionType();
if (FT->getNumParams() != 2 || !FT->getParamType(0)->isPointerTy() || if (FT->getNumParams() != 2 || !FT->getParamType(0)->isPointerTy() ||
Context not available.
// Known to have no uses (see above). // Known to have no uses (see above).
return EmitFWrite( return EmitFWrite(
CI->getArgOperand(0), CI->getArgOperand(0),
ConstantInt::get(DL->getIntPtrType(CI->getContext()), Len - 1), ConstantInt::get(DL.getIntPtrType(CI->getContext()), Len - 1),
CI->getArgOperand(1), B, DL, TLI); CI->getArgOperand(1), B, DL, TLI);
} }
Context not available.
if (Str.empty() && CI->use_empty()) { if (Str.empty() && CI->use_empty()) {
// puts("") -> putchar('\n') // puts("") -> putchar('\n')
Value *Res = EmitPutChar(B.getInt32('\n'), B, DL, TLI); Value *Res = EmitPutChar(B.getInt32('\n'), B, TLI);
if (CI->use_empty() || !Res) if (CI->use_empty() || !Res)
return Res; return Res;
return B.CreateIntCast(Res, CI->getType(), true); return B.CreateIntCast(Res, CI->getType(), true);
Context not available.
} }
LibCallSimplifier::LibCallSimplifier( LibCallSimplifier::LibCallSimplifier(
const DataLayout *DL, const TargetLibraryInfo *TLI, const DataLayout &DL, const TargetLibraryInfo *TLI,
function_ref<void(Instruction *, Value *)> Replacer) function_ref<void(Instruction *, Value *)> Replacer)
: FortifiedSimplifier(DL, TLI), DL(DL), TLI(TLI), UnsafeFPShrink(false), : FortifiedSimplifier(TLI), DL(DL), TLI(TLI), UnsafeFPShrink(false),
Replacer(Replacer) {} Replacer(Replacer) {}
void LibCallSimplifier::replaceAllUsesWith(Instruction *I, Value *With) { void LibCallSimplifier::replaceAllUsesWith(Instruction *I, Value *With) {
Context not available.
Value *FortifiedLibCallSimplifier::optimizeMemCpyChk(CallInst *CI, IRBuilder<> &B) { Value *FortifiedLibCallSimplifier::optimizeMemCpyChk(CallInst *CI, IRBuilder<> &B) {
Function *Callee = CI->getCalledFunction(); Function *Callee = CI->getCalledFunction();
if (!checkStringCopyLibFuncSignature(Callee, LibFunc::memcpy_chk, DL)) if (!checkStringCopyLibFuncSignature(Callee, LibFunc::memcpy_chk))
return nullptr; return nullptr;
if (isFortifiedCallFoldable(CI, 3, 2, false)) { if (isFortifiedCallFoldable(CI, 3, 2, false)) {
Context not available.
Value *FortifiedLibCallSimplifier::optimizeMemMoveChk(CallInst *CI, IRBuilder<> &B) { Value *FortifiedLibCallSimplifier::optimizeMemMoveChk(CallInst *CI, IRBuilder<> &B) {
Function *Callee = CI->getCalledFunction(); Function *Callee = CI->getCalledFunction();
if (!checkStringCopyLibFuncSignature(Callee, LibFunc::memmove_chk, DL)) if (!checkStringCopyLibFuncSignature(Callee, LibFunc::memmove_chk))
return nullptr; return nullptr;
if (isFortifiedCallFoldable(CI, 3, 2, false)) { if (isFortifiedCallFoldable(CI, 3, 2, false)) {
Context not available.
Value *FortifiedLibCallSimplifier::optimizeMemSetChk(CallInst *CI, IRBuilder<> &B) { Value *FortifiedLibCallSimplifier::optimizeMemSetChk(CallInst *CI, IRBuilder<> &B) {
Function *Callee = CI->getCalledFunction(); Function *Callee = CI->getCalledFunction();
if (!checkStringCopyLibFuncSignature(Callee, LibFunc::memset_chk, DL)) if (!checkStringCopyLibFuncSignature(Callee, LibFunc::memset_chk))
return nullptr; return nullptr;
if (isFortifiedCallFoldable(CI, 3, 2, false)) { if (isFortifiedCallFoldable(CI, 3, 2, false)) {
Context not available.
LibFunc::Func Func) { LibFunc::Func Func) {
Function *Callee = CI->getCalledFunction(); Function *Callee = CI->getCalledFunction();
StringRef Name = Callee->getName(); StringRef Name = Callee->getName();
const DataLayout &DL = CI->getModule()->getDataLayout();
if (!checkStringCopyLibFuncSignature(Callee, Func, DL)) if (!checkStringCopyLibFuncSignature(Callee, Func))
return nullptr; return nullptr;
Value *Dst = CI->getArgOperand(0), *Src = CI->getArgOperand(1), Value *Dst = CI->getArgOperand(0), *Src = CI->getArgOperand(1),
Context not available.
// TODO: It might be nice to get a maximum length out of the possible // TODO: It might be nice to get a maximum length out of the possible
// string lengths for varying. // string lengths for varying.
if (isFortifiedCallFoldable(CI, 2, 1, true)) { if (isFortifiedCallFoldable(CI, 2, 1, true)) {
Value *Ret = EmitStrCpy(Dst, Src, B, DL, TLI, Name.substr(2, 6)); Value *Ret = EmitStrCpy(Dst, Src, B, TLI, Name.substr(2, 6));
return Ret; return Ret;
} else if (!OnlyLowerUnknownSize) { } else if (!OnlyLowerUnknownSize) {
// Maybe we can stil fold __st[rp]cpy_chk to __memcpy_chk. // Maybe we can stil fold __st[rp]cpy_chk to __memcpy_chk.
Context not available.
if (Len == 0) if (Len == 0)
return nullptr; return nullptr;
// This optimization requires DataLayout. Type *SizeTTy = DL.getIntPtrType(CI->getContext());
if (!DL)
return nullptr;
Type *SizeTTy = DL->getIntPtrType(CI->getContext());
Value *LenV = ConstantInt::get(SizeTTy, Len); Value *LenV = ConstantInt::get(SizeTTy, Len);
Value *Ret = EmitMemCpyChk(Dst, Src, LenV, ObjSize, B, DL, TLI); Value *Ret = EmitMemCpyChk(Dst, Src, LenV, ObjSize, B, DL, TLI);
// If the function was an __stpcpy_chk, and we were able to fold it into // If the function was an __stpcpy_chk, and we were able to fold it into
Context not available.
Function *Callee = CI->getCalledFunction(); Function *Callee = CI->getCalledFunction();
StringRef Name = Callee->getName(); StringRef Name = Callee->getName();
if (!checkStringCopyLibFuncSignature(Callee, Func, DL)) if (!checkStringCopyLibFuncSignature(Callee, Func))
return nullptr; return nullptr;
if (isFortifiedCallFoldable(CI, 3, 2, false)) { if (isFortifiedCallFoldable(CI, 3, 2, false)) {
Value *Ret = Value *Ret = EmitStrNCpy(CI->getArgOperand(0), CI->getArgOperand(1),
EmitStrNCpy(CI->getArgOperand(0), CI->getArgOperand(1), CI->getArgOperand(2), B, TLI, Name.substr(2, 7));
CI->getArgOperand(2), B, DL, TLI, Name.substr(2, 7));
return Ret; return Ret;
} }
return nullptr; return nullptr;
Context not available.
return nullptr; return nullptr;
} }
FortifiedLibCallSimplifier:: FortifiedLibCallSimplifier::FortifiedLibCallSimplifier(
FortifiedLibCallSimplifier(const DataLayout *DL, const TargetLibraryInfo *TLI, const TargetLibraryInfo *TLI, bool OnlyLowerUnknownSize)
bool OnlyLowerUnknownSize) : TLI(TLI), OnlyLowerUnknownSize(OnlyLowerUnknownSize) {}
: DL(DL), TLI(TLI), OnlyLowerUnknownSize(OnlyLowerUnknownSize) {
}
Context not available.

lib/Transforms/Vectorize/BBVectorize.cpp

Context not available.
AA = &P->getAnalysis<AliasAnalysis>(); AA = &P->getAnalysis<AliasAnalysis>();
DT = &P->getAnalysis<DominatorTreeWrapperPass>().getDomTree(); DT = &P->getAnalysis<DominatorTreeWrapperPass>().getDomTree();
SE = &P->getAnalysis<ScalarEvolution>(); SE = &P->getAnalysis<ScalarEvolution>();
DL = &F.getParent()->getDataLayout();
TTI = IgnoreTargetInfo TTI = IgnoreTargetInfo
? nullptr ? nullptr
: &P->getAnalysis<TargetTransformInfoWrapperPass>().getTTI(F); : &P->getAnalysis<TargetTransformInfoWrapperPass>().getTTI(F);
Context not available.
AliasAnalysis *AA; AliasAnalysis *AA;
DominatorTree *DT; DominatorTree *DT;
ScalarEvolution *SE; ScalarEvolution *SE;
const DataLayout *DL;
const TargetTransformInfo *TTI; const TargetTransformInfo *TTI;
// FIXME: const correct? // FIXME: const correct?
Context not available.
AA = &getAnalysis<AliasAnalysis>(); AA = &getAnalysis<AliasAnalysis>();
DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree(); DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
SE = &getAnalysis<ScalarEvolution>(); SE = &getAnalysis<ScalarEvolution>();
DL = &BB.getModule()->getDataLayout();
TTI = IgnoreTargetInfo TTI = IgnoreTargetInfo
? nullptr ? nullptr
: &getAnalysis<TargetTransformInfoWrapperPass>().getTTI( : &getAnalysis<TargetTransformInfoWrapperPass>().getTTI(
Context not available.
dyn_cast<SCEVConstant>(OffsetSCEV)) { dyn_cast<SCEVConstant>(OffsetSCEV)) {
ConstantInt *IntOff = ConstOffSCEV->getValue(); ConstantInt *IntOff = ConstOffSCEV->getValue();
int64_t Offset = IntOff->getSExtValue(); int64_t Offset = IntOff->getSExtValue();
const DataLayout &DL = I->getModule()->getDataLayout();
Type *VTy = IPtr->getType()->getPointerElementType(); Type *VTy = IPtr->getType()->getPointerElementType();
int64_t VTyTSS = (int64_t) DL->getTypeStoreSize(VTy); int64_t VTyTSS = (int64_t)DL.getTypeStoreSize(VTy);
Type *VTy2 = JPtr->getType()->getPointerElementType(); Type *VTy2 = JPtr->getType()->getPointerElementType();
if (VTy != VTy2 && Offset < 0) { if (VTy != VTy2 && Offset < 0) {
int64_t VTy2TSS = (int64_t) DL->getTypeStoreSize(VTy2); int64_t VTy2TSS = (int64_t)DL.getTypeStoreSize(VTy2);
OffsetInElmts = Offset/VTy2TSS; OffsetInElmts = Offset/VTy2TSS;
return (abs64(Offset) % VTy2TSS) == 0; return (abs64(Offset) % VTy2TSS) == 0;
} }
Context not available.
// It is important to cleanup here so that future iterations of this // It is important to cleanup here so that future iterations of this
// function have less work to do. // function have less work to do.
(void) SimplifyInstructionsInBlock(&BB, DL, AA->getTargetLibraryInfo()); (void)SimplifyInstructionsInBlock(&BB, AA->getTargetLibraryInfo());
return true; return true;
} }
Context not available.
return false; return false;
} }
// We can't vectorize memory operations without target data
if (!DL && IsSimpleLoadStore)
return false;
Type *T1, *T2; Type *T1, *T2;
getInstructionTypes(I, T1, T2); getInstructionTypes(I, T1, T2);
Context not available.
if (T2->isX86_FP80Ty() || T2->isPPC_FP128Ty() || T2->isX86_MMXTy()) if (T2->isX86_FP80Ty() || T2->isPPC_FP128Ty() || T2->isX86_MMXTy())
return false; return false;
if ((!Config.VectorizePointers || !DL) && if (!Config.VectorizePointers && (T1->getScalarType()->isPointerTy() ||
(T1->getScalarType()->isPointerTy() || T2->getScalarType()->isPointerTy()))
T2->getScalarType()->isPointerTy()))
return false; return false;
if (!TTI && (T1->getPrimitiveSizeInBits() >= Config.VectorBits || if (!TTI && (T1->getPrimitiveSizeInBits() >= Config.VectorBits ||
Context not available.
// An aligned load or store is possible only if the instruction // An aligned load or store is possible only if the instruction
// with the lower offset has an alignment suitable for the // with the lower offset has an alignment suitable for the
// vector type. // vector type.
const DataLayout &DL = I->getModule()->getDataLayout();
unsigned VecAlignment = DL->getPrefTypeAlignment(VType); unsigned VecAlignment = DL.getPrefTypeAlignment(VType);
if (BottomAlignment < VecAlignment) if (BottomAlignment < VecAlignment)
return false; return false;
} }
Context not available.

lib/Transforms/Vectorize/LoopVectorize.cpp

Context not available.
class InnerLoopVectorizer { class InnerLoopVectorizer {
public: public:
InnerLoopVectorizer(Loop *OrigLoop, ScalarEvolution *SE, LoopInfo *LI, InnerLoopVectorizer(Loop *OrigLoop, ScalarEvolution *SE, LoopInfo *LI,
DominatorTree *DT, const DataLayout *DL, DominatorTree *DT, const TargetLibraryInfo *TLI,
const TargetLibraryInfo *TLI, unsigned VecWidth, unsigned VecWidth, unsigned UnrollFactor)
unsigned UnrollFactor) : OrigLoop(OrigLoop), SE(SE), LI(LI), DT(DT), TLI(TLI), VF(VecWidth),
: OrigLoop(OrigLoop), SE(SE), LI(LI), DT(DT), DL(DL), TLI(TLI), UF(UnrollFactor), Builder(SE->getContext()), Induction(nullptr),
VF(VecWidth), UF(UnrollFactor), Builder(SE->getContext()), OldInduction(nullptr), WidenMap(UnrollFactor), Legal(nullptr) {}
Induction(nullptr), OldInduction(nullptr), WidenMap(UnrollFactor),
Legal(nullptr) {}
// Perform the actual loop widening (vectorization). // Perform the actual loop widening (vectorization).
void vectorize(LoopVectorizationLegality *L) { void vectorize(LoopVectorizationLegality *L) {
Context not available.
DominatorTree *DT; DominatorTree *DT;
/// Alias Analysis. /// Alias Analysis.
AliasAnalysis *AA; AliasAnalysis *AA;
/// Data Layout.
const DataLayout *DL;
/// Target Library Info. /// Target Library Info.
const TargetLibraryInfo *TLI; const TargetLibraryInfo *TLI;
Context not available.
class InnerLoopUnroller : public InnerLoopVectorizer { class InnerLoopUnroller : public InnerLoopVectorizer {
public: public:
InnerLoopUnroller(Loop *OrigLoop, ScalarEvolution *SE, LoopInfo *LI, InnerLoopUnroller(Loop *OrigLoop, ScalarEvolution *SE, LoopInfo *LI,
DominatorTree *DT, const DataLayout *DL, DominatorTree *DT, const TargetLibraryInfo *TLI,
const TargetLibraryInfo *TLI, unsigned UnrollFactor) : unsigned UnrollFactor)
InnerLoopVectorizer(OrigLoop, SE, LI, DT, DL, TLI, 1, UnrollFactor) { } : InnerLoopVectorizer(OrigLoop, SE, LI, DT, TLI, 1, UnrollFactor) {}
private: private:
void scalarizeInstruction(Instruction *Instr, void scalarizeInstruction(Instruction *Instr,
Context not available.
/// induction variable and the different reduction variables. /// induction variable and the different reduction variables.
class LoopVectorizationLegality { class LoopVectorizationLegality {
public: public:
LoopVectorizationLegality(Loop *L, ScalarEvolution *SE, const DataLayout *DL, LoopVectorizationLegality(Loop *L, ScalarEvolution *SE, DominatorTree *DT,
DominatorTree *DT, TargetLibraryInfo *TLI, TargetLibraryInfo *TLI, AliasAnalysis *AA,
AliasAnalysis *AA, Function *F, Function *F, const TargetTransformInfo *TTI,
const TargetTransformInfo *TTI,
LoopAccessAnalysis *LAA) LoopAccessAnalysis *LAA)
: NumPredStores(0), TheLoop(L), SE(SE), DL(DL), : NumPredStores(0), TheLoop(L), SE(SE), TLI(TLI), TheFunction(F),
TLI(TLI), TheFunction(F), TTI(TTI), DT(DT), LAA(LAA), LAI(nullptr), TTI(TTI), DT(DT), LAA(LAA), LAI(nullptr), Induction(nullptr),
Induction(nullptr), WidestIndTy(nullptr), HasFunNoNaNAttr(false) {} WidestIndTy(nullptr), HasFunNoNaNAttr(false) {}
/// This enum represents the kinds of reductions that we support. /// This enum represents the kinds of reductions that we support.
enum ReductionKind { enum ReductionKind {
Context not available.
Loop *TheLoop; Loop *TheLoop;
/// Scev analysis. /// Scev analysis.
ScalarEvolution *SE; ScalarEvolution *SE;
/// DataLayout analysis.
const DataLayout *DL;
/// Target Library Info. /// Target Library Info.
TargetLibraryInfo *TLI; TargetLibraryInfo *TLI;
/// Parent function /// Parent function
Context not available.
LoopVectorizationCostModel(Loop *L, ScalarEvolution *SE, LoopInfo *LI, LoopVectorizationCostModel(Loop *L, ScalarEvolution *SE, LoopInfo *LI,
LoopVectorizationLegality *Legal, LoopVectorizationLegality *Legal,
const TargetTransformInfo &TTI, const TargetTransformInfo &TTI,
const DataLayout *DL, const TargetLibraryInfo *TLI, const TargetLibraryInfo *TLI, AssumptionCache *AC,
AssumptionCache *AC, const Function *F, const Function *F, const LoopVectorizeHints *Hints)
const LoopVectorizeHints *Hints) : TheLoop(L), SE(SE), LI(LI), Legal(Legal), TTI(TTI), TLI(TLI),
: TheLoop(L), SE(SE), LI(LI), Legal(Legal), TTI(TTI), DL(DL), TLI(TLI),
TheFunction(F), Hints(Hints) { TheFunction(F), Hints(Hints) {
CodeMetrics::collectEphemeralValues(L, AC, EphValues); CodeMetrics::collectEphemeralValues(L, AC, EphValues);
} }
Context not available.
LoopVectorizationLegality *Legal; LoopVectorizationLegality *Legal;
/// Vector target information. /// Vector target information.
const TargetTransformInfo &TTI; const TargetTransformInfo &TTI;
/// Target data layout information.
const DataLayout *DL;
/// Target Library Info. /// Target Library Info.
const TargetLibraryInfo *TLI; const TargetLibraryInfo *TLI;
const Function *TheFunction; const Function *TheFunction;
Context not available.
} }
ScalarEvolution *SE; ScalarEvolution *SE;
const DataLayout *DL;
LoopInfo *LI; LoopInfo *LI;
TargetTransformInfo *TTI; TargetTransformInfo *TTI;
DominatorTree *DT; DominatorTree *DT;
Context not available.
bool runOnFunction(Function &F) override { bool runOnFunction(Function &F) override {
SE = &getAnalysis<ScalarEvolution>(); SE = &getAnalysis<ScalarEvolution>();
DL = &F.getParent()->getDataLayout();
LI = &getAnalysis<LoopInfoWrapperPass>().getLoopInfo(); LI = &getAnalysis<LoopInfoWrapperPass>().getLoopInfo();
TTI = &getAnalysis<TargetTransformInfoWrapperPass>().getTTI(F); TTI = &getAnalysis<TargetTransformInfoWrapperPass>().getTTI(F);
DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree(); DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
Context not available.
if (!TTI->getNumberOfRegisters(true)) if (!TTI->getNumberOfRegisters(true))
return false; return false;
if (!DL) {
DEBUG(dbgs() << "\nLV: Not vectorizing " << F.getName()
<< ": Missing data layout\n");
return false;
}
// Build up a worklist of inner-loops to vectorize. This is necessary as // Build up a worklist of inner-loops to vectorize. This is necessary as
// the act of vectorizing or partially unrolling a loop creates new loops // the act of vectorizing or partially unrolling a loop creates new loops
// and can invalidate iterators across the loops. // and can invalidate iterators across the loops.
Context not available.
} }
// Check if it is legal to vectorize the loop. // Check if it is legal to vectorize the loop.
LoopVectorizationLegality LVL(L, SE, DL, DT, TLI, AA, F, TTI, LAA); LoopVectorizationLegality LVL(L, SE, DT, TLI, AA, F, TTI, LAA);
if (!LVL.canVectorize()) { if (!LVL.canVectorize()) {
DEBUG(dbgs() << "LV: Not vectorizing: Cannot prove legality.\n"); DEBUG(dbgs() << "LV: Not vectorizing: Cannot prove legality.\n");
emitMissedWarning(F, L, Hints); emitMissedWarning(F, L, Hints);
Context not available.
} }
// Use the cost model. // Use the cost model.
LoopVectorizationCostModel CM(L, SE, LI, &LVL, *TTI, DL, TLI, AC, F, LoopVectorizationCostModel CM(L, SE, LI, &LVL, *TTI, TLI, AC, F, &Hints);
&Hints);
// Check the function attributes to find out if this function should be // Check the function attributes to find out if this function should be
// optimized for size. // optimized for size.
Context not available.
// We decided not to vectorize, but we may want to unroll. // We decided not to vectorize, but we may want to unroll.
InnerLoopUnroller Unroller(L, SE, LI, DT, DL, TLI, UF); InnerLoopUnroller Unroller(L, SE, LI, DT, TLI, UF);
Unroller.vectorize(&LVL); Unroller.vectorize(&LVL);
} else { } else {
// If we decided that it is *legal* to vectorize the loop then do it. // If we decided that it is *legal* to vectorize the loop then do it.
InnerLoopVectorizer LB(L, SE, LI, DT, DL, TLI, VF.Width, UF); InnerLoopVectorizer LB(L, SE, LI, DT, TLI, VF.Width, UF);
LB.vectorize(&LVL); LB.vectorize(&LVL);
++LoopsVectorized; ++LoopsVectorized;
Context not available.
/// \brief Find the operand of the GEP that should be checked for consecutive /// \brief Find the operand of the GEP that should be checked for consecutive
/// stores. This ignores trailing indices that have no effect on the final /// stores. This ignores trailing indices that have no effect on the final
/// pointer. /// pointer.
static unsigned getGEPInductionOperand(const DataLayout *DL, static unsigned getGEPInductionOperand(const GetElementPtrInst *Gep) {
const GetElementPtrInst *Gep) { const DataLayout &DL = Gep->getModule()->getDataLayout();
unsigned LastOperand = Gep->getNumOperands() - 1; unsigned LastOperand = Gep->getNumOperands() - 1;
unsigned GEPAllocSize = DL->getTypeAllocSize( unsigned GEPAllocSize = DL.getTypeAllocSize(
cast<PointerType>(Gep->getType()->getScalarType())->getElementType()); cast<PointerType>(Gep->getType()->getScalarType())->getElementType());
// Walk backwards and try to peel off zeros. // Walk backwards and try to peel off zeros.
Context not available.
// If it's a type with the same allocation size as the result of the GEP we // If it's a type with the same allocation size as the result of the GEP we
// can peel off the zero index. // can peel off the zero index.
if (DL->getTypeAllocSize(*GEPTI) != GEPAllocSize) if (DL.getTypeAllocSize(*GEPTI) != GEPAllocSize)
break; break;
--LastOperand; --LastOperand;
} }
Context not available.
return II.getConsecutiveDirection(); return II.getConsecutiveDirection();
} }
unsigned InductionOperand = getGEPInductionOperand(DL, Gep); unsigned InductionOperand = getGEPInductionOperand(Gep);
// Check that all of the gep indices are uniform except for our induction // Check that all of the gep indices are uniform except for our induction
// operand. // operand.
Context not available.
unsigned Alignment = LI ? LI->getAlignment() : SI->getAlignment(); unsigned Alignment = LI ? LI->getAlignment() : SI->getAlignment();
// An alignment of 0 means target abi alignment. We need to use the scalar's // An alignment of 0 means target abi alignment. We need to use the scalar's
// target abi alignment in such a case. // target abi alignment in such a case.
const DataLayout &DL = Instr->getModule()->getDataLayout();
if (!Alignment) if (!Alignment)
Alignment = DL->getABITypeAlignment(ScalarDataTy); Alignment = DL.getABITypeAlignment(ScalarDataTy);
unsigned AddressSpace = Ptr->getType()->getPointerAddressSpace(); unsigned AddressSpace = Ptr->getType()->getPointerAddressSpace();
unsigned ScalarAllocatedSize = DL->getTypeAllocSize(ScalarDataTy); unsigned ScalarAllocatedSize = DL.getTypeAllocSize(ScalarDataTy);
unsigned VectorElementSize = DL->getTypeStoreSize(DataTy)/VF; unsigned VectorElementSize = DL.getTypeStoreSize(DataTy) / VF;
if (SI && Legal->blockNeedsPredication(SI->getParent()) && if (SI && Legal->blockNeedsPredication(SI->getParent()) &&
!Legal->isMaskRequired(SI)) !Legal->isMaskRequired(SI))
Context not available.
// The last index does not have to be the induction. It can be // The last index does not have to be the induction. It can be
// consecutive and be a function of the index. For example A[I+1]; // consecutive and be a function of the index. For example A[I+1];
unsigned NumOperands = Gep->getNumOperands(); unsigned NumOperands = Gep->getNumOperands();
unsigned InductionOperand = getGEPInductionOperand(DL, Gep); unsigned InductionOperand = getGEPInductionOperand(Gep);
// Create the new GEP with the new induction variable. // Create the new GEP with the new induction variable.
GetElementPtrInst *Gep2 = cast<GetElementPtrInst>(Gep->clone()); GetElementPtrInst *Gep2 = cast<GetElementPtrInst>(Gep->clone());
Context not available.
ExitCount = SE->getAddExpr(BackedgeTakeCount, ExitCount = SE->getAddExpr(BackedgeTakeCount,
SE->getConstant(BackedgeTakeCount->getType(), 1)); SE->getConstant(BackedgeTakeCount->getType(), 1));
const DataLayout &DL = OldBasicBlock->getModule()->getDataLayout();
// Expand the trip count and place the new instructions in the preheader. // Expand the trip count and place the new instructions in the preheader.
// Notice that the pre-header does not change, only the loop body. // Notice that the pre-header does not change, only the loop body.
SCEVExpander Exp(*SE, "induction"); SCEVExpander Exp(*SE, DL, "induction");
// We need to test whether the backedge-taken count is uint##_max. Adding one // We need to test whether the backedge-taken count is uint##_max. Adding one
// to it will cause overflow and an incorrect loop trip count in the vector // to it will cause overflow and an incorrect loop trip count in the vector
Context not available.
// Look for the attribute signaling the absence of NaNs. // Look for the attribute signaling the absence of NaNs.
Function &F = *Header->getParent(); Function &F = *Header->getParent();
const DataLayout &DL = F.getParent()->getDataLayout();
if (F.hasFnAttribute("no-nans-fp-math")) if (F.hasFnAttribute("no-nans-fp-math"))
HasFunNoNaNAttr = HasFunNoNaNAttr =
F.getFnAttribute("no-nans-fp-math").getValueAsString() == "true"; F.getFnAttribute("no-nans-fp-math").getValueAsString() == "true";
Context not available.
if (IK_NoInduction != IK) { if (IK_NoInduction != IK) {
// Get the widest type. // Get the widest type.
if (!WidestIndTy) if (!WidestIndTy)
WidestIndTy = convertPointerToIntegerType(*DL, PhiTy); WidestIndTy = convertPointerToIntegerType(DL, PhiTy);
else else
WidestIndTy = getWiderType(*DL, PhiTy, WidestIndTy); WidestIndTy = getWiderType(DL, PhiTy, WidestIndTy);
// Int inductions are special because we only allow one IV. // Int inductions are special because we only allow one IV.
if (IK == IK_IntInduction && StepValue->isOne()) { if (IK == IK_IntInduction && StepValue->isOne()) {
Context not available.
///\brief Remove GEPs whose indices but the last one are loop invariant and ///\brief Remove GEPs whose indices but the last one are loop invariant and
/// return the induction operand of the gep pointer. /// return the induction operand of the gep pointer.
static Value *stripGetElementPtr(Value *Ptr, ScalarEvolution *SE, static Value *stripGetElementPtr(Value *Ptr, ScalarEvolution *SE, Loop *Lp) {
const DataLayout *DL, Loop *Lp) {
GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(Ptr); GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(Ptr);
if (!GEP) if (!GEP)
return Ptr; return Ptr;
unsigned InductionOperand = getGEPInductionOperand(DL, GEP); unsigned InductionOperand = getGEPInductionOperand(GEP);
// Check that all of the gep indices are uniform except for our induction // Check that all of the gep indices are uniform except for our induction
// operand. // operand.
Context not available.
///\brief Get the stride of a pointer access in a loop. ///\brief Get the stride of a pointer access in a loop.
/// Looks for symbolic strides "a[i*stride]". Returns the symbolic stride as a /// Looks for symbolic strides "a[i*stride]". Returns the symbolic stride as a
/// pointer to the Value, or null otherwise. /// pointer to the Value, or null otherwise.
static Value *getStrideFromPointer(Value *Ptr, ScalarEvolution *SE, static Value *getStrideFromPointer(Value *Ptr, ScalarEvolution *SE, Loop *Lp) {
const DataLayout *DL, Loop *Lp) {
const PointerType *PtrTy = dyn_cast<PointerType>(Ptr->getType()); const PointerType *PtrTy = dyn_cast<PointerType>(Ptr->getType());
if (!PtrTy || PtrTy->isAggregateType()) if (!PtrTy || PtrTy->isAggregateType())
return nullptr; return nullptr;
Context not available.
// The size of the pointer access. // The size of the pointer access.
int64_t PtrAccessSize = 1; int64_t PtrAccessSize = 1;
Ptr = stripGetElementPtr(Ptr, SE, DL, Lp); Ptr = stripGetElementPtr(Ptr, SE, Lp);
const SCEV *V = SE->getSCEV(Ptr); const SCEV *V = SE->getSCEV(Ptr);
if (Ptr != OrigPtr) if (Ptr != OrigPtr)
Context not available.
// Strip off the size of access multiplication if we are still analyzing the // Strip off the size of access multiplication if we are still analyzing the
// pointer. // pointer.
if (OrigPtr == Ptr) { if (OrigPtr == Ptr) {
DL->getTypeAllocSize(PtrTy->getElementType()); const DataLayout &DL = Lp->getHeader()->getModule()->getDataLayout();
DL.getTypeAllocSize(PtrTy->getElementType());
if (const SCEVMulExpr *M = dyn_cast<SCEVMulExpr>(V)) { if (const SCEVMulExpr *M = dyn_cast<SCEVMulExpr>(V)) {
if (M->getOperand(0)->getSCEVType() != scConstant) if (M->getOperand(0)->getSCEVType() != scConstant)
return nullptr; return nullptr;
Context not available.
else else
return; return;
Value *Stride = getStrideFromPointer(Ptr, SE, DL, TheLoop); Value *Stride = getStrideFromPointer(Ptr, SE, TheLoop);
if (!Stride) if (!Stride)
return; return;
Context not available.
if (!PointerElementType->isSized()) if (!PointerElementType->isSized())
return IK_NoInduction; return IK_NoInduction;
int64_t Size = static_cast<int64_t>(DL->getTypeAllocSize(PointerElementType)); const DataLayout &DL = Phi->getModule()->getDataLayout();
int64_t Size = static_cast<int64_t>(DL.getTypeAllocSize(PointerElementType));
int64_t CVSize = CV->getSExtValue(); int64_t CVSize = CV->getSExtValue();
if (CVSize % Size) if (CVSize % Size)
return IK_NoInduction; return IK_NoInduction;
Context not available.
unsigned LoopVectorizationCostModel::getWidestType() { unsigned LoopVectorizationCostModel::getWidestType() {
unsigned MaxWidth = 8; unsigned MaxWidth = 8;
const DataLayout &DL = TheFunction->getParent()->getDataLayout();
// For each block. // For each block.
for (Loop::block_iterator bb = TheLoop->block_begin(), for (Loop::block_iterator bb = TheLoop->block_begin(),
Context not available.
continue; continue;
MaxWidth = std::max(MaxWidth, MaxWidth = std::max(MaxWidth,
(unsigned)DL->getTypeSizeInBits(T->getScalarType())); (unsigned)DL.getTypeSizeInBits(T->getScalarType()));
} }
} }
Context not available.
// Scalarized loads/stores. // Scalarized loads/stores.
int ConsecutiveStride = Legal->isConsecutivePtr(Ptr); int ConsecutiveStride = Legal->isConsecutivePtr(Ptr);
bool Reverse = ConsecutiveStride < 0; bool Reverse = ConsecutiveStride < 0;
unsigned ScalarAllocatedSize = DL->getTypeAllocSize(ValTy); const DataLayout &DL = I->getModule()->getDataLayout();
unsigned VectorElementSize = DL->getTypeStoreSize(VectorTy)/VF; unsigned ScalarAllocatedSize = DL.getTypeAllocSize(ValTy);
unsigned VectorElementSize = DL.getTypeStoreSize(VectorTy) / VF;
if (!ConsecutiveStride || ScalarAllocatedSize != VectorElementSize) { if (!ConsecutiveStride || ScalarAllocatedSize != VectorElementSize) {
bool IsComplexComputation = bool IsComplexComputation =
isLikelyComplexAddressComputation(Ptr, Legal, SE, TheLoop); isLikelyComplexAddressComputation(Ptr, Legal, SE, TheLoop);
Context not available.

lib/Transforms/Vectorize/SLPVectorizer.cpp

Context not available.
typedef SmallPtrSet<Value *, 16> ValueSet; typedef SmallPtrSet<Value *, 16> ValueSet;
typedef SmallVector<StoreInst *, 8> StoreList; typedef SmallVector<StoreInst *, 8> StoreList;
BoUpSLP(Function *Func, ScalarEvolution *Se, const DataLayout *Dl, BoUpSLP(Function *Func, ScalarEvolution *Se, TargetTransformInfo *Tti,
TargetTransformInfo *Tti, TargetLibraryInfo *TLi, AliasAnalysis *Aa, TargetLibraryInfo *TLi, AliasAnalysis *Aa, LoopInfo *Li,
LoopInfo *Li, DominatorTree *Dt, AssumptionCache *AC) DominatorTree *Dt, AssumptionCache *AC)
: NumLoadsWantToKeepOrder(0), NumLoadsWantToChangeOrder(0), F(Func), : NumLoadsWantToKeepOrder(0), NumLoadsWantToChangeOrder(0), F(Func),
SE(Se), DL(Dl), TTI(Tti), TLI(TLi), AA(Aa), LI(Li), DT(Dt), SE(Se), TTI(Tti), TLI(TLi), AA(Aa), LI(Li), DT(Dt),
Builder(Se->getContext()) { Builder(Se->getContext()) {
CodeMetrics::collectEphemeralValues(F, AC, EphValues); CodeMetrics::collectEphemeralValues(F, AC, EphValues);
} }
Context not available.
} }
/// \returns true if the memory operations A and B are consecutive. /// \returns true if the memory operations A and B are consecutive.
bool isConsecutiveAccess(Value *A, Value *B); bool isConsecutiveAccess(Value *A, Value *B, const DataLayout &DL);
/// \brief Perform LICM and CSE on the newly generated gather sequences. /// \brief Perform LICM and CSE on the newly generated gather sequences.
void optimizeGatherSequence(); void optimizeGatherSequence();
Context not available.
// Analysis and block reference. // Analysis and block reference.
Function *F; Function *F;
ScalarEvolution *SE; ScalarEvolution *SE;
const DataLayout *DL;
TargetTransformInfo *TTI; TargetTransformInfo *TTI;
TargetLibraryInfo *TLI; TargetLibraryInfo *TLI;
AliasAnalysis *AA; AliasAnalysis *AA;
Context not available.
DEBUG(dbgs() << "SLP: Gathering non-simple loads.\n"); DEBUG(dbgs() << "SLP: Gathering non-simple loads.\n");
return; return;
} }
if (!isConsecutiveAccess(VL[i], VL[i + 1])) { const DataLayout &DL = F->getParent()->getDataLayout();
if (VL.size() == 2 && isConsecutiveAccess(VL[1], VL[0])) { if (!isConsecutiveAccess(VL[i], VL[i + 1], DL)) {
if (VL.size() == 2 && isConsecutiveAccess(VL[1], VL[0], DL)) {
++NumLoadsWantToChangeOrder; ++NumLoadsWantToChangeOrder;
} }
BS.cancelScheduling(VL); BS.cancelScheduling(VL);
Context not available.
return; return;
} }
case Instruction::Store: { case Instruction::Store: {
const DataLayout &DL = F->getParent()->getDataLayout();
// Check if the stores are consecutive or of we need to swizzle them. // Check if the stores are consecutive or of we need to swizzle them.
for (unsigned i = 0, e = VL.size() - 1; i < e; ++i) for (unsigned i = 0, e = VL.size() - 1; i < e; ++i)
if (!isConsecutiveAccess(VL[i], VL[i + 1])) { if (!isConsecutiveAccess(VL[i], VL[i + 1], DL)) {
BS.cancelScheduling(VL); BS.cancelScheduling(VL);
newTreeEntry(VL, false); newTreeEntry(VL, false);
DEBUG(dbgs() << "SLP: Non-consecutive store.\n"); DEBUG(dbgs() << "SLP: Non-consecutive store.\n");
Context not available.
return -1; return -1;
} }
bool BoUpSLP::isConsecutiveAccess(Value *A, Value *B) { bool BoUpSLP::isConsecutiveAccess(Value *A, Value *B, const DataLayout &DL) {
Value *PtrA = getPointerOperand(A); Value *PtrA = getPointerOperand(A);
Value *PtrB = getPointerOperand(B); Value *PtrB = getPointerOperand(B);
unsigned ASA = getAddressSpaceOperand(A); unsigned ASA = getAddressSpaceOperand(A);
Context not available.
if (PtrA == PtrB || PtrA->getType() != PtrB->getType()) if (PtrA == PtrB || PtrA->getType() != PtrB->getType())
return false; return false;
unsigned PtrBitWidth = DL->getPointerSizeInBits(ASA); unsigned PtrBitWidth = DL.getPointerSizeInBits(ASA);
Type *Ty = cast<PointerType>(PtrA->getType())->getElementType(); Type *Ty = cast<PointerType>(PtrA->getType())->getElementType();
APInt Size(PtrBitWidth, DL->getTypeStoreSize(Ty)); APInt Size(PtrBitWidth, DL.getTypeStoreSize(Ty));
APInt OffsetA(PtrBitWidth, 0), OffsetB(PtrBitWidth, 0); APInt OffsetA(PtrBitWidth, 0), OffsetB(PtrBitWidth, 0);
PtrA = PtrA->stripAndAccumulateInBoundsConstantOffsets(*DL, OffsetA); PtrA = PtrA->stripAndAccumulateInBoundsConstantOffsets(DL, OffsetA);
PtrB = PtrB->stripAndAccumulateInBoundsConstantOffsets(*DL, OffsetB); PtrB = PtrB->stripAndAccumulateInBoundsConstantOffsets(DL, OffsetB);
APInt OffsetDelta = OffsetB - OffsetA; APInt OffsetDelta = OffsetB - OffsetA;
Context not available.
void BoUpSLP::reorderAltShuffleOperands(ArrayRef<Value *> VL, void BoUpSLP::reorderAltShuffleOperands(ArrayRef<Value *> VL,
SmallVectorImpl<Value *> &Left, SmallVectorImpl<Value *> &Left,
SmallVectorImpl<Value *> &Right) { SmallVectorImpl<Value *> &Right) {
const DataLayout &DL = F->getParent()->getDataLayout();
// Push left and right operands of binary operation into Left and Right // Push left and right operands of binary operation into Left and Right
for (unsigned i = 0, e = VL.size(); i < e; ++i) { for (unsigned i = 0, e = VL.size(); i < e; ++i) {
Context not available.
if (LoadInst *L1 = dyn_cast<LoadInst>(Right[j + 1])) { if (LoadInst *L1 = dyn_cast<LoadInst>(Right[j + 1])) {
Instruction *VL1 = cast<Instruction>(VL[j]); Instruction *VL1 = cast<Instruction>(VL[j]);
Instruction *VL2 = cast<Instruction>(VL[j + 1]); Instruction *VL2 = cast<Instruction>(VL[j + 1]);
if (isConsecutiveAccess(L, L1) && VL1->isCommutative()) { if (isConsecutiveAccess(L, L1, DL) && VL1->isCommutative()) {
std::swap(Left[j], Right[j]); std::swap(Left[j], Right[j]);
continue; continue;
} else if (isConsecutiveAccess(L, L1) && VL2->isCommutative()) { } else if (isConsecutiveAccess(L, L1, DL) && VL2->isCommutative()) {
std::swap(Left[j + 1], Right[j + 1]); std::swap(Left[j + 1], Right[j + 1]);
continue; continue;
} }
Context not available.
if (LoadInst *L1 = dyn_cast<LoadInst>(Left[j + 1])) { if (LoadInst *L1 = dyn_cast<LoadInst>(Left[j + 1])) {
Instruction *VL1 = cast<Instruction>(VL[j]); Instruction *VL1 = cast<Instruction>(VL[j]);
Instruction *VL2 = cast<Instruction>(VL[j + 1]); Instruction *VL2 = cast<Instruction>(VL[j + 1]);
if (isConsecutiveAccess(L, L1) && VL1->isCommutative()) { if (isConsecutiveAccess(L, L1, DL) && VL1->isCommutative()) {
std::swap(Left[j], Right[j]); std::swap(Left[j], Right[j]);
continue; continue;
} else if (isConsecutiveAccess(L, L1) && VL2->isCommutative()) { } else if (isConsecutiveAccess(L, L1, DL) && VL2->isCommutative()) {
std::swap(Left[j + 1], Right[j + 1]); std::swap(Left[j + 1], Right[j + 1]);
continue; continue;
} }
Context not available.
Right = OrigRight; Right = OrigRight;
} }
const DataLayout &DL = F->getParent()->getDataLayout();
// Finally check if we can get longer vectorizable chain by reordering // Finally check if we can get longer vectorizable chain by reordering
// without breaking the good operand order detected above. // without breaking the good operand order detected above.
// E.g. If we have something like- // E.g. If we have something like-
Context not available.
for (unsigned j = 0; j < VL.size() - 1; ++j) { for (unsigned j = 0; j < VL.size() - 1; ++j) {
if (LoadInst *L = dyn_cast<LoadInst>(Left[j])) { if (LoadInst *L = dyn_cast<LoadInst>(Left[j])) {
if (LoadInst *L1 = dyn_cast<LoadInst>(Right[j + 1])) { if (LoadInst *L1 = dyn_cast<LoadInst>(Right[j + 1])) {
if (isConsecutiveAccess(L, L1)) { if (isConsecutiveAccess(L, L1, DL)) {
std::swap(Left[j + 1], Right[j + 1]); std::swap(Left[j + 1], Right[j + 1]);
continue; continue;
} }
Context not available.
} }
if (LoadInst *L = dyn_cast<LoadInst>(Right[j])) { if (LoadInst *L = dyn_cast<LoadInst>(Right[j])) {
if (LoadInst *L1 = dyn_cast<LoadInst>(Left[j + 1])) { if (LoadInst *L1 = dyn_cast<LoadInst>(Left[j + 1])) {
if (isConsecutiveAccess(L, L1)) { if (isConsecutiveAccess(L, L1, DL)) {
std::swap(Left[j + 1], Right[j + 1]); std::swap(Left[j + 1], Right[j + 1]);
continue; continue;
} }
Context not available.
return Gather(E->Scalars, VecTy); return Gather(E->Scalars, VecTy);
} }
const DataLayout &DL = F->getParent()->getDataLayout();
unsigned Opcode = getSameOpcode(E->Scalars); unsigned Opcode = getSameOpcode(E->Scalars);
switch (Opcode) { switch (Opcode) {
Context not available.
unsigned Alignment = LI->getAlignment(); unsigned Alignment = LI->getAlignment();
LI = Builder.CreateLoad(VecPtr); LI = Builder.CreateLoad(VecPtr);
if (!Alignment) if (!Alignment) {
Alignment = DL->getABITypeAlignment(ScalarLoadTy); Alignment = DL.getABITypeAlignment(ScalarLoadTy);
}
LI->setAlignment(Alignment); LI->setAlignment(Alignment);
E->VectorizedValue = LI; E->VectorizedValue = LI;
++NumVectorInstructions; ++NumVectorInstructions;
Context not available.
ExternalUses.push_back( ExternalUses.push_back(
ExternalUser(SI->getPointerOperand(), cast<User>(VecPtr), 0)); ExternalUser(SI->getPointerOperand(), cast<User>(VecPtr), 0));
if (!Alignment) if (!Alignment) {
Alignment = DL->getABITypeAlignment(SI->getValueOperand()->getType()); Alignment = DL.getABITypeAlignment(SI->getValueOperand()->getType());
}
S->setAlignment(Alignment); S->setAlignment(Alignment);
E->VectorizedValue = S; E->VectorizedValue = S;
++NumVectorInstructions; ++NumVectorInstructions;
Context not available.
} }
ScalarEvolution *SE; ScalarEvolution *SE;
const DataLayout *DL;
TargetTransformInfo *TTI; TargetTransformInfo *TTI;
TargetLibraryInfo *TLI; TargetLibraryInfo *TLI;
AliasAnalysis *AA; AliasAnalysis *AA;
Context not available.
return false; return false;
SE = &getAnalysis<ScalarEvolution>(); SE = &getAnalysis<ScalarEvolution>();
DL = &F.getParent()->getDataLayout();
TTI = &getAnalysis<TargetTransformInfoWrapperPass>().getTTI(F); TTI = &getAnalysis<TargetTransformInfoWrapperPass>().getTTI(F);
auto *TLIP = getAnalysisIfAvailable<TargetLibraryInfoWrapperPass>(); auto *TLIP = getAnalysisIfAvailable<TargetLibraryInfoWrapperPass>();
TLI = TLIP ? &TLIP->getTLI() : nullptr; TLI = TLIP ? &TLIP->getTLI() : nullptr;
Context not available.
if (!TTI->getNumberOfRegisters(true)) if (!TTI->getNumberOfRegisters(true))
return false; return false;
// Must have DataLayout. We can't require it because some tests run w/o
// triple.
if (!DL)
return false;
// Don't vectorize when the attribute NoImplicitFloat is used. // Don't vectorize when the attribute NoImplicitFloat is used.
if (F.hasFnAttribute(Attribute::NoImplicitFloat)) if (F.hasFnAttribute(Attribute::NoImplicitFloat))
return false; return false;
Context not available.
// Use the bottom up slp vectorizer to construct chains that start with // Use the bottom up slp vectorizer to construct chains that start with
// store instructions. // store instructions.
BoUpSLP R(&F, SE, DL, TTI, TLI, AA, LI, DT, AC); BoUpSLP R(&F, SE, TTI, TLI, AA, LI, DT, AC);
// A general note: the vectorizer must use BoUpSLP::eraseInstruction() to // A general note: the vectorizer must use BoUpSLP::eraseInstruction() to
// delete instructions. // delete instructions.
Context not available.
DEBUG(dbgs() << "SLP: Analyzing a store chain of length " << ChainLen DEBUG(dbgs() << "SLP: Analyzing a store chain of length " << ChainLen
<< "\n"); << "\n");
Type *StoreTy = cast<StoreInst>(Chain[0])->getValueOperand()->getType(); Type *StoreTy = cast<StoreInst>(Chain[0])->getValueOperand()->getType();
unsigned Sz = DL->getTypeSizeInBits(StoreTy); auto &DL = cast<StoreInst>(Chain[0])->getModule()->getDataLayout();
unsigned Sz = DL.getTypeSizeInBits(StoreTy);
unsigned VF = MinVecRegSize / Sz; unsigned VF = MinVecRegSize / Sz;
if (!isPowerOf2_32(Sz) || VF < 2) if (!isPowerOf2_32(Sz) || VF < 2)
Context not available.
bool SLPVectorizer::vectorizeStores(ArrayRef<StoreInst *> Stores, bool SLPVectorizer::vectorizeStores(ArrayRef<StoreInst *> Stores,
int costThreshold, BoUpSLP &R) { int costThreshold, BoUpSLP &R) {
SetVector<Value *> Heads, Tails; SetVector<StoreInst *> Heads, Tails;
SmallDenseMap<Value *, Value *> ConsecutiveChain; SmallDenseMap<StoreInst *, StoreInst *> ConsecutiveChain;
// We may run into multiple chains that merge into a single chain. We mark the // We may run into multiple chains that merge into a single chain. We mark the
// stores that we vectorized so that we don't visit the same store twice. // stores that we vectorized so that we don't visit the same store twice.
Context not available.
for (unsigned j = 0; j < e; ++j) { for (unsigned j = 0; j < e; ++j) {
if (i == j) if (i == j)
continue; continue;
const DataLayout &DL = Stores[i]->getModule()->getDataLayout();
if (R.isConsecutiveAccess(Stores[i], Stores[j])) { if (R.isConsecutiveAccess(Stores[i], Stores[j], DL)) {
Tails.insert(Stores[j]); Tails.insert(Stores[j]);
Heads.insert(Stores[i]); Heads.insert(Stores[i]);
ConsecutiveChain[Stores[i]] = Stores[j]; ConsecutiveChain[Stores[i]] = Stores[j];
Context not available.
} }
// For stores that start but don't end a link in the chain: // For stores that start but don't end a link in the chain:
for (SetVector<Value *>::iterator it = Heads.begin(), e = Heads.end(); for (SetVector<StoreInst *>::iterator it = Heads.begin(), e = Heads.end();
it != e; ++it) { it != e; ++it) {
if (Tails.count(*it)) if (Tails.count(*it))
continue; continue;
Context not available.
// We found a store instr that starts a chain. Now follow the chain and try // We found a store instr that starts a chain. Now follow the chain and try
// to vectorize it. // to vectorize it.
BoUpSLP::ValueList Operands; BoUpSLP::ValueList Operands;
Value *I = *it; StoreInst *I = *it;
// Collect the chain into a list. // Collect the chain into a list.
while (Tails.count(I) || Heads.count(I)) { while (Tails.count(I) || Heads.count(I)) {
if (VectorizedStores.count(I)) if (VectorizedStores.count(I))
Context not available.
unsigned SLPVectorizer::collectStores(BasicBlock *BB, BoUpSLP &R) { unsigned SLPVectorizer::collectStores(BasicBlock *BB, BoUpSLP &R) {
unsigned count = 0; unsigned count = 0;
StoreRefs.clear(); StoreRefs.clear();
const DataLayout &DL = BB->getModule()->getDataLayout();
for (BasicBlock::iterator it = BB->begin(), e = BB->end(); it != e; ++it) { for (BasicBlock::iterator it = BB->begin(), e = BB->end(); it != e; ++it) {
StoreInst *SI = dyn_cast<StoreInst>(it); StoreInst *SI = dyn_cast<StoreInst>(it);
if (!SI) if (!SI)
Context not available.
return false; return false;
unsigned Opcode0 = I0->getOpcode(); unsigned Opcode0 = I0->getOpcode();
const DataLayout &DL = I0->getModule()->getDataLayout();
Type *Ty0 = I0->getType(); Type *Ty0 = I0->getType();
unsigned Sz = DL->getTypeSizeInBits(Ty0); unsigned Sz = DL.getTypeSizeInBits(Ty0);
unsigned VF = MinVecRegSize / Sz; unsigned VF = MinVecRegSize / Sz;
for (int i = 0, e = VL.size(); i < e; ++i) { for (int i = 0, e = VL.size(); i < e; ++i) {
Context not available.
ReducedValueOpcode(0), ReduxWidth(0), IsPairwiseReduction(false) {} ReducedValueOpcode(0), ReduxWidth(0), IsPairwiseReduction(false) {}
/// \brief Try to find a reduction tree. /// \brief Try to find a reduction tree.
bool matchAssociativeReduction(PHINode *Phi, BinaryOperator *B, bool matchAssociativeReduction(PHINode *Phi, BinaryOperator *B) {
const DataLayout *DL) {
assert((!Phi || assert((!Phi ||
std::find(Phi->op_begin(), Phi->op_end(), B) != Phi->op_end()) && std::find(Phi->op_begin(), Phi->op_end(), B) != Phi->op_end()) &&
"Thi phi needs to use the binary operator"); "Thi phi needs to use the binary operator");
Context not available.
if (!isValidElementType(Ty)) if (!isValidElementType(Ty))
return false; return false;
const DataLayout &DL = B->getModule()->getDataLayout();
ReductionOpcode = B->getOpcode(); ReductionOpcode = B->getOpcode();
ReducedValueOpcode = 0; ReducedValueOpcode = 0;
ReduxWidth = MinVecRegSize / DL->getTypeSizeInBits(Ty); ReduxWidth = MinVecRegSize / DL.getTypeSizeInBits(Ty);
ReductionRoot = B; ReductionRoot = B;
ReductionPHI = Phi; ReductionPHI = Phi;
Context not available.
// Try to match and vectorize a horizontal reduction. // Try to match and vectorize a horizontal reduction.
HorizontalReduction HorRdx; HorizontalReduction HorRdx;
if (ShouldVectorizeHor && if (ShouldVectorizeHor && HorRdx.matchAssociativeReduction(P, BI) &&
HorRdx.matchAssociativeReduction(P, BI, DL) &&
HorRdx.tryToReduce(R, TTI)) { HorRdx.tryToReduce(R, TTI)) {
Changed = true; Changed = true;
it = BB->begin(); it = BB->begin();
Context not available.
if (BinaryOperator *BinOp = if (BinaryOperator *BinOp =
dyn_cast<BinaryOperator>(SI->getValueOperand())) { dyn_cast<BinaryOperator>(SI->getValueOperand())) {
HorizontalReduction HorRdx; HorizontalReduction HorRdx;
if (((HorRdx.matchAssociativeReduction(nullptr, BinOp, DL) && if (((HorRdx.matchAssociativeReduction(nullptr, BinOp) &&
HorRdx.tryToReduce(R, TTI)) || HorRdx.tryToReduce(R, TTI)) ||
tryToVectorize(BinOp, R))) { tryToVectorize(BinOp, R))) {
Changed = true; Changed = true;
Context not available.

unittests/IR/IRBuilderTest.cpp

Context not available.
EXPECT_EQ(Ty1, IntegerType::get(Ctx, 1)); EXPECT_EQ(Ty1, IntegerType::get(Ctx, 1));
DataLayout* DL = new DataLayout(M.get()); DataLayout* DL = new DataLayout(M.get());
IntegerType *IntPtrTy = Builder.getIntPtrTy(DL); IntegerType *IntPtrTy = Builder.getIntPtrTy(*DL);
unsigned IntPtrBitSize = DL->getPointerSizeInBits(0); unsigned IntPtrBitSize = DL->getPointerSizeInBits(0);
EXPECT_EQ(IntPtrTy, IntegerType::get(Ctx, IntPtrBitSize)); EXPECT_EQ(IntPtrTy, IntegerType::get(Ctx, IntPtrBitSize));
delete DL; delete DL;
Context not available.

unittests/IR/InstructionsTest.cpp

Context not available.
"2:32:32-f64:64:64-v64:64:64-v128:128:128-a:0:64-s:64:64-f80" "2:32:32-f64:64:64-v64:64:64-v128:128:128-a:0:64-s:64:64-f80"
":128:128-n8:16:32:64-S128"); ":128:128-n8:16:32:64-S128");
// Make sure we don't crash // Make sure we don't crash
GetPointerBaseWithConstantOffset(Gep0, Offset, &TD); GetPointerBaseWithConstantOffset(Gep0, Offset, TD);
GetPointerBaseWithConstantOffset(Gep1, Offset, &TD); GetPointerBaseWithConstantOffset(Gep1, Offset, TD);
GetPointerBaseWithConstantOffset(Gep2, Offset, &TD); GetPointerBaseWithConstantOffset(Gep2, Offset, TD);
GetPointerBaseWithConstantOffset(Gep3, Offset, &TD); GetPointerBaseWithConstantOffset(Gep3, Offset, TD);
// Gep of Geps // Gep of Geps
GetElementPtrInst *GepII0 = GetElementPtrInst::Create(Gep0, C2xi32b); GetElementPtrInst *GepII0 = GetElementPtrInst::Create(Gep0, C2xi32b);
Context not available.