AMDGPU: Don't try memory optimzations in libcall optimizer

[arsenm]

Summary

This was trying to find a loaded value for some reason when looking
for sincos arguments. This is untested and shouldn't be necessary.

[arsenm]

3b2f3238a4d7d8935188f1264df0887dead1e9ea

llvm/lib/Target/AMDGPU/AMDGPULibCalls.cpp

private:
   bool fold_sqrt(FPMathOperator *FPOp, IRBuilder<> &B, const FuncInfo &FInfo);
 
   std::tuple<Value *, Value *, Value *> insertSinCos(Value *Arg,
                                                      FastMathFlags FMF,
                                                      IRBuilder<> &B,
                                                      FunctionCallee Fsincos);
 
   // sin/cos
-  bool fold_sincos(FPMathOperator *FPOp, IRBuilder<> &B, const FuncInfo &FInfo,
-                   AliasAnalysis *AA);
+  bool fold_sincos(FPMathOperator *FPOp, IRBuilder<> &B, const FuncInfo &FInfo);
 
   // __read_pipe/__write_pipe
   bool fold_read_write_pipe(CallInst *CI, IRBuilder<> &B,
                             const FuncInfo &FInfo);
 
   // Get a scalar native builtin single argument FP function
   FunctionCallee getNativeFunction(Module *M, const FuncInfo &FInfo);
 
protected:
 
   static void replaceCall(FPMathOperator *I, Value *With) {
     replaceCall(cast<Instruction>(I), With);
   }
 
 public:
   AMDGPULibCalls() {}
 
-  bool fold(CallInst *CI, AliasAnalysis *AA = nullptr);
+  bool fold(CallInst *CI);
 
   void initFunction(const Function &F);
   void initNativeFuncs();
 
   // Replace a normal math function call with that native version
   bool useNative(CallInst *CI);
 };
 
 } // end llvm namespace
 
 namespace {
 
   class AMDGPUSimplifyLibCalls : public FunctionPass {
 
   AMDGPULibCalls Simplifier;
 
   public:
     static char ID; // Pass identification
 
     AMDGPUSimplifyLibCalls() : FunctionPass(ID) {
       initializeAMDGPUSimplifyLibCallsPass(*PassRegistry::getPassRegistry());
     }
 
-    void getAnalysisUsage(AnalysisUsage &AU) const override {
-      AU.addRequired<AAResultsWrapperPass>();
-    }
-
     bool runOnFunction(Function &M) override;
   };
 
   class AMDGPUUseNativeCalls : public FunctionPass {
 
   AMDGPULibCalls Simplifier;
 
   public:
     static char ID; // Pass identification
 
     AMDGPUUseNativeCalls() : FunctionPass(ID) {
       initializeAMDGPUUseNativeCallsPass(*PassRegistry::getPassRegistry());
       Simplifier.initNativeFuncs();
     }
 
+    void getAnalysisUsage(AnalysisUsage &AU) const override {
+      // TODO: Preserves most
+    }
+
     bool runOnFunction(Function &F) override;
   };
 
 } // end anonymous namespace.
 
 char AMDGPUSimplifyLibCalls::ID = 0;
 char AMDGPUUseNativeCalls::ID = 0;
 
 INITIALIZE_PASS_BEGIN(AMDGPUSimplifyLibCalls, "amdgpu-simplifylib",
                       "Simplify well-known AMD library calls", false, false)
-INITIALIZE_PASS_DEPENDENCY(AAResultsWrapperPass)
 INITIALIZE_PASS_END(AMDGPUSimplifyLibCalls, "amdgpu-simplifylib",
                     "Simplify well-known AMD library calls", false, false)
 
 INITIALIZE_PASS(AMDGPUUseNativeCalls, "amdgpu-usenative",
                 "Replace builtin math calls with that native versions.",
                 false, false)
 
 template <typename IRB>
bool AMDGPULibCalls::fold_read_write_pipe(CallInst *CI, IRBuilder<> &B,
   CI->replaceAllUsesWith(NCI);
   CI->dropAllReferences();
   CI->eraseFromParent();
 
   return true;
 }
 
 // This function returns false if no change; return true otherwise.
-bool AMDGPULibCalls::fold(CallInst *CI, AliasAnalysis *AA) {
+bool AMDGPULibCalls::fold(CallInst *CI) {
   Function *Callee = CI->getCalledFunction();
   // Ignore indirect calls.
   if (!Callee || Callee->isIntrinsic() || CI->isNoBuiltin())
     return false;
 
   FuncInfo FInfo;
   if (!parseFunctionName(Callee->getName(), FInfo))
     return false;
if (FPMathOperator *FPOp = dyn_cast<FPMathOperator>(CI)) {
     case AMDGPULibFunc::EI_POWN:
       return fold_pow(FPOp, B, FInfo);
     case AMDGPULibFunc::EI_ROOTN:
       return fold_rootn(FPOp, B, FInfo);
     case AMDGPULibFunc::EI_SQRT:
       return fold_sqrt(FPOp, B, FInfo);
     case AMDGPULibFunc::EI_COS:
     case AMDGPULibFunc::EI_SIN:
-      return fold_sincos(FPOp, B, FInfo, AA);
+      return fold_sincos(FPOp, B, FInfo);
     default:
       break;
     }
   } else {
     // Specialized optimizations for each function call
     switch (FInfo.getId()) {
     case AMDGPULibFunc::EI_READ_PIPE_2:
     case AMDGPULibFunc::EI_READ_PIPE_4:
AMDGPULibCalls::insertSinCos(Value *Arg, FastMathFlags FMF, IRBuilder<> &B,
 
   CallInst *SinCos = CreateCallEx2(B, Fsincos, Arg, CastAlloc);
   LoadInst *LoadCos = B.CreateLoad(Alloc->getAllocatedType(), Alloc);
   return {SinCos, LoadCos, SinCos};
 }
 
 // fold sin, cos -> sincos.
 bool AMDGPULibCalls::fold_sincos(FPMathOperator *FPOp, IRBuilder<> &B,
-                                 const FuncInfo &fInfo, AliasAnalysis *AA) {
+                                 const FuncInfo &fInfo) {
   assert(fInfo.getId() == AMDGPULibFunc::EI_SIN ||
          fInfo.getId() == AMDGPULibFunc::EI_COS);
 
   if ((getArgType(fInfo) != AMDGPULibFunc::F32 &&
        getArgType(fInfo) != AMDGPULibFunc::F64) ||
       fInfo.getPrefix() != AMDGPULibFunc::NOPFX)
     return false;
 
   bool const isSin = fInfo.getId() == AMDGPULibFunc::EI_SIN;
 
   Value *CArgVal = FPOp->getOperand(0);
   CallInst *CI = cast<CallInst>(FPOp);
-  BasicBlock * const CBB = CI->getParent();
-
-  int const MaxScan = 30;
   bool Changed = false;
 
-  { // fold in load value.
-    LoadInst *LI = dyn_cast<LoadInst>(CArgVal);
-    if (LI && LI->getParent() == CBB) {
-      BasicBlock::iterator BBI = LI->getIterator();
-      Value *AvailableVal = FindAvailableLoadedValue(LI, CBB, BBI, MaxScan, AA);
-      if (AvailableVal) {
-        Changed = true;
-        CArgVal->replaceAllUsesWith(AvailableVal);
-        if (CArgVal->getNumUses() == 0)
-          LI->eraseFromParent();
-        CArgVal = FPOp->getOperand(0);
-      }
-    }
-  }
-
   Function *F = B.GetInsertBlock()->getParent();
   Module *M = F->getParent();
 
   // Merge the sin and cos. For OpenCL 2.0, there may only be a generic pointer
   // implementation. Prefer the private form if available.
   AMDGPULibFunc SinCosLibFuncPrivate(AMDGPULibFunc::EI_SINCOS, fInfo);
   SinCosLibFuncPrivate.getLeads()[0].PtrKind =
       AMDGPULibFunc::getEPtrKindFromAddrSpace(AMDGPUAS::PRIVATE_ADDRESS);

 
 bool AMDGPUSimplifyLibCalls::runOnFunction(Function &F) {
   if (skipFunction(F))
     return false;
 
   Simplifier.initFunction(F);
 
   bool Changed = false;
-  auto AA = &getAnalysis<AAResultsWrapperPass>().getAAResults();
 
   LLVM_DEBUG(dbgs() << "AMDIC: process function ";
              F.printAsOperand(dbgs(), false, F.getParent()); dbgs() << '\n';);
 
   for (auto &BB : F) {
     for (BasicBlock::iterator I = BB.begin(), E = BB.end(); I != E; ) {
       // Ignore non-calls.
       CallInst *CI = dyn_cast<CallInst>(I);
       ++I;
       if (CI) {
-        if (Simplifier.fold(CI, AA))
+        if (Simplifier.fold(CI))
           Changed = true;
       }
     }
   }
   return Changed;
 }
 
 PreservedAnalyses AMDGPUSimplifyLibCallsPass::run(Function &F,
                                                   FunctionAnalysisManager &AM) {
   AMDGPULibCalls Simplifier;
   Simplifier.initNativeFuncs();
   Simplifier.initFunction(F);
 
   bool Changed = false;
-  auto AA = &AM.getResult<AAManager>(F);
 
   LLVM_DEBUG(dbgs() << "AMDIC: process function ";
              F.printAsOperand(dbgs(), false, F.getParent()); dbgs() << '\n';);
 
   for (auto &BB : F) {
     for (BasicBlock::iterator I = BB.begin(), E = BB.end(); I != E;) {
       // Ignore non-calls.
       CallInst *CI = dyn_cast<CallInst>(I);
       ++I;
 
       if (CI) {
-        if (Simplifier.fold(CI, AA))
+        if (Simplifier.fold(CI))
           Changed = true;
       }
     }
   }
   return Changed ? PreservedAnalyses::none() : PreservedAnalyses::all();
 }
 
 bool AMDGPUUseNativeCalls::runOnFunction(Function &F) {