AMDGPU: Don't use InstVisitor for AMDGPUPromoteAlloca

[arsenm]

Summary

Frontend authors are strongly encouraged to keep allocas
in the entry block, so don't bother visiting every instruction
in the other blocks of the function.

[• tstellarAMD]

LGTM.

[arsenm]

r263206

lib/Target/AMDGPU/AMDGPUPromoteAlloca.cpp

 // by migrating them to local address space.
 //
 //===----------------------------------------------------------------------===//
 
 #include "AMDGPU.h"
 #include "AMDGPUSubtarget.h"
 #include "llvm/Analysis/ValueTracking.h"
 #include "llvm/IR/IRBuilder.h"
-#include "llvm/IR/InstVisitor.h"
+#include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/MDBuilder.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 
 #define DEBUG_TYPE "amdgpu-promote-alloca"
 
 using namespace llvm;
 
 namespace {
 
 // FIXME: This can create globals so should be a module pass.
-class AMDGPUPromoteAlloca : public FunctionPass,
-                            public InstVisitor<AMDGPUPromoteAlloca> {
+class AMDGPUPromoteAlloca : public FunctionPass {
 private:
   const TargetMachine *TM;
   Module *Mod;
   MDNode *MaxWorkGroupSizeRange;
 
   // FIXME: This should be per-kernel.
   int LocalMemAvailable;
 
public:
 
   bool doInitialization(Module &M) override;
   bool runOnFunction(Function &F) override;
 
   const char *getPassName() const override {
     return "AMDGPU Promote Alloca";
   }
 
-  void visitAlloca(AllocaInst &I);
+  void handleAlloca(AllocaInst &I);
 };
 
 } // End anonymous namespace
 
 char AMDGPUPromoteAlloca::ID = 0;
 
 INITIALIZE_TM_PASS(AMDGPUPromoteAlloca, DEBUG_TYPE,
                    "AMDGPU promote alloca to vector or LDS", false, false)
for (Use &U : GV.uses()) {
         LocalMemAvailable -=
           Mod->getDataLayout().getTypeAllocSize(GV.getValueType());
     }
   }
 
   LocalMemAvailable = std::max(0, LocalMemAvailable);
   DEBUG(dbgs() << LocalMemAvailable << " bytes free in local memory.\n");
 
-  visit(F);
+  BasicBlock &EntryBB = *F.begin();
+  for (auto I = EntryBB.begin(), E = EntryBB.end(); I != E; ) {
+    AllocaInst *AI = dyn_cast<AllocaInst>(I);
+
+    ++I;
+    if (AI)
+      handleAlloca(*AI);
+  }
 
   return true;
 }
 
 std::pair<Value *, Value *>
 AMDGPUPromoteAlloca::getLocalSizeYZ(IRBuilder<> &Builder) {
   if (!IsAMDHSA) {
     Function *LocalSizeYFn
for (User *User : Val->users()) {
     WorkList.push_back(User);
     if (!collectUsesWithPtrTypes(User, WorkList))
       return false;
   }
 
   return true;
 }
 
-void AMDGPUPromoteAlloca::visitAlloca(AllocaInst &I) {
+void AMDGPUPromoteAlloca::handleAlloca(AllocaInst &I) {
   if (!I.isStaticAlloca())
     return;
 
   IRBuilder<> Builder(&I);
 
   // First try to replace the alloca with a vector
   Type *AllocaTy = I.getAllocatedType();