[NFC][OpaquePtr] Avoid calling getPointerElementType()

[aeubanks]

Summary

Pointee types are going away soon.

For this, we mostly just care about store/load types, which are already
available without the pointee types. The other intrinsics always use
i8*.

[aeubanks]

one more missed location

[aeubanks]

ping

[dblaikie]

Looks right to me

llvm/lib/Target/PowerPC/PPCLoopInstrFormPrep.cpp

private:
     /// Check if required PHI node is already exist in Loop \p L.
     bool alreadyPrepared(Loop *L, Instruction* MemI,
                          const SCEV *BasePtrStartSCEV,
                          const SCEVConstant *BasePtrIncSCEV,
                          InstrForm Form);
 
     /// Collect condition matched(\p isValidCandidate() returns true)
     /// candidates in Loop \p L.
-    SmallVector<Bucket, 16>
-    collectCandidates(Loop *L,
-                      std::function<bool(const Instruction *, const Value *)>
-                          isValidCandidate,
-                      unsigned MaxCandidateNum);
+    SmallVector<Bucket, 16> collectCandidates(
+        Loop *L,
+        std::function<bool(const Instruction *, const Value *, const Type *)>
 
     /// Add a candidate to candidates \p Buckets.
     void addOneCandidate(Instruction *MemI, const SCEV *LSCEV,
                          SmallVector<Bucket, 16> &Buckets,
                          unsigned MaxCandidateNum);
 
     /// Prepare all candidates in \p Buckets for update form.
     bool updateFormPrep(Loop *L, SmallVector<Bucket, 16> &Buckets);
if (!FoundBucket) {
     if (Buckets.size() == MaxCandidateNum)
       return;
     Buckets.push_back(Bucket(LSCEV, MemI));
   }
 }
 
 SmallVector<Bucket, 16> PPCLoopInstrFormPrep::collectCandidates(
     Loop *L,
-    std::function<bool(const Instruction *, const Value *)> isValidCandidate,
+    std::function<bool(const Instruction *, const Value *, const Type *)>
+        isValidCandidate,
     unsigned MaxCandidateNum) {
   SmallVector<Bucket, 16> Buckets;
   for (const auto &BB : L->blocks())
     for (auto &J : *BB) {
       Value *PtrValue;
+      Type *PointerElementType;
 
       if (LoadInst *LMemI = dyn_cast<LoadInst>(&J)) {
         PtrValue = LMemI->getPointerOperand();
+        PointerElementType = LMemI->getType();
       } else if (StoreInst *SMemI = dyn_cast<StoreInst>(&J)) {
         PtrValue = SMemI->getPointerOperand();
+        PointerElementType = SMemI->getValueOperand()->getType();
       } else if (IntrinsicInst *IMemI = dyn_cast<IntrinsicInst>(&J)) {
+        PointerElementType = Type::getInt8Ty(J.getContext());
         if (IMemI->getIntrinsicID() == Intrinsic::prefetch ||
             IMemI->getIntrinsicID() == Intrinsic::ppc_vsx_lxvp) {
           PtrValue = IMemI->getArgOperand(0);
         } else if (IMemI->getIntrinsicID() == Intrinsic::ppc_vsx_stxvp) {
           PtrValue = IMemI->getArgOperand(1);
         } else continue;
       } else continue;
 
       unsigned PtrAddrSpace = PtrValue->getType()->getPointerAddressSpace();
       if (PtrAddrSpace)
         continue;
 
       if (L->isLoopInvariant(PtrValue))
         continue;
 
       const SCEV *LSCEV = SE->getSCEVAtScope(PtrValue, L);
       const SCEVAddRecExpr *LARSCEV = dyn_cast<SCEVAddRecExpr>(LSCEV);
       if (!LARSCEV || LARSCEV->getLoop() != L)
         continue;
 
-      if (isValidCandidate(&J, PtrValue))
+      if (isValidCandidate(&J, PtrValue, PointerElementType))
         addOneCandidate(&J, LSCEV, Buckets, MaxCandidateNum);
     }
   return Buckets;
 }
 
 bool PPCLoopInstrFormPrep::prepareBaseForDispFormChain(Bucket &BucketChain,
                                                     InstrForm Form) {
   // RemainderOffsetInfo details:
if (LoopPredecessor)
       MadeChange = true;
   }
   if (!LoopPredecessor) {
     LLVM_DEBUG(dbgs() << "PIP fails since no predecessor for current loop.\n");
     return MadeChange;
   }
   // Check if a load/store has update form. This lambda is used by function
   // collectCandidates which can collect candidates for types defined by lambda.
-  auto isUpdateFormCandidate = [&] (const Instruction *I,
-                                    const Value *PtrValue) {
+  auto isUpdateFormCandidate = [&](const Instruction *I, const Value *PtrValue,
+                                   const Type *PointerElementType) {
     assert((PtrValue && I) && "Invalid parameter!");
     // There are no update forms for Altivec vector load/stores.
-    if (ST && ST->hasAltivec() &&
-        PtrValue->getType()->getPointerElementType()->isVectorTy())
+    if (ST && ST->hasAltivec() && PointerElementType->isVectorTy())
       return false;
     // There are no update forms for P10 lxvp/stxvp intrinsic.
     auto *II = dyn_cast<IntrinsicInst>(I);
     if (II && ((II->getIntrinsicID() == Intrinsic::ppc_vsx_lxvp) ||
                II->getIntrinsicID() == Intrinsic::ppc_vsx_stxvp))
       return false;
     // See getPreIndexedAddressParts, the displacement for LDU/STDU has to
     // be 4's multiple (DS-form). For i64 loads/stores when the displacement
     // fits in a 16-bit signed field but isn't a multiple of 4, it will be
     // useless and possible to break some original well-form addressing mode
     // to make this pre-inc prep for it.
-    if (PtrValue->getType()->getPointerElementType()->isIntegerTy(64)) {
+    if (PointerElementType->isIntegerTy(64)) {
       const SCEV *LSCEV = SE->getSCEVAtScope(const_cast<Value *>(PtrValue), L);
       const SCEVAddRecExpr *LARSCEV = dyn_cast<SCEVAddRecExpr>(LSCEV);
       if (!LARSCEV || LARSCEV->getLoop() != L)
         return false;
       if (const SCEVConstant *StepConst =
               dyn_cast<SCEVConstant>(LARSCEV->getStepRecurrence(*SE))) {
         const APInt &ConstInt = StepConst->getValue()->getValue();
         if (ConstInt.isSignedIntN(16) && ConstInt.srem(4) != 0)
           return false;
       }
     }
     return true;
   };
-  
   // Check if a load/store has DS form.
-  auto isDSFormCandidate = [] (const Instruction *I, const Value *PtrValue) {
+  auto isDSFormCandidate = [](const Instruction *I, const Value *PtrValue,
+                              const Type *PointerElementType) {
     assert((PtrValue && I) && "Invalid parameter!");
     if (isa<IntrinsicInst>(I))
       return false;
-    Type *PointerElementType = PtrValue->getType()->getPointerElementType();
     return (PointerElementType->isIntegerTy(64)) ||
            (PointerElementType->isFloatTy()) ||
            (PointerElementType->isDoubleTy()) ||
            (PointerElementType->isIntegerTy(32) &&
             llvm::any_of(I->users(),
                          [](const User *U) { return isa<SExtInst>(U); }));
   };
 
   // Check if a load/store has DQ form.
-  auto isDQFormCandidate = [&] (const Instruction *I, const Value *PtrValue) {
+  auto isDQFormCandidate = [&](const Instruction *I, const Value *PtrValue,
+                               const Type *PointerElementType) {
     assert((PtrValue && I) && "Invalid parameter!");
     // Check if it is a P10 lxvp/stxvp intrinsic.
     auto *II = dyn_cast<IntrinsicInst>(I);
     if (II)
       return II->getIntrinsicID() == Intrinsic::ppc_vsx_lxvp ||
              II->getIntrinsicID() == Intrinsic::ppc_vsx_stxvp;
     // Check if it is a P9 vector load/store.
-    return ST && ST->hasP9Vector() &&
-           (PtrValue->getType()->getPointerElementType()->isVectorTy());
+    return ST && ST->hasP9Vector() && (PointerElementType->isVectorTy());
   };
 
   // intrinsic for update form.
   SmallVector<Bucket, 16> UpdateFormBuckets =
       collectCandidates(L, isUpdateFormCandidate, MaxVarsUpdateForm);
 
   // Prepare for update form.
   if (!UpdateFormBuckets.empty())