LLVM  4.0.0
CostModel.cpp
Go to the documentation of this file.
1 //===- CostModel.cpp ------ Cost Model Analysis ---------------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file defines the cost model analysis. It provides a very basic cost
11 // estimation for LLVM-IR. This analysis uses the services of the codegen
12 // to approximate the cost of any IR instruction when lowered to machine
13 // instructions. The cost results are unit-less and the cost number represents
14 // the throughput of the machine assuming that all loads hit the cache, all
15 // branches are predicted, etc. The cost numbers can be added in order to
16 // compare two or more transformation alternatives.
17 //
18 //===----------------------------------------------------------------------===//
19 
20 #include "llvm/ADT/STLExtras.h"
21 #include "llvm/Analysis/Passes.h"
24 #include "llvm/IR/Function.h"
25 #include "llvm/IR/Instructions.h"
26 #include "llvm/IR/IntrinsicInst.h"
27 #include "llvm/IR/Value.h"
28 #include "llvm/Pass.h"
30 #include "llvm/Support/Debug.h"
32 using namespace llvm;
33 
34 #define CM_NAME "cost-model"
35 #define DEBUG_TYPE CM_NAME
36 
37 static cl::opt<bool> EnableReduxCost("costmodel-reduxcost", cl::init(false),
38  cl::Hidden,
39  cl::desc("Recognize reduction patterns."));
40 
41 namespace {
42  class CostModelAnalysis : public FunctionPass {
43 
44  public:
45  static char ID; // Class identification, replacement for typeinfo
46  CostModelAnalysis() : FunctionPass(ID), F(nullptr), TTI(nullptr) {
49  }
50 
51  /// Returns the expected cost of the instruction.
52  /// Returns -1 if the cost is unknown.
53  /// Note, this method does not cache the cost calculation and it
54  /// can be expensive in some cases.
55  unsigned getInstructionCost(const Instruction *I) const;
56 
57  private:
58  void getAnalysisUsage(AnalysisUsage &AU) const override;
59  bool runOnFunction(Function &F) override;
60  void print(raw_ostream &OS, const Module*) const override;
61 
62  /// The function that we analyze.
63  Function *F;
64  /// Target information.
65  const TargetTransformInfo *TTI;
66  };
67 } // End of anonymous namespace
68 
69 // Register this pass.
70 char CostModelAnalysis::ID = 0;
71 static const char cm_name[] = "Cost Model Analysis";
72 INITIALIZE_PASS_BEGIN(CostModelAnalysis, CM_NAME, cm_name, false, true)
73 INITIALIZE_PASS_END (CostModelAnalysis, CM_NAME, cm_name, false, true)
74 
76  return new CostModelAnalysis();
77 }
78 
79 void
80 CostModelAnalysis::getAnalysisUsage(AnalysisUsage &AU) const {
81  AU.setPreservesAll();
82 }
83 
84 bool
85 CostModelAnalysis::runOnFunction(Function &F) {
86  this->F = &F;
87  auto *TTIWP = getAnalysisIfAvailable<TargetTransformInfoWrapperPass>();
88  TTI = TTIWP ? &TTIWP->getTTI(F) : nullptr;
89 
90  return false;
91 }
92 
94  for (unsigned i = 0, MaskSize = Mask.size(); i < MaskSize; ++i)
95  if (Mask[i] >= 0 && Mask[i] != (int)(MaskSize - 1 - i))
96  return false;
97  return true;
98 }
99 
101  bool Vec0 = false;
102  bool Vec1 = false;
103  for (unsigned i = 0, NumVecElts = Mask.size(); i < NumVecElts; ++i) {
104  if (Mask[i] >= 0) {
105  if ((unsigned)Mask[i] >= NumVecElts)
106  Vec1 = true;
107  else
108  Vec0 = true;
109  }
110  }
111  return !(Vec0 && Vec1);
112 }
113 
115  for (unsigned i = 0; i < Mask.size(); ++i)
116  if (Mask[i] > 0)
117  return false;
118  return true;
119 }
120 
122  bool isAlternate = true;
123  unsigned MaskSize = Mask.size();
124 
125  // Example: shufflevector A, B, <0,5,2,7>
126  for (unsigned i = 0; i < MaskSize && isAlternate; ++i) {
127  if (Mask[i] < 0)
128  continue;
129  isAlternate = Mask[i] == (int)((i & 1) ? MaskSize + i : i);
130  }
131 
132  if (isAlternate)
133  return true;
134 
135  isAlternate = true;
136  // Example: shufflevector A, B, <4,1,6,3>
137  for (unsigned i = 0; i < MaskSize && isAlternate; ++i) {
138  if (Mask[i] < 0)
139  continue;
140  isAlternate = Mask[i] == (int)((i & 1) ? i : MaskSize + i);
141  }
142 
143  return isAlternate;
144 }
145 
149 
150  // Check for a splat of a constant or for a non uniform vector of constants.
151  if (isa<ConstantVector>(V) || isa<ConstantDataVector>(V)) {
153  if (cast<Constant>(V)->getSplatValue() != nullptr)
155  }
156 
157  // Check for a splat of a uniform value. This is not loop aware, so return
158  // true only for the obviously uniform cases (argument, globalvalue)
159  const Value *Splat = getSplatValue(V);
160  if (Splat && (isa<Argument>(Splat) || isa<GlobalValue>(Splat)))
162 
163  return OpInfo;
164 }
165 
166 static bool matchPairwiseShuffleMask(ShuffleVectorInst *SI, bool IsLeft,
167  unsigned Level) {
168  // We don't need a shuffle if we just want to have element 0 in position 0 of
169  // the vector.
170  if (!SI && Level == 0 && IsLeft)
171  return true;
172  else if (!SI)
173  return false;
174 
176 
177  // Build a mask of 0, 2, ... (left) or 1, 3, ... (right) depending on whether
178  // we look at the left or right side.
179  for (unsigned i = 0, e = (1 << Level), val = !IsLeft; i != e; ++i, val += 2)
180  Mask[i] = val;
181 
182  SmallVector<int, 16> ActualMask = SI->getShuffleMask();
183  return Mask == ActualMask;
184 }
185 
187  unsigned Level, unsigned NumLevels) {
188  // Match one level of pairwise operations.
189  // %rdx.shuf.0.0 = shufflevector <4 x float> %rdx, <4 x float> undef,
190  // <4 x i32> <i32 0, i32 2 , i32 undef, i32 undef>
191  // %rdx.shuf.0.1 = shufflevector <4 x float> %rdx, <4 x float> undef,
192  // <4 x i32> <i32 1, i32 3, i32 undef, i32 undef>
193  // %bin.rdx.0 = fadd <4 x float> %rdx.shuf.0.0, %rdx.shuf.0.1
194  if (BinOp == nullptr)
195  return false;
196 
197  assert(BinOp->getType()->isVectorTy() && "Expecting a vector type");
198 
199  unsigned Opcode = BinOp->getOpcode();
200  Value *L = BinOp->getOperand(0);
201  Value *R = BinOp->getOperand(1);
202 
204  if (!LS && Level)
205  return false;
207  if (!RS && Level)
208  return false;
209 
210  // On level 0 we can omit one shufflevector instruction.
211  if (!Level && !RS && !LS)
212  return false;
213 
214  // Shuffle inputs must match.
215  Value *NextLevelOpL = LS ? LS->getOperand(0) : nullptr;
216  Value *NextLevelOpR = RS ? RS->getOperand(0) : nullptr;
217  Value *NextLevelOp = nullptr;
218  if (NextLevelOpR && NextLevelOpL) {
219  // If we have two shuffles their operands must match.
220  if (NextLevelOpL != NextLevelOpR)
221  return false;
222 
223  NextLevelOp = NextLevelOpL;
224  } else if (Level == 0 && (NextLevelOpR || NextLevelOpL)) {
225  // On the first level we can omit the shufflevector <0, undef,...>. So the
226  // input to the other shufflevector <1, undef> must match with one of the
227  // inputs to the current binary operation.
228  // Example:
229  // %NextLevelOpL = shufflevector %R, <1, undef ...>
230  // %BinOp = fadd %NextLevelOpL, %R
231  if (NextLevelOpL && NextLevelOpL != R)
232  return false;
233  else if (NextLevelOpR && NextLevelOpR != L)
234  return false;
235 
236  NextLevelOp = NextLevelOpL ? R : L;
237  } else
238  return false;
239 
240  // Check that the next levels binary operation exists and matches with the
241  // current one.
242  BinaryOperator *NextLevelBinOp = nullptr;
243  if (Level + 1 != NumLevels) {
244  if (!(NextLevelBinOp = dyn_cast<BinaryOperator>(NextLevelOp)))
245  return false;
246  else if (NextLevelBinOp->getOpcode() != Opcode)
247  return false;
248  }
249 
250  // Shuffle mask for pairwise operation must match.
251  if (matchPairwiseShuffleMask(LS, true, Level)) {
252  if (!matchPairwiseShuffleMask(RS, false, Level))
253  return false;
254  } else if (matchPairwiseShuffleMask(RS, true, Level)) {
255  if (!matchPairwiseShuffleMask(LS, false, Level))
256  return false;
257  } else
258  return false;
259 
260  if (++Level == NumLevels)
261  return true;
262 
263  // Match next level.
264  return matchPairwiseReductionAtLevel(NextLevelBinOp, Level, NumLevels);
265 }
266 
267 static bool matchPairwiseReduction(const ExtractElementInst *ReduxRoot,
268  unsigned &Opcode, Type *&Ty) {
269  if (!EnableReduxCost)
270  return false;
271 
272  // Need to extract the first element.
273  ConstantInt *CI = dyn_cast<ConstantInt>(ReduxRoot->getOperand(1));
274  unsigned Idx = ~0u;
275  if (CI)
276  Idx = CI->getZExtValue();
277  if (Idx != 0)
278  return false;
279 
280  BinaryOperator *RdxStart = dyn_cast<BinaryOperator>(ReduxRoot->getOperand(0));
281  if (!RdxStart)
282  return false;
283 
284  Type *VecTy = ReduxRoot->getOperand(0)->getType();
285  unsigned NumVecElems = VecTy->getVectorNumElements();
286  if (!isPowerOf2_32(NumVecElems))
287  return false;
288 
289  // We look for a sequence of shuffle,shuffle,add triples like the following
290  // that builds a pairwise reduction tree.
291  //
292  // (X0, X1, X2, X3)
293  // (X0 + X1, X2 + X3, undef, undef)
294  // ((X0 + X1) + (X2 + X3), undef, undef, undef)
295  //
296  // %rdx.shuf.0.0 = shufflevector <4 x float> %rdx, <4 x float> undef,
297  // <4 x i32> <i32 0, i32 2 , i32 undef, i32 undef>
298  // %rdx.shuf.0.1 = shufflevector <4 x float> %rdx, <4 x float> undef,
299  // <4 x i32> <i32 1, i32 3, i32 undef, i32 undef>
300  // %bin.rdx.0 = fadd <4 x float> %rdx.shuf.0.0, %rdx.shuf.0.1
301  // %rdx.shuf.1.0 = shufflevector <4 x float> %bin.rdx.0, <4 x float> undef,
302  // <4 x i32> <i32 0, i32 undef, i32 undef, i32 undef>
303  // %rdx.shuf.1.1 = shufflevector <4 x float> %bin.rdx.0, <4 x float> undef,
304  // <4 x i32> <i32 1, i32 undef, i32 undef, i32 undef>
305  // %bin.rdx8 = fadd <4 x float> %rdx.shuf.1.0, %rdx.shuf.1.1
306  // %r = extractelement <4 x float> %bin.rdx8, i32 0
307  if (!matchPairwiseReductionAtLevel(RdxStart, 0, Log2_32(NumVecElems)))
308  return false;
309 
310  Opcode = RdxStart->getOpcode();
311  Ty = VecTy;
312 
313  return true;
314 }
315 
316 static std::pair<Value *, ShuffleVectorInst *>
318 
319  Value *L = B->getOperand(0);
320  Value *R = B->getOperand(1);
321  ShuffleVectorInst *S = nullptr;
322 
323  if ((S = dyn_cast<ShuffleVectorInst>(L)))
324  return std::make_pair(R, S);
325 
326  S = dyn_cast<ShuffleVectorInst>(R);
327  return std::make_pair(L, S);
328 }
329 
331  unsigned &Opcode, Type *&Ty) {
332  if (!EnableReduxCost)
333  return false;
334 
335  // Need to extract the first element.
336  ConstantInt *CI = dyn_cast<ConstantInt>(ReduxRoot->getOperand(1));
337  unsigned Idx = ~0u;
338  if (CI)
339  Idx = CI->getZExtValue();
340  if (Idx != 0)
341  return false;
342 
343  BinaryOperator *RdxStart = dyn_cast<BinaryOperator>(ReduxRoot->getOperand(0));
344  if (!RdxStart)
345  return false;
346  unsigned RdxOpcode = RdxStart->getOpcode();
347 
348  Type *VecTy = ReduxRoot->getOperand(0)->getType();
349  unsigned NumVecElems = VecTy->getVectorNumElements();
350  if (!isPowerOf2_32(NumVecElems))
351  return false;
352 
353  // We look for a sequence of shuffles and adds like the following matching one
354  // fadd, shuffle vector pair at a time.
355  //
356  // %rdx.shuf = shufflevector <4 x float> %rdx, <4 x float> undef,
357  // <4 x i32> <i32 2, i32 3, i32 undef, i32 undef>
358  // %bin.rdx = fadd <4 x float> %rdx, %rdx.shuf
359  // %rdx.shuf7 = shufflevector <4 x float> %bin.rdx, <4 x float> undef,
360  // <4 x i32> <i32 1, i32 undef, i32 undef, i32 undef>
361  // %bin.rdx8 = fadd <4 x float> %bin.rdx, %rdx.shuf7
362  // %r = extractelement <4 x float> %bin.rdx8, i32 0
363 
364  unsigned MaskStart = 1;
365  Value *RdxOp = RdxStart;
366  SmallVector<int, 32> ShuffleMask(NumVecElems, 0);
367  unsigned NumVecElemsRemain = NumVecElems;
368  while (NumVecElemsRemain - 1) {
369  // Check for the right reduction operation.
370  BinaryOperator *BinOp;
371  if (!(BinOp = dyn_cast<BinaryOperator>(RdxOp)))
372  return false;
373  if (BinOp->getOpcode() != RdxOpcode)
374  return false;
375 
376  Value *NextRdxOp;
377  ShuffleVectorInst *Shuffle;
378  std::tie(NextRdxOp, Shuffle) = getShuffleAndOtherOprd(BinOp);
379 
380  // Check the current reduction operation and the shuffle use the same value.
381  if (Shuffle == nullptr)
382  return false;
383  if (Shuffle->getOperand(0) != NextRdxOp)
384  return false;
385 
386  // Check that shuffle masks matches.
387  for (unsigned j = 0; j != MaskStart; ++j)
388  ShuffleMask[j] = MaskStart + j;
389  // Fill the rest of the mask with -1 for undef.
390  std::fill(&ShuffleMask[MaskStart], ShuffleMask.end(), -1);
391 
393  if (ShuffleMask != Mask)
394  return false;
395 
396  RdxOp = NextRdxOp;
397  NumVecElemsRemain /= 2;
398  MaskStart *= 2;
399  }
400 
401  Opcode = RdxOpcode;
402  Ty = VecTy;
403  return true;
404 }
405 
406 unsigned CostModelAnalysis::getInstructionCost(const Instruction *I) const {
407  if (!TTI)
408  return -1;
409 
410  switch (I->getOpcode()) {
411  case Instruction::GetElementPtr:
412  return TTI->getUserCost(I);
413 
414  case Instruction::Ret:
415  case Instruction::PHI:
416  case Instruction::Br: {
417  return TTI->getCFInstrCost(I->getOpcode());
418  }
419  case Instruction::Add:
420  case Instruction::FAdd:
421  case Instruction::Sub:
422  case Instruction::FSub:
423  case Instruction::Mul:
424  case Instruction::FMul:
425  case Instruction::UDiv:
426  case Instruction::SDiv:
427  case Instruction::FDiv:
428  case Instruction::URem:
429  case Instruction::SRem:
430  case Instruction::FRem:
431  case Instruction::Shl:
432  case Instruction::LShr:
433  case Instruction::AShr:
434  case Instruction::And:
435  case Instruction::Or:
436  case Instruction::Xor: {
438  getOperandInfo(I->getOperand(0));
440  getOperandInfo(I->getOperand(1));
442  return TTI->getArithmeticInstrCost(I->getOpcode(), I->getType(), Op1VK,
445  Operands);
446  }
447  case Instruction::Select: {
448  const SelectInst *SI = cast<SelectInst>(I);
449  Type *CondTy = SI->getCondition()->getType();
450  return TTI->getCmpSelInstrCost(I->getOpcode(), I->getType(), CondTy);
451  }
452  case Instruction::ICmp:
453  case Instruction::FCmp: {
454  Type *ValTy = I->getOperand(0)->getType();
455  return TTI->getCmpSelInstrCost(I->getOpcode(), ValTy);
456  }
457  case Instruction::Store: {
458  const StoreInst *SI = cast<StoreInst>(I);
459  Type *ValTy = SI->getValueOperand()->getType();
460  return TTI->getMemoryOpCost(I->getOpcode(), ValTy,
461  SI->getAlignment(),
462  SI->getPointerAddressSpace());
463  }
464  case Instruction::Load: {
465  const LoadInst *LI = cast<LoadInst>(I);
466  return TTI->getMemoryOpCost(I->getOpcode(), I->getType(),
467  LI->getAlignment(),
468  LI->getPointerAddressSpace());
469  }
470  case Instruction::ZExt:
471  case Instruction::SExt:
472  case Instruction::FPToUI:
473  case Instruction::FPToSI:
474  case Instruction::FPExt:
475  case Instruction::PtrToInt:
476  case Instruction::IntToPtr:
477  case Instruction::SIToFP:
478  case Instruction::UIToFP:
479  case Instruction::Trunc:
480  case Instruction::FPTrunc:
481  case Instruction::BitCast:
482  case Instruction::AddrSpaceCast: {
483  Type *SrcTy = I->getOperand(0)->getType();
484  return TTI->getCastInstrCost(I->getOpcode(), I->getType(), SrcTy);
485  }
486  case Instruction::ExtractElement: {
487  const ExtractElementInst * EEI = cast<ExtractElementInst>(I);
489  unsigned Idx = -1;
490  if (CI)
491  Idx = CI->getZExtValue();
492 
493  // Try to match a reduction sequence (series of shufflevector and vector
494  // adds followed by a extractelement).
495  unsigned ReduxOpCode;
496  Type *ReduxType;
497 
498  if (matchVectorSplittingReduction(EEI, ReduxOpCode, ReduxType))
499  return TTI->getReductionCost(ReduxOpCode, ReduxType, false);
500  else if (matchPairwiseReduction(EEI, ReduxOpCode, ReduxType))
501  return TTI->getReductionCost(ReduxOpCode, ReduxType, true);
502 
503  return TTI->getVectorInstrCost(I->getOpcode(),
504  EEI->getOperand(0)->getType(), Idx);
505  }
506  case Instruction::InsertElement: {
507  const InsertElementInst * IE = cast<InsertElementInst>(I);
509  unsigned Idx = -1;
510  if (CI)
511  Idx = CI->getZExtValue();
512  return TTI->getVectorInstrCost(I->getOpcode(),
513  IE->getType(), Idx);
514  }
515  case Instruction::ShuffleVector: {
516  const ShuffleVectorInst *Shuffle = cast<ShuffleVectorInst>(I);
517  Type *VecTypOp0 = Shuffle->getOperand(0)->getType();
518  unsigned NumVecElems = VecTypOp0->getVectorNumElements();
520 
521  if (NumVecElems == Mask.size()) {
522  if (isReverseVectorMask(Mask))
523  return TTI->getShuffleCost(TargetTransformInfo::SK_Reverse, VecTypOp0,
524  0, nullptr);
525  if (isAlternateVectorMask(Mask))
526  return TTI->getShuffleCost(TargetTransformInfo::SK_Alternate,
527  VecTypOp0, 0, nullptr);
528 
530  return TTI->getShuffleCost(TargetTransformInfo::SK_Broadcast,
531  VecTypOp0, 0, nullptr);
532 
533  if (isSingleSourceVectorMask(Mask))
534  return TTI->getShuffleCost(TargetTransformInfo::SK_PermuteSingleSrc,
535  VecTypOp0, 0, nullptr);
536 
537  return TTI->getShuffleCost(TargetTransformInfo::SK_PermuteTwoSrc,
538  VecTypOp0, 0, nullptr);
539  }
540 
541  return -1;
542  }
543  case Instruction::Call:
544  if (const IntrinsicInst *II = dyn_cast<IntrinsicInst>(I)) {
546  for (unsigned J = 0, JE = II->getNumArgOperands(); J != JE; ++J)
547  Args.push_back(II->getArgOperand(J));
548 
549  FastMathFlags FMF;
550  if (auto *FPMO = dyn_cast<FPMathOperator>(II))
551  FMF = FPMO->getFastMathFlags();
552 
553  return TTI->getIntrinsicInstrCost(II->getIntrinsicID(), II->getType(),
554  Args, FMF);
555  }
556  return -1;
557  default:
558  // We don't have any information on this instruction.
559  return -1;
560  }
561 }
562 
563 void CostModelAnalysis::print(raw_ostream &OS, const Module*) const {
564  if (!F)
565  return;
566 
567  for (BasicBlock &B : *F) {
568  for (Instruction &Inst : B) {
569  unsigned Cost = getInstructionCost(&Inst);
570  if (Cost != (unsigned)-1)
571  OS << "Cost Model: Found an estimated cost of " << Cost;
572  else
573  OS << "Cost Model: Unknown cost";
574 
575  OS << " for instruction: " << Inst << "\n";
576  }
577  }
578 }
MachineLoop * L
Value * getValueOperand()
Definition: Instructions.h:391
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
size_t i
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:52
void initializeCostModelAnalysisPass(PassRegistry &)
const Value * getSplatValue(const Value *V)
Get splat value if the input is a splat vector or return nullptr.
This instruction constructs a fixed permutation of two input vectors.
An instruction for reading from memory.
Definition: Instructions.h:164
static TargetTransformInfo::OperandValueKind getOperandInfo(Value *V)
Definition: CostModel.cpp:146
static const char cm_name[]
Definition: CostModel.cpp:71
This class represents the LLVM 'select' instruction.
static bool matchPairwiseReduction(const ExtractElementInst *ReduxRoot, unsigned &Opcode, Type *&Ty)
Definition: CostModel.cpp:267
uint64_t getZExtValue() const
Return the constant as a 64-bit unsigned integer value after it has been zero extended as appropriate...
Definition: Constants.h:154
unsigned getPointerAddressSpace() const
Returns the address space of the pointer operand.
Definition: Instructions.h:399
Choose alternate elements from vector.
#define F(x, y, z)
Definition: MD5.cpp:51
VectorType * getType() const
Overload to return most specific vector type.
static bool isZeroEltBroadcastVectorMask(ArrayRef< int > Mask)
Definition: CostModel.cpp:114
Function Alias Analysis false
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: APInt.h:33
static GCRegistry::Add< OcamlGC > B("ocaml","ocaml 3.10-compatible GC")
An instruction for storing to memory.
Definition: Instructions.h:300
Reverse the order of the vector.
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:141
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:395
This instruction inserts a single (scalar) element into a VectorType value.
unsigned getAlignment() const
Return the alignment of the access that is being performed.
Definition: Instructions.h:348
constexpr bool isPowerOf2_32(uint32_t Value)
isPowerOf2_32 - This function returns true if the argument is a power of two > 0. ...
Definition: MathExtras.h:399
static bool isReverseVectorMask(ArrayRef< int > Mask)
Definition: CostModel.cpp:93
LLVM Basic Block Representation.
Definition: BasicBlock.h:51
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:45
bool isVectorTy() const
True if this is an instance of VectorType.
Definition: Type.h:219
const Value * getCondition() const
APInt Or(const APInt &LHS, const APInt &RHS)
Bitwise OR function for APInt.
Definition: APInt.h:1947
APInt Xor(const APInt &LHS, const APInt &RHS)
Bitwise XOR function for APInt.
Definition: APInt.h:1952
#define CM_NAME
Definition: CostModel.cpp:34
Represent the analysis usage information of a pass.
INITIALIZE_PASS_END(RegBankSelect, DEBUG_TYPE,"Assign register bank of generic virtual registers", false, false) RegBankSelect
FunctionPass class - This class is used to implement most global optimizations.
Definition: Pass.h:298
Value * getOperand(unsigned i) const
Definition: User.h:145
Merge elements from two source vectors into one with any shuffle mask.
static cl::opt< bool > EnableReduxCost("costmodel-reduxcost", cl::init(false), cl::Hidden, cl::desc("Recognize reduction patterns."))
BinaryOps getOpcode() const
Definition: InstrTypes.h:541
static std::pair< Value *, ShuffleVectorInst * > getShuffleAndOtherOprd(BinaryOperator *B)
Definition: CostModel.cpp:317
This is the shared class of boolean and integer constants.
Definition: Constants.h:88
This pass provides access to the codegen interfaces that are needed for IR-level transformations.
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:843
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:230
static bool isSingleSourceVectorMask(ArrayRef< int > Mask)
Definition: CostModel.cpp:100
static bool matchPairwiseReductionAtLevel(const BinaryOperator *BinOp, unsigned Level, unsigned NumLevels)
Definition: CostModel.cpp:186
#define INITIALIZE_PASS_BEGIN(passName, arg, name, cfg, analysis)
Definition: PassSupport.h:50
unsigned getPointerAddressSpace() const
Returns the address space of the pointer operand.
Definition: Instructions.h:275
unsigned Log2_32(uint32_t Value)
Log2_32 - This function returns the floor log base 2 of the specified value, -1 if the value is zero...
Definition: MathExtras.h:513
static bool isAlternateVectorMask(ArrayRef< int > Mask)
Definition: CostModel.cpp:121
void setPreservesAll()
Set by analyses that do not transform their input at all.
unsigned getVectorNumElements() const
Definition: DerivedTypes.h:438
APInt And(const APInt &LHS, const APInt &RHS)
Bitwise AND function for APInt.
Definition: APInt.h:1942
Basic Alias true
LLVM_ATTRIBUTE_ALWAYS_INLINE iterator end()
Definition: SmallVector.h:119
unsigned getAlignment() const
Return the alignment of the access that is being performed.
Definition: Instructions.h:227
#define I(x, y, z)
Definition: MD5.cpp:54
LLVM_ATTRIBUTE_ALWAYS_INLINE size_type size() const
Definition: SmallVector.h:135
iterator_range< value_op_iterator > operand_values()
Definition: User.h:237
static bool matchPairwiseShuffleMask(ShuffleVectorInst *SI, bool IsLeft, unsigned Level)
Definition: CostModel.cpp:166
LLVM_NODISCARD std::enable_if<!is_simple_type< Y >::value, typename cast_retty< X, const Y >::ret_type >::type dyn_cast(const Y &Val)
Definition: Casting.h:287
This instruction extracts a single (scalar) element from a VectorType value.
VectorType * getType() const
Overload to return most specific vector type.
FunctionPass * createCostModelAnalysisPass()
Definition: CostModel.cpp:75
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
LLVM Value Representation.
Definition: Value.h:71
unsigned getOpcode() const
Returns a member of one of the enums like Instruction::Add.
Definition: Instruction.h:111
std::underlying_type< E >::type Mask()
Get a bitmask with 1s in all places up to the high-order bit of E's largest value.
Definition: BitmaskEnum.h:81
Broadcast element 0 to all other elements.
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:44
static bool matchVectorSplittingReduction(const ExtractElementInst *ReduxRoot, unsigned &Opcode, Type *&Ty)
Definition: CostModel.cpp:330
Convenience struct for specifying and reasoning about fast-math flags.
Definition: Operator.h:168
OperandValueKind
Additional information about an operand's possible values.
This pass exposes codegen information to IR-level passes.
static void getShuffleMask(Constant *Mask, SmallVectorImpl< int > &Result)
Convert the input shuffle mask operand to a vector of integers.
A wrapper class for inspecting calls to intrinsic functions.
Definition: IntrinsicInst.h:44
Shuffle elements of single source vector with any shuffle mask.