LLVM  4.0.0
InstCombineVectorOps.cpp
Go to the documentation of this file.
1 //===- InstCombineVectorOps.cpp -------------------------------------------===//
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 implements instcombine for ExtractElement, InsertElement and
11 // ShuffleVector.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #include "InstCombineInternal.h"
16 #include "llvm/ADT/DenseMap.h"
19 #include "llvm/IR/PatternMatch.h"
20 using namespace llvm;
21 using namespace PatternMatch;
22 
23 #define DEBUG_TYPE "instcombine"
24 
25 /// Return true if the value is cheaper to scalarize than it is to leave as a
26 /// vector operation. isConstant indicates whether we're extracting one known
27 /// element. If false we're extracting a variable index.
28 static bool cheapToScalarize(Value *V, bool isConstant) {
29  if (Constant *C = dyn_cast<Constant>(V)) {
30  if (isConstant) return true;
31 
32  // If all elts are the same, we can extract it and use any of the values.
33  if (Constant *Op0 = C->getAggregateElement(0U)) {
34  for (unsigned i = 1, e = V->getType()->getVectorNumElements(); i != e;
35  ++i)
36  if (C->getAggregateElement(i) != Op0)
37  return false;
38  return true;
39  }
40  }
42  if (!I) return false;
43 
44  // Insert element gets simplified to the inserted element or is deleted if
45  // this is constant idx extract element and its a constant idx insertelt.
46  if (I->getOpcode() == Instruction::InsertElement && isConstant &&
47  isa<ConstantInt>(I->getOperand(2)))
48  return true;
49  if (I->getOpcode() == Instruction::Load && I->hasOneUse())
50  return true;
51  if (BinaryOperator *BO = dyn_cast<BinaryOperator>(I))
52  if (BO->hasOneUse() &&
53  (cheapToScalarize(BO->getOperand(0), isConstant) ||
54  cheapToScalarize(BO->getOperand(1), isConstant)))
55  return true;
56  if (CmpInst *CI = dyn_cast<CmpInst>(I))
57  if (CI->hasOneUse() &&
58  (cheapToScalarize(CI->getOperand(0), isConstant) ||
59  cheapToScalarize(CI->getOperand(1), isConstant)))
60  return true;
61 
62  return false;
63 }
64 
65 // If we have a PHI node with a vector type that is only used to feed
66 // itself and be an operand of extractelement at a constant location,
67 // try to replace the PHI of the vector type with a PHI of a scalar type.
68 Instruction *InstCombiner::scalarizePHI(ExtractElementInst &EI, PHINode *PN) {
70  // The users we want the PHI to have are:
71  // 1) The EI ExtractElement (we already know this)
72  // 2) Possibly more ExtractElements with the same index.
73  // 3) Another operand, which will feed back into the PHI.
74  Instruction *PHIUser = nullptr;
75  for (auto U : PN->users()) {
76  if (ExtractElementInst *EU = dyn_cast<ExtractElementInst>(U)) {
77  if (EI.getIndexOperand() == EU->getIndexOperand())
78  Extracts.push_back(EU);
79  else
80  return nullptr;
81  } else if (!PHIUser) {
82  PHIUser = cast<Instruction>(U);
83  } else {
84  return nullptr;
85  }
86  }
87 
88  if (!PHIUser)
89  return nullptr;
90 
91  // Verify that this PHI user has one use, which is the PHI itself,
92  // and that it is a binary operation which is cheap to scalarize.
93  // otherwise return NULL.
94  if (!PHIUser->hasOneUse() || !(PHIUser->user_back() == PN) ||
95  !(isa<BinaryOperator>(PHIUser)) || !cheapToScalarize(PHIUser, true))
96  return nullptr;
97 
98  // Create a scalar PHI node that will replace the vector PHI node
99  // just before the current PHI node.
100  PHINode *scalarPHI = cast<PHINode>(InsertNewInstWith(
101  PHINode::Create(EI.getType(), PN->getNumIncomingValues(), ""), *PN));
102  // Scalarize each PHI operand.
103  for (unsigned i = 0; i < PN->getNumIncomingValues(); i++) {
104  Value *PHIInVal = PN->getIncomingValue(i);
105  BasicBlock *inBB = PN->getIncomingBlock(i);
106  Value *Elt = EI.getIndexOperand();
107  // If the operand is the PHI induction variable:
108  if (PHIInVal == PHIUser) {
109  // Scalarize the binary operation. Its first operand is the
110  // scalar PHI, and the second operand is extracted from the other
111  // vector operand.
112  BinaryOperator *B0 = cast<BinaryOperator>(PHIUser);
113  unsigned opId = (B0->getOperand(0) == PN) ? 1 : 0;
114  Value *Op = InsertNewInstWith(
115  ExtractElementInst::Create(B0->getOperand(opId), Elt,
116  B0->getOperand(opId)->getName() + ".Elt"),
117  *B0);
118  Value *newPHIUser = InsertNewInstWith(
120  scalarPHI, Op, B0), *B0);
121  scalarPHI->addIncoming(newPHIUser, inBB);
122  } else {
123  // Scalarize PHI input:
124  Instruction *newEI = ExtractElementInst::Create(PHIInVal, Elt, "");
125  // Insert the new instruction into the predecessor basic block.
126  Instruction *pos = dyn_cast<Instruction>(PHIInVal);
127  BasicBlock::iterator InsertPos;
128  if (pos && !isa<PHINode>(pos)) {
129  InsertPos = ++pos->getIterator();
130  } else {
131  InsertPos = inBB->getFirstInsertionPt();
132  }
133 
134  InsertNewInstWith(newEI, *InsertPos);
135 
136  scalarPHI->addIncoming(newEI, inBB);
137  }
138  }
139 
140  for (auto E : Extracts)
141  replaceInstUsesWith(*E, scalarPHI);
142 
143  return &EI;
144 }
145 
148  EI.getVectorOperand(), EI.getIndexOperand(), DL, &TLI, &DT, &AC))
149  return replaceInstUsesWith(EI, V);
150 
151  // If vector val is constant with all elements the same, replace EI with
152  // that element. We handle a known element # below.
153  if (Constant *C = dyn_cast<Constant>(EI.getOperand(0)))
154  if (cheapToScalarize(C, false))
155  return replaceInstUsesWith(EI, C->getAggregateElement(0U));
156 
157  // If extracting a specified index from the vector, see if we can recursively
158  // find a previously computed scalar that was inserted into the vector.
159  if (ConstantInt *IdxC = dyn_cast<ConstantInt>(EI.getOperand(1))) {
160  unsigned IndexVal = IdxC->getZExtValue();
161  unsigned VectorWidth = EI.getVectorOperandType()->getNumElements();
162 
163  // InstSimplify handles cases where the index is invalid.
164  assert(IndexVal < VectorWidth);
165 
166  // This instruction only demands the single element from the input vector.
167  // If the input vector has a single use, simplify it based on this use
168  // property.
169  if (EI.getOperand(0)->hasOneUse() && VectorWidth != 1) {
170  APInt UndefElts(VectorWidth, 0);
171  APInt DemandedMask(VectorWidth, 0);
172  DemandedMask.setBit(IndexVal);
173  if (Value *V = SimplifyDemandedVectorElts(EI.getOperand(0), DemandedMask,
174  UndefElts)) {
175  EI.setOperand(0, V);
176  return &EI;
177  }
178  }
179 
180  // If this extractelement is directly using a bitcast from a vector of
181  // the same number of elements, see if we can find the source element from
182  // it. In this case, we will end up needing to bitcast the scalars.
183  if (BitCastInst *BCI = dyn_cast<BitCastInst>(EI.getOperand(0))) {
184  if (VectorType *VT = dyn_cast<VectorType>(BCI->getOperand(0)->getType()))
185  if (VT->getNumElements() == VectorWidth)
186  if (Value *Elt = findScalarElement(BCI->getOperand(0), IndexVal))
187  return new BitCastInst(Elt, EI.getType());
188  }
189 
190  // If there's a vector PHI feeding a scalar use through this extractelement
191  // instruction, try to scalarize the PHI.
192  if (PHINode *PN = dyn_cast<PHINode>(EI.getOperand(0))) {
193  Instruction *scalarPHI = scalarizePHI(EI, PN);
194  if (scalarPHI)
195  return scalarPHI;
196  }
197  }
198 
199  if (Instruction *I = dyn_cast<Instruction>(EI.getOperand(0))) {
200  // Push extractelement into predecessor operation if legal and
201  // profitable to do so.
202  if (BinaryOperator *BO = dyn_cast<BinaryOperator>(I)) {
203  if (I->hasOneUse() &&
204  cheapToScalarize(BO, isa<ConstantInt>(EI.getOperand(1)))) {
205  Value *newEI0 =
206  Builder->CreateExtractElement(BO->getOperand(0), EI.getOperand(1),
207  EI.getName()+".lhs");
208  Value *newEI1 =
209  Builder->CreateExtractElement(BO->getOperand(1), EI.getOperand(1),
210  EI.getName()+".rhs");
211  return BinaryOperator::CreateWithCopiedFlags(BO->getOpcode(),
212  newEI0, newEI1, BO);
213  }
214  } else if (InsertElementInst *IE = dyn_cast<InsertElementInst>(I)) {
215  // Extracting the inserted element?
216  if (IE->getOperand(2) == EI.getOperand(1))
217  return replaceInstUsesWith(EI, IE->getOperand(1));
218  // If the inserted and extracted elements are constants, they must not
219  // be the same value, extract from the pre-inserted value instead.
220  if (isa<Constant>(IE->getOperand(2)) && isa<Constant>(EI.getOperand(1))) {
221  Worklist.AddValue(EI.getOperand(0));
222  EI.setOperand(0, IE->getOperand(0));
223  return &EI;
224  }
225  } else if (ShuffleVectorInst *SVI = dyn_cast<ShuffleVectorInst>(I)) {
226  // If this is extracting an element from a shufflevector, figure out where
227  // it came from and extract from the appropriate input element instead.
228  if (ConstantInt *Elt = dyn_cast<ConstantInt>(EI.getOperand(1))) {
229  int SrcIdx = SVI->getMaskValue(Elt->getZExtValue());
230  Value *Src;
231  unsigned LHSWidth =
232  SVI->getOperand(0)->getType()->getVectorNumElements();
233 
234  if (SrcIdx < 0)
235  return replaceInstUsesWith(EI, UndefValue::get(EI.getType()));
236  if (SrcIdx < (int)LHSWidth)
237  Src = SVI->getOperand(0);
238  else {
239  SrcIdx -= LHSWidth;
240  Src = SVI->getOperand(1);
241  }
243  return ExtractElementInst::Create(Src,
244  ConstantInt::get(Int32Ty,
245  SrcIdx, false));
246  }
247  } else if (CastInst *CI = dyn_cast<CastInst>(I)) {
248  // Canonicalize extractelement(cast) -> cast(extractelement).
249  // Bitcasts can change the number of vector elements, and they cost
250  // nothing.
251  if (CI->hasOneUse() && (CI->getOpcode() != Instruction::BitCast)) {
252  Value *EE = Builder->CreateExtractElement(CI->getOperand(0),
253  EI.getIndexOperand());
254  Worklist.AddValue(EE);
255  return CastInst::Create(CI->getOpcode(), EE, EI.getType());
256  }
257  } else if (SelectInst *SI = dyn_cast<SelectInst>(I)) {
258  if (SI->hasOneUse()) {
259  // TODO: For a select on vectors, it might be useful to do this if it
260  // has multiple extractelement uses. For vector select, that seems to
261  // fight the vectorizer.
262 
263  // If we are extracting an element from a vector select or a select on
264  // vectors, create a select on the scalars extracted from the vector
265  // arguments.
266  Value *TrueVal = SI->getTrueValue();
267  Value *FalseVal = SI->getFalseValue();
268 
269  Value *Cond = SI->getCondition();
270  if (Cond->getType()->isVectorTy()) {
271  Cond = Builder->CreateExtractElement(Cond,
272  EI.getIndexOperand(),
273  Cond->getName() + ".elt");
274  }
275 
276  Value *V1Elem
277  = Builder->CreateExtractElement(TrueVal,
278  EI.getIndexOperand(),
279  TrueVal->getName() + ".elt");
280 
281  Value *V2Elem
282  = Builder->CreateExtractElement(FalseVal,
283  EI.getIndexOperand(),
284  FalseVal->getName() + ".elt");
285  return SelectInst::Create(Cond,
286  V1Elem,
287  V2Elem,
288  SI->getName() + ".elt");
289  }
290  }
291  }
292  return nullptr;
293 }
294 
295 /// If V is a shuffle of values that ONLY returns elements from either LHS or
296 /// RHS, return the shuffle mask and true. Otherwise, return false.
297 static bool collectSingleShuffleElements(Value *V, Value *LHS, Value *RHS,
299  assert(LHS->getType() == RHS->getType() &&
300  "Invalid CollectSingleShuffleElements");
301  unsigned NumElts = V->getType()->getVectorNumElements();
302 
303  if (isa<UndefValue>(V)) {
304  Mask.assign(NumElts, UndefValue::get(Type::getInt32Ty(V->getContext())));
305  return true;
306  }
307 
308  if (V == LHS) {
309  for (unsigned i = 0; i != NumElts; ++i)
311  return true;
312  }
313 
314  if (V == RHS) {
315  for (unsigned i = 0; i != NumElts; ++i)
317  i+NumElts));
318  return true;
319  }
320 
321  if (InsertElementInst *IEI = dyn_cast<InsertElementInst>(V)) {
322  // If this is an insert of an extract from some other vector, include it.
323  Value *VecOp = IEI->getOperand(0);
324  Value *ScalarOp = IEI->getOperand(1);
325  Value *IdxOp = IEI->getOperand(2);
326 
327  if (!isa<ConstantInt>(IdxOp))
328  return false;
329  unsigned InsertedIdx = cast<ConstantInt>(IdxOp)->getZExtValue();
330 
331  if (isa<UndefValue>(ScalarOp)) { // inserting undef into vector.
332  // We can handle this if the vector we are inserting into is
333  // transitively ok.
334  if (collectSingleShuffleElements(VecOp, LHS, RHS, Mask)) {
335  // If so, update the mask to reflect the inserted undef.
336  Mask[InsertedIdx] = UndefValue::get(Type::getInt32Ty(V->getContext()));
337  return true;
338  }
339  } else if (ExtractElementInst *EI = dyn_cast<ExtractElementInst>(ScalarOp)){
340  if (isa<ConstantInt>(EI->getOperand(1))) {
341  unsigned ExtractedIdx =
342  cast<ConstantInt>(EI->getOperand(1))->getZExtValue();
343  unsigned NumLHSElts = LHS->getType()->getVectorNumElements();
344 
345  // This must be extracting from either LHS or RHS.
346  if (EI->getOperand(0) == LHS || EI->getOperand(0) == RHS) {
347  // We can handle this if the vector we are inserting into is
348  // transitively ok.
349  if (collectSingleShuffleElements(VecOp, LHS, RHS, Mask)) {
350  // If so, update the mask to reflect the inserted value.
351  if (EI->getOperand(0) == LHS) {
352  Mask[InsertedIdx % NumElts] =
354  ExtractedIdx);
355  } else {
356  assert(EI->getOperand(0) == RHS);
357  Mask[InsertedIdx % NumElts] =
359  ExtractedIdx + NumLHSElts);
360  }
361  return true;
362  }
363  }
364  }
365  }
366  }
367 
368  return false;
369 }
370 
371 /// If we have insertion into a vector that is wider than the vector that we
372 /// are extracting from, try to widen the source vector to allow a single
373 /// shufflevector to replace one or more insert/extract pairs.
375  ExtractElementInst *ExtElt,
376  InstCombiner &IC) {
377  VectorType *InsVecType = InsElt->getType();
378  VectorType *ExtVecType = ExtElt->getVectorOperandType();
379  unsigned NumInsElts = InsVecType->getVectorNumElements();
380  unsigned NumExtElts = ExtVecType->getVectorNumElements();
381 
382  // The inserted-to vector must be wider than the extracted-from vector.
383  if (InsVecType->getElementType() != ExtVecType->getElementType() ||
384  NumExtElts >= NumInsElts)
385  return;
386 
387  // Create a shuffle mask to widen the extended-from vector using undefined
388  // values. The mask selects all of the values of the original vector followed
389  // by as many undefined values as needed to create a vector of the same length
390  // as the inserted-to vector.
391  SmallVector<Constant *, 16> ExtendMask;
392  IntegerType *IntType = Type::getInt32Ty(InsElt->getContext());
393  for (unsigned i = 0; i < NumExtElts; ++i)
394  ExtendMask.push_back(ConstantInt::get(IntType, i));
395  for (unsigned i = NumExtElts; i < NumInsElts; ++i)
396  ExtendMask.push_back(UndefValue::get(IntType));
397 
398  Value *ExtVecOp = ExtElt->getVectorOperand();
399  auto *ExtVecOpInst = dyn_cast<Instruction>(ExtVecOp);
400  BasicBlock *InsertionBlock = (ExtVecOpInst && !isa<PHINode>(ExtVecOpInst))
401  ? ExtVecOpInst->getParent()
402  : ExtElt->getParent();
403 
404  // TODO: This restriction matches the basic block check below when creating
405  // new extractelement instructions. If that limitation is removed, this one
406  // could also be removed. But for now, we just bail out to ensure that we
407  // will replace the extractelement instruction that is feeding our
408  // insertelement instruction. This allows the insertelement to then be
409  // replaced by a shufflevector. If the insertelement is not replaced, we can
410  // induce infinite looping because there's an optimization for extractelement
411  // that will delete our widening shuffle. This would trigger another attempt
412  // here to create that shuffle, and we spin forever.
413  if (InsertionBlock != InsElt->getParent())
414  return;
415 
416  // TODO: This restriction matches the check in visitInsertElementInst() and
417  // prevents an infinite loop caused by not turning the extract/insert pair
418  // into a shuffle. We really should not need either check, but we're lacking
419  // folds for shufflevectors because we're afraid to generate shuffle masks
420  // that the backend can't handle.
421  if (InsElt->hasOneUse() && isa<InsertElementInst>(InsElt->user_back()))
422  return;
423 
424  auto *WideVec = new ShuffleVectorInst(ExtVecOp, UndefValue::get(ExtVecType),
425  ConstantVector::get(ExtendMask));
426 
427  // Insert the new shuffle after the vector operand of the extract is defined
428  // (as long as it's not a PHI) or at the start of the basic block of the
429  // extract, so any subsequent extracts in the same basic block can use it.
430  // TODO: Insert before the earliest ExtractElementInst that is replaced.
431  if (ExtVecOpInst && !isa<PHINode>(ExtVecOpInst))
432  WideVec->insertAfter(ExtVecOpInst);
433  else
434  IC.InsertNewInstWith(WideVec, *ExtElt->getParent()->getFirstInsertionPt());
435 
436  // Replace extracts from the original narrow vector with extracts from the new
437  // wide vector.
438  for (User *U : ExtVecOp->users()) {
440  if (!OldExt || OldExt->getParent() != WideVec->getParent())
441  continue;
442  auto *NewExt = ExtractElementInst::Create(WideVec, OldExt->getOperand(1));
443  NewExt->insertAfter(WideVec);
444  IC.replaceInstUsesWith(*OldExt, NewExt);
445  }
446 }
447 
448 /// We are building a shuffle to create V, which is a sequence of insertelement,
449 /// extractelement pairs. If PermittedRHS is set, then we must either use it or
450 /// not rely on the second vector source. Return a std::pair containing the
451 /// left and right vectors of the proposed shuffle (or 0), and set the Mask
452 /// parameter as required.
453 ///
454 /// Note: we intentionally don't try to fold earlier shuffles since they have
455 /// often been chosen carefully to be efficiently implementable on the target.
456 typedef std::pair<Value *, Value *> ShuffleOps;
457 
460  Value *PermittedRHS,
461  InstCombiner &IC) {
462  assert(V->getType()->isVectorTy() && "Invalid shuffle!");
463  unsigned NumElts = V->getType()->getVectorNumElements();
464 
465  if (isa<UndefValue>(V)) {
466  Mask.assign(NumElts, UndefValue::get(Type::getInt32Ty(V->getContext())));
467  return std::make_pair(
468  PermittedRHS ? UndefValue::get(PermittedRHS->getType()) : V, nullptr);
469  }
470 
471  if (isa<ConstantAggregateZero>(V)) {
472  Mask.assign(NumElts, ConstantInt::get(Type::getInt32Ty(V->getContext()),0));
473  return std::make_pair(V, nullptr);
474  }
475 
476  if (InsertElementInst *IEI = dyn_cast<InsertElementInst>(V)) {
477  // If this is an insert of an extract from some other vector, include it.
478  Value *VecOp = IEI->getOperand(0);
479  Value *ScalarOp = IEI->getOperand(1);
480  Value *IdxOp = IEI->getOperand(2);
481 
482  if (ExtractElementInst *EI = dyn_cast<ExtractElementInst>(ScalarOp)) {
483  if (isa<ConstantInt>(EI->getOperand(1)) && isa<ConstantInt>(IdxOp)) {
484  unsigned ExtractedIdx =
485  cast<ConstantInt>(EI->getOperand(1))->getZExtValue();
486  unsigned InsertedIdx = cast<ConstantInt>(IdxOp)->getZExtValue();
487 
488  // Either the extracted from or inserted into vector must be RHSVec,
489  // otherwise we'd end up with a shuffle of three inputs.
490  if (EI->getOperand(0) == PermittedRHS || PermittedRHS == nullptr) {
491  Value *RHS = EI->getOperand(0);
492  ShuffleOps LR = collectShuffleElements(VecOp, Mask, RHS, IC);
493  assert(LR.second == nullptr || LR.second == RHS);
494 
495  if (LR.first->getType() != RHS->getType()) {
496  // Although we are giving up for now, see if we can create extracts
497  // that match the inserts for another round of combining.
498  replaceExtractElements(IEI, EI, IC);
499 
500  // We tried our best, but we can't find anything compatible with RHS
501  // further up the chain. Return a trivial shuffle.
502  for (unsigned i = 0; i < NumElts; ++i)
504  return std::make_pair(V, nullptr);
505  }
506 
507  unsigned NumLHSElts = RHS->getType()->getVectorNumElements();
508  Mask[InsertedIdx % NumElts] =
510  NumLHSElts+ExtractedIdx);
511  return std::make_pair(LR.first, RHS);
512  }
513 
514  if (VecOp == PermittedRHS) {
515  // We've gone as far as we can: anything on the other side of the
516  // extractelement will already have been converted into a shuffle.
517  unsigned NumLHSElts =
519  for (unsigned i = 0; i != NumElts; ++i)
522  i == InsertedIdx ? ExtractedIdx : NumLHSElts + i));
523  return std::make_pair(EI->getOperand(0), PermittedRHS);
524  }
525 
526  // If this insertelement is a chain that comes from exactly these two
527  // vectors, return the vector and the effective shuffle.
528  if (EI->getOperand(0)->getType() == PermittedRHS->getType() &&
529  collectSingleShuffleElements(IEI, EI->getOperand(0), PermittedRHS,
530  Mask))
531  return std::make_pair(EI->getOperand(0), PermittedRHS);
532  }
533  }
534  }
535 
536  // Otherwise, we can't do anything fancy. Return an identity vector.
537  for (unsigned i = 0; i != NumElts; ++i)
539  return std::make_pair(V, nullptr);
540 }
541 
542 /// Try to find redundant insertvalue instructions, like the following ones:
543 /// %0 = insertvalue { i8, i32 } undef, i8 %x, 0
544 /// %1 = insertvalue { i8, i32 } %0, i8 %y, 0
545 /// Here the second instruction inserts values at the same indices, as the
546 /// first one, making the first one redundant.
547 /// It should be transformed to:
548 /// %0 = insertvalue { i8, i32 } undef, i8 %y, 0
550  bool IsRedundant = false;
551  ArrayRef<unsigned int> FirstIndices = I.getIndices();
552 
553  // If there is a chain of insertvalue instructions (each of them except the
554  // last one has only one use and it's another insertvalue insn from this
555  // chain), check if any of the 'children' uses the same indices as the first
556  // instruction. In this case, the first one is redundant.
557  Value *V = &I;
558  unsigned Depth = 0;
559  while (V->hasOneUse() && Depth < 10) {
560  User *U = V->user_back();
561  auto UserInsInst = dyn_cast<InsertValueInst>(U);
562  if (!UserInsInst || U->getOperand(0) != V)
563  break;
564  if (UserInsInst->getIndices() == FirstIndices) {
565  IsRedundant = true;
566  break;
567  }
568  V = UserInsInst;
569  Depth++;
570  }
571 
572  if (IsRedundant)
573  return replaceInstUsesWith(I, I.getOperand(0));
574  return nullptr;
575 }
576 
578  int MaskSize = Shuf.getMask()->getType()->getVectorNumElements();
579  int VecSize = Shuf.getOperand(0)->getType()->getVectorNumElements();
580 
581  // A vector select does not change the size of the operands.
582  if (MaskSize != VecSize)
583  return false;
584 
585  // Each mask element must be undefined or choose a vector element from one of
586  // the source operands without crossing vector lanes.
587  for (int i = 0; i != MaskSize; ++i) {
588  int Elt = Shuf.getMaskValue(i);
589  if (Elt != -1 && Elt != i && Elt != i + VecSize)
590  return false;
591  }
592 
593  return true;
594 }
595 
596 // Turn a chain of inserts that splats a value into a canonical insert + shuffle
597 // splat. That is:
598 // insertelt(insertelt(insertelt(insertelt X, %k, 0), %k, 1), %k, 2) ... ->
599 // shufflevector(insertelt(X, %k, 0), undef, zero)
601  // We are interested in the last insert in a chain. So, if this insert
602  // has a single user, and that user is an insert, bail.
603  if (InsElt.hasOneUse() && isa<InsertElementInst>(InsElt.user_back()))
604  return nullptr;
605 
606  VectorType *VT = cast<VectorType>(InsElt.getType());
607  int NumElements = VT->getNumElements();
608 
609  // Do not try to do this for a one-element vector, since that's a nop,
610  // and will cause an inf-loop.
611  if (NumElements == 1)
612  return nullptr;
613 
614  Value *SplatVal = InsElt.getOperand(1);
615  InsertElementInst *CurrIE = &InsElt;
616  SmallVector<bool, 16> ElementPresent(NumElements, false);
617 
618  // Walk the chain backwards, keeping track of which indices we inserted into,
619  // until we hit something that isn't an insert of the splatted value.
620  while (CurrIE) {
621  ConstantInt *Idx = dyn_cast<ConstantInt>(CurrIE->getOperand(2));
622  if (!Idx || CurrIE->getOperand(1) != SplatVal)
623  return nullptr;
624 
625  // Check none of the intermediate steps have any additional uses.
626  if ((CurrIE != &InsElt) && !CurrIE->hasOneUse())
627  return nullptr;
628 
629  ElementPresent[Idx->getZExtValue()] = true;
630  CurrIE = dyn_cast<InsertElementInst>(CurrIE->getOperand(0));
631  }
632 
633  // Make sure we've seen an insert into every element.
634  if (llvm::any_of(ElementPresent, [](bool Present) { return !Present; }))
635  return nullptr;
636 
637  // All right, create the insert + shuffle.
638  Instruction *InsertFirst = InsertElementInst::Create(
639  UndefValue::get(VT), SplatVal,
640  ConstantInt::get(Type::getInt32Ty(InsElt.getContext()), 0), "", &InsElt);
641 
643  VectorType::get(Type::getInt32Ty(InsElt.getContext()), NumElements));
644 
645  return new ShuffleVectorInst(InsertFirst, UndefValue::get(VT), ZeroMask);
646 }
647 
648 /// insertelt (shufflevector X, CVec, Mask|insertelt X, C1, CIndex1), C, CIndex
649 /// --> shufflevector X, CVec', Mask'
651  auto *Inst = dyn_cast<Instruction>(InsElt.getOperand(0));
652  // Bail out if the parent has more than one use. In that case, we'd be
653  // replacing the insertelt with a shuffle, and that's not a clear win.
654  if (!Inst || !Inst->hasOneUse())
655  return nullptr;
656  if (auto *Shuf = dyn_cast<ShuffleVectorInst>(InsElt.getOperand(0))) {
657  // The shuffle must have a constant vector operand. The insertelt must have
658  // a constant scalar being inserted at a constant position in the vector.
659  Constant *ShufConstVec, *InsEltScalar;
660  uint64_t InsEltIndex;
661  if (!match(Shuf->getOperand(1), m_Constant(ShufConstVec)) ||
662  !match(InsElt.getOperand(1), m_Constant(InsEltScalar)) ||
663  !match(InsElt.getOperand(2), m_ConstantInt(InsEltIndex)))
664  return nullptr;
665 
666  // Adding an element to an arbitrary shuffle could be expensive, but a
667  // shuffle that selects elements from vectors without crossing lanes is
668  // assumed cheap.
669  // If we're just adding a constant into that shuffle, it will still be
670  // cheap.
671  if (!isShuffleEquivalentToSelect(*Shuf))
672  return nullptr;
673 
674  // From the above 'select' check, we know that the mask has the same number
675  // of elements as the vector input operands. We also know that each constant
676  // input element is used in its lane and can not be used more than once by
677  // the shuffle. Therefore, replace the constant in the shuffle's constant
678  // vector with the insertelt constant. Replace the constant in the shuffle's
679  // mask vector with the insertelt index plus the length of the vector
680  // (because the constant vector operand of a shuffle is always the 2nd
681  // operand).
682  Constant *Mask = Shuf->getMask();
683  unsigned NumElts = Mask->getType()->getVectorNumElements();
684  SmallVector<Constant *, 16> NewShufElts(NumElts);
685  SmallVector<Constant *, 16> NewMaskElts(NumElts);
686  for (unsigned I = 0; I != NumElts; ++I) {
687  if (I == InsEltIndex) {
688  NewShufElts[I] = InsEltScalar;
689  Type *Int32Ty = Type::getInt32Ty(Shuf->getContext());
690  NewMaskElts[I] = ConstantInt::get(Int32Ty, InsEltIndex + NumElts);
691  } else {
692  // Copy over the existing values.
693  NewShufElts[I] = ShufConstVec->getAggregateElement(I);
694  NewMaskElts[I] = Mask->getAggregateElement(I);
695  }
696  }
697 
698  // Create new operands for a shuffle that includes the constant of the
699  // original insertelt. The old shuffle will be dead now.
700  return new ShuffleVectorInst(Shuf->getOperand(0),
701  ConstantVector::get(NewShufElts),
702  ConstantVector::get(NewMaskElts));
703  } else if (auto *IEI = dyn_cast<InsertElementInst>(Inst)) {
704  // Transform sequences of insertelements ops with constant data/indexes into
705  // a single shuffle op.
706  unsigned NumElts = InsElt.getType()->getNumElements();
707 
708  uint64_t InsertIdx[2];
709  Constant *Val[2];
710  if (!match(InsElt.getOperand(2), m_ConstantInt(InsertIdx[0])) ||
711  !match(InsElt.getOperand(1), m_Constant(Val[0])) ||
712  !match(IEI->getOperand(2), m_ConstantInt(InsertIdx[1])) ||
713  !match(IEI->getOperand(1), m_Constant(Val[1])))
714  return nullptr;
715  SmallVector<Constant *, 16> Values(NumElts);
717  auto ValI = std::begin(Val);
718  // Generate new constant vector and mask.
719  // We have 2 values/masks from the insertelements instructions. Insert them
720  // into new value/mask vectors.
721  for (uint64_t I : InsertIdx) {
722  if (!Values[I]) {
723  assert(!Mask[I]);
724  Values[I] = *ValI;
725  Mask[I] = ConstantInt::get(Type::getInt32Ty(InsElt.getContext()),
726  NumElts + I);
727  }
728  ++ValI;
729  }
730  // Remaining values are filled with 'undef' values.
731  for (unsigned I = 0; I < NumElts; ++I) {
732  if (!Values[I]) {
733  assert(!Mask[I]);
734  Values[I] = UndefValue::get(InsElt.getType()->getElementType());
735  Mask[I] = ConstantInt::get(Type::getInt32Ty(InsElt.getContext()), I);
736  }
737  }
738  // Create new operands for a shuffle that includes the constant of the
739  // original insertelt.
740  return new ShuffleVectorInst(IEI->getOperand(0),
741  ConstantVector::get(Values),
742  ConstantVector::get(Mask));
743  }
744  return nullptr;
745 }
746 
748  Value *VecOp = IE.getOperand(0);
749  Value *ScalarOp = IE.getOperand(1);
750  Value *IdxOp = IE.getOperand(2);
751 
752  // Inserting an undef or into an undefined place, remove this.
753  if (isa<UndefValue>(ScalarOp) || isa<UndefValue>(IdxOp))
754  replaceInstUsesWith(IE, VecOp);
755 
756  // If the inserted element was extracted from some other vector, and if the
757  // indexes are constant, try to turn this into a shufflevector operation.
758  if (ExtractElementInst *EI = dyn_cast<ExtractElementInst>(ScalarOp)) {
759  if (isa<ConstantInt>(EI->getOperand(1)) && isa<ConstantInt>(IdxOp)) {
760  unsigned NumInsertVectorElts = IE.getType()->getNumElements();
761  unsigned NumExtractVectorElts =
763  unsigned ExtractedIdx =
764  cast<ConstantInt>(EI->getOperand(1))->getZExtValue();
765  unsigned InsertedIdx = cast<ConstantInt>(IdxOp)->getZExtValue();
766 
767  if (ExtractedIdx >= NumExtractVectorElts) // Out of range extract.
768  return replaceInstUsesWith(IE, VecOp);
769 
770  if (InsertedIdx >= NumInsertVectorElts) // Out of range insert.
771  return replaceInstUsesWith(IE, UndefValue::get(IE.getType()));
772 
773  // If we are extracting a value from a vector, then inserting it right
774  // back into the same place, just use the input vector.
775  if (EI->getOperand(0) == VecOp && ExtractedIdx == InsertedIdx)
776  return replaceInstUsesWith(IE, VecOp);
777 
778  // If this insertelement isn't used by some other insertelement, turn it
779  // (and any insertelements it points to), into one big shuffle.
780  if (!IE.hasOneUse() || !isa<InsertElementInst>(IE.user_back())) {
782  ShuffleOps LR = collectShuffleElements(&IE, Mask, nullptr, *this);
783 
784  // The proposed shuffle may be trivial, in which case we shouldn't
785  // perform the combine.
786  if (LR.first != &IE && LR.second != &IE) {
787  // We now have a shuffle of LHS, RHS, Mask.
788  if (LR.second == nullptr)
789  LR.second = UndefValue::get(LR.first->getType());
790  return new ShuffleVectorInst(LR.first, LR.second,
791  ConstantVector::get(Mask));
792  }
793  }
794  }
795  }
796 
797  unsigned VWidth = VecOp->getType()->getVectorNumElements();
798  APInt UndefElts(VWidth, 0);
799  APInt AllOnesEltMask(APInt::getAllOnesValue(VWidth));
800  if (Value *V = SimplifyDemandedVectorElts(&IE, AllOnesEltMask, UndefElts)) {
801  if (V != &IE)
802  return replaceInstUsesWith(IE, V);
803  return &IE;
804  }
805 
807  return Shuf;
808 
809  // Turn a sequence of inserts that broadcasts a scalar into a single
810  // insert + shufflevector.
811  if (Instruction *Broadcast = foldInsSequenceIntoBroadcast(IE))
812  return Broadcast;
813 
814  return nullptr;
815 }
816 
817 /// Return true if we can evaluate the specified expression tree if the vector
818 /// elements were shuffled in a different order.
820  unsigned Depth = 5) {
821  // We can always reorder the elements of a constant.
822  if (isa<Constant>(V))
823  return true;
824 
825  // We won't reorder vector arguments. No IPO here.
827  if (!I) return false;
828 
829  // Two users may expect different orders of the elements. Don't try it.
830  if (!I->hasOneUse())
831  return false;
832 
833  if (Depth == 0) return false;
834 
835  switch (I->getOpcode()) {
836  case Instruction::Add:
837  case Instruction::FAdd:
838  case Instruction::Sub:
839  case Instruction::FSub:
840  case Instruction::Mul:
841  case Instruction::FMul:
842  case Instruction::UDiv:
843  case Instruction::SDiv:
844  case Instruction::FDiv:
845  case Instruction::URem:
846  case Instruction::SRem:
847  case Instruction::FRem:
848  case Instruction::Shl:
849  case Instruction::LShr:
850  case Instruction::AShr:
851  case Instruction::And:
852  case Instruction::Or:
853  case Instruction::Xor:
854  case Instruction::ICmp:
855  case Instruction::FCmp:
856  case Instruction::Trunc:
857  case Instruction::ZExt:
858  case Instruction::SExt:
859  case Instruction::FPToUI:
860  case Instruction::FPToSI:
861  case Instruction::UIToFP:
862  case Instruction::SIToFP:
863  case Instruction::FPTrunc:
864  case Instruction::FPExt:
865  case Instruction::GetElementPtr: {
866  for (Value *Operand : I->operands()) {
867  if (!CanEvaluateShuffled(Operand, Mask, Depth-1))
868  return false;
869  }
870  return true;
871  }
872  case Instruction::InsertElement: {
874  if (!CI) return false;
875  int ElementNumber = CI->getLimitedValue();
876 
877  // Verify that 'CI' does not occur twice in Mask. A single 'insertelement'
878  // can't put an element into multiple indices.
879  bool SeenOnce = false;
880  for (int i = 0, e = Mask.size(); i != e; ++i) {
881  if (Mask[i] == ElementNumber) {
882  if (SeenOnce)
883  return false;
884  SeenOnce = true;
885  }
886  }
887  return CanEvaluateShuffled(I->getOperand(0), Mask, Depth-1);
888  }
889  }
890  return false;
891 }
892 
893 /// Rebuild a new instruction just like 'I' but with the new operands given.
894 /// In the event of type mismatch, the type of the operands is correct.
896  // We don't want to use the IRBuilder here because we want the replacement
897  // instructions to appear next to 'I', not the builder's insertion point.
898  switch (I->getOpcode()) {
899  case Instruction::Add:
900  case Instruction::FAdd:
901  case Instruction::Sub:
902  case Instruction::FSub:
903  case Instruction::Mul:
904  case Instruction::FMul:
905  case Instruction::UDiv:
906  case Instruction::SDiv:
907  case Instruction::FDiv:
908  case Instruction::URem:
909  case Instruction::SRem:
910  case Instruction::FRem:
911  case Instruction::Shl:
912  case Instruction::LShr:
913  case Instruction::AShr:
914  case Instruction::And:
915  case Instruction::Or:
916  case Instruction::Xor: {
917  BinaryOperator *BO = cast<BinaryOperator>(I);
918  assert(NewOps.size() == 2 && "binary operator with #ops != 2");
919  BinaryOperator *New =
920  BinaryOperator::Create(cast<BinaryOperator>(I)->getOpcode(),
921  NewOps[0], NewOps[1], "", BO);
922  if (isa<OverflowingBinaryOperator>(BO)) {
923  New->setHasNoUnsignedWrap(BO->hasNoUnsignedWrap());
924  New->setHasNoSignedWrap(BO->hasNoSignedWrap());
925  }
926  if (isa<PossiblyExactOperator>(BO)) {
927  New->setIsExact(BO->isExact());
928  }
929  if (isa<FPMathOperator>(BO))
930  New->copyFastMathFlags(I);
931  return New;
932  }
933  case Instruction::ICmp:
934  assert(NewOps.size() == 2 && "icmp with #ops != 2");
935  return new ICmpInst(I, cast<ICmpInst>(I)->getPredicate(),
936  NewOps[0], NewOps[1]);
937  case Instruction::FCmp:
938  assert(NewOps.size() == 2 && "fcmp with #ops != 2");
939  return new FCmpInst(I, cast<FCmpInst>(I)->getPredicate(),
940  NewOps[0], NewOps[1]);
941  case Instruction::Trunc:
942  case Instruction::ZExt:
943  case Instruction::SExt:
944  case Instruction::FPToUI:
945  case Instruction::FPToSI:
946  case Instruction::UIToFP:
947  case Instruction::SIToFP:
948  case Instruction::FPTrunc:
949  case Instruction::FPExt: {
950  // It's possible that the mask has a different number of elements from
951  // the original cast. We recompute the destination type to match the mask.
952  Type *DestTy =
954  NewOps[0]->getType()->getVectorNumElements());
955  assert(NewOps.size() == 1 && "cast with #ops != 1");
956  return CastInst::Create(cast<CastInst>(I)->getOpcode(), NewOps[0], DestTy,
957  "", I);
958  }
959  case Instruction::GetElementPtr: {
960  Value *Ptr = NewOps[0];
961  ArrayRef<Value*> Idx = NewOps.slice(1);
963  cast<GetElementPtrInst>(I)->getSourceElementType(), Ptr, Idx, "", I);
964  GEP->setIsInBounds(cast<GetElementPtrInst>(I)->isInBounds());
965  return GEP;
966  }
967  }
968  llvm_unreachable("failed to rebuild vector instructions");
969 }
970 
971 Value *
972 InstCombiner::EvaluateInDifferentElementOrder(Value *V, ArrayRef<int> Mask) {
973  // Mask.size() does not need to be equal to the number of vector elements.
974 
975  assert(V->getType()->isVectorTy() && "can't reorder non-vector elements");
976  if (isa<UndefValue>(V)) {
978  Mask.size()));
979  }
980  if (isa<ConstantAggregateZero>(V)) {
983  Mask.size()));
984  }
985  if (Constant *C = dyn_cast<Constant>(V)) {
986  SmallVector<Constant *, 16> MaskValues;
987  for (int i = 0, e = Mask.size(); i != e; ++i) {
988  if (Mask[i] == -1)
989  MaskValues.push_back(UndefValue::get(Builder->getInt32Ty()));
990  else
991  MaskValues.push_back(Builder->getInt32(Mask[i]));
992  }
994  ConstantVector::get(MaskValues));
995  }
996 
997  Instruction *I = cast<Instruction>(V);
998  switch (I->getOpcode()) {
999  case Instruction::Add:
1000  case Instruction::FAdd:
1001  case Instruction::Sub:
1002  case Instruction::FSub:
1003  case Instruction::Mul:
1004  case Instruction::FMul:
1005  case Instruction::UDiv:
1006  case Instruction::SDiv:
1007  case Instruction::FDiv:
1008  case Instruction::URem:
1009  case Instruction::SRem:
1010  case Instruction::FRem:
1011  case Instruction::Shl:
1012  case Instruction::LShr:
1013  case Instruction::AShr:
1014  case Instruction::And:
1015  case Instruction::Or:
1016  case Instruction::Xor:
1017  case Instruction::ICmp:
1018  case Instruction::FCmp:
1019  case Instruction::Trunc:
1020  case Instruction::ZExt:
1021  case Instruction::SExt:
1022  case Instruction::FPToUI:
1023  case Instruction::FPToSI:
1024  case Instruction::UIToFP:
1025  case Instruction::SIToFP:
1026  case Instruction::FPTrunc:
1027  case Instruction::FPExt:
1028  case Instruction::Select:
1029  case Instruction::GetElementPtr: {
1030  SmallVector<Value*, 8> NewOps;
1031  bool NeedsRebuild = (Mask.size() != I->getType()->getVectorNumElements());
1032  for (int i = 0, e = I->getNumOperands(); i != e; ++i) {
1033  Value *V = EvaluateInDifferentElementOrder(I->getOperand(i), Mask);
1034  NewOps.push_back(V);
1035  NeedsRebuild |= (V != I->getOperand(i));
1036  }
1037  if (NeedsRebuild) {
1038  return buildNew(I, NewOps);
1039  }
1040  return I;
1041  }
1042  case Instruction::InsertElement: {
1043  int Element = cast<ConstantInt>(I->getOperand(2))->getLimitedValue();
1044 
1045  // The insertelement was inserting at Element. Figure out which element
1046  // that becomes after shuffling. The answer is guaranteed to be unique
1047  // by CanEvaluateShuffled.
1048  bool Found = false;
1049  int Index = 0;
1050  for (int e = Mask.size(); Index != e; ++Index) {
1051  if (Mask[Index] == Element) {
1052  Found = true;
1053  break;
1054  }
1055  }
1056 
1057  // If element is not in Mask, no need to handle the operand 1 (element to
1058  // be inserted). Just evaluate values in operand 0 according to Mask.
1059  if (!Found)
1060  return EvaluateInDifferentElementOrder(I->getOperand(0), Mask);
1061 
1062  Value *V = EvaluateInDifferentElementOrder(I->getOperand(0), Mask);
1063  return InsertElementInst::Create(V, I->getOperand(1),
1064  Builder->getInt32(Index), "", I);
1065  }
1066  }
1067  llvm_unreachable("failed to reorder elements of vector instruction!");
1068 }
1069 
1071  bool &isLHSID, bool &isRHSID) {
1072  isLHSID = isRHSID = true;
1073 
1074  for (unsigned i = 0, e = Mask.size(); i != e; ++i) {
1075  if (Mask[i] < 0) continue; // Ignore undef values.
1076  // Is this an identity shuffle of the LHS value?
1077  isLHSID &= (Mask[i] == (int)i);
1078 
1079  // Is this an identity shuffle of the RHS value?
1080  isRHSID &= (Mask[i]-e == i);
1081  }
1082 }
1083 
1084 // Returns true if the shuffle is extracting a contiguous range of values from
1085 // LHS, for example:
1086 // +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
1087 // Input: |AA|BB|CC|DD|EE|FF|GG|HH|II|JJ|KK|LL|MM|NN|OO|PP|
1088 // Shuffles to: |EE|FF|GG|HH|
1089 // +--+--+--+--+
1091  SmallVector<int, 16> &Mask) {
1092  unsigned LHSElems = SVI.getOperand(0)->getType()->getVectorNumElements();
1093  unsigned MaskElems = Mask.size();
1094  unsigned BegIdx = Mask.front();
1095  unsigned EndIdx = Mask.back();
1096  if (BegIdx > EndIdx || EndIdx >= LHSElems || EndIdx - BegIdx != MaskElems - 1)
1097  return false;
1098  for (unsigned I = 0; I != MaskElems; ++I)
1099  if (static_cast<unsigned>(Mask[I]) != BegIdx + I)
1100  return false;
1101  return true;
1102 }
1103 
1105  Value *LHS = SVI.getOperand(0);
1106  Value *RHS = SVI.getOperand(1);
1107  SmallVector<int, 16> Mask = SVI.getShuffleMask();
1109 
1110  bool MadeChange = false;
1111 
1112  // Undefined shuffle mask -> undefined value.
1113  if (isa<UndefValue>(SVI.getOperand(2)))
1114  return replaceInstUsesWith(SVI, UndefValue::get(SVI.getType()));
1115 
1116  unsigned VWidth = SVI.getType()->getVectorNumElements();
1117 
1118  APInt UndefElts(VWidth, 0);
1119  APInt AllOnesEltMask(APInt::getAllOnesValue(VWidth));
1120  if (Value *V = SimplifyDemandedVectorElts(&SVI, AllOnesEltMask, UndefElts)) {
1121  if (V != &SVI)
1122  return replaceInstUsesWith(SVI, V);
1123  LHS = SVI.getOperand(0);
1124  RHS = SVI.getOperand(1);
1125  MadeChange = true;
1126  }
1127 
1128  unsigned LHSWidth = LHS->getType()->getVectorNumElements();
1129 
1130  // Canonicalize shuffle(x ,x,mask) -> shuffle(x, undef,mask')
1131  // Canonicalize shuffle(undef,x,mask) -> shuffle(x, undef,mask').
1132  if (LHS == RHS || isa<UndefValue>(LHS)) {
1133  if (isa<UndefValue>(LHS) && LHS == RHS) {
1134  // shuffle(undef,undef,mask) -> undef.
1135  Value *Result = (VWidth == LHSWidth)
1136  ? LHS : UndefValue::get(SVI.getType());
1137  return replaceInstUsesWith(SVI, Result);
1138  }
1139 
1140  // Remap any references to RHS to use LHS.
1142  for (unsigned i = 0, e = LHSWidth; i != VWidth; ++i) {
1143  if (Mask[i] < 0) {
1144  Elts.push_back(UndefValue::get(Int32Ty));
1145  continue;
1146  }
1147 
1148  if ((Mask[i] >= (int)e && isa<UndefValue>(RHS)) ||
1149  (Mask[i] < (int)e && isa<UndefValue>(LHS))) {
1150  Mask[i] = -1; // Turn into undef.
1151  Elts.push_back(UndefValue::get(Int32Ty));
1152  } else {
1153  Mask[i] = Mask[i] % e; // Force to LHS.
1154  Elts.push_back(ConstantInt::get(Int32Ty, Mask[i]));
1155  }
1156  }
1157  SVI.setOperand(0, SVI.getOperand(1));
1158  SVI.setOperand(1, UndefValue::get(RHS->getType()));
1159  SVI.setOperand(2, ConstantVector::get(Elts));
1160  LHS = SVI.getOperand(0);
1161  RHS = SVI.getOperand(1);
1162  MadeChange = true;
1163  }
1164 
1165  if (VWidth == LHSWidth) {
1166  // Analyze the shuffle, are the LHS or RHS and identity shuffles?
1167  bool isLHSID, isRHSID;
1168  recognizeIdentityMask(Mask, isLHSID, isRHSID);
1169 
1170  // Eliminate identity shuffles.
1171  if (isLHSID) return replaceInstUsesWith(SVI, LHS);
1172  if (isRHSID) return replaceInstUsesWith(SVI, RHS);
1173  }
1174 
1175  if (isa<UndefValue>(RHS) && CanEvaluateShuffled(LHS, Mask)) {
1176  Value *V = EvaluateInDifferentElementOrder(LHS, Mask);
1177  return replaceInstUsesWith(SVI, V);
1178  }
1179 
1180  // SROA generates shuffle+bitcast when the extracted sub-vector is bitcast to
1181  // a non-vector type. We can instead bitcast the original vector followed by
1182  // an extract of the desired element:
1183  //
1184  // %sroa = shufflevector <16 x i8> %in, <16 x i8> undef,
1185  // <4 x i32> <i32 0, i32 1, i32 2, i32 3>
1186  // %1 = bitcast <4 x i8> %sroa to i32
1187  // Becomes:
1188  // %bc = bitcast <16 x i8> %in to <4 x i32>
1189  // %ext = extractelement <4 x i32> %bc, i32 0
1190  //
1191  // If the shuffle is extracting a contiguous range of values from the input
1192  // vector then each use which is a bitcast of the extracted size can be
1193  // replaced. This will work if the vector types are compatible, and the begin
1194  // index is aligned to a value in the casted vector type. If the begin index
1195  // isn't aligned then we can shuffle the original vector (keeping the same
1196  // vector type) before extracting.
1197  //
1198  // This code will bail out if the target type is fundamentally incompatible
1199  // with vectors of the source type.
1200  //
1201  // Example of <16 x i8>, target type i32:
1202  // Index range [4,8): v-----------v Will work.
1203  // +--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
1204  // <16 x i8>: | | | | | | | | | | | | | | | | |
1205  // <4 x i32>: | | | | |
1206  // +-----------+-----------+-----------+-----------+
1207  // Index range [6,10): ^-----------^ Needs an extra shuffle.
1208  // Target type i40: ^--------------^ Won't work, bail.
1209  if (isShuffleExtractingFromLHS(SVI, Mask)) {
1210  Value *V = LHS;
1211  unsigned MaskElems = Mask.size();
1212  unsigned BegIdx = Mask.front();
1213  VectorType *SrcTy = cast<VectorType>(V->getType());
1214  unsigned VecBitWidth = SrcTy->getBitWidth();
1215  unsigned SrcElemBitWidth = DL.getTypeSizeInBits(SrcTy->getElementType());
1216  assert(SrcElemBitWidth && "vector elements must have a bitwidth");
1217  unsigned SrcNumElems = SrcTy->getNumElements();
1220  for (User *U : SVI.users())
1221  if (BitCastInst *BC = dyn_cast<BitCastInst>(U))
1222  if (!BC->use_empty())
1223  // Only visit bitcasts that weren't previously handled.
1224  BCs.push_back(BC);
1225  for (BitCastInst *BC : BCs) {
1226  Type *TgtTy = BC->getDestTy();
1227  unsigned TgtElemBitWidth = DL.getTypeSizeInBits(TgtTy);
1228  if (!TgtElemBitWidth)
1229  continue;
1230  unsigned TgtNumElems = VecBitWidth / TgtElemBitWidth;
1231  bool VecBitWidthsEqual = VecBitWidth == TgtNumElems * TgtElemBitWidth;
1232  bool BegIsAligned = 0 == ((SrcElemBitWidth * BegIdx) % TgtElemBitWidth);
1233  if (!VecBitWidthsEqual)
1234  continue;
1235  if (!VectorType::isValidElementType(TgtTy))
1236  continue;
1237  VectorType *CastSrcTy = VectorType::get(TgtTy, TgtNumElems);
1238  if (!BegIsAligned) {
1239  // Shuffle the input so [0,NumElements) contains the output, and
1240  // [NumElems,SrcNumElems) is undef.
1241  SmallVector<Constant *, 16> ShuffleMask(SrcNumElems,
1242  UndefValue::get(Int32Ty));
1243  for (unsigned I = 0, E = MaskElems, Idx = BegIdx; I != E; ++Idx, ++I)
1244  ShuffleMask[I] = ConstantInt::get(Int32Ty, Idx);
1245  V = Builder->CreateShuffleVector(V, UndefValue::get(V->getType()),
1246  ConstantVector::get(ShuffleMask),
1247  SVI.getName() + ".extract");
1248  BegIdx = 0;
1249  }
1250  unsigned SrcElemsPerTgtElem = TgtElemBitWidth / SrcElemBitWidth;
1251  assert(SrcElemsPerTgtElem);
1252  BegIdx /= SrcElemsPerTgtElem;
1253  bool BCAlreadyExists = NewBCs.find(CastSrcTy) != NewBCs.end();
1254  auto *NewBC =
1255  BCAlreadyExists
1256  ? NewBCs[CastSrcTy]
1257  : Builder->CreateBitCast(V, CastSrcTy, SVI.getName() + ".bc");
1258  if (!BCAlreadyExists)
1259  NewBCs[CastSrcTy] = NewBC;
1260  auto *Ext = Builder->CreateExtractElement(
1261  NewBC, ConstantInt::get(Int32Ty, BegIdx), SVI.getName() + ".extract");
1262  // The shufflevector isn't being replaced: the bitcast that used it
1263  // is. InstCombine will visit the newly-created instructions.
1264  replaceInstUsesWith(*BC, Ext);
1265  MadeChange = true;
1266  }
1267  }
1268 
1269  // If the LHS is a shufflevector itself, see if we can combine it with this
1270  // one without producing an unusual shuffle.
1271  // Cases that might be simplified:
1272  // 1.
1273  // x1=shuffle(v1,v2,mask1)
1274  // x=shuffle(x1,undef,mask)
1275  // ==>
1276  // x=shuffle(v1,undef,newMask)
1277  // newMask[i] = (mask[i] < x1.size()) ? mask1[mask[i]] : -1
1278  // 2.
1279  // x1=shuffle(v1,undef,mask1)
1280  // x=shuffle(x1,x2,mask)
1281  // where v1.size() == mask1.size()
1282  // ==>
1283  // x=shuffle(v1,x2,newMask)
1284  // newMask[i] = (mask[i] < x1.size()) ? mask1[mask[i]] : mask[i]
1285  // 3.
1286  // x2=shuffle(v2,undef,mask2)
1287  // x=shuffle(x1,x2,mask)
1288  // where v2.size() == mask2.size()
1289  // ==>
1290  // x=shuffle(x1,v2,newMask)
1291  // newMask[i] = (mask[i] < x1.size())
1292  // ? mask[i] : mask2[mask[i]-x1.size()]+x1.size()
1293  // 4.
1294  // x1=shuffle(v1,undef,mask1)
1295  // x2=shuffle(v2,undef,mask2)
1296  // x=shuffle(x1,x2,mask)
1297  // where v1.size() == v2.size()
1298  // ==>
1299  // x=shuffle(v1,v2,newMask)
1300  // newMask[i] = (mask[i] < x1.size())
1301  // ? mask1[mask[i]] : mask2[mask[i]-x1.size()]+v1.size()
1302  //
1303  // Here we are really conservative:
1304  // we are absolutely afraid of producing a shuffle mask not in the input
1305  // program, because the code gen may not be smart enough to turn a merged
1306  // shuffle into two specific shuffles: it may produce worse code. As such,
1307  // we only merge two shuffles if the result is either a splat or one of the
1308  // input shuffle masks. In this case, merging the shuffles just removes
1309  // one instruction, which we know is safe. This is good for things like
1310  // turning: (splat(splat)) -> splat, or
1311  // merge(V[0..n], V[n+1..2n]) -> V[0..2n]
1312  ShuffleVectorInst* LHSShuffle = dyn_cast<ShuffleVectorInst>(LHS);
1313  ShuffleVectorInst* RHSShuffle = dyn_cast<ShuffleVectorInst>(RHS);
1314  if (LHSShuffle)
1315  if (!isa<UndefValue>(LHSShuffle->getOperand(1)) && !isa<UndefValue>(RHS))
1316  LHSShuffle = nullptr;
1317  if (RHSShuffle)
1318  if (!isa<UndefValue>(RHSShuffle->getOperand(1)))
1319  RHSShuffle = nullptr;
1320  if (!LHSShuffle && !RHSShuffle)
1321  return MadeChange ? &SVI : nullptr;
1322 
1323  Value* LHSOp0 = nullptr;
1324  Value* LHSOp1 = nullptr;
1325  Value* RHSOp0 = nullptr;
1326  unsigned LHSOp0Width = 0;
1327  unsigned RHSOp0Width = 0;
1328  if (LHSShuffle) {
1329  LHSOp0 = LHSShuffle->getOperand(0);
1330  LHSOp1 = LHSShuffle->getOperand(1);
1331  LHSOp0Width = LHSOp0->getType()->getVectorNumElements();
1332  }
1333  if (RHSShuffle) {
1334  RHSOp0 = RHSShuffle->getOperand(0);
1335  RHSOp0Width = RHSOp0->getType()->getVectorNumElements();
1336  }
1337  Value* newLHS = LHS;
1338  Value* newRHS = RHS;
1339  if (LHSShuffle) {
1340  // case 1
1341  if (isa<UndefValue>(RHS)) {
1342  newLHS = LHSOp0;
1343  newRHS = LHSOp1;
1344  }
1345  // case 2 or 4
1346  else if (LHSOp0Width == LHSWidth) {
1347  newLHS = LHSOp0;
1348  }
1349  }
1350  // case 3 or 4
1351  if (RHSShuffle && RHSOp0Width == LHSWidth) {
1352  newRHS = RHSOp0;
1353  }
1354  // case 4
1355  if (LHSOp0 == RHSOp0) {
1356  newLHS = LHSOp0;
1357  newRHS = nullptr;
1358  }
1359 
1360  if (newLHS == LHS && newRHS == RHS)
1361  return MadeChange ? &SVI : nullptr;
1362 
1363  SmallVector<int, 16> LHSMask;
1364  SmallVector<int, 16> RHSMask;
1365  if (newLHS != LHS)
1366  LHSMask = LHSShuffle->getShuffleMask();
1367  if (RHSShuffle && newRHS != RHS)
1368  RHSMask = RHSShuffle->getShuffleMask();
1369 
1370  unsigned newLHSWidth = (newLHS != LHS) ? LHSOp0Width : LHSWidth;
1371  SmallVector<int, 16> newMask;
1372  bool isSplat = true;
1373  int SplatElt = -1;
1374  // Create a new mask for the new ShuffleVectorInst so that the new
1375  // ShuffleVectorInst is equivalent to the original one.
1376  for (unsigned i = 0; i < VWidth; ++i) {
1377  int eltMask;
1378  if (Mask[i] < 0) {
1379  // This element is an undef value.
1380  eltMask = -1;
1381  } else if (Mask[i] < (int)LHSWidth) {
1382  // This element is from left hand side vector operand.
1383  //
1384  // If LHS is going to be replaced (case 1, 2, or 4), calculate the
1385  // new mask value for the element.
1386  if (newLHS != LHS) {
1387  eltMask = LHSMask[Mask[i]];
1388  // If the value selected is an undef value, explicitly specify it
1389  // with a -1 mask value.
1390  if (eltMask >= (int)LHSOp0Width && isa<UndefValue>(LHSOp1))
1391  eltMask = -1;
1392  } else
1393  eltMask = Mask[i];
1394  } else {
1395  // This element is from right hand side vector operand
1396  //
1397  // If the value selected is an undef value, explicitly specify it
1398  // with a -1 mask value. (case 1)
1399  if (isa<UndefValue>(RHS))
1400  eltMask = -1;
1401  // If RHS is going to be replaced (case 3 or 4), calculate the
1402  // new mask value for the element.
1403  else if (newRHS != RHS) {
1404  eltMask = RHSMask[Mask[i]-LHSWidth];
1405  // If the value selected is an undef value, explicitly specify it
1406  // with a -1 mask value.
1407  if (eltMask >= (int)RHSOp0Width) {
1408  assert(isa<UndefValue>(RHSShuffle->getOperand(1))
1409  && "should have been check above");
1410  eltMask = -1;
1411  }
1412  } else
1413  eltMask = Mask[i]-LHSWidth;
1414 
1415  // If LHS's width is changed, shift the mask value accordingly.
1416  // If newRHS == NULL, i.e. LHSOp0 == RHSOp0, we want to remap any
1417  // references from RHSOp0 to LHSOp0, so we don't need to shift the mask.
1418  // If newRHS == newLHS, we want to remap any references from newRHS to
1419  // newLHS so that we can properly identify splats that may occur due to
1420  // obfuscation across the two vectors.
1421  if (eltMask >= 0 && newRHS != nullptr && newLHS != newRHS)
1422  eltMask += newLHSWidth;
1423  }
1424 
1425  // Check if this could still be a splat.
1426  if (eltMask >= 0) {
1427  if (SplatElt >= 0 && SplatElt != eltMask)
1428  isSplat = false;
1429  SplatElt = eltMask;
1430  }
1431 
1432  newMask.push_back(eltMask);
1433  }
1434 
1435  // If the result mask is equal to one of the original shuffle masks,
1436  // or is a splat, do the replacement.
1437  if (isSplat || newMask == LHSMask || newMask == RHSMask || newMask == Mask) {
1439  for (unsigned i = 0, e = newMask.size(); i != e; ++i) {
1440  if (newMask[i] < 0) {
1441  Elts.push_back(UndefValue::get(Int32Ty));
1442  } else {
1443  Elts.push_back(ConstantInt::get(Int32Ty, newMask[i]));
1444  }
1445  }
1446  if (!newRHS)
1447  newRHS = UndefValue::get(newLHS->getType());
1448  return new ShuffleVectorInst(newLHS, newRHS, ConstantVector::get(Elts));
1449  }
1450 
1451  // If the result mask is an identity, replace uses of this instruction with
1452  // corresponding argument.
1453  bool isLHSID, isRHSID;
1454  recognizeIdentityMask(newMask, isLHSID, isRHSID);
1455  if (isLHSID && VWidth == LHSOp0Width) return replaceInstUsesWith(SVI, newLHS);
1456  if (isRHSID && VWidth == RHSOp0Width) return replaceInstUsesWith(SVI, newRHS);
1457 
1458  return MadeChange ? &SVI : nullptr;
1459 }
static bool isShuffleEquivalentToSelect(ShuffleVectorInst &Shuf)
Instruction * visitInsertValueInst(InsertValueInst &IV)
Try to find redundant insertvalue instructions, like the following ones: %0 = insertvalue { i8...
Instruction * InsertNewInstWith(Instruction *New, Instruction &Old)
Same as InsertNewInstBefore, but also sets the debug loc.
This class is the base class for the comparison instructions.
Definition: InstrTypes.h:870
void addIncoming(Value *V, BasicBlock *BB)
Add an incoming value to the end of the PHI list.
static APInt getAllOnesValue(unsigned numBits)
Get the all-ones value.
Definition: APInt.h:458
Value * findScalarElement(Value *V, unsigned EltNo)
Given a vector and an element number, see if the scalar value is already around as a register...
size_t i
ArrayRef< unsigned > getIndices() const
static Instruction * foldConstantInsEltIntoShuffle(InsertElementInst &InsElt)
insertelt (shufflevector X, CVec, Mask|insertelt X, C1, CIndex1), C, CIndex –> shufflevector X...
void setBit(unsigned bitPosition)
Set a given bit to 1.
Definition: APInt.cpp:553
unsigned getNumOperands() const
Definition: User.h:167
static ConstantAggregateZero * get(Type *Ty)
Definition: Constants.cpp:1254
class_match< Constant > m_Constant()
Match an arbitrary Constant and ignore it.
Definition: PatternMatch.h:83
std::pair< Value *, Value * > ShuffleOps
We are building a shuffle to create V, which is a sequence of insertelement, extractelement pairs...
This instruction constructs a fixed permutation of two input vectors.
static SelectInst * Create(Value *C, Value *S1, Value *S2, const Twine &NameStr="", Instruction *InsertBefore=nullptr, Instruction *MDFrom=nullptr)
const_iterator begin(StringRef path)
Get begin iterator over path.
Definition: Path.cpp:233
const Function * getParent() const
Return the enclosing method, or null if none.
Definition: BasicBlock.h:100
static bool isShuffleExtractingFromLHS(ShuffleVectorInst &SVI, SmallVector< int, 16 > &Mask)
Hexagon Common GEP
Constant * getMask() const
StringRef getName() const
Return a constant reference to the value's name.
Definition: Value.cpp:191
bool match(Val *V, const Pattern &P)
Definition: PatternMatch.h:41
ArrayRef< T > slice(size_t N, size_t M) const
slice(n, m) - Chop off the first N elements of the array, and keep M elements in the array...
Definition: ArrayRef.h:171
static InsertElementInst * Create(Value *Vec, Value *NewElt, Value *Idx, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
static ShuffleOps collectShuffleElements(Value *V, SmallVectorImpl< Constant * > &Mask, Value *PermittedRHS, InstCombiner &IC)
This class represents the LLVM 'select' instruction.
This is the base class for all instructions that perform data casts.
Definition: InstrTypes.h:578
void setIsInBounds(bool b=true)
Set or clear the inbounds flag on this GEP instruction.
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: APFloat.h:32
VectorType * getVectorOperandType() const
static Constant * get(ArrayRef< Constant * > V)
Definition: Constants.cpp:994
The core instruction combiner logic.
unsigned getBitWidth() const
Return the number of bits in the Vector type.
Definition: DerivedTypes.h:428
static bool CanEvaluateShuffled(Value *V, ArrayRef< int > Mask, unsigned Depth=5)
Return true if we can evaluate the specified expression tree if the vector elements were shuffled in ...
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
void assign(size_type NumElts, const T &Elt)
Definition: SmallVector.h:418
static Instruction * foldInsSequenceIntoBroadcast(InsertElementInst &InsElt)
VectorType * getType() const
Overload to return most specific vector type.
static bool isValidElementType(Type *ElemTy)
Return true if the specified type is valid as a element type.
Definition: Type.cpp:646
This instruction compares its operands according to the predicate given to the constructor.
uint64_t getLimitedValue(uint64_t Limit=~0ULL) const
getLimitedValue - If the value is smaller than the specified limit, return it, otherwise return the l...
Definition: Constants.h:256
This class represents a no-op cast from one type to another.
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: APInt.h:33
class_match< ConstantInt > m_ConstantInt()
Match an arbitrary ConstantInt and ignore it.
Definition: PatternMatch.h:75
Instruction * visitExtractElementInst(ExtractElementInst &EI)
Type * getScalarType() const LLVM_READONLY
If this is a vector type, return the element type, otherwise return 'this'.
Definition: Type.cpp:44
Type * getElementType() const
Definition: DerivedTypes.h:336
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:141
static GCRegistry::Add< CoreCLRGC > E("coreclr","CoreCLR-compatible GC")
unsigned getNumIncomingValues() const
Return the number of incoming edges.
Instruction * visitInsertElementInst(InsertElementInst &IE)
an instruction for type-safe pointer arithmetic to access elements of arrays and structs ...
Definition: Instructions.h:830
This instruction inserts a single (scalar) element into a VectorType value.
LLVM Basic Block Representation.
Definition: BasicBlock.h:51
bool isExact() const
Determine whether the exact flag is set.
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
This is an important base class in LLVM.
Definition: Constant.h:42
APInt Or(const APInt &LHS, const APInt &RHS)
Bitwise OR function for APInt.
Definition: APInt.h:1947
bool hasNoSignedWrap() const
Determine whether the no signed wrap flag is set.
APInt Xor(const APInt &LHS, const APInt &RHS)
Bitwise XOR function for APInt.
Definition: APInt.h:1952
static Constant * getShuffleVector(Constant *V1, Constant *V2, Constant *Mask, Type *OnlyIfReducedTy=nullptr)
Definition: Constants.cpp:2042
BasicBlock * getIncomingBlock(unsigned i) const
Return incoming basic block number i.
bool any_of(R &&Range, UnaryPredicate P)
Provide wrappers to std::any_of which take ranges instead of having to pass begin/end explicitly...
Definition: STLExtras.h:743
This instruction compares its operands according to the predicate given to the constructor.
uint64_t getNumElements() const
Definition: DerivedTypes.h:335
Value * getOperand(unsigned i) const
Definition: User.h:145
op_range operands()
Definition: User.h:213
self_iterator getIterator()
Definition: ilist_node.h:81
Class to represent integer types.
Definition: DerivedTypes.h:39
Constant * getAggregateElement(unsigned Elt) const
For aggregates (struct/array/vector) return the constant that corresponds to the specified element if...
Definition: Constants.cpp:265
static void replaceExtractElements(InsertElementInst *InsElt, ExtractElementInst *ExtElt, InstCombiner &IC)
If we have insertion into a vector that is wider than the vector that we are extracting from...
static UndefValue * get(Type *T)
Static factory methods - Return an 'undef' object of the specified type.
Definition: Constants.cpp:1337
LLVMContext & getContext() const
All values hold a context through their type.
Definition: Value.cpp:654
static GetElementPtrInst * Create(Type *PointeeType, Value *Ptr, ArrayRef< Value * > IdxList, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
Definition: Instructions.h:857
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
BinaryOps getOpcode() const
Definition: InstrTypes.h:541
Iterator for intrusive lists based on ilist_node.
This is the shared class of boolean and integer constants.
Definition: Constants.h:88
bool hasNoUnsignedWrap() const
Determine whether the no unsigned wrap flag is set.
Value * getIncomingValue(unsigned i) const
Return incoming value number x.
static bool collectSingleShuffleElements(Value *V, Value *LHS, Value *RHS, SmallVectorImpl< Constant * > &Mask)
If V is a shuffle of values that ONLY returns elements from either LHS or RHS, return the shuffle mas...
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
Instruction * user_back()
Specialize the methods defined in Value, as we know that an instruction can only be used by other ins...
Definition: Instruction.h:59
static Constant * get(Type *Ty, uint64_t V, bool isSigned=false)
If Ty is a vector type, return a Constant with a splat of the given value.
Definition: Constants.cpp:558
static PHINode * Create(Type *Ty, unsigned NumReservedValues, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
Constructors - NumReservedValues is a hint for the number of incoming edges that this phi node will h...
static GCRegistry::Add< ShadowStackGC > C("shadow-stack","Very portable GC for uncooperative code generators")
void setOperand(unsigned i, Value *Val)
Definition: User.h:150
Class to represent vector types.
Definition: DerivedTypes.h:369
Value * SimplifyExtractElementInst(Value *Vec, Value *Idx, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr, const DominatorTree *DT=nullptr, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr)
Given operands for an ExtractElementInst, fold the result or return null.
Class for arbitrary precision integers.
Definition: APInt.h:77
static BinaryOperator * Create(BinaryOps Op, Value *S1, Value *S2, const Twine &Name=Twine(), Instruction *InsertBefore=nullptr)
Construct a binary instruction, given the opcode and the two operands.
iterator_range< user_iterator > users()
Definition: Value.h:370
unsigned getVectorNumElements() const
Definition: DerivedTypes.h:438
APInt And(const APInt &LHS, const APInt &RHS)
Bitwise AND function for APInt.
Definition: APInt.h:1942
static CastInst * Create(Instruction::CastOps, Value *S, Type *Ty, const Twine &Name="", Instruction *InsertBefore=nullptr)
Provides a way to construct any of the CastInst subclasses using an opcode instead of the subclass's ...
static int getMaskValue(Constant *Mask, unsigned Elt)
Return the shuffle mask value for the specified element of the mask.
static BinaryOperator * CreateWithCopiedFlags(BinaryOps Opc, Value *V1, Value *V2, BinaryOperator *CopyBO, const Twine &Name="")
Definition: InstrTypes.h:403
static bool cheapToScalarize(Value *V, bool isConstant)
Return true if the value is cheaper to scalarize than it is to leave as a vector operation.
static Value * buildNew(Instruction *I, ArrayRef< Value * > NewOps)
Rebuild a new instruction just like 'I' but with the new operands given.
static IntegerType * getInt32Ty(LLVMContext &C)
Definition: Type.cpp:169
void insertAfter(Instruction *InsertPos)
Insert an unlinked instruction into a basic block immediately after the specified instruction...
Definition: Instruction.cpp:88
#define I(x, y, z)
Definition: MD5.cpp:54
Instruction * visitShuffleVectorInst(ShuffleVectorInst &SVI)
LLVM_ATTRIBUTE_ALWAYS_INLINE size_type size() const
Definition: SmallVector.h:135
bool hasOneUse() const
Return true if there is exactly one user of this value.
Definition: Value.h:383
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.
static bool isSplat(ArrayRef< Value * > VL)
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
Instruction * replaceInstUsesWith(Instruction &I, Value *V)
A combiner-aware RAUW-like routine.
LLVM Value Representation.
Definition: Value.h:71
This file provides internal interfaces used to implement the InstCombine.
unsigned getOpcode() const
Returns a member of one of the enums like Instruction::Add.
Definition: Instruction.h:111
static VectorType * get(Type *ElementType, unsigned NumElements)
This static method is the primary way to construct an VectorType.
Definition: Type.cpp:631
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
static void recognizeIdentityMask(const SmallVectorImpl< int > &Mask, bool &isLHSID, bool &isRHSID)
iterator getFirstInsertionPt()
Returns an iterator to the first instruction in this block that is suitable for inserting a non-PHI i...
Definition: BasicBlock.cpp:209
int * Ptr
static ExtractElementInst * Create(Value *Vec, Value *Idx, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
static void getShuffleMask(Constant *Mask, SmallVectorImpl< int > &Result)
Convert the input shuffle mask operand to a vector of integers.
const BasicBlock * getParent() const
Definition: Instruction.h:62
IntegerType * Int32Ty
User * user_back()
Definition: Value.h:356
This instruction inserts a struct field of array element value into an aggregate value.