[IR] Ignore globals with the `llvm.` prefix when calculating module hash

[paulkirth]

Summary

This came up in This came up in
https://reviews.llvm.org/D146776#inline-1489091 and is slightly related
to https://reviews.llvm.org/D153855. In both patches, there is the
observation that some modifications of the module should not invalidate
analysis, such as when adding a declaration or some metadata the won't
be used when compiling the current module.

This patch implements the suggestion that we should ignore globals that have
the llvm. prefix when calculating the module hash.

Fixes https://github.com/llvm/llvm-project/issues/63590

[aeubanks]

llvm/unittests/IR/PassManagerTest.cpp

1090

I've been meaning to write some unittests that specifically just check (in)equality of llvm::StructuralHash of two modules so we can avoid doing that. Going through a pass manager shouldn't be necessary. I can do that, or if you have time you can start that :)

[paulkirth]

llvm/unittests/IR/PassManagerTest.cpp

1090

I'm going on vacation starting tomorrow,so I'm not sure I'll have time to get to it until after that.

But, just in case I do scrounge the time, are there other important cases you know of of the top of your head?

[aeubanks]

llvm/unittests/IR/PassManagerTest.cpp

1090

it's basically just all the cases in StructuralHashImpl, there aren't that many right now. it would be good to get some tests out so it's easy to test future changes

[paulkirth]

Rebase. I will update the test code after D154308 lands.

[paulkirth]

As discussed I will rebase this on top of D154308, and update the tests accordingly.

[paulkirth]

Rebase and update test.

[aeubanks]

lgtm

llvm/lib/IR/StructuralHash.cpp

while (!BBs.empty()) {
           continue;
         BBs.push_back(Term->getSuccessor(i));
       }
     }
   }
 
   void update(const GlobalVariable &GV) {
     // Declarations and used/compiler.used don't affect analyses.
-    // Same for llvm.embedded.object, which is always a metadata section.
-    if (GV.isDeclaration() ||
-        GV.getName() == "llvm.compiler.used" || GV.getName() == "llvm.used" ||
-        GV.getName() == "llvm.embedded.object")
+    // Since there are several `llvm.*` metadata, like `llvm.embedded.object`,
+    // we ignore anything with the `.llvm` prefix
+    if (GV.isDeclaration() || GV.getName().starts_with("llvm."))
       return;
     hash(23456); // Global header
     hash(GV.getValueType()->getTypeID());
   }
 
   void update(const Module &M) {
     for (const GlobalVariable &GV : M.globals())
       update(GV);

llvm/unittests/IR/PassManagerTest.cpp

 //===- llvm/unittest/IR/PassManager.cpp - PassManager tests ---------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/IR/PassManager.h"
 #include "llvm/Analysis/AssumptionCache.h"
 #include "llvm/Analysis/TargetTransformInfo.h"
 #include "llvm/AsmParser/Parser.h"
+#include "llvm/IR/Constants.h"
 #include "llvm/IR/Dominators.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/PassManagerImpl.h"
 #include "llvm/Passes/StandardInstrumentations.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Transforms/Scalar/SimplifyCFG.h"
+#include "llvm/Transforms/Utils/ModuleUtils.h"
 #include "gtest/gtest.h"
 
 using namespace llvm;
 
 namespace {
 
 class TestFunctionAnalysis : public AnalysisInfoMixin<TestFunctionAnalysis> {
 public:
TEST_F(PassManagerTest, ModulePassMissedModuleAnalysisInvalidation) {
   ModulePassManager MPM;
   MPM.addPass(WrongModulePass2());
 
   EXPECT_DEATH(
       MPM.run(*M, MAM),
       "Module changed by WrongModulePass2 without invalidating analyses");
 }
 
+struct InsertMetadataPass : PassInfoMixin<InsertMetadataPass> {
+  PreservedAnalyses run(Module &M, ModuleAnalysisManager &MAM) {
+    StringRef Data = "foo";
+    MemoryBufferRef Buf(Data, "ModuleData");
+    Constant *ModuleConstant = ConstantDataArray::get(
+        M.getContext(), ArrayRef(Buf.getBufferStart(), Buf.getBufferSize()));
+    GlobalVariable *GV = new GlobalVariable(
+        M, ModuleConstant->getType(), true, GlobalValue::PrivateLinkage,
+        ModuleConstant, "llvm.foo");
+  appendToCompilerUsed(M, GV);
+    return PreservedAnalyses::all();
+  }
+  static StringRef name() { return "InsertMetadataPass"; }
+};
+
+TEST_F(PassManagerTest, ModulePassNoAnalysisInvalidation) {
+  LLVMContext Context;
+  auto M = parseIR(Context, "define void @foo() {\n"
+                            "  %a = add i32 0, 0\n"
+                            "  ret void\n"
+                            "}\n");
+
+  FunctionAnalysisManager FAM;
+  ModuleAnalysisManager MAM;
+  PassInstrumentationCallbacks PIC;
+  StandardInstrumentations SI(M->getContext(), /*DebugLogging*/ false);
+  SI.registerCallbacks(PIC, &MAM);
+  MAM.registerPass([&] { return FunctionAnalysisManagerModuleProxy(FAM); });
+  MAM.registerPass([&] { return PassInstrumentationAnalysis(&PIC); });
+  FAM.registerPass([&] { return PassInstrumentationAnalysis(&PIC); });
+  FAM.registerPass([&] { return ModuleAnalysisManagerFunctionProxy(MAM); });
+
+  ModulePassManager MPM;
+  MPM.addPass(InsertMetadataPass());
+  EXPECT_TRUE(MPM.run(*M, MAM).areAllPreserved());
+
+}
+
+
 #endif
 }