Clang-format LoadStoreVectorizer

[jlebar]

lib/Transforms/Vectorize/LoadStoreVectorizer.cpp

837 ↗

(On Diff #63113)

This is ugly. Does clang-format like it better if we put braces inside the DEBUG()?

DEBUG({
  dbgs() << ...;
  for (...) {}
});

Same above for many of the other multi-instruction DEBUGs.

[asbirlea]

lib/Transforms/Vectorize/LoadStoreVectorizer.cpp

837 ↗

(On Diff #63113)

Looks like yes, it does. Updating shortly.

[asbirlea]

Add braces for cleaner reformat.

[jlebar]

lib/Transforms/Vectorize/LoadStoreVectorizer.cpp

455 ↗

(On Diff #63119)

Probably should have braces here, too.

844 ↗

(On Diff #63119)

Do we need braces around the for loop? llvm style usually leaves them out.

[asbirlea]

lib/Transforms/Vectorize/LoadStoreVectorizer.cpp

455 ↗

(On Diff #63119)

TBH I like more the formatting without. Either works though.

844 ↗

(On Diff #63119)

Removing those.

[asbirlea]

Minor formatting.

llvm/trunk/lib/Transforms/Vectorize/LoadStoreVectorizer.cpp

 //===----- LoadStoreVectorizer.cpp - GPU Load & Store Vectorizer ----------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 //===----------------------------------------------------------------------===//
 
-#include "llvm/Transforms/Vectorize.h"
 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/PostOrderIterator.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/Analysis/AliasAnalysis.h"
 #include "llvm/Analysis/ScalarEvolution.h"
 #include "llvm/Analysis/ScalarEvolutionExpressions.h"
 #include "llvm/Analysis/TargetTransformInfo.h"
 #include "llvm/Analysis/ValueTracking.h"
 #include "llvm/Analysis/VectorUtils.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/Dominators.h"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/Type.h"
 #include "llvm/IR/Value.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
+#include "llvm/Transforms/Vectorize.h"
 
 using namespace llvm;
 
 #define DEBUG_TYPE "load-store-vectorizer"
 STATISTIC(NumVectorInstructions, "Number of vector accesses generated");
 STATISTIC(NumScalarsVectorized, "Number of scalar accesses vectorized");
 
 namespace {
class Vectorizer {
   const DataLayout &DL;
   IRBuilder<> Builder;
   ValueListMap StoreRefs;
   ValueListMap LoadRefs;
 
 public:
   Vectorizer(Function &F, AliasAnalysis &AA, DominatorTree &DT,
              ScalarEvolution &SE, TargetTransformInfo &TTI)
       : F(F), AA(AA), DT(DT), SE(SE), TTI(TTI),
-      DL(F.getParent()->getDataLayout()),
-      Builder(SE.getContext()) {}
+        DL(F.getParent()->getDataLayout()), Builder(SE.getContext()) {}
 
   bool run();
 
 private:
   Value *getPointerOperand(Value *I);
 
   unsigned getPointerAddressSpace(Value *I);
 

 bool LoadStoreVectorizer::runOnFunction(Function &F) {
   // Don't vectorize when the attribute NoImplicitFloat is used.
   if (skipFunction(F) || F.hasFnAttribute(Attribute::NoImplicitFloat))
     return false;
 
   AliasAnalysis &AA = getAnalysis<AAResultsWrapperPass>().getAAResults();
   DominatorTree &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
   ScalarEvolution &SE = getAnalysis<ScalarEvolutionWrapperPass>().getSE();
-  TargetTransformInfo &TTI
-    = getAnalysis<TargetTransformInfoWrapperPass>().getTTI(F);
+  TargetTransformInfo &TTI =
+      getAnalysis<TargetTransformInfoWrapperPass>().getTTI(F);
 
   Vectorizer V(F, AA, DT, SE, TTI);
   return V.run();
 }
 
 // Vectorizer Implementation
 bool Vectorizer::run() {
   bool Changed = false;
bool Vectorizer::isConsecutiveAccess(Value *A, Value *B) {
 
   // Make sure that A and B are different pointers of the same size type.
   unsigned PtrBitWidth = DL.getPointerSizeInBits(ASA);
   Type *PtrATy = PtrA->getType()->getPointerElementType();
   Type *PtrBTy = PtrB->getType()->getPointerElementType();
   if (PtrA == PtrB ||
       DL.getTypeStoreSize(PtrATy) != DL.getTypeStoreSize(PtrBTy) ||
       DL.getTypeStoreSize(PtrATy->getScalarType()) !=
           DL.getTypeStoreSize(PtrBTy->getScalarType()))
     return false;
 
   APInt Size(PtrBitWidth, DL.getTypeStoreSize(PtrATy));
 
   APInt OffsetA(PtrBitWidth, 0), OffsetB(PtrBitWidth, 0);
   PtrA = PtrA->stripAndAccumulateInBoundsConstantOffsets(DL, OffsetA);
   PtrB = PtrB->stripAndAccumulateInBoundsConstantOffsets(DL, OffsetB);
 
bool Vectorizer::isVectorizable(ArrayRef<Value *> Chain,
                                 BasicBlock::iterator To) {
   SmallVector<std::pair<Value *, unsigned>, 16> MemoryInstrs;
   SmallVector<std::pair<Value *, unsigned>, 16> ChainInstrs;
 
   unsigned Idx = 0;
   for (auto I = From, E = To; I != E; ++I, ++Idx) {
     if (isa<LoadInst>(I) || isa<StoreInst>(I)) {
       if (!is_contained(Chain, &*I))
-        MemoryInstrs.push_back({ &*I, Idx });
+        MemoryInstrs.push_back({&*I, Idx});
       else
-        ChainInstrs.push_back({ &*I, Idx });
+        ChainInstrs.push_back({&*I, Idx});
     } else if (I->mayHaveSideEffects()) {
       DEBUG(dbgs() << "LSV: Found side-effecting operation: " << *I << '\n');
       return false;
     }
   }
 
   assert(Chain.size() == ChainInstrs.size() &&
          "All instructions in the Chain must exist in [From, To).");
for (auto EntryChain : ChainInstrs) {
       // Same case, but in reverse.
       if (isa<LoadInst>(V) && isa<StoreInst>(VV) && VVIdx > VIdx)
         continue;
 
       Instruction *M0 = cast<Instruction>(V);
       Instruction *M1 = cast<Instruction>(VV);
 
       if (!AA.isNoAlias(MemoryLocation::get(M0), MemoryLocation::get(M1))) {
-        DEBUG(
+        DEBUG({
           Value *Ptr0 = getPointerOperand(M0);
           Value *Ptr1 = getPointerOperand(M1);
 
           dbgs() << "LSV: Found alias.\n"
                     "        Aliasing instruction and pointer:\n"
                  << *V << " aliases " << *Ptr0 << '\n'
                  << "        Aliased instruction and pointer:\n"
                  << *VV << " aliases " << *Ptr1 << '\n'
-          );
+        });
 
         return false;
       }
     }
   }
 
   return true;
 }
if (LoadInst *LI = dyn_cast<LoadInst>(&I)) {
       unsigned AS = Ptr->getType()->getPointerAddressSpace();
       unsigned VecRegSize = TTI.getLoadStoreVecRegBitWidth(AS);
 
       // No point in looking at these if they're too big to vectorize.
       if (TySize > VecRegSize / 2)
         continue;
 
       // Make sure all the users of a vector are constant-index extracts.
-      if (isa<VectorType>(Ty) &&
-          !all_of(LI->users(), [LI](const User *U) {
+      if (isa<VectorType>(Ty) && !all_of(LI->users(), [LI](const User *U) {
             const Instruction *UI = cast<Instruction>(U);
             return isa<ExtractElementInst>(UI) &&
                    isa<ConstantInt>(UI->getOperand(1));
           }))
         continue;
 
       // TODO: Target hook to filter types.
 
if (LoadInst *LI = dyn_cast<LoadInst>(&I)) {
         continue;
 
       Value *Ptr = SI->getPointerOperand();
       unsigned AS = Ptr->getType()->getPointerAddressSpace();
       unsigned VecRegSize = TTI.getLoadStoreVecRegBitWidth(AS);
       if (TySize > VecRegSize / 2)
         continue;
 
-      if (isa<VectorType>(Ty) &&
-          !all_of(SI->users(), [SI](const User *U) {
+      if (isa<VectorType>(Ty) && !all_of(SI->users(), [SI](const User *U) {
             const Instruction *UI = cast<Instruction>(U);
             return isa<ExtractElementInst>(UI) &&
                    isa<ConstantInt>(UI->getOperand(1));
           }))
         continue;
 
       // Save store location.
       Value *ObjPtr = GetUnderlyingObject(Ptr, DL);
bool Vectorizer::vectorizeStoreChain(ArrayRef<Value *> Chain) {
   // TODO: Target hook to control types to split to.
   if (ChainSize > VF) {
     DEBUG(dbgs() << "LSV: Vector factor is too big."
                     " Creating two separate arrays.\n");
     return vectorizeStoreChain(Chain.slice(0, VF)) |
            vectorizeStoreChain(Chain.slice(VF));
   }
 
-  DEBUG(
+  DEBUG({
     dbgs() << "LSV: Stores to vectorize:\n";
     for (Value *V : Chain)
       V->dump();
-  );
+  });
 
   // Check alignment restrictions.
   unsigned Alignment = getAlignment(S0);
 
   // If the store is going to be misaligned, don't vectorize it.
   // TODO: Check TLI.allowsMisalignedMemoryAccess
   if ((Alignment % SzInBytes) != 0 && (Alignment % TargetBaseAlign) != 0) {
     if (S0->getPointerAddressSpace() == 0) {
for (unsigned I = 0, E = Chain.size(); I != E; ++I) {
       StoreInst *Store = cast<StoreInst>(Chain[I]);
       for (unsigned J = 0, NE = VecStoreTy->getNumElements(); J != NE; ++J) {
         unsigned NewIdx = J + I * VecWidth;
         Value *Extract = Builder.CreateExtractElement(Store->getValueOperand(),
                                                       Builder.getInt32(J));
         if (Extract->getType() != StoreTy->getScalarType())
           Extract = Builder.CreateBitCast(Extract, StoreTy->getScalarType());
 
-        Value *Insert = Builder.CreateInsertElement(Vec, Extract,
-                                                    Builder.getInt32(NewIdx));
+        Value *Insert =
+            Builder.CreateInsertElement(Vec, Extract, Builder.getInt32(NewIdx));
         Vec = Insert;
       }
     }
   } else {
     for (unsigned I = 0, E = Chain.size(); I != E; ++I) {
       StoreInst *Store = cast<StoreInst>(Chain[I]);
       Value *Extract = Store->getValueOperand();
       if (Extract->getType() != StoreTy->getScalarType())
-        Extract = Builder.CreateBitOrPointerCast(Extract, StoreTy->getScalarType());
+        Extract =
+            Builder.CreateBitOrPointerCast(Extract, StoreTy->getScalarType());
 
-      Value *Insert = Builder.CreateInsertElement(Vec, Extract,
-                                                  Builder.getInt32(I));
+      Value *Insert =
+          Builder.CreateInsertElement(Vec, Extract, Builder.getInt32(I));
       Vec = Insert;
     }
   }
 
   Value *Bitcast =
       Builder.CreateBitCast(S0->getPointerOperand(), VecTy->getPointerTo(AS));
   StoreInst *SI = cast<StoreInst>(Builder.CreateStore(Vec, Bitcast));
   propagateMetadata(SI, Chain);
   SI->setAlignment(Alignment);
 
   eraseInstructions(Chain);
   ++NumVectorInstructions;
   NumScalarsVectorized += Chain.size();
   return true;
for (const auto &V : Chain) {
     if (LoadTy->isIntOrIntVectorTy())
       break;
 
     if (LoadTy->isPtrOrPtrVectorTy()) {
       LoadTy = Type::getIntNTy(F.getParent()->getContext(),
                                DL.getTypeSizeInBits(LoadTy));
       break;
     }
-
   }
 
   unsigned Sz = DL.getTypeSizeInBits(LoadTy);
   unsigned AS = L0->getPointerAddressSpace();
   unsigned VecRegSize = TTI.getLoadStoreVecRegBitWidth(AS);
   unsigned VF = VecRegSize / Sz;
   unsigned ChainSize = Chain.size();
 
   if (!isPowerOf2_32(Sz) || VF < 2 || ChainSize < 2)
     return false;
 
   // Load size should be 1B, 2B or multiple of 4B.
   // TODO: Should size constraint be a target hook?
   unsigned SzInBytes = (Sz / 8) * ChainSize;
   if (SzInBytes > 2 && SzInBytes % 4 != 0) {
-    DEBUG(dbgs() << "LSV: Size should be 1B, 2B or multiple of 4B. Splitting.\n");
+    DEBUG(dbgs() << "LSV: Size should be 1B, 2B "
+                    "or multiple of 4B. Splitting.\n");
     if (SzInBytes == 3)
       return vectorizeLoadChain(Chain.slice(0, ChainSize - 1));
     auto Chains = splitOddVectorElts(Chain, Sz);
     return vectorizeLoadChain(Chains.first) | vectorizeLoadChain(Chains.second);
   }
 
   VectorType *VecTy;
   VectorType *VecLoadTy = dyn_cast<VectorType>(LoadTy);
if (L0->getPointerAddressSpace() == 0) {
       } else {
         return false;
       }
     } else {
       return false;
     }
   }
 
-  DEBUG(
+  DEBUG({
     dbgs() << "LSV: Loads to vectorize:\n";
     for (Value *V : Chain)
       V->dump();
-  );
+  });
 
   BasicBlock::iterator First, Last;
   std::tie(First, Last) = getBoundaryInstrs(Chain);
 
   if (!isVectorizable(Chain, First, Last))
     return false;
 
   // Set insert point.
   Builder.SetInsertPoint(&*Last);
 
   Value *Bitcast =
       Builder.CreateBitCast(L0->getPointerOperand(), VecTy->getPointerTo(AS));
 
   LoadInst *LI = cast<LoadInst>(Builder.CreateLoad(Bitcast));
   propagateMetadata(LI, Chain);
   LI->setAlignment(Alignment);
 
   if (VecLoadTy) {
     SmallVector<Instruction *, 16> InstrsToErase;
     SmallVector<Instruction *, 16> InstrsToReorder;
 
     unsigned VecWidth = VecLoadTy->getNumElements();
     for (unsigned I = 0, E = Chain.size(); I != E; ++I) {
       for (auto Use : Chain[I]->users()) {
         Instruction *UI = cast<Instruction>(Use);
         unsigned Idx = cast<ConstantInt>(UI->getOperand(1))->getZExtValue();
         unsigned NewIdx = Idx + I * VecWidth;
         Value *V = Builder.CreateExtractElement(LI, Builder.getInt32(NewIdx));
         Instruction *Extracted = cast<Instruction>(V);
         if (Extracted->getType() != UI->getType())
-          Extracted =
-            cast<Instruction>(Builder.CreateBitCast(Extracted, UI->getType()));
+          Extracted = cast<Instruction>(
+              Builder.CreateBitCast(Extracted, UI->getType()));
 
         // Replace the old instruction.
         UI->replaceAllUsesWith(Extracted);
         InstrsToReorder.push_back(Extracted);
         InstrsToErase.push_back(UI);
       }
     }
 
     for (Instruction *ModUser : InstrsToReorder)
       reorder(ModUser);
 
     for (auto I : InstrsToErase)
       I->eraseFromParent();
   } else {
     SmallVector<Instruction *, 16> InstrsToReorder;
 
     for (unsigned I = 0, E = Chain.size(); I != E; ++I) {
       Value *V = Builder.CreateExtractElement(LI, Builder.getInt32(I));
       Instruction *Extracted = cast<Instruction>(V);
       Instruction *UI = cast<Instruction>(Chain[I]);
       if (Extracted->getType() != UI->getType()) {
-        Extracted =
-          cast<Instruction>(Builder.CreateBitOrPointerCast(Extracted, UI->getType()));
+        Extracted = cast<Instruction>(
+            Builder.CreateBitOrPointerCast(Extracted, UI->getType()));
       }
 
       // Replace the old instruction.
       UI->replaceAllUsesWith(Extracted);
       InstrsToReorder.push_back(Extracted);
     }
 
     for (Instruction *ModUser : InstrsToReorder)