Intermediate changes

commit_hash:2ec2671384dd8e604d41bc5c52c2f7858e4afea6

1 files changed, 0 insertions, 1440 deletions

diff --git a/contrib/libs/llvm14/lib/Analysis/VectorUtils.cpp b/contrib/libs/llvm14/lib/Analysis/VectorUtils.cpp
deleted file mode 100644
index 655c248907f..00000000000
--- a/contrib/libs/llvm14/lib/Analysis/VectorUtils.cpp
+++ /dev/null
@@ -1,1440 +0,0 @@
-//===----------- VectorUtils.cpp - Vectorizer utility functions -----------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-// This file defines vectorizer utilities.
-//
-//===----------------------------------------------------------------------===//
-
-#include "llvm/Analysis/VectorUtils.h"
-#include "llvm/ADT/EquivalenceClasses.h"
-#include "llvm/Analysis/DemandedBits.h"
-#include "llvm/Analysis/LoopInfo.h"
-#include "llvm/Analysis/LoopIterator.h"
-#include "llvm/Analysis/ScalarEvolution.h"
-#include "llvm/Analysis/ScalarEvolutionExpressions.h"
-#include "llvm/Analysis/TargetTransformInfo.h"
-#include "llvm/Analysis/ValueTracking.h"
-#include "llvm/IR/Constants.h"
-#include "llvm/IR/GetElementPtrTypeIterator.h"
-#include "llvm/IR/IRBuilder.h"
-#include "llvm/IR/PatternMatch.h"
-#include "llvm/IR/Value.h"
-#include "llvm/Support/CommandLine.h"
-
-#define DEBUG_TYPE "vectorutils"
-
-using namespace llvm;
-using namespace llvm::PatternMatch;
-
-/// Maximum factor for an interleaved memory access.
-static cl::opt<unsigned> MaxInterleaveGroupFactor(
-    "max-interleave-group-factor", cl::Hidden,
-    cl::desc("Maximum factor for an interleaved access group (default = 8)"),
-    cl::init(8));
-
-/// Return true if all of the intrinsic's arguments and return type are scalars
-/// for the scalar form of the intrinsic, and vectors for the vector form of the
-/// intrinsic (except operands that are marked as always being scalar by
-/// hasVectorInstrinsicScalarOpd).
-bool llvm::isTriviallyVectorizable(Intrinsic::ID ID) {
-  switch (ID) {
-  case Intrinsic::abs:   // Begin integer bit-manipulation.
-  case Intrinsic::bswap:
-  case Intrinsic::bitreverse:
-  case Intrinsic::ctpop:
-  case Intrinsic::ctlz:
-  case Intrinsic::cttz:
-  case Intrinsic::fshl:
-  case Intrinsic::fshr:
-  case Intrinsic::smax:
-  case Intrinsic::smin:
-  case Intrinsic::umax:
-  case Intrinsic::umin:
-  case Intrinsic::sadd_sat:
-  case Intrinsic::ssub_sat:
-  case Intrinsic::uadd_sat:
-  case Intrinsic::usub_sat:
-  case Intrinsic::smul_fix:
-  case Intrinsic::smul_fix_sat:
-  case Intrinsic::umul_fix:
-  case Intrinsic::umul_fix_sat:
-  case Intrinsic::sqrt: // Begin floating-point.
-  case Intrinsic::sin:
-  case Intrinsic::cos:
-  case Intrinsic::exp:
-  case Intrinsic::exp2:
-  case Intrinsic::log:
-  case Intrinsic::log10:
-  case Intrinsic::log2:
-  case Intrinsic::fabs:
-  case Intrinsic::minnum:
-  case Intrinsic::maxnum:
-  case Intrinsic::minimum:
-  case Intrinsic::maximum:
-  case Intrinsic::copysign:
-  case Intrinsic::floor:
-  case Intrinsic::ceil:
-  case Intrinsic::trunc:
-  case Intrinsic::rint:
-  case Intrinsic::nearbyint:
-  case Intrinsic::round:
-  case Intrinsic::roundeven:
-  case Intrinsic::pow:
-  case Intrinsic::fma:
-  case Intrinsic::fmuladd:
-  case Intrinsic::powi:
-  case Intrinsic::canonicalize:
-    return true;
-  default:
-    return false;
-  }
-}
-
-/// Identifies if the vector form of the intrinsic has a scalar operand.
-bool llvm::hasVectorInstrinsicScalarOpd(Intrinsic::ID ID,
-                                        unsigned ScalarOpdIdx) {
-  switch (ID) {
-  case Intrinsic::abs:
-  case Intrinsic::ctlz:
-  case Intrinsic::cttz:
-  case Intrinsic::powi:
-    return (ScalarOpdIdx == 1);
-  case Intrinsic::smul_fix:
-  case Intrinsic::smul_fix_sat:
-  case Intrinsic::umul_fix:
-  case Intrinsic::umul_fix_sat:
-    return (ScalarOpdIdx == 2);
-  default:
-    return false;
-  }
-}
-
-bool llvm::hasVectorInstrinsicOverloadedScalarOpd(Intrinsic::ID ID,
-                                                  unsigned ScalarOpdIdx) {
-  switch (ID) {
-  case Intrinsic::powi:
-    return (ScalarOpdIdx == 1);
-  default:
-    return false;
-  }
-}
-
-/// Returns intrinsic ID for call.
-/// For the input call instruction it finds mapping intrinsic and returns
-/// its ID, in case it does not found it return not_intrinsic.
-Intrinsic::ID llvm::getVectorIntrinsicIDForCall(const CallInst *CI,
-                                                const TargetLibraryInfo *TLI) {
-  Intrinsic::ID ID = getIntrinsicForCallSite(*CI, TLI);
-  if (ID == Intrinsic::not_intrinsic)
-    return Intrinsic::not_intrinsic;
-
-  if (isTriviallyVectorizable(ID) || ID == Intrinsic::lifetime_start ||
-      ID == Intrinsic::lifetime_end || ID == Intrinsic::assume ||
-      ID == Intrinsic::experimental_noalias_scope_decl ||
-      ID == Intrinsic::sideeffect || ID == Intrinsic::pseudoprobe)
-    return ID;
-  return Intrinsic::not_intrinsic;
-}
-
-/// Find the operand of the GEP that should be checked for consecutive
-/// stores. This ignores trailing indices that have no effect on the final
-/// pointer.
-unsigned llvm::getGEPInductionOperand(const GetElementPtrInst *Gep) {
-  const DataLayout &DL = Gep->getModule()->getDataLayout();
-  unsigned LastOperand = Gep->getNumOperands() - 1;
-  TypeSize GEPAllocSize = DL.getTypeAllocSize(Gep->getResultElementType());
-
-  // Walk backwards and try to peel off zeros.
-  while (LastOperand > 1 && match(Gep->getOperand(LastOperand), m_Zero())) {
-    // Find the type we're currently indexing into.
-    gep_type_iterator GEPTI = gep_type_begin(Gep);
-    std::advance(GEPTI, LastOperand - 2);
-
-    // If it's a type with the same allocation size as the result of the GEP we
-    // can peel off the zero index.
-    if (DL.getTypeAllocSize(GEPTI.getIndexedType()) != GEPAllocSize)
-      break;
-    --LastOperand;
-  }
-
-  return LastOperand;
-}
-
-/// If the argument is a GEP, then returns the operand identified by
-/// getGEPInductionOperand. However, if there is some other non-loop-invariant
-/// operand, it returns that instead.
-Value *llvm::stripGetElementPtr(Value *Ptr, ScalarEvolution *SE, Loop *Lp) {
-  GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(Ptr);
-  if (!GEP)
-    return Ptr;
-
-  unsigned InductionOperand = getGEPInductionOperand(GEP);
-
-  // Check that all of the gep indices are uniform except for our induction
-  // operand.
-  for (unsigned i = 0, e = GEP->getNumOperands(); i != e; ++i)
-    if (i != InductionOperand &&
-        !SE->isLoopInvariant(SE->getSCEV(GEP->getOperand(i)), Lp))
-      return Ptr;
-  return GEP->getOperand(InductionOperand);
-}
-
-/// If a value has only one user that is a CastInst, return it.
-Value *llvm::getUniqueCastUse(Value *Ptr, Loop *Lp, Type *Ty) {
-  Value *UniqueCast = nullptr;
-  for (User *U : Ptr->users()) {
-    CastInst *CI = dyn_cast<CastInst>(U);
-    if (CI && CI->getType() == Ty) {
-      if (!UniqueCast)
-        UniqueCast = CI;
-      else
-        return nullptr;
-    }
-  }
-  return UniqueCast;
-}
-
-/// Get the stride of a pointer access in a loop. Looks for symbolic
-/// strides "a[i*stride]". Returns the symbolic stride, or null otherwise.
-Value *llvm::getStrideFromPointer(Value *Ptr, ScalarEvolution *SE, Loop *Lp) {
-  auto *PtrTy = dyn_cast<PointerType>(Ptr->getType());
-  if (!PtrTy || PtrTy->isAggregateType())
-    return nullptr;
-
-  // Try to remove a gep instruction to make the pointer (actually index at this
-  // point) easier analyzable. If OrigPtr is equal to Ptr we are analyzing the
-  // pointer, otherwise, we are analyzing the index.
-  Value *OrigPtr = Ptr;
-
-  // The size of the pointer access.
-  int64_t PtrAccessSize = 1;
-
-  Ptr = stripGetElementPtr(Ptr, SE, Lp);
-  const SCEV *V = SE->getSCEV(Ptr);
-
-  if (Ptr != OrigPtr)
-    // Strip off casts.
-    while (const SCEVIntegralCastExpr *C = dyn_cast<SCEVIntegralCastExpr>(V))
-      V = C->getOperand();
-
-  const SCEVAddRecExpr *S = dyn_cast<SCEVAddRecExpr>(V);
-  if (!S)
-    return nullptr;
-
-  V = S->getStepRecurrence(*SE);
-  if (!V)
-    return nullptr;
-
-  // Strip off the size of access multiplication if we are still analyzing the
-  // pointer.
-  if (OrigPtr == Ptr) {
-    if (const SCEVMulExpr *M = dyn_cast<SCEVMulExpr>(V)) {
-      if (M->getOperand(0)->getSCEVType() != scConstant)
-        return nullptr;
-
-      const APInt &APStepVal = cast<SCEVConstant>(M->getOperand(0))->getAPInt();
-
-      // Huge step value - give up.
-      if (APStepVal.getBitWidth() > 64)
-        return nullptr;
-
-      int64_t StepVal = APStepVal.getSExtValue();
-      if (PtrAccessSize != StepVal)
-        return nullptr;
-      V = M->getOperand(1);
-    }
-  }
-
-  // Strip off casts.
-  Type *StripedOffRecurrenceCast = nullptr;
-  if (const SCEVIntegralCastExpr *C = dyn_cast<SCEVIntegralCastExpr>(V)) {
-    StripedOffRecurrenceCast = C->getType();
-    V = C->getOperand();
-  }
-
-  // Look for the loop invariant symbolic value.
-  const SCEVUnknown *U = dyn_cast<SCEVUnknown>(V);
-  if (!U)
-    return nullptr;
-
-  Value *Stride = U->getValue();
-  if (!Lp->isLoopInvariant(Stride))
-    return nullptr;
-
-  // If we have stripped off the recurrence cast we have to make sure that we
-  // return the value that is used in this loop so that we can replace it later.
-  if (StripedOffRecurrenceCast)
-    Stride = getUniqueCastUse(Stride, Lp, StripedOffRecurrenceCast);
-
-  return Stride;
-}
-
-/// Given a vector and an element number, see if the scalar value is
-/// already around as a register, for example if it were inserted then extracted
-/// from the vector.
-Value *llvm::findScalarElement(Value *V, unsigned EltNo) {
-  assert(V->getType()->isVectorTy() && "Not looking at a vector?");
-  VectorType *VTy = cast<VectorType>(V->getType());
-  // For fixed-length vector, return undef for out of range access.
-  if (auto *FVTy = dyn_cast<FixedVectorType>(VTy)) {
-    unsigned Width = FVTy->getNumElements();
-    if (EltNo >= Width)
-      return UndefValue::get(FVTy->getElementType());
-  }
-
-  if (Constant *C = dyn_cast<Constant>(V))
-    return C->getAggregateElement(EltNo);
-
-  if (InsertElementInst *III = dyn_cast<InsertElementInst>(V)) {
-    // If this is an insert to a variable element, we don't know what it is.
-    if (!isa<ConstantInt>(III->getOperand(2)))
-      return nullptr;
-    unsigned IIElt = cast<ConstantInt>(III->getOperand(2))->getZExtValue();
-
-    // If this is an insert to the element we are looking for, return the
-    // inserted value.
-    if (EltNo == IIElt)
-      return III->getOperand(1);
-
-    // Guard against infinite loop on malformed, unreachable IR.
-    if (III == III->getOperand(0))
-      return nullptr;
-
-    // Otherwise, the insertelement doesn't modify the value, recurse on its
-    // vector input.
-    return findScalarElement(III->getOperand(0), EltNo);
-  }
-
-  ShuffleVectorInst *SVI = dyn_cast<ShuffleVectorInst>(V);
-  // Restrict the following transformation to fixed-length vector.
-  if (SVI && isa<FixedVectorType>(SVI->getType())) {
-    unsigned LHSWidth =
-        cast<FixedVectorType>(SVI->getOperand(0)->getType())->getNumElements();
-    int InEl = SVI->getMaskValue(EltNo);
-    if (InEl < 0)
-      return UndefValue::get(VTy->getElementType());
-    if (InEl < (int)LHSWidth)
-      return findScalarElement(SVI->getOperand(0), InEl);
-    return findScalarElement(SVI->getOperand(1), InEl - LHSWidth);
-  }
-
-  // Extract a value from a vector add operation with a constant zero.
-  // TODO: Use getBinOpIdentity() to generalize this.
-  Value *Val; Constant *C;
-  if (match(V, m_Add(m_Value(Val), m_Constant(C))))
-    if (Constant *Elt = C->getAggregateElement(EltNo))
-      if (Elt->isNullValue())
-        return findScalarElement(Val, EltNo);
-
-  // If the vector is a splat then we can trivially find the scalar element.
-  if (isa<ScalableVectorType>(VTy))
-    if (Value *Splat = getSplatValue(V))
-      if (EltNo < VTy->getElementCount().getKnownMinValue())
-        return Splat;
-
-  // Otherwise, we don't know.
-  return nullptr;
-}
-
-int llvm::getSplatIndex(ArrayRef<int> Mask) {
-  int SplatIndex = -1;
-  for (int M : Mask) {
-    // Ignore invalid (undefined) mask elements.
-    if (M < 0)
-      continue;
-
-    // There can be only 1 non-negative mask element value if this is a splat.
-    if (SplatIndex != -1 && SplatIndex != M)
-      return -1;
-
-    // Initialize the splat index to the 1st non-negative mask element.
-    SplatIndex = M;
-  }
-  assert((SplatIndex == -1 || SplatIndex >= 0) && "Negative index?");
-  return SplatIndex;
-}
-
-/// Get splat value if the input is a splat vector or return nullptr.
-/// This function is not fully general. It checks only 2 cases:
-/// the input value is (1) a splat constant vector or (2) a sequence
-/// of instructions that broadcasts a scalar at element 0.
-Value *llvm::getSplatValue(const Value *V) {
-  if (isa<VectorType>(V->getType()))
-    if (auto *C = dyn_cast<Constant>(V))
-      return C->getSplatValue();
-
-  // shuf (inselt ?, Splat, 0), ?, <0, undef, 0, ...>
-  Value *Splat;
-  if (match(V,
-            m_Shuffle(m_InsertElt(m_Value(), m_Value(Splat), m_ZeroInt()),
-                      m_Value(), m_ZeroMask())))
-    return Splat;
-
-  return nullptr;
-}
-
-bool llvm::isSplatValue(const Value *V, int Index, unsigned Depth) {
-  assert(Depth <= MaxAnalysisRecursionDepth && "Limit Search Depth");
-
-  if (isa<VectorType>(V->getType())) {
-    if (isa<UndefValue>(V))
-      return true;
-    // FIXME: We can allow undefs, but if Index was specified, we may want to
-    //        check that the constant is defined at that index.
-    if (auto *C = dyn_cast<Constant>(V))
-      return C->getSplatValue() != nullptr;
-  }
-
-  if (auto *Shuf = dyn_cast<ShuffleVectorInst>(V)) {
-    // FIXME: We can safely allow undefs here. If Index was specified, we will
-    //        check that the mask elt is defined at the required index.
-    if (!is_splat(Shuf->getShuffleMask()))
-      return false;
-
-    // Match any index.
-    if (Index == -1)
-      return true;
-
-    // Match a specific element. The mask should be defined at and match the
-    // specified index.
-    return Shuf->getMaskValue(Index) == Index;
-  }
-
-  // The remaining tests are all recursive, so bail out if we hit the limit.
-  if (Depth++ == MaxAnalysisRecursionDepth)
-    return false;
-
-  // If both operands of a binop are splats, the result is a splat.
-  Value *X, *Y, *Z;
-  if (match(V, m_BinOp(m_Value(X), m_Value(Y))))
-    return isSplatValue(X, Index, Depth) && isSplatValue(Y, Index, Depth);
-
-  // If all operands of a select are splats, the result is a splat.
-  if (match(V, m_Select(m_Value(X), m_Value(Y), m_Value(Z))))
-    return isSplatValue(X, Index, Depth) && isSplatValue(Y, Index, Depth) &&
-           isSplatValue(Z, Index, Depth);
-
-  // TODO: Add support for unary ops (fneg), casts, intrinsics (overflow ops).
-
-  return false;
-}
-
-void llvm::narrowShuffleMaskElts(int Scale, ArrayRef<int> Mask,
-                                 SmallVectorImpl<int> &ScaledMask) {
-  assert(Scale > 0 && "Unexpected scaling factor");
-
-  // Fast-path: if no scaling, then it is just a copy.
-  if (Scale == 1) {
-    ScaledMask.assign(Mask.begin(), Mask.end());
-    return;
-  }
-
-  ScaledMask.clear();
-  for (int MaskElt : Mask) {
-    if (MaskElt >= 0) {
-      assert(((uint64_t)Scale * MaskElt + (Scale - 1)) <= INT32_MAX &&
-             "Overflowed 32-bits");
-    }
-    for (int SliceElt = 0; SliceElt != Scale; ++SliceElt)
-      ScaledMask.push_back(MaskElt < 0 ? MaskElt : Scale * MaskElt + SliceElt);
-  }
-}
-
-bool llvm::widenShuffleMaskElts(int Scale, ArrayRef<int> Mask,
-                                SmallVectorImpl<int> &ScaledMask) {
-  assert(Scale > 0 && "Unexpected scaling factor");
-
-  // Fast-path: if no scaling, then it is just a copy.
-  if (Scale == 1) {
-    ScaledMask.assign(Mask.begin(), Mask.end());
-    return true;
-  }
-
-  // We must map the original elements down evenly to a type with less elements.
-  int NumElts = Mask.size();
-  if (NumElts % Scale != 0)
-    return false;
-
-  ScaledMask.clear();
-  ScaledMask.reserve(NumElts / Scale);
-
-  // Step through the input mask by splitting into Scale-sized slices.
-  do {
-    ArrayRef<int> MaskSlice = Mask.take_front(Scale);
-    assert((int)MaskSlice.size() == Scale && "Expected Scale-sized slice.");
-
-    // The first element of the slice determines how we evaluate this slice.
-    int SliceFront = MaskSlice.front();
-    if (SliceFront < 0) {
-      // Negative values (undef or other "sentinel" values) must be equal across
-      // the entire slice.
-      if (!is_splat(MaskSlice))
-        return false;
-      ScaledMask.push_back(SliceFront);
-    } else {
-      // A positive mask element must be cleanly divisible.
-      if (SliceFront % Scale != 0)
-        return false;
-      // Elements of the slice must be consecutive.
-      for (int i = 1; i < Scale; ++i)
-        if (MaskSlice[i] != SliceFront + i)
-          return false;
-      ScaledMask.push_back(SliceFront / Scale);
-    }
-    Mask = Mask.drop_front(Scale);
-  } while (!Mask.empty());
-
-  assert((int)ScaledMask.size() * Scale == NumElts && "Unexpected scaled mask");
-
-  // All elements of the original mask can be scaled down to map to the elements
-  // of a mask with wider elements.
-  return true;
-}
-
-MapVector<Instruction *, uint64_t>
-llvm::computeMinimumValueSizes(ArrayRef<BasicBlock *> Blocks, DemandedBits &DB,
-                               const TargetTransformInfo *TTI) {
-
-  // DemandedBits will give us every value's live-out bits. But we want
-  // to ensure no extra casts would need to be inserted, so every DAG
-  // of connected values must have the same minimum bitwidth.
-  EquivalenceClasses<Value *> ECs;
-  SmallVector<Value *, 16> Worklist;
-  SmallPtrSet<Value *, 4> Roots;
-  SmallPtrSet<Value *, 16> Visited;
-  DenseMap<Value *, uint64_t> DBits;
-  SmallPtrSet<Instruction *, 4> InstructionSet;
-  MapVector<Instruction *, uint64_t> MinBWs;
-
-  // Determine the roots. We work bottom-up, from truncs or icmps.
-  bool SeenExtFromIllegalType = false;
-  for (auto *BB : Blocks)
-    for (auto &I : *BB) {
-      InstructionSet.insert(&I);
-
-      if (TTI && (isa<ZExtInst>(&I) || isa<SExtInst>(&I)) &&
-          !TTI->isTypeLegal(I.getOperand(0)->getType()))
-        SeenExtFromIllegalType = true;
-
-      // Only deal with non-vector integers up to 64-bits wide.
-      if ((isa<TruncInst>(&I) || isa<ICmpInst>(&I)) &&
-          !I.getType()->isVectorTy() &&
-          I.getOperand(0)->getType()->getScalarSizeInBits() <= 64) {
-        // Don't make work for ourselves. If we know the loaded type is legal,
-        // don't add it to the worklist.
-        if (TTI && isa<TruncInst>(&I) && TTI->isTypeLegal(I.getType()))
-          continue;
-
-        Worklist.push_back(&I);
-        Roots.insert(&I);
-      }
-    }
-  // Early exit.
-  if (Worklist.empty() || (TTI && !SeenExtFromIllegalType))
-    return MinBWs;
-
-  // Now proceed breadth-first, unioning values together.
-  while (!Worklist.empty()) {
-    Value *Val = Worklist.pop_back_val();
-    Value *Leader = ECs.getOrInsertLeaderValue(Val);
-
-    if (Visited.count(Val))
-      continue;
-    Visited.insert(Val);
-
-    // Non-instructions terminate a chain successfully.
-    if (!isa<Instruction>(Val))
-      continue;
-    Instruction *I = cast<Instruction>(Val);
-
-    // If we encounter a type that is larger than 64 bits, we can't represent
-    // it so bail out.
-    if (DB.getDemandedBits(I).getBitWidth() > 64)
-      return MapVector<Instruction *, uint64_t>();
-
-    uint64_t V = DB.getDemandedBits(I).getZExtValue();
-    DBits[Leader] |= V;
-    DBits[I] = V;
-
-    // Casts, loads and instructions outside of our range terminate a chain
-    // successfully.
-    if (isa<SExtInst>(I) || isa<ZExtInst>(I) || isa<LoadInst>(I) ||
-        !InstructionSet.count(I))
-      continue;
-
-    // Unsafe casts terminate a chain unsuccessfully. We can't do anything
-    // useful with bitcasts, ptrtoints or inttoptrs and it'd be unsafe to
-    // transform anything that relies on them.
-    if (isa<BitCastInst>(I) || isa<PtrToIntInst>(I) || isa<IntToPtrInst>(I) ||
-        !I->getType()->isIntegerTy()) {
-      DBits[Leader] |= ~0ULL;
-      continue;
-    }
-
-    // We don't modify the types of PHIs. Reductions will already have been
-    // truncated if possible, and inductions' sizes will have been chosen by
-    // indvars.
-    if (isa<PHINode>(I))
-      continue;
-
-    if (DBits[Leader] == ~0ULL)
-      // All bits demanded, no point continuing.
-      continue;
-
-    for (Value *O : cast<User>(I)->operands()) {
-      ECs.unionSets(Leader, O);
-      Worklist.push_back(O);
-    }
-  }
-
-  // Now we've discovered all values, walk them to see if there are
-  // any users we didn't see. If there are, we can't optimize that
-  // chain.
-  for (auto &I : DBits)
-    for (auto *U : I.first->users())
-      if (U->getType()->isIntegerTy() && DBits.count(U) == 0)
-        DBits[ECs.getOrInsertLeaderValue(I.first)] |= ~0ULL;
-
-  for (auto I = ECs.begin(), E = ECs.end(); I != E; ++I) {
-    uint64_t LeaderDemandedBits = 0;
-    for (Value *M : llvm::make_range(ECs.member_begin(I), ECs.member_end()))
-      LeaderDemandedBits |= DBits[M];
-
-    uint64_t MinBW = (sizeof(LeaderDemandedBits) * 8) -
-                     llvm::countLeadingZeros(LeaderDemandedBits);
-    // Round up to a power of 2
-    if (!isPowerOf2_64((uint64_t)MinBW))
-      MinBW = NextPowerOf2(MinBW);
-
-    // We don't modify the types of PHIs. Reductions will already have been
-    // truncated if possible, and inductions' sizes will have been chosen by
-    // indvars.
-    // If we are required to shrink a PHI, abandon this entire equivalence class.
-    bool Abort = false;
-    for (Value *M : llvm::make_range(ECs.member_begin(I), ECs.member_end()))
-      if (isa<PHINode>(M) && MinBW < M->getType()->getScalarSizeInBits()) {
-        Abort = true;
-        break;
-      }
-    if (Abort)
-      continue;
-
-    for (Value *M : llvm::make_range(ECs.member_begin(I), ECs.member_end())) {
-      if (!isa<Instruction>(M))
-        continue;
-      Type *Ty = M->getType();
-      if (Roots.count(M))
-        Ty = cast<Instruction>(M)->getOperand(0)->getType();
-      if (MinBW < Ty->getScalarSizeInBits())
-        MinBWs[cast<Instruction>(M)] = MinBW;
-    }
-  }
-
-  return MinBWs;
-}
-
-/// Add all access groups in @p AccGroups to @p List.
-template <typename ListT>
-static void addToAccessGroupList(ListT &List, MDNode *AccGroups) {
-  // Interpret an access group as a list containing itself.
-  if (AccGroups->getNumOperands() == 0) {
-    assert(isValidAsAccessGroup(AccGroups) && "Node must be an access group");
-    List.insert(AccGroups);
-    return;
-  }
-
-  for (auto &AccGroupListOp : AccGroups->operands()) {
-    auto *Item = cast<MDNode>(AccGroupListOp.get());
-    assert(isValidAsAccessGroup(Item) && "List item must be an access group");
-    List.insert(Item);
-  }
-}
-
-MDNode *llvm::uniteAccessGroups(MDNode *AccGroups1, MDNode *AccGroups2) {
-  if (!AccGroups1)
-    return AccGroups2;
-  if (!AccGroups2)
-    return AccGroups1;
-  if (AccGroups1 == AccGroups2)
-    return AccGroups1;
-
-  SmallSetVector<Metadata *, 4> Union;
-  addToAccessGroupList(Union, AccGroups1);
-  addToAccessGroupList(Union, AccGroups2);
-
-  if (Union.size() == 0)
-    return nullptr;
-  if (Union.size() == 1)
-    return cast<MDNode>(Union.front());
-
-  LLVMContext &Ctx = AccGroups1->getContext();
-  return MDNode::get(Ctx, Union.getArrayRef());
-}
-
-MDNode *llvm::intersectAccessGroups(const Instruction *Inst1,
-                                    const Instruction *Inst2) {
-  bool MayAccessMem1 = Inst1->mayReadOrWriteMemory();
-  bool MayAccessMem2 = Inst2->mayReadOrWriteMemory();
-
-  if (!MayAccessMem1 && !MayAccessMem2)
-    return nullptr;
-  if (!MayAccessMem1)
-    return Inst2->getMetadata(LLVMContext::MD_access_group);
-  if (!MayAccessMem2)
-    return Inst1->getMetadata(LLVMContext::MD_access_group);
-
-  MDNode *MD1 = Inst1->getMetadata(LLVMContext::MD_access_group);
-  MDNode *MD2 = Inst2->getMetadata(LLVMContext::MD_access_group);
-  if (!MD1 || !MD2)
-    return nullptr;
-  if (MD1 == MD2)
-    return MD1;
-
-  // Use set for scalable 'contains' check.
-  SmallPtrSet<Metadata *, 4> AccGroupSet2;
-  addToAccessGroupList(AccGroupSet2, MD2);
-
-  SmallVector<Metadata *, 4> Intersection;
-  if (MD1->getNumOperands() == 0) {
-    assert(isValidAsAccessGroup(MD1) && "Node must be an access group");
-    if (AccGroupSet2.count(MD1))
-      Intersection.push_back(MD1);
-  } else {
-    for (const MDOperand &Node : MD1->operands()) {
-      auto *Item = cast<MDNode>(Node.get());
-      assert(isValidAsAccessGroup(Item) && "List item must be an access group");
-      if (AccGroupSet2.count(Item))
-        Intersection.push_back(Item);
-    }
-  }
-
-  if (Intersection.size() == 0)
-    return nullptr;
-  if (Intersection.size() == 1)
-    return cast<MDNode>(Intersection.front());
-
-  LLVMContext &Ctx = Inst1->getContext();
-  return MDNode::get(Ctx, Intersection);
-}
-
-/// \returns \p I after propagating metadata from \p VL.
-Instruction *llvm::propagateMetadata(Instruction *Inst, ArrayRef<Value *> VL) {
-  if (VL.empty())
-    return Inst;
-  Instruction *I0 = cast<Instruction>(VL[0]);
-  SmallVector<std::pair<unsigned, MDNode *>, 4> Metadata;
-  I0->getAllMetadataOtherThanDebugLoc(Metadata);
-
-  for (auto Kind : {LLVMContext::MD_tbaa, LLVMContext::MD_alias_scope,
-                    LLVMContext::MD_noalias, LLVMContext::MD_fpmath,
-                    LLVMContext::MD_nontemporal, LLVMContext::MD_invariant_load,
-                    LLVMContext::MD_access_group}) {
-    MDNode *MD = I0->getMetadata(Kind);
-
-    for (int J = 1, E = VL.size(); MD && J != E; ++J) {
-      const Instruction *IJ = cast<Instruction>(VL[J]);
-      MDNode *IMD = IJ->getMetadata(Kind);
-      switch (Kind) {
-      case LLVMContext::MD_tbaa:
-        MD = MDNode::getMostGenericTBAA(MD, IMD);
-        break;
-      case LLVMContext::MD_alias_scope:
-        MD = MDNode::getMostGenericAliasScope(MD, IMD);
-        break;
-      case LLVMContext::MD_fpmath:
-        MD = MDNode::getMostGenericFPMath(MD, IMD);
-        break;
-      case LLVMContext::MD_noalias:
-      case LLVMContext::MD_nontemporal:
-      case LLVMContext::MD_invariant_load:
-        MD = MDNode::intersect(MD, IMD);
-        break;
-      case LLVMContext::MD_access_group:
-        MD = intersectAccessGroups(Inst, IJ);
-        break;
-      default:
-        llvm_unreachable("unhandled metadata");
-      }
-    }
-
-    Inst->setMetadata(Kind, MD);
-  }
-
-  return Inst;
-}
-
-Constant *
-llvm::createBitMaskForGaps(IRBuilderBase &Builder, unsigned VF,
-                           const InterleaveGroup<Instruction> &Group) {
-  // All 1's means mask is not needed.
-  if (Group.getNumMembers() == Group.getFactor())
-    return nullptr;
-
-  // TODO: support reversed access.
-  assert(!Group.isReverse() && "Reversed group not supported.");
-
-  SmallVector<Constant *, 16> Mask;
-  for (unsigned i = 0; i < VF; i++)
-    for (unsigned j = 0; j < Group.getFactor(); ++j) {
-      unsigned HasMember = Group.getMember(j) ? 1 : 0;
-      Mask.push_back(Builder.getInt1(HasMember));
-    }
-
-  return ConstantVector::get(Mask);
-}
-
-llvm::SmallVector<int, 16>
-llvm::createReplicatedMask(unsigned ReplicationFactor, unsigned VF) {
-  SmallVector<int, 16> MaskVec;
-  for (unsigned i = 0; i < VF; i++)
-    for (unsigned j = 0; j < ReplicationFactor; j++)
-      MaskVec.push_back(i);
-
-  return MaskVec;
-}
-
-llvm::SmallVector<int, 16> llvm::createInterleaveMask(unsigned VF,
-                                                      unsigned NumVecs) {
-  SmallVector<int, 16> Mask;
-  for (unsigned i = 0; i < VF; i++)
-    for (unsigned j = 0; j < NumVecs; j++)
-      Mask.push_back(j * VF + i);
-
-  return Mask;
-}
-
-llvm::SmallVector<int, 16>
-llvm::createStrideMask(unsigned Start, unsigned Stride, unsigned VF) {
-  SmallVector<int, 16> Mask;
-  for (unsigned i = 0; i < VF; i++)
-    Mask.push_back(Start + i * Stride);
-
-  return Mask;
-}
-
-llvm::SmallVector<int, 16> llvm::createSequentialMask(unsigned Start,
-                                                      unsigned NumInts,
-                                                      unsigned NumUndefs) {
-  SmallVector<int, 16> Mask;
-  for (unsigned i = 0; i < NumInts; i++)
-    Mask.push_back(Start + i);
-
-  for (unsigned i = 0; i < NumUndefs; i++)
-    Mask.push_back(-1);
-
-  return Mask;
-}
-
-llvm::SmallVector<int, 16> llvm::createUnaryMask(ArrayRef<int> Mask,
-                                                 unsigned NumElts) {
-  // Avoid casts in the loop and make sure we have a reasonable number.
-  int NumEltsSigned = NumElts;
-  assert(NumEltsSigned > 0 && "Expected smaller or non-zero element count");
-
-  // If the mask chooses an element from operand 1, reduce it to choose from the
-  // corresponding element of operand 0. Undef mask elements are unchanged.
-  SmallVector<int, 16> UnaryMask;
-  for (int MaskElt : Mask) {
-    assert((MaskElt < NumEltsSigned * 2) && "Expected valid shuffle mask");
-    int UnaryElt = MaskElt >= NumEltsSigned ? MaskElt - NumEltsSigned : MaskElt;
-    UnaryMask.push_back(UnaryElt);
-  }
-  return UnaryMask;
-}
-
-/// A helper function for concatenating vectors. This function concatenates two
-/// vectors having the same element type. If the second vector has fewer
-/// elements than the first, it is padded with undefs.
-static Value *concatenateTwoVectors(IRBuilderBase &Builder, Value *V1,
-                                    Value *V2) {
-  VectorType *VecTy1 = dyn_cast<VectorType>(V1->getType());
-  VectorType *VecTy2 = dyn_cast<VectorType>(V2->getType());
-  assert(VecTy1 && VecTy2 &&
-         VecTy1->getScalarType() == VecTy2->getScalarType() &&
-         "Expect two vectors with the same element type");
-
-  unsigned NumElts1 = cast<FixedVectorType>(VecTy1)->getNumElements();
-  unsigned NumElts2 = cast<FixedVectorType>(VecTy2)->getNumElements();
-  assert(NumElts1 >= NumElts2 && "Unexpect the first vector has less elements");
-
-  if (NumElts1 > NumElts2) {
-    // Extend with UNDEFs.
-    V2 = Builder.CreateShuffleVector(
-        V2, createSequentialMask(0, NumElts2, NumElts1 - NumElts2));
-  }
-
-  return Builder.CreateShuffleVector(
-      V1, V2, createSequentialMask(0, NumElts1 + NumElts2, 0));
-}
-
-Value *llvm::concatenateVectors(IRBuilderBase &Builder,
-                                ArrayRef<Value *> Vecs) {
-  unsigned NumVecs = Vecs.size();
-  assert(NumVecs > 1 && "Should be at least two vectors");
-
-  SmallVector<Value *, 8> ResList;
-  ResList.append(Vecs.begin(), Vecs.end());
-  do {
-    SmallVector<Value *, 8> TmpList;
-    for (unsigned i = 0; i < NumVecs - 1; i += 2) {
-      Value *V0 = ResList[i], *V1 = ResList[i + 1];
-      assert((V0->getType() == V1->getType() || i == NumVecs - 2) &&
-             "Only the last vector may have a different type");
-
-      TmpList.push_back(concatenateTwoVectors(Builder, V0, V1));
-    }
-
-    // Push the last vector if the total number of vectors is odd.
-    if (NumVecs % 2 != 0)
-      TmpList.push_back(ResList[NumVecs - 1]);
-
-    ResList = TmpList;
-    NumVecs = ResList.size();
-  } while (NumVecs > 1);
-
-  return ResList[0];
-}
-
-bool llvm::maskIsAllZeroOrUndef(Value *Mask) {
-  assert(isa<VectorType>(Mask->getType()) &&
-         isa<IntegerType>(Mask->getType()->getScalarType()) &&
-         cast<IntegerType>(Mask->getType()->getScalarType())->getBitWidth() ==
-             1 &&
-         "Mask must be a vector of i1");
-
-  auto *ConstMask = dyn_cast<Constant>(Mask);
-  if (!ConstMask)
-    return false;
-  if (ConstMask->isNullValue() || isa<UndefValue>(ConstMask))
-    return true;
-  if (isa<ScalableVectorType>(ConstMask->getType()))
-    return false;
-  for (unsigned
-           I = 0,
-           E = cast<FixedVectorType>(ConstMask->getType())->getNumElements();
-       I != E; ++I) {
-    if (auto *MaskElt = ConstMask->getAggregateElement(I))
-      if (MaskElt->isNullValue() || isa<UndefValue>(MaskElt))
-        continue;
-    return false;
-  }
-  return true;
-}
-
-bool llvm::maskIsAllOneOrUndef(Value *Mask) {
-  assert(isa<VectorType>(Mask->getType()) &&
-         isa<IntegerType>(Mask->getType()->getScalarType()) &&
-         cast<IntegerType>(Mask->getType()->getScalarType())->getBitWidth() ==
-             1 &&
-         "Mask must be a vector of i1");
-
-  auto *ConstMask = dyn_cast<Constant>(Mask);
-  if (!ConstMask)
-    return false;
-  if (ConstMask->isAllOnesValue() || isa<UndefValue>(ConstMask))
-    return true;
-  if (isa<ScalableVectorType>(ConstMask->getType()))
-    return false;
-  for (unsigned
-           I = 0,
-           E = cast<FixedVectorType>(ConstMask->getType())->getNumElements();
-       I != E; ++I) {
-    if (auto *MaskElt = ConstMask->getAggregateElement(I))
-      if (MaskElt->isAllOnesValue() || isa<UndefValue>(MaskElt))
-        continue;
-    return false;
-  }
-  return true;
-}
-
-/// TODO: This is a lot like known bits, but for
-/// vectors.  Is there something we can common this with?
-APInt llvm::possiblyDemandedEltsInMask(Value *Mask) {
-  assert(isa<FixedVectorType>(Mask->getType()) &&
-         isa<IntegerType>(Mask->getType()->getScalarType()) &&
-         cast<IntegerType>(Mask->getType()->getScalarType())->getBitWidth() ==
-             1 &&
-         "Mask must be a fixed width vector of i1");
-
-  const unsigned VWidth =
-      cast<FixedVectorType>(Mask->getType())->getNumElements();
-  APInt DemandedElts = APInt::getAllOnes(VWidth);
-  if (auto *CV = dyn_cast<ConstantVector>(Mask))
-    for (unsigned i = 0; i < VWidth; i++)
-      if (CV->getAggregateElement(i)->isNullValue())
-        DemandedElts.clearBit(i);
-  return DemandedElts;
-}
-
-bool InterleavedAccessInfo::isStrided(int Stride) {
-  unsigned Factor = std::abs(Stride);
-  return Factor >= 2 && Factor <= MaxInterleaveGroupFactor;
-}
-
-void InterleavedAccessInfo::collectConstStrideAccesses(
-    MapVector<Instruction *, StrideDescriptor> &AccessStrideInfo,
-    const ValueToValueMap &Strides) {
-  auto &DL = TheLoop->getHeader()->getModule()->getDataLayout();
-
-  // Since it's desired that the load/store instructions be maintained in
-  // "program order" for the interleaved access analysis, we have to visit the
-  // blocks in the loop in reverse postorder (i.e., in a topological order).
-  // Such an ordering will ensure that any load/store that may be executed
-  // before a second load/store will precede the second load/store in
-  // AccessStrideInfo.
-  LoopBlocksDFS DFS(TheLoop);
-  DFS.perform(LI);
-  for (BasicBlock *BB : make_range(DFS.beginRPO(), DFS.endRPO()))
-    for (auto &I : *BB) {
-      Value *Ptr = getLoadStorePointerOperand(&I);
-      if (!Ptr)
-        continue;
-      Type *ElementTy = getLoadStoreType(&I);
-
-      // We don't check wrapping here because we don't know yet if Ptr will be
-      // part of a full group or a group with gaps. Checking wrapping for all
-      // pointers (even those that end up in groups with no gaps) will be overly
-      // conservative. For full groups, wrapping should be ok since if we would
-      // wrap around the address space we would do a memory access at nullptr
-      // even without the transformation. The wrapping checks are therefore
-      // deferred until after we've formed the interleaved groups.
-      int64_t Stride = getPtrStride(PSE, ElementTy, Ptr, TheLoop, Strides,
-                                    /*Assume=*/true, /*ShouldCheckWrap=*/false);
-
-      const SCEV *Scev = replaceSymbolicStrideSCEV(PSE, Strides, Ptr);
-      uint64_t Size = DL.getTypeAllocSize(ElementTy);
-      AccessStrideInfo[&I] = StrideDescriptor(Stride, Scev, Size,
-                                              getLoadStoreAlignment(&I));
-    }
-}
-
-// Analyze interleaved accesses and collect them into interleaved load and
-// store groups.
-//
-// When generating code for an interleaved load group, we effectively hoist all
-// loads in the group to the location of the first load in program order. When
-// generating code for an interleaved store group, we sink all stores to the
-// location of the last store. This code motion can change the order of load
-// and store instructions and may break dependences.
-//
-// The code generation strategy mentioned above ensures that we won't violate
-// any write-after-read (WAR) dependences.
-//
-// E.g., for the WAR dependence:  a = A[i];      // (1)
-//                                A[i] = b;      // (2)
-//
-// The store group of (2) is always inserted at or below (2), and the load
-// group of (1) is always inserted at or above (1). Thus, the instructions will
-// never be reordered. All other dependences are checked to ensure the
-// correctness of the instruction reordering.
-//
-// The algorithm visits all memory accesses in the loop in bottom-up program
-// order. Program order is established by traversing the blocks in the loop in
-// reverse postorder when collecting the accesses.
-//
-// We visit the memory accesses in bottom-up order because it can simplify the
-// construction of store groups in the presence of write-after-write (WAW)
-// dependences.
-//
-// E.g., for the WAW dependence:  A[i] = a;      // (1)
-//                                A[i] = b;      // (2)
-//                                A[i + 1] = c;  // (3)
-//
-// We will first create a store group with (3) and (2). (1) can't be added to
-// this group because it and (2) are dependent. However, (1) can be grouped
-// with other accesses that may precede it in program order. Note that a
-// bottom-up order does not imply that WAW dependences should not be checked.
-void InterleavedAccessInfo::analyzeInterleaving(
-                                 bool EnablePredicatedInterleavedMemAccesses) {
-  LLVM_DEBUG(dbgs() << "LV: Analyzing interleaved accesses...\n");
-  const ValueToValueMap &Strides = LAI->getSymbolicStrides();
-
-  // Holds all accesses with a constant stride.
-  MapVector<Instruction *, StrideDescriptor> AccessStrideInfo;
-  collectConstStrideAccesses(AccessStrideInfo, Strides);
-
-  if (AccessStrideInfo.empty())
-    return;
-
-  // Collect the dependences in the loop.
-  collectDependences();
-
-  // Holds all interleaved store groups temporarily.
-  SmallSetVector<InterleaveGroup<Instruction> *, 4> StoreGroups;
-  // Holds all interleaved load groups temporarily.
-  SmallSetVector<InterleaveGroup<Instruction> *, 4> LoadGroups;
-
-  // Search in bottom-up program order for pairs of accesses (A and B) that can
-  // form interleaved load or store groups. In the algorithm below, access A
-  // precedes access B in program order. We initialize a group for B in the
-  // outer loop of the algorithm, and then in the inner loop, we attempt to
-  // insert each A into B's group if:
-  //
-  //  1. A and B have the same stride,
-  //  2. A and B have the same memory object size, and
-  //  3. A belongs in B's group according to its distance from B.
-  //
-  // Special care is taken to ensure group formation will not break any
-  // dependences.
-  for (auto BI = AccessStrideInfo.rbegin(), E = AccessStrideInfo.rend();
-       BI != E; ++BI) {
-    Instruction *B = BI->first;
-    StrideDescriptor DesB = BI->second;
-
-    // Initialize a group for B if it has an allowable stride. Even if we don't
-    // create a group for B, we continue with the bottom-up algorithm to ensure
-    // we don't break any of B's dependences.
-    InterleaveGroup<Instruction> *Group = nullptr;
-    if (isStrided(DesB.Stride) &&
-        (!isPredicated(B->getParent()) || EnablePredicatedInterleavedMemAccesses)) {
-      Group = getInterleaveGroup(B);
-      if (!Group) {
-        LLVM_DEBUG(dbgs() << "LV: Creating an interleave group with:" << *B
-                          << '\n');
-        Group = createInterleaveGroup(B, DesB.Stride, DesB.Alignment);
-      }
-      if (B->mayWriteToMemory())
-        StoreGroups.insert(Group);
-      else
-        LoadGroups.insert(Group);
-    }
-
-    for (auto AI = std::next(BI); AI != E; ++AI) {
-      Instruction *A = AI->first;
-      StrideDescriptor DesA = AI->second;
-
-      // Our code motion strategy implies that we can't have dependences
-      // between accesses in an interleaved group and other accesses located
-      // between the first and last member of the group. Note that this also
-      // means that a group can't have more than one member at a given offset.
-      // The accesses in a group can have dependences with other accesses, but
-      // we must ensure we don't extend the boundaries of the group such that
-      // we encompass those dependent accesses.
-      //
-      // For example, assume we have the sequence of accesses shown below in a
-      // stride-2 loop:
-      //
-      //  (1, 2) is a group | A[i]   = a;  // (1)
-      //                    | A[i-1] = b;  // (2) |
-      //                      A[i-3] = c;  // (3)
-      //                      A[i]   = d;  // (4) | (2, 4) is not a group
-      //
-      // Because accesses (2) and (3) are dependent, we can group (2) with (1)
-      // but not with (4). If we did, the dependent access (3) would be within
-      // the boundaries of the (2, 4) group.
-      if (!canReorderMemAccessesForInterleavedGroups(&*AI, &*BI)) {
-        // If a dependence exists and A is already in a group, we know that A
-        // must be a store since A precedes B and WAR dependences are allowed.
-        // Thus, A would be sunk below B. We release A's group to prevent this
-        // illegal code motion. A will then be free to form another group with
-        // instructions that precede it.
-        if (isInterleaved(A)) {
-          InterleaveGroup<Instruction> *StoreGroup = getInterleaveGroup(A);
-
-          LLVM_DEBUG(dbgs() << "LV: Invalidated store group due to "
-                               "dependence between " << *A << " and "<< *B << '\n');
-
-          StoreGroups.remove(StoreGroup);
-          releaseGroup(StoreGroup);
-        }
-
-        // If a dependence exists and A is not already in a group (or it was
-        // and we just released it), B might be hoisted above A (if B is a
-        // load) or another store might be sunk below A (if B is a store). In
-        // either case, we can't add additional instructions to B's group. B
-        // will only form a group with instructions that it precedes.
-        break;
-      }
-
-      // At this point, we've checked for illegal code motion. If either A or B
-      // isn't strided, there's nothing left to do.
-      if (!isStrided(DesA.Stride) || !isStrided(DesB.Stride))
-        continue;
-
-      // Ignore A if it's already in a group or isn't the same kind of memory
-      // operation as B.
-      // Note that mayReadFromMemory() isn't mutually exclusive to
-      // mayWriteToMemory in the case of atomic loads. We shouldn't see those
-      // here, canVectorizeMemory() should have returned false - except for the
-      // case we asked for optimization remarks.
-      if (isInterleaved(A) ||
-          (A->mayReadFromMemory() != B->mayReadFromMemory()) ||
-          (A->mayWriteToMemory() != B->mayWriteToMemory()))
-        continue;
-
-      // Check rules 1 and 2. Ignore A if its stride or size is different from
-      // that of B.
-      if (DesA.Stride != DesB.Stride || DesA.Size != DesB.Size)
-        continue;
-
-      // Ignore A if the memory object of A and B don't belong to the same
-      // address space
-      if (getLoadStoreAddressSpace(A) != getLoadStoreAddressSpace(B))
-        continue;
-
-      // Calculate the distance from A to B.
-      const SCEVConstant *DistToB = dyn_cast<SCEVConstant>(
-          PSE.getSE()->getMinusSCEV(DesA.Scev, DesB.Scev));
-      if (!DistToB)
-        continue;
-      int64_t DistanceToB = DistToB->getAPInt().getSExtValue();
-
-      // Check rule 3. Ignore A if its distance to B is not a multiple of the
-      // size.
-      if (DistanceToB % static_cast<int64_t>(DesB.Size))
-        continue;
-
-      // All members of a predicated interleave-group must have the same predicate,
-      // and currently must reside in the same BB.
-      BasicBlock *BlockA = A->getParent();
-      BasicBlock *BlockB = B->getParent();
-      if ((isPredicated(BlockA) || isPredicated(BlockB)) &&
-          (!EnablePredicatedInterleavedMemAccesses || BlockA != BlockB))
-        continue;
-
-      // The index of A is the index of B plus A's distance to B in multiples
-      // of the size.
-      int IndexA =
-          Group->getIndex(B) + DistanceToB / static_cast<int64_t>(DesB.Size);
-
-      // Try to insert A into B's group.
-      if (Group->insertMember(A, IndexA, DesA.Alignment)) {
-        LLVM_DEBUG(dbgs() << "LV: Inserted:" << *A << '\n'
-                          << "    into the interleave group with" << *B
-                          << '\n');
-        InterleaveGroupMap[A] = Group;
-
-        // Set the first load in program order as the insert position.
-        if (A->mayReadFromMemory())
-          Group->setInsertPos(A);
-      }
-    } // Iteration over A accesses.
-  }   // Iteration over B accesses.
-
-  auto InvalidateGroupIfMemberMayWrap = [&](InterleaveGroup<Instruction> *Group,
-                                            int Index,
-                                            std::string FirstOrLast) -> bool {
-    Instruction *Member = Group->getMember(Index);
-    assert(Member && "Group member does not exist");
-    Value *MemberPtr = getLoadStorePointerOperand(Member);
-    Type *AccessTy = getLoadStoreType(Member);
-    if (getPtrStride(PSE, AccessTy, MemberPtr, TheLoop, Strides,
-                     /*Assume=*/false, /*ShouldCheckWrap=*/true))
-      return false;
-    LLVM_DEBUG(dbgs() << "LV: Invalidate candidate interleaved group due to "
-                      << FirstOrLast
-                      << " group member potentially pointer-wrapping.\n");
-    releaseGroup(Group);
-    return true;
-  };
-
-  // Remove interleaved groups with gaps whose memory
-  // accesses may wrap around. We have to revisit the getPtrStride analysis,
-  // this time with ShouldCheckWrap=true, since collectConstStrideAccesses does
-  // not check wrapping (see documentation there).
-  // FORNOW we use Assume=false;
-  // TODO: Change to Assume=true but making sure we don't exceed the threshold
-  // of runtime SCEV assumptions checks (thereby potentially failing to
-  // vectorize altogether).
-  // Additional optional optimizations:
-  // TODO: If we are peeling the loop and we know that the first pointer doesn't
-  // wrap then we can deduce that all pointers in the group don't wrap.
-  // This means that we can forcefully peel the loop in order to only have to
-  // check the first pointer for no-wrap. When we'll change to use Assume=true
-  // we'll only need at most one runtime check per interleaved group.
-  for (auto *Group : LoadGroups) {
-    // Case 1: A full group. Can Skip the checks; For full groups, if the wide
-    // load would wrap around the address space we would do a memory access at
-    // nullptr even without the transformation.
-    if (Group->getNumMembers() == Group->getFactor())
-      continue;
-
-    // Case 2: If first and last members of the group don't wrap this implies
-    // that all the pointers in the group don't wrap.
-    // So we check only group member 0 (which is always guaranteed to exist),
-    // and group member Factor - 1; If the latter doesn't exist we rely on
-    // peeling (if it is a non-reversed accsess -- see Case 3).
-    if (InvalidateGroupIfMemberMayWrap(Group, 0, std::string("first")))
-      continue;
-    if (Group->getMember(Group->getFactor() - 1))
-      InvalidateGroupIfMemberMayWrap(Group, Group->getFactor() - 1,
-                                     std::string("last"));
-    else {
-      // Case 3: A non-reversed interleaved load group with gaps: We need
-      // to execute at least one scalar epilogue iteration. This will ensure
-      // we don't speculatively access memory out-of-bounds. We only need
-      // to look for a member at index factor - 1, since every group must have
-      // a member at index zero.
-      if (Group->isReverse()) {
-        LLVM_DEBUG(
-            dbgs() << "LV: Invalidate candidate interleaved group due to "
-                      "a reverse access with gaps.\n");
-        releaseGroup(Group);
-        continue;
-      }
-      LLVM_DEBUG(
-          dbgs() << "LV: Interleaved group requires epilogue iteration.\n");
-      RequiresScalarEpilogue = true;
-    }
-  }
-
-  for (auto *Group : StoreGroups) {
-    // Case 1: A full group. Can Skip the checks; For full groups, if the wide
-    // store would wrap around the address space we would do a memory access at
-    // nullptr even without the transformation.
-    if (Group->getNumMembers() == Group->getFactor())
-      continue;
-
-    // Interleave-store-group with gaps is implemented using masked wide store.
-    // Remove interleaved store groups with gaps if
-    // masked-interleaved-accesses are not enabled by the target.
-    if (!EnablePredicatedInterleavedMemAccesses) {
-      LLVM_DEBUG(
-          dbgs() << "LV: Invalidate candidate interleaved store group due "
-                    "to gaps.\n");
-      releaseGroup(Group);
-      continue;
-    }
-
-    // Case 2: If first and last members of the group don't wrap this implies
-    // that all the pointers in the group don't wrap.
-    // So we check only group member 0 (which is always guaranteed to exist),
-    // and the last group member. Case 3 (scalar epilog) is not relevant for
-    // stores with gaps, which are implemented with masked-store (rather than
-    // speculative access, as in loads).
-    if (InvalidateGroupIfMemberMayWrap(Group, 0, std::string("first")))
-      continue;
-    for (int Index = Group->getFactor() - 1; Index > 0; Index--)
-      if (Group->getMember(Index)) {
-        InvalidateGroupIfMemberMayWrap(Group, Index, std::string("last"));
-        break;
-      }
-  }
-}
-
-void InterleavedAccessInfo::invalidateGroupsRequiringScalarEpilogue() {
-  // If no group had triggered the requirement to create an epilogue loop,
-  // there is nothing to do.
-  if (!requiresScalarEpilogue())
-    return;
-
-  bool ReleasedGroup = false;
-  // Release groups requiring scalar epilogues. Note that this also removes them
-  // from InterleaveGroups.
-  for (auto *Group : make_early_inc_range(InterleaveGroups)) {
-    if (!Group->requiresScalarEpilogue())
-      continue;
-    LLVM_DEBUG(
-        dbgs()
-        << "LV: Invalidate candidate interleaved group due to gaps that "
-           "require a scalar epilogue (not allowed under optsize) and cannot "
-           "be masked (not enabled). \n");
-    releaseGroup(Group);
-    ReleasedGroup = true;
-  }
-  assert(ReleasedGroup && "At least one group must be invalidated, as a "
-                          "scalar epilogue was required");
-  (void)ReleasedGroup;
-  RequiresScalarEpilogue = false;
-}
-
-template <typename InstT>
-void InterleaveGroup<InstT>::addMetadata(InstT *NewInst) const {
-  llvm_unreachable("addMetadata can only be used for Instruction");
-}
-
-namespace llvm {
-template <>
-void InterleaveGroup<Instruction>::addMetadata(Instruction *NewInst) const {
-  SmallVector<Value *, 4> VL;
-  std::transform(Members.begin(), Members.end(), std::back_inserter(VL),
-                 [](std::pair<int, Instruction *> p) { return p.second; });
-  propagateMetadata(NewInst, VL);
-}
-}
-
-std::string VFABI::mangleTLIVectorName(StringRef VectorName,
-                                       StringRef ScalarName, unsigned numArgs,
-                                       ElementCount VF) {
-  SmallString<256> Buffer;
-  llvm::raw_svector_ostream Out(Buffer);
-  Out << "_ZGV" << VFABI::_LLVM_ << "N";
-  if (VF.isScalable())
-    Out << 'x';
-  else
-    Out << VF.getFixedValue();
-  for (unsigned I = 0; I < numArgs; ++I)
-    Out << "v";
-  Out << "_" << ScalarName << "(" << VectorName << ")";
-  return std::string(Out.str());
-}
-
-void VFABI::getVectorVariantNames(
-    const CallInst &CI, SmallVectorImpl<std::string> &VariantMappings) {
-  const StringRef S = CI.getFnAttr(VFABI::MappingsAttrName).getValueAsString();
-  if (S.empty())
-    return;
-
-  SmallVector<StringRef, 8> ListAttr;
-  S.split(ListAttr, ",");
-
-  for (auto &S : SetVector<StringRef>(ListAttr.begin(), ListAttr.end())) {
-#ifndef NDEBUG
-    LLVM_DEBUG(dbgs() << "VFABI: adding mapping '" << S << "'\n");
-    Optional<VFInfo> Info = VFABI::tryDemangleForVFABI(S, *(CI.getModule()));
-    assert(Info.hasValue() && "Invalid name for a VFABI variant.");
-    assert(CI.getModule()->getFunction(Info.getValue().VectorName) &&
-           "Vector function is missing.");
-#endif
-    VariantMappings.push_back(std::string(S));
-  }
-}
-
-bool VFShape::hasValidParameterList() const {
-  for (unsigned Pos = 0, NumParams = Parameters.size(); Pos < NumParams;
-       ++Pos) {
-    assert(Parameters[Pos].ParamPos == Pos && "Broken parameter list.");
-
-    switch (Parameters[Pos].ParamKind) {
-    default: // Nothing to check.
-      break;
-    case VFParamKind::OMP_Linear:
-    case VFParamKind::OMP_LinearRef:
-    case VFParamKind::OMP_LinearVal:
-    case VFParamKind::OMP_LinearUVal:
-      // Compile time linear steps must be non-zero.
-      if (Parameters[Pos].LinearStepOrPos == 0)
-        return false;
-      break;
-    case VFParamKind::OMP_LinearPos:
-    case VFParamKind::OMP_LinearRefPos:
-    case VFParamKind::OMP_LinearValPos:
-    case VFParamKind::OMP_LinearUValPos:
-      // The runtime linear step must be referring to some other
-      // parameters in the signature.
-      if (Parameters[Pos].LinearStepOrPos >= int(NumParams))
-        return false;
-      // The linear step parameter must be marked as uniform.
-      if (Parameters[Parameters[Pos].LinearStepOrPos].ParamKind !=
-          VFParamKind::OMP_Uniform)
-        return false;
-      // The linear step parameter can't point at itself.
-      if (Parameters[Pos].LinearStepOrPos == int(Pos))
-        return false;
-      break;
-    case VFParamKind::GlobalPredicate:
-      // The global predicate must be the unique. Can be placed anywhere in the
-      // signature.
-      for (unsigned NextPos = Pos + 1; NextPos < NumParams; ++NextPos)
-        if (Parameters[NextPos].ParamKind == VFParamKind::GlobalPredicate)
-          return false;
-      break;
-    }
-  }
-  return true;
-}