Preserve GlobalsAA analysis result in LowerConstantIntrinsics

[rsanthir.quic]

Summary

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

[fhahn]

LGTM. LowerConstantIntrinsics should not modify globals and can preserve GlobalsAA. This is also in line with what we currently do in many other passes and not preserving GlobalsAA can lead to serious performance regressions.

I can commit this patch for you in a day or so, to give other people a chance to chime in as well.

[rsanthir.quic]

@Florian since we've given it a couple days, would it be ok to make the commit now?

[Florian]

In D82342#2126288, @rsanthir.quic wrote:

@Florian since we've given it a couple days, would it be ok to make the commit now?

@fhahn I think this was directed towards you.

[fhahn]

In D82342#2126288, @rsanthir.quic wrote:

@Florian since we've given it a couple days, would it be ok to make the commit now?

Thanks for the reminder! Committed as e6cf796bab7e02d2b8ac7fd495f14f5e21494270

[rsanthir.quic]

My apologies @Florian! Thank you @fhahn!

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();
 }