ExpandLargeDivRem.cpp Source File (original) (raw)

33using namespace llvm;

38 cl::desc("div and rem instructions on integers with "

39 "more than bits are expanded."));

42 auto *C = dyn_cast(V);

43 if ()

44 return false;

46 APInt Val = C->getValue();

48 Val = -Val;

50}

52static bool isSigned(unsigned int Opcode) {

53 return Opcode == Instruction::SDiv || Opcode == Instruction::SRem;

54}

62 unsigned NumElements = VTy->getElementCount().getFixedValue();

64 for (unsigned Idx = 0; Idx < NumElements; ++Idx) {

69 if (auto *NewBO = dyn_cast(Op)) {

70 NewBO->copyIRFlags(Op, true);

72 }

73 }

77}

89 return false;

92 switch (I.getOpcode()) {

93 case Instruction::UDiv:

94 case Instruction::SDiv:

95 case Instruction::URem:

96 case Instruction::SRem: {

98 if (I.getOperand(0)->getType()->isScalableTy())

99 continue;

100

101 auto *IntTy = dyn_cast(I.getType()->getScalarType());

102 if (!IntTy || IntTy->getIntegerBitWidth() <= MaxLegalDivRemBitWidth)

103 continue;

104

105

106

108 continue;

109

110 if (I.getOperand(0)->getType()->isVectorTy())

111 ReplaceVector.push_back(&cast(I));

112 else

113 Replace.push_back(&cast(I));

115 break;

116 }

117 default:

118 break;

119 }

120 }

121

122 while (!ReplaceVector.empty()) {

125 }

126

127 if (Replace.empty())

128 return false;

129

130 while (!Replace.empty()) {

132

133 if (I->getOpcode() == Instruction::UDiv ||

134 I->getOpcode() == Instruction::SDiv) {

136 } else {

138 }

139 }

140

142}

143

144namespace {

145class ExpandLargeDivRemLegacyPass : public FunctionPass {

146public:

147 static char ID;

148

151 }

152

154 auto *TM = &getAnalysis().getTM<TargetMachine>();

155 auto *TLI = TM->getSubtargetImpl(F)->getTargetLowering();

157 }

158

163 }

164};

165}

166

172}

173

174char ExpandLargeDivRemLegacyPass::ID = 0;

176 "Expand large div/rem", false, false)

179

181 return new ExpandLargeDivRemLegacyPass();

182}

Expand Atomic instructions

Returns the sub type a function will return at a given Idx Should correspond to the result type of an ExtractValue instruction executed with just that one unsigned Idx

static cl::opt< unsigned > ExpandDivRemBits("expand-div-rem-bits", cl::Hidden, cl::init(llvm::IntegerType::MAX_INT_BITS), cl::desc("div and rem instructions on integers with " "more than bits are expanded."))

static bool isSigned(unsigned int Opcode)

static void scalarize(BinaryOperator *BO, SmallVectorImpl< BinaryOperator * > &Replace)

static bool runImpl(Function &F, const TargetLowering &TLI)

static bool isConstantPowerOfTwo(llvm::Value *V, bool SignedOp)

static Expected< BitVector > expand(StringRef S, StringRef Original)

This is the interface for a simple mod/ref and alias analysis over globals.

This header defines various interfaces for pass management in LLVM.

FunctionAnalysisManager FAM

#define INITIALIZE_PASS_END(passName, arg, name, cfg, analysis)

#define INITIALIZE_PASS_BEGIN(passName, arg, name, cfg, analysis)

This file defines the SmallVector class.

This file describes how to lower LLVM code to machine code.

Target-Independent Code Generator Pass Configuration Options pass.

A wrapper pass to provide the legacy pass manager access to a suitably prepared AAResults object.

Class for arbitrary precision integers.

bool isNegative() const

Determine sign of this APInt.

bool isPowerOf2() const

Check if this APInt's value is a power of two greater than zero.

A container for analyses that lazily runs them and caches their results.

Represent the analysis usage information of a pass.

AnalysisUsage & addRequired()

AnalysisUsage & addPreserved()

Add the specified Pass class to the set of analyses preserved by this pass.

BinaryOps getOpcode() const

This class represents an Operation in the Expression.

PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM)

FunctionPass class - This class is used to implement most global optimizations.

virtual bool runOnFunction(Function &F)=0

runOnFunction - Virtual method overriden by subclasses to do the per-function processing of the pass.

Legacy wrapper pass to provide the GlobalsAAResult object.

Value * CreateInsertElement(Type *VecTy, Value *NewElt, Value *Idx, const Twine &Name="")

Value * CreateExtractElement(Value *Vec, Value *Idx, const Twine &Name="")

Value * CreateBinOp(Instruction::BinaryOps Opc, Value *LHS, Value *RHS, const Twine &Name="", MDNode *FPMathTag=nullptr)

This provides a uniform API for creating instructions and inserting them into a basic block: either a...

InstListType::iterator eraseFromParent()

This method unlinks 'this' from the containing basic block and deletes it.

@ MAX_INT_BITS

Maximum number of bits that can be specified.

static PassRegistry * getPassRegistry()

getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...

virtual void getAnalysisUsage(AnalysisUsage &) const

getAnalysisUsage - This function should be overriden by passes that need analysis information to do t...

static PoisonValue * get(Type *T)

Static factory methods - Return an 'poison' object of the specified type.

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

static PreservedAnalyses none()

Convenience factory function for the empty preserved set.

static PreservedAnalyses all()

Construct a special preserved set that preserves all passes.

This class consists of common code factored out of the SmallVector class to reduce code duplication b...

void push_back(const T &Elt)

This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.

unsigned getMaxDivRemBitWidthSupported() const

Returns the size in bits of the maximum div/rem the backend supports.

This class defines information used to lower LLVM code to legal SelectionDAG operators that the targe...

Primary interface to the complete machine description for the target machine.

virtual const TargetSubtargetInfo * getSubtargetImpl(const Function &) const

Virtual method implemented by subclasses that returns a reference to that target's TargetSubtargetInf...

Target-Independent Code Generator Pass Configuration Options.

TargetSubtargetInfo - Generic base class for all target subtargets.

virtual const TargetLowering * getTargetLowering() const

void dropAllReferences()

Drop all references to operands.

Value * getOperand(unsigned i) const

LLVM Value Representation.

Type * getType() const

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

void replaceAllUsesWith(Value *V)

Change all uses of this to point to a new Value.

@ C

The default llvm calling convention, compatible with C.

unsigned ID

LLVM IR allows to use arbitrary numbers as calling convention identifiers.

initializer< Ty > init(const Ty &Val)

This is an optimization pass for GlobalISel generic memory operations.

bool expandDivision(BinaryOperator *Div)

Generate code to divide two integers, replacing Div with the generated code.

void initializeExpandLargeDivRemLegacyPassPass(PassRegistry &)

FunctionPass * createExpandLargeDivRemPass()

bool expandRemainder(BinaryOperator *Rem)

Generate code to calculate the remainder of two integers, replacing Rem with the generated code.