InferAlignment.cpp Source File (original) (raw)

27using namespace llvm;

38 Align NewAlign = Fn(PtrOp, OldAlign, PrefAlign);

39 if (NewAlign > OldAlign) {

41 return true;

42 }

43 }

46 const APInt *Const;

49 if (Const->ult(ActualAlign.value())) {

51 return true;

52 }

53 }

56 if ()

57 return false;

60 switch (II->getIntrinsicID()) {

61 case Intrinsic::masked_load:

62 case Intrinsic::masked_store: {

63 unsigned PtrOpIdx = II->getIntrinsicID() == Intrinsic::masked_load ? 0 : 1;

64 Value *PtrOp = II->getArgOperand(PtrOpIdx);

65 Type *Type = II->getIntrinsicID() == Intrinsic::masked_load

66 ? II->getType()

67 : II->getArgOperand(0)->getType();

69 Align OldAlign = II->getParamAlign(PtrOpIdx).valueOrOne();

70 Align PrefAlign = DL.getPrefTypeAlign(Type);

71 Align NewAlign = Fn(PtrOp, OldAlign, PrefAlign);

72 if (NewAlign <= OldAlign)

73 return false;

75 II->addParamAttr(PtrOpIdx,

77 return true;

78 }

79 default:

80 return false;

81 }

82}

94 if (PrefAlign > OldAlign)

95 return std::max(OldAlign,

97 return OldAlign;

98 });

99 }

100 }

101

102

105 unsigned TrailZ =

107 return Align(1ull << std::min(Known.getBitWidth() - 1, TrailZ));

108 };

109

110

111

113 auto InferFromBasePointer = [&](Value *PtrOp, Align LoadStoreAlign) {

114 APInt OffsetFromBase(DL.getIndexTypeSizeInBits(PtrOp->getType()), 0);

116

117

118 Align BasePointerAlign =

120

121 auto [It, Inserted] =

122 BestBasePointerAligns.try_emplace(PtrOp, BasePointerAlign);

123 if (!Inserted) {

124

125

126

127

128 if (It->second > BasePointerAlign) {

129 Align BetterLoadStoreAlign =

131 return BetterLoadStoreAlign;

132 }

133 It->second = BasePointerAlign;

134 }

135 return LoadStoreAlign;

136 };

137

139

140

141

142

143

144

145 BestBasePointerAligns.clear();

146

150 return std::max(InferFromKnownBits(I, PtrOp),

151 InferFromBasePointer(PtrOp, OldAlign));

152 });

153 }

154 }

155

157}

158

This file implements a class to represent arbitrary precision integral constant values and operations...

MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL

static bool tryToImproveAlign(const DataLayout &DL, Instruction *I, function_ref< Align(Value *PtrOp, Align OldAlign, Align PrefAlign)> Fn)

Definition InferAlignment.cpp:30

bool inferAlignment(Function &F, AssumptionCache &AC, DominatorTree &DT)

Definition InferAlignment.cpp:84

uint64_t IntrinsicInst * II

Class for arbitrary precision integers.

uint64_t getLimitedValue(uint64_t Limit=UINT64_MAX) const

If this value is smaller than the specified limit, return it, otherwise return the limit value.

PassT::Result & getResult(IRUnitT &IR, ExtraArgTs... ExtraArgs)

Get the result of an analysis pass for a given IR unit.

A function analysis which provides an AssumptionCache.

A cache of @llvm.assume calls within a function.

static LLVM_ABI Attribute getWithAlignment(LLVMContext &Context, Align Alignment)

Return a uniquified Attribute object that has the specific alignment set.

LLVM Basic Block Representation.

static LLVM_ABI Constant * getNullValue(Type *Ty)

Constructor to create a '0' constant of arbitrary type.

A parsed version of the target data layout string in and methods for querying it.

std::pair< iterator, bool > try_emplace(KeyT &&Key, Ts &&...Args)

Analysis pass which computes a DominatorTree.

Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree.

A wrapper class for inspecting calls to intrinsic functions.

A set of analyses that are preserved following a run of a transformation pass.

static PreservedAnalyses all()

Construct a special preserved set that preserves all passes.

The instances of the Type class are immutable: once they are created, they are never changed.

LLVM Value Representation.

Type * getType() const

All values are typed, get the type of this value.

LLVM_ABI const Value * stripAndAccumulateConstantOffsets(const DataLayout &DL, APInt &Offset, bool AllowNonInbounds, bool AllowInvariantGroup=false, function_ref< bool(Value &Value, APInt &Offset)> ExternalAnalysis=nullptr, bool LookThroughIntToPtr=false) const

Accumulate the constant offset this value has compared to a base pointer.

static constexpr unsigned MaxAlignmentExponent

The maximum alignment for instructions.

An efficient, type-erasing, non-owning reference to a callable.

BinaryOp_match< LHS, RHS, Instruction::And > m_And(const LHS &L, const RHS &R)

auto m_PtrToIntOrAddr(const OpTy &Op)

Matches PtrToInt or PtrToAddr.

ap_match< APInt > m_APInt(const APInt *&Res)

Match a ConstantInt or splatted ConstantVector, binding the specified pointer to the contained APInt.

bool match(Val *V, const Pattern &P)

class_match< Value > m_Value()

Match an arbitrary value and ignore it.

This is an optimization pass for GlobalISel generic memory operations.

decltype(auto) dyn_cast(const From &Val)

dyn_cast - Return the argument parameter cast to the specified type.

const Value * getLoadStorePointerOperand(const Value *V)

A helper function that returns the pointer operand of a load or store instruction.

Align getLoadStoreAlignment(const Value *I)

A helper function that returns the alignment of load or store instruction.

LLVM_ABI void computeKnownBits(const Value *V, KnownBits &Known, const DataLayout &DL, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr, bool UseInstrInfo=true, unsigned Depth=0)

Determine which bits of V are known to be either zero or one and return them in the KnownZero/KnownOn...

LLVM_ABI Align tryEnforceAlignment(Value *V, Align PrefAlign, const DataLayout &DL)

If the specified pointer points to an object that we control, try to modify the object's alignment to...

Align commonAlignment(Align A, uint64_t Offset)

Returns the alignment that satisfies both alignments.

Type * getLoadStoreType(const Value *I)

A helper function that returns the type of a load or store instruction.

void setLoadStoreAlignment(Value *I, Align NewAlign)

A helper function that set the alignment of load or store instruction.

AnalysisManager< Function > FunctionAnalysisManager

Convenience typedef for the Function analysis manager.

This struct is a compact representation of a valid (non-zero power of two) alignment.

constexpr uint64_t value() const

This is a hole in the type system and should not be abused.

PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM)

Definition InferAlignment.cpp:159

unsigned countMinTrailingZeros() const

Returns the minimum number of trailing zero bits.

unsigned getBitWidth() const

Get the bit width of this value.