contrib/llvm-project/llvm/lib/CodeGen/InterleavedAccessPass.cpp

   1 //===- InterleavedAccessPass.cpp ------------------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // This file implements the Interleaved Access pass, which identifies
  10 // interleaved memory accesses and transforms them into target specific
  11 // intrinsics.
  12 //
  13 // An interleaved load reads data from memory into several vectors, with
  14 // DE-interleaving the data on a factor. An interleaved store writes several
  15 // vectors to memory with RE-interleaving the data on a factor.
  16 //
  17 // As interleaved accesses are difficult to identified in CodeGen (mainly
  18 // because the VECTOR_SHUFFLE DAG node is quite different from the shufflevector
  19 // IR), we identify and transform them to intrinsics in this pass so the
  20 // intrinsics can be easily matched into target specific instructions later in
  21 // CodeGen.
  22 //
  23 // E.g. An interleaved load (Factor = 2):
  24 //        %wide.vec = load <8 x i32>, <8 x i32>* %ptr
  25 //        %v0 = shuffle <8 x i32> %wide.vec, <8 x i32> poison, <0, 2, 4, 6>
  26 //        %v1 = shuffle <8 x i32> %wide.vec, <8 x i32> poison, <1, 3, 5, 7>
  27 //
  28 // It could be transformed into a ld2 intrinsic in AArch64 backend or a vld2
  29 // intrinsic in ARM backend.
  30 //
  31 // In X86, this can be further optimized into a set of target
  32 // specific loads followed by an optimized sequence of shuffles.
  33 //
  34 // E.g. An interleaved store (Factor = 3):
  35 //        %i.vec = shuffle <8 x i32> %v0, <8 x i32> %v1,
  36 //                                    <0, 4, 8, 1, 5, 9, 2, 6, 10, 3, 7, 11>
  37 //        store <12 x i32> %i.vec, <12 x i32>* %ptr
  38 //
  39 // It could be transformed into a st3 intrinsic in AArch64 backend or a vst3
  40 // intrinsic in ARM backend.
  41 //
  42 // Similarly, a set of interleaved stores can be transformed into an optimized
  43 // sequence of shuffles followed by a set of target specific stores for X86.
  44 //
  45 //===----------------------------------------------------------------------===//
  46
  47 #include "llvm/ADT/ArrayRef.h"
  48 #include "llvm/ADT/DenseMap.h"
  49 #include "llvm/ADT/SmallVector.h"
  50 #include "llvm/CodeGen/TargetLowering.h"
  51 #include "llvm/CodeGen/TargetPassConfig.h"
  52 #include "llvm/CodeGen/TargetSubtargetInfo.h"
  53 #include "llvm/IR/Constants.h"
  54 #include "llvm/IR/Dominators.h"
  55 #include "llvm/IR/Function.h"
  56 #include "llvm/IR/IRBuilder.h"
  57 #include "llvm/IR/InstIterator.h"
  58 #include "llvm/IR/Instruction.h"
  59 #include "llvm/IR/Instructions.h"
  60 #include "llvm/IR/Type.h"
  61 #include "llvm/InitializePasses.h"
  62 #include "llvm/Pass.h"
  63 #include "llvm/Support/Casting.h"
  64 #include "llvm/Support/CommandLine.h"
  65 #include "llvm/Support/Debug.h"
  66 #include "llvm/Support/MathExtras.h"
  67 #include "llvm/Support/raw_ostream.h"
  68 #include "llvm/Target/TargetMachine.h"
  69 #include "llvm/Transforms/Utils/Local.h"
  70 #include <cassert>
  71 #include <utility>
  72
  73 using namespace llvm;
  74
  75 #define DEBUG_TYPE "interleaved-access"
  76
  77 static cl::opt<bool> LowerInterleavedAccesses(
  78     "lower-interleaved-accesses",
  79     cl::desc("Enable lowering interleaved accesses to intrinsics"),
  80     cl::init(true), cl::Hidden);
  81
  82 namespace {
  83
  84 class InterleavedAccess : public FunctionPass {
  85 public:
  86   static char ID;
  87
  88   InterleavedAccess() : FunctionPass(ID) {
  89     initializeInterleavedAccessPass(*PassRegistry::getPassRegistry());
  90   }
  91
  92   StringRef getPassName() const override { return "Interleaved Access Pass"; }
  93
  94   bool runOnFunction(Function &F) override;
  95
  96   void getAnalysisUsage(AnalysisUsage &AU) const override {
  97     AU.addRequired<DominatorTreeWrapperPass>();
  98     AU.setPreservesCFG();
  99   }
 100
 101 private:
 102   DominatorTree *DT = nullptr;
 103   const TargetLowering *TLI = nullptr;
 104
 105   /// The maximum supported interleave factor.
 106   unsigned MaxFactor;
 107
 108   /// Transform an interleaved load into target specific intrinsics.
 109   bool lowerInterleavedLoad(LoadInst *LI,
 110                             SmallVector<Instruction *, 32> &DeadInsts);
 111
 112   /// Transform an interleaved store into target specific intrinsics.
 113   bool lowerInterleavedStore(StoreInst *SI,
 114                              SmallVector<Instruction *, 32> &DeadInsts);
 115
 116   /// Returns true if the uses of an interleaved load by the
 117   /// extractelement instructions in \p Extracts can be replaced by uses of the
 118   /// shufflevector instructions in \p Shuffles instead. If so, the necessary
 119   /// replacements are also performed.
 120   bool tryReplaceExtracts(ArrayRef<ExtractElementInst *> Extracts,
 121                           ArrayRef<ShuffleVectorInst *> Shuffles);
 122
 123   /// Given a number of shuffles of the form shuffle(binop(x,y)), convert them
 124   /// to binop(shuffle(x), shuffle(y)) to allow the formation of an
 125   /// interleaving load. Any newly created shuffles that operate on \p LI will
 126   /// be added to \p Shuffles. Returns true, if any changes to the IR have been
 127   /// made.
 128   bool replaceBinOpShuffles(ArrayRef<ShuffleVectorInst *> BinOpShuffles,
 129                             SmallVectorImpl<ShuffleVectorInst *> &Shuffles,
 130                             LoadInst *LI);
 131 };
 132
 133 } // end anonymous namespace.
 134
 135 char InterleavedAccess::ID = 0;
 136
 137 INITIALIZE_PASS_BEGIN(InterleavedAccess, DEBUG_TYPE,
 138     "Lower interleaved memory accesses to target specific intrinsics", false,
 139     false)
 140 INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
 141 INITIALIZE_PASS_END(InterleavedAccess, DEBUG_TYPE,
 142     "Lower interleaved memory accesses to target specific intrinsics", false,
 143     false)
 144
 145 FunctionPass *llvm::createInterleavedAccessPass() {
 146   return new InterleavedAccess();
 147 }
 148
 149 /// Check if the mask is a DE-interleave mask of the given factor
 150 /// \p Factor like:
 151 ///     <Index, Index+Factor, ..., Index+(NumElts-1)*Factor>
 152 static bool isDeInterleaveMaskOfFactor(ArrayRef<int> Mask, unsigned Factor,
 153                                        unsigned &Index) {
 154   // Check all potential start indices from 0 to (Factor - 1).
 155   for (Index = 0; Index < Factor; Index++) {
 156     unsigned i = 0;
 157
 158     // Check that elements are in ascending order by Factor. Ignore undef
 159     // elements.
 160     for (; i < Mask.size(); i++)
 161       if (Mask[i] >= 0 && static_cast<unsigned>(Mask[i]) != Index + i * Factor)
 162         break;
 163
 164     if (i == Mask.size())
 165       return true;
 166   }
 167
 168   return false;
 169 }
 170
 171 /// Check if the mask is a DE-interleave mask for an interleaved load.
 172 ///
 173 /// E.g. DE-interleave masks (Factor = 2) could be:
 174 ///     <0, 2, 4, 6>    (mask of index 0 to extract even elements)
 175 ///     <1, 3, 5, 7>    (mask of index 1 to extract odd elements)
 176 static bool isDeInterleaveMask(ArrayRef<int> Mask, unsigned &Factor,
 177                                unsigned &Index, unsigned MaxFactor,
 178                                unsigned NumLoadElements) {
 179   if (Mask.size() < 2)
 180     return false;
 181
 182   // Check potential Factors.
 183   for (Factor = 2; Factor <= MaxFactor; Factor++) {
 184     // Make sure we don't produce a load wider than the input load.
 185     if (Mask.size() * Factor > NumLoadElements)
 186       return false;
 187     if (isDeInterleaveMaskOfFactor(Mask, Factor, Index))
 188       return true;
 189   }
 190
 191   return false;
 192 }
 193
 194 /// Check if the mask can be used in an interleaved store.
 195 //
 196 /// It checks for a more general pattern than the RE-interleave mask.
 197 /// I.e. <x, y, ... z, x+1, y+1, ...z+1, x+2, y+2, ...z+2, ...>
 198 /// E.g. For a Factor of 2 (LaneLen=4): <4, 32, 5, 33, 6, 34, 7, 35>
 199 /// E.g. For a Factor of 3 (LaneLen=4): <4, 32, 16, 5, 33, 17, 6, 34, 18, 7, 35, 19>
 200 /// E.g. For a Factor of 4 (LaneLen=2): <8, 2, 12, 4, 9, 3, 13, 5>
 201 ///
 202 /// The particular case of an RE-interleave mask is:
 203 /// I.e. <0, LaneLen, ... , LaneLen*(Factor - 1), 1, LaneLen + 1, ...>
 204 /// E.g. For a Factor of 2 (LaneLen=4): <0, 4, 1, 5, 2, 6, 3, 7>
 205 static bool isReInterleaveMask(ArrayRef<int> Mask, unsigned &Factor,
 206                                unsigned MaxFactor, unsigned OpNumElts) {
 207   unsigned NumElts = Mask.size();
 208   if (NumElts < 4)
 209     return false;
 210
 211   // Check potential Factors.
 212   for (Factor = 2; Factor <= MaxFactor; Factor++) {
 213     if (NumElts % Factor)
 214       continue;
 215
 216     unsigned LaneLen = NumElts / Factor;
 217     if (!isPowerOf2_32(LaneLen))
 218       continue;
 219
 220     // Check whether each element matches the general interleaved rule.
 221     // Ignore undef elements, as long as the defined elements match the rule.
 222     // Outer loop processes all factors (x, y, z in the above example)
 223     unsigned I = 0, J;
 224     for (; I < Factor; I++) {
 225       unsigned SavedLaneValue;
 226       unsigned SavedNoUndefs = 0;
 227
 228       // Inner loop processes consecutive accesses (x, x+1... in the example)
 229       for (J = 0; J < LaneLen - 1; J++) {
 230         // Lane computes x's position in the Mask
 231         unsigned Lane = J * Factor + I;
 232         unsigned NextLane = Lane + Factor;
 233         int LaneValue = Mask[Lane];
 234         int NextLaneValue = Mask[NextLane];
 235
 236         // If both are defined, values must be sequential
 237         if (LaneValue >= 0 && NextLaneValue >= 0 &&
 238             LaneValue + 1 != NextLaneValue)
 239           break;
 240
 241         // If the next value is undef, save the current one as reference
 242         if (LaneValue >= 0 && NextLaneValue < 0) {
 243           SavedLaneValue = LaneValue;
 244           SavedNoUndefs = 1;
 245         }
 246
 247         // Undefs are allowed, but defined elements must still be consecutive:
 248         // i.e.: x,..., undef,..., x + 2,..., undef,..., undef,..., x + 5, ....
 249         // Verify this by storing the last non-undef followed by an undef
 250         // Check that following non-undef masks are incremented with the
 251         // corresponding distance.
 252         if (SavedNoUndefs > 0 && LaneValue < 0) {
 253           SavedNoUndefs++;
 254           if (NextLaneValue >= 0 &&
 255               SavedLaneValue + SavedNoUndefs != (unsigned)NextLaneValue)
 256             break;
 257         }
 258       }
 259
 260       if (J < LaneLen - 1)
 261         break;
 262
 263       int StartMask = 0;
 264       if (Mask[I] >= 0) {
 265         // Check that the start of the I range (J=0) is greater than 0
 266         StartMask = Mask[I];
 267       } else if (Mask[(LaneLen - 1) * Factor + I] >= 0) {
 268         // StartMask defined by the last value in lane
 269         StartMask = Mask[(LaneLen - 1) * Factor + I] - J;
 270       } else if (SavedNoUndefs > 0) {
 271         // StartMask defined by some non-zero value in the j loop
 272         StartMask = SavedLaneValue - (LaneLen - 1 - SavedNoUndefs);
 273       }
 274       // else StartMask remains set to 0, i.e. all elements are undefs
 275
 276       if (StartMask < 0)
 277         break;
 278       // We must stay within the vectors; This case can happen with undefs.
 279       if (StartMask + LaneLen > OpNumElts*2)
 280         break;
 281     }
 282
 283     // Found an interleaved mask of current factor.
 284     if (I == Factor)
 285       return true;
 286   }
 287
 288   return false;
 289 }
 290
 291 bool InterleavedAccess::lowerInterleavedLoad(
 292     LoadInst *LI, SmallVector<Instruction *, 32> &DeadInsts) {
 293   if (!LI->isSimple() || isa<ScalableVectorType>(LI->getType()))
 294     return false;
 295
 296   // Check if all users of this load are shufflevectors. If we encounter any
 297   // users that are extractelement instructions or binary operators, we save
 298   // them to later check if they can be modified to extract from one of the
 299   // shufflevectors instead of the load.
 300
 301   SmallVector<ShuffleVectorInst *, 4> Shuffles;
 302   SmallVector<ExtractElementInst *, 4> Extracts;
 303   // BinOpShuffles need to be handled a single time in case both operands of the
 304   // binop are the same load.
 305   SmallSetVector<ShuffleVectorInst *, 4> BinOpShuffles;
 306
 307   for (auto *User : LI->users()) {
 308     auto *Extract = dyn_cast<ExtractElementInst>(User);
 309     if (Extract && isa<ConstantInt>(Extract->getIndexOperand())) {
 310       Extracts.push_back(Extract);
 311       continue;
 312     }
 313     auto *BI = dyn_cast<BinaryOperator>(User);
 314     if (BI && BI->hasOneUse()) {
 315       if (auto *SVI = dyn_cast<ShuffleVectorInst>(*BI->user_begin())) {
 316         BinOpShuffles.insert(SVI);
 317         continue;
 318       }
 319     }
 320     auto *SVI = dyn_cast<ShuffleVectorInst>(User);
 321     if (!SVI || !isa<UndefValue>(SVI->getOperand(1)))
 322       return false;
 323
 324     Shuffles.push_back(SVI);
 325   }
 326
 327   if (Shuffles.empty() && BinOpShuffles.empty())
 328     return false;
 329
 330   unsigned Factor, Index;
 331
 332   unsigned NumLoadElements =
 333       cast<FixedVectorType>(LI->getType())->getNumElements();
 334   auto *FirstSVI = Shuffles.size() > 0 ? Shuffles[0] : BinOpShuffles[0];
 335   // Check if the first shufflevector is DE-interleave shuffle.
 336   if (!isDeInterleaveMask(FirstSVI->getShuffleMask(), Factor, Index, MaxFactor,
 337                           NumLoadElements))
 338     return false;
 339
 340   // Holds the corresponding index for each DE-interleave shuffle.
 341   SmallVector<unsigned, 4> Indices;
 342
 343   Type *VecTy = FirstSVI->getType();
 344
 345   // Check if other shufflevectors are also DE-interleaved of the same type
 346   // and factor as the first shufflevector.
 347   for (auto *Shuffle : Shuffles) {
 348     if (Shuffle->getType() != VecTy)
 349       return false;
 350     if (!isDeInterleaveMaskOfFactor(Shuffle->getShuffleMask(), Factor,
 351                                     Index))
 352       return false;
 353
 354     assert(Shuffle->getShuffleMask().size() <= NumLoadElements);
 355     Indices.push_back(Index);
 356   }
 357   for (auto *Shuffle : BinOpShuffles) {
 358     if (Shuffle->getType() != VecTy)
 359       return false;
 360     if (!isDeInterleaveMaskOfFactor(Shuffle->getShuffleMask(), Factor,
 361                                     Index))
 362       return false;
 363
 364     assert(Shuffle->getShuffleMask().size() <= NumLoadElements);
 365
 366     if (cast<Instruction>(Shuffle->getOperand(0))->getOperand(0) == LI)
 367       Indices.push_back(Index);
 368     if (cast<Instruction>(Shuffle->getOperand(0))->getOperand(1) == LI)
 369       Indices.push_back(Index);
 370   }
 371
 372   // Try and modify users of the load that are extractelement instructions to
 373   // use the shufflevector instructions instead of the load.
 374   if (!tryReplaceExtracts(Extracts, Shuffles))
 375     return false;
 376
 377   bool BinOpShuffleChanged =
 378       replaceBinOpShuffles(BinOpShuffles.getArrayRef(), Shuffles, LI);
 379
 380   LLVM_DEBUG(dbgs() << "IA: Found an interleaved load: " << *LI << "\n");
 381
 382   // Try to create target specific intrinsics to replace the load and shuffles.
 383   if (!TLI->lowerInterleavedLoad(LI, Shuffles, Indices, Factor)) {
 384     // If Extracts is not empty, tryReplaceExtracts made changes earlier.
 385     return !Extracts.empty() || BinOpShuffleChanged;
 386   }
 387
 388   append_range(DeadInsts, Shuffles);
 389
 390   DeadInsts.push_back(LI);
 391   return true;
 392 }
 393
 394 bool InterleavedAccess::replaceBinOpShuffles(
 395     ArrayRef<ShuffleVectorInst *> BinOpShuffles,
 396     SmallVectorImpl<ShuffleVectorInst *> &Shuffles, LoadInst *LI) {
 397   for (auto *SVI : BinOpShuffles) {
 398     BinaryOperator *BI = cast<BinaryOperator>(SVI->getOperand(0));
 399     Type *BIOp0Ty = BI->getOperand(0)->getType();
 400     ArrayRef<int> Mask = SVI->getShuffleMask();
 401     assert(all_of(Mask, [&](int Idx) {
 402       return Idx < (int)cast<FixedVectorType>(BIOp0Ty)->getNumElements();
 403     }));
 404
 405     auto *NewSVI1 =
 406         new ShuffleVectorInst(BI->getOperand(0), PoisonValue::get(BIOp0Ty),
 407                               Mask, SVI->getName(), SVI);
 408     auto *NewSVI2 = new ShuffleVectorInst(
 409         BI->getOperand(1), PoisonValue::get(BI->getOperand(1)->getType()), Mask,
 410         SVI->getName(), SVI);
 411     BinaryOperator *NewBI = BinaryOperator::CreateWithCopiedFlags(
 412         BI->getOpcode(), NewSVI1, NewSVI2, BI, BI->getName(), SVI);
 413     SVI->replaceAllUsesWith(NewBI);
 414     LLVM_DEBUG(dbgs() << "  Replaced: " << *BI << "\n    And   : " << *SVI
 415                       << "\n  With    : " << *NewSVI1 << "\n    And   : "
 416                       << *NewSVI2 << "\n    And   : " << *NewBI << "\n");
 417     RecursivelyDeleteTriviallyDeadInstructions(SVI);
 418     if (NewSVI1->getOperand(0) == LI)
 419       Shuffles.push_back(NewSVI1);
 420     if (NewSVI2->getOperand(0) == LI)
 421       Shuffles.push_back(NewSVI2);
 422   }
 423
 424   return !BinOpShuffles.empty();
 425 }
 426
 427 bool InterleavedAccess::tryReplaceExtracts(
 428     ArrayRef<ExtractElementInst *> Extracts,
 429     ArrayRef<ShuffleVectorInst *> Shuffles) {
 430   // If there aren't any extractelement instructions to modify, there's nothing
 431   // to do.
 432   if (Extracts.empty())
 433     return true;
 434
 435   // Maps extractelement instructions to vector-index pairs. The extractlement
 436   // instructions will be modified to use the new vector and index operands.
 437   DenseMap<ExtractElementInst *, std::pair<Value *, int>> ReplacementMap;
 438
 439   for (auto *Extract : Extracts) {
 440     // The vector index that is extracted.
 441     auto *IndexOperand = cast<ConstantInt>(Extract->getIndexOperand());
 442     auto Index = IndexOperand->getSExtValue();
 443
 444     // Look for a suitable shufflevector instruction. The goal is to modify the
 445     // extractelement instruction (which uses an interleaved load) to use one
 446     // of the shufflevector instructions instead of the load.
 447     for (auto *Shuffle : Shuffles) {
 448       // If the shufflevector instruction doesn't dominate the extract, we
 449       // can't create a use of it.
 450       if (!DT->dominates(Shuffle, Extract))
 451         continue;
 452
 453       // Inspect the indices of the shufflevector instruction. If the shuffle
 454       // selects the same index that is extracted, we can modify the
 455       // extractelement instruction.
 456       SmallVector<int, 4> Indices;
 457       Shuffle->getShuffleMask(Indices);
 458       for (unsigned I = 0; I < Indices.size(); ++I)
 459         if (Indices[I] == Index) {
 460           assert(Extract->getOperand(0) == Shuffle->getOperand(0) &&
 461                  "Vector operations do not match");
 462           ReplacementMap[Extract] = std::make_pair(Shuffle, I);
 463           break;
 464         }
 465
 466       // If we found a suitable shufflevector instruction, stop looking.
 467       if (ReplacementMap.count(Extract))
 468         break;
 469     }
 470
 471     // If we did not find a suitable shufflevector instruction, the
 472     // extractelement instruction cannot be modified, so we must give up.
 473     if (!ReplacementMap.count(Extract))
 474       return false;
 475   }
 476
 477   // Finally, perform the replacements.
 478   IRBuilder<> Builder(Extracts[0]->getContext());
 479   for (auto &Replacement : ReplacementMap) {
 480     auto *Extract = Replacement.first;
 481     auto *Vector = Replacement.second.first;
 482     auto Index = Replacement.second.second;
 483     Builder.SetInsertPoint(Extract);
 484     Extract->replaceAllUsesWith(Builder.CreateExtractElement(Vector, Index));
 485     Extract->eraseFromParent();
 486   }
 487
 488   return true;
 489 }
 490
 491 bool InterleavedAccess::lowerInterleavedStore(
 492     StoreInst *SI, SmallVector<Instruction *, 32> &DeadInsts) {
 493   if (!SI->isSimple())
 494     return false;
 495
 496   auto *SVI = dyn_cast<ShuffleVectorInst>(SI->getValueOperand());
 497   if (!SVI || !SVI->hasOneUse() || isa<ScalableVectorType>(SVI->getType()))
 498     return false;
 499
 500   // Check if the shufflevector is RE-interleave shuffle.
 501   unsigned Factor;
 502   unsigned OpNumElts =
 503       cast<FixedVectorType>(SVI->getOperand(0)->getType())->getNumElements();
 504   if (!isReInterleaveMask(SVI->getShuffleMask(), Factor, MaxFactor, OpNumElts))
 505     return false;
 506
 507   LLVM_DEBUG(dbgs() << "IA: Found an interleaved store: " << *SI << "\n");
 508
 509   // Try to create target specific intrinsics to replace the store and shuffle.
 510   if (!TLI->lowerInterleavedStore(SI, SVI, Factor))
 511     return false;
 512
 513   // Already have a new target specific interleaved store. Erase the old store.
 514   DeadInsts.push_back(SI);
 515   DeadInsts.push_back(SVI);
 516   return true;
 517 }
 518
 519 bool InterleavedAccess::runOnFunction(Function &F) {
 520   auto *TPC = getAnalysisIfAvailable<TargetPassConfig>();
 521   if (!TPC || !LowerInterleavedAccesses)
 522     return false;
 523
 524   LLVM_DEBUG(dbgs() << "*** " << getPassName() << ": " << F.getName() << "\n");
 525
 526   DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
 527   auto &TM = TPC->getTM<TargetMachine>();
 528   TLI = TM.getSubtargetImpl(F)->getTargetLowering();
 529   MaxFactor = TLI->getMaxSupportedInterleaveFactor();
 530
 531   // Holds dead instructions that will be erased later.
 532   SmallVector<Instruction *, 32> DeadInsts;
 533   bool Changed = false;
 534
 535   for (auto &I : instructions(F)) {
 536     if (auto *LI = dyn_cast<LoadInst>(&I))
 537       Changed |= lowerInterleavedLoad(LI, DeadInsts);
 538
 539     if (auto *SI = dyn_cast<StoreInst>(&I))
 540       Changed |= lowerInterleavedStore(SI, DeadInsts);
 541   }
 542
 543   for (auto I : DeadInsts)
 544     I->eraseFromParent();
 545
 546   return Changed;
 547 }