fix vectorization of library calls

[tim.schmielau]

Summary

Vectorization of library calls was unnecessarily fragile as
LoopAccessAnalysis would only consult the hardcoded list of
vectorizable functions for (call) instructions marked as potentially
reading from memory. However, few of the library functions in
llvm/include/llvm/Analysis/VecFuncs.def actually do that.

Thus commit ea75be3d9df448b6abafaf752a8141764d93ca33 and its
recommit 5f0a349738304caf5f8083166f785a91048f574d broke library
call vectorization by correctly declaring many library functions
as write only.

Apply the obvious fix of considering any call for vectorization,
not just those to functions that may read from memory.

Also change the libm-vector-calls tests so they would have
caught the issue.

[RKSimon]

llvm/lib/Analysis/LoopAccessAnalysis.cpp

2212

Drop the `Call &&` now that its inside the if()

[tim.schmielau]

• Remove duplicate checks

[tim.schmielau]

llvm/lib/Analysis/LoopAccessAnalysis.cpp

2212

Oops, thanks.

[tim.schmielau]

Re-uploading patch after follow-on patch got mixed in

[tim.schmielau]

Re-uploading once again. arc diff --preview creates a preview that looks correct, but just arc diff is somehow mixing in the other patch I currently have open on top of this one.

[RKSimon]

SGTM but I don't know this code particularly well - @fhahn any thoughts?

[tim.schmielau]

Superseded by D156478.

llvm/lib/Analysis/LoopAccessAnalysis.cpp

 //===- LoopAccessAnalysis.cpp - Loop Access Analysis Implementation --------==//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
void LoopAccessInfo::analyzeLoop(AAResults *AA, LoopInfo *LI,
   // Traverse blocks in fixed RPOT order, regardless of their storage in the
   // loop info, as it may be arbitrary.
   LoopBlocksRPO RPOT(TheLoop);
   RPOT.perform(LI);
   for (BasicBlock *BB : RPOT) {
     // Scan the BB and collect legal loads and stores. Also detect any
     // convergent instructions.
     for (Instruction &I : *BB) {
-      if (auto *Call = dyn_cast<CallBase>(&I)) {
-        if (Call->isConvergent())
+      if (auto *CB = dyn_cast<CallBase>(&I)) {
+        if (CB->isConvergent())
           HasConvergentOp = true;
       }
 
       // With both a non-vectorizable memory instruction and a convergent
       // operation, found in this loop, no reason to continue the search.
       if (HasComplexMemInst && HasConvergentOp) {
         CanVecMem = false;
         return;
       }
 
       // Avoid hitting recordAnalysis multiple times.
       if (HasComplexMemInst)
         continue;
 
-      // If this is a load, save it. If this instruction can read from memory
-      // but is not a load, then we quit. Notice that we don't handle function
-      // calls that read or write.
-      if (I.mayReadFromMemory()) {
+      if (auto *Call = dyn_cast<CallInst>(&I)) {
         // Many math library functions read the rounding mode. We will only
         // vectorize a loop if it contains known function calls that don't set
         // the flag. Therefore, it is safe to ignore this read from memory.
-        auto *Call = dyn_cast<CallInst>(&I);
-        if (Call && getVectorIntrinsicIDForCall(Call, TLI))
+        if (getVectorIntrinsicIDForCall(Call, TLI))
           continue;
 
         // If the function has an explicit vectorized counterpart, we can safely
         // assume that it can be vectorized.
-        if (Call && !Call->isNoBuiltin() && Call->getCalledFunction() &&
+        if (!Call->isNoBuiltin() && Call->getCalledFunction() &&
             !VFDatabase::getMappings(*Call).empty())
           continue;
+      }
 
+      // If this is a load, save it. If this instruction can read from memory
+      // but is not a load, then we quit. Notice that we don't handle function
+      // calls that read or write.
+      if (I.mayReadFromMemory()) {
         auto *Ld = dyn_cast<LoadInst>(&I);
         if (!Ld) {
           recordAnalysis("CantVectorizeInstruction", Ld)
             << "instruction cannot be vectorized";
           HasComplexMemInst = true;
           continue;
         }
         if (!Ld->isSimple() && !IsAnnotatedParallel) {

llvm/test/Transforms/LoopVectorize/X86/libm-vector-calls-VF2-VF8.ll

 for.end:                                          ; preds = %for.body
   ret void
 }
 
 !131 = distinct !{!131, !132, !133}
 !132 = !{!"llvm.loop.vectorize.width", i32 8}
 !133 = !{!"llvm.loop.vectorize.enable", i1 true}
 
-attributes #0 = { nounwind readnone }
+; functions are in fact "readnone" but clang only emits the weaker "writeonly" as other math functions may write errno.
+attributes #0 = { nounwind writeonly }
 
 declare double @sin(double) #0
 declare float @sinf(float) #0
 declare double @llvm.sin.f64(double) #0
 declare float @llvm.sin.f32(float) #0
 declare double @cos(double) #0
 declare float @cosf(float) #0
 declare double @llvm.cos.f64(double) #0
 declare float @llvm.cos.f32(float) #0
 declare float @expf(float) #0
 declare float @powf(float, float) #0
 declare float @llvm.exp.f32(float) #0
 declare float @logf(float) #0
 declare float @llvm.pow.f32(float, float) #0

llvm/test/Transforms/LoopVectorize/X86/libm-vector-calls.ll

 for.end:                                          ; preds = %for.body
   ret void
 }
 
 !131 = distinct !{!131, !132, !133}
 !132 = !{!"llvm.loop.vectorize.width", i32 4}
 !133 = !{!"llvm.loop.vectorize.enable", i1 true}
 
-attributes #0 = { nounwind readnone }
+; functions are in fact "readnone" but clang only emits the weaker "writeonly" as other math functions may write errno.
+attributes #0 = { nounwind writeonly }
 
 declare double @sin(double) #0
 declare float @sinf(float) #0
 declare double @llvm.sin.f64(double) #0
 declare float @llvm.sin.f32(float) #0
 declare double @cos(double) #0
 declare float @cosf(float) #0
 declare double @llvm.cos.f64(double) #0
 declare float @llvm.cos.f32(float) #0
 declare float @expf(float) #0
 declare float @powf(float, float) #0
 declare float @llvm.exp.f32(float) #0
 declare float @logf(float) #0
 declare float @llvm.pow.f32(float, float) #0