Preserve GlobalsAA analysis result in LowerConstantIntrinsics and InjectTLIMappings

[rsanthir.quic]

Summary

Both LowerConstantIntrinsics and InjectTLIMappings fail to preserve the analysis result of GlobalsAA. Not preserving the analysis might affect benchmark performance. This change fixes this issue.

[rsanthir.quic]

Ran clang-format to update the patch

[fpetrogalli]

llvm/lib/Transforms/Utils/InjectTLIMappings.cpp

148

Hi @rsanthir.quic

Thank you for your patch.

Didn't you have to add this pass to the tests checking the pass sequence? Have you run make check-all on your changes?

Francesco

[fhahn]

LGTM. Neither InjectTLIMappings nor LowerConstantIntrinsics should modify globals and can preserve GlobalsAA. This is also in line with what we currently do in many other passes.

llvm/lib/Transforms/Scalar/LowerConstantIntrinsics.cpp

141

hmm, there's probably potential for preserving more here. But that's for potential follow-ups.

llvm/lib/Transforms/Utils/InjectTLIMappings.cpp

148

AFAIK if GlobalsAA is only used if it is available. So if it is not preserved, it won't be re-built, so this change won't impact any of the pipeline tests.

[fhahn]

It might be good to commit both patches separately.

[rsanthir.quic]

I can definitely split this into two different patches

llvm/lib/Transforms/Utils/InjectTLIMappings.cpp

148

Thanks for the explanation @fhahn, I did run make check-all as well, and I didnt notice any issues anyway @fpetrogalli

[fpetrogalli]

llvm/lib/Transforms/Utils/InjectTLIMappings.cpp

148

Thank you for confirming, LGTM.

Francesco

[rsanthir.quic]

I've split the changes up:
https://reviews.llvm.org/D82342
https://reviews.llvm.org/D82343

[rsanthir.quic]

Abandoning as I have split in the following:
https://reviews.llvm.org/D82342
https://reviews.llvm.org/D82343

llvm/lib/Transforms/Scalar/LowerConstantIntrinsics.cpp

 // and provides constant propagation and basic CFG cleanup on the result.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Transforms/Scalar/LowerConstantIntrinsics.h"
 #include "llvm/ADT/PostOrderIterator.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/Statistic.h"
+#include "llvm/Analysis/GlobalsModRef.h"
 #include "llvm/Analysis/InstructionSimplify.h"
 #include "llvm/Analysis/MemoryBuiltins.h"
 #include "llvm/Analysis/TargetLibraryInfo.h"
 #include "llvm/IR/BasicBlock.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/IntrinsicInst.h"
static bool lowerConstantIntrinsics(Function &F, const TargetLibraryInfo *TLI) {
   }
   if (HasDeadBlocks)
     removeUnreachableBlocks(F);
   return !Worklist.empty();
 }
 
 PreservedAnalyses
 LowerConstantIntrinsicsPass::run(Function &F, FunctionAnalysisManager &AM) {
-  if (lowerConstantIntrinsics(F, AM.getCachedResult<TargetLibraryAnalysis>(F)))
-    return PreservedAnalyses::none();
+  if (lowerConstantIntrinsics(F,
+                              AM.getCachedResult<TargetLibraryAnalysis>(F))) {
+    PreservedAnalyses PA;
+    PA.preserve<GlobalsAA>();
+    return PA;
+  }
 
   return PreservedAnalyses::all();
 }
 
 namespace {
 /// Legacy pass for lowering is.constant intrinsics out of the IR.
 ///
 /// When this pass is run over a function it converts is.constant intrinsics
 /// into 'true' or 'false'. This complements the normal constant folding
 /// to 'true' as part of Instruction Simplify passes.
 class LowerConstantIntrinsics : public FunctionPass {
 public:
   static char ID;
   LowerConstantIntrinsics() : FunctionPass(ID) {
     initializeLowerConstantIntrinsicsPass(*PassRegistry::getPassRegistry());
   }
 
   bool runOnFunction(Function &F) override {
     auto *TLIP = getAnalysisIfAvailable<TargetLibraryInfoWrapperPass>();
     const TargetLibraryInfo *TLI = TLIP ? &TLIP->getTLI(F) : nullptr;
     return lowerConstantIntrinsics(F, TLI);
   }
+
+  void getAnalysisUsage(AnalysisUsage &AU) const override {
+    AU.addPreserved<GlobalsAAWrapperPass>();
+  }
 };
 } // namespace
 
 char LowerConstantIntrinsics::ID = 0;
 INITIALIZE_PASS(LowerConstantIntrinsics, "lower-constant-intrinsics",
                 "Lower constant intrinsics", false, false)
 
 FunctionPass *llvm::createLowerConstantIntrinsicsPass() {
   return new LowerConstantIntrinsics();
 }

llvm/lib/Transforms/Utils/InjectTLIMappings.cpp

 //===- InjectTLIMAppings.cpp - TLI to VFABI attribute injection  ----------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // Populates the VFABI attribute with the scalar-to-vector mappings
 // from the TargetLibraryInfo.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Transforms/Utils/InjectTLIMappings.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/Analysis/DemandedBits.h"
+#include "llvm/Analysis/GlobalsModRef.h"
 #include "llvm/Analysis/OptimizationRemarkEmitter.h"
 #include "llvm/Analysis/VectorUtils.h"
 #include "llvm/IR/InstIterator.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/Transforms/Utils.h"
 #include "llvm/Transforms/Utils/ModuleUtils.h"
 
 using namespace llvm;
void InjectTLIMappingsLegacy::getAnalysisUsage(AnalysisUsage &AU) const {
   AU.setPreservesCFG();
   AU.addRequired<TargetLibraryInfoWrapperPass>();
   AU.addPreserved<TargetLibraryInfoWrapperPass>();
   AU.addPreserved<ScalarEvolutionWrapperPass>();
   AU.addPreserved<AAResultsWrapperPass>();
   AU.addPreserved<LoopAccessLegacyAnalysis>();
   AU.addPreserved<DemandedBitsWrapperPass>();
   AU.addPreserved<OptimizationRemarkEmitterWrapperPass>();
+  AU.addPreserved<GlobalsAAWrapperPass>();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Legacy Pass manager initialization
 ////////////////////////////////////////////////////////////////////////////////
 char InjectTLIMappingsLegacy::ID = 0;
 
 INITIALIZE_PASS_BEGIN(InjectTLIMappingsLegacy, DEBUG_TYPE,
                       "Inject TLI Mappings", false, false)
 INITIALIZE_PASS_DEPENDENCY(TargetLibraryInfoWrapperPass)
 INITIALIZE_PASS_END(InjectTLIMappingsLegacy, DEBUG_TYPE, "Inject TLI Mappings",
                     false, false)
 
 FunctionPass *llvm::createInjectTLIMappingsLegacyPass() {
   return new InjectTLIMappingsLegacy();
 }