Address comments from ilovepi

Author: kyulee-com

llvm/include/llvm/Analysis/StructuralHash.h

@@ -13,15 +13,18 @@
 
 namespace llvm {
 
+enum class StructuralHashOptions { None, Detailed, CallTargetIgnored };
+
 /// Printer pass for  StructuralHashes
 class StructuralHashPrinterPass
     : public PassInfoMixin<StructuralHashPrinterPass> {
   raw_ostream &OS;
-  bool EnableDetailedStructuralHash;
+  const StructuralHashOptions Options;
 
 public:
-  explicit StructuralHashPrinterPass(raw_ostream &OS, bool Detailed)
-      : OS(OS), EnableDetailedStructuralHash(Detailed) {}
+  explicit StructuralHashPrinterPass(raw_ostream &OS,
+                                     StructuralHashOptions Options)
+      : OS(OS), Options(Options) {}
 
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &MAM);
 

llvm/lib/Analysis/StructuralHash.cpp

@@ -21,14 +21,33 @@ using namespace llvm;
 PreservedAnalyses StructuralHashPrinterPass::run(Module &M,
                                                  ModuleAnalysisManager &MAM) {
   OS << "Module Hash: "
-     << format("%016" PRIx64, StructuralHash(M, EnableDetailedStructuralHash))
+     << format("%016" PRIx64,
+               StructuralHash(M, Options != StructuralHashOptions::None))
      << "\n";
   for (Function &F : M) {
     if (F.isDeclaration())
       continue;
-    OS << "Function " << F.getName() << " Hash: "
-       << format("%016" PRIx64, StructuralHash(F, EnableDetailedStructuralHash))
-       << "\n";
+    if (Options == StructuralHashOptions::CallTargetIgnored) {
+      auto IgnoreOp = [&](const Instruction *I, unsigned OpndIdx) {
+        return I->getOpcode() == Instruction::Call &&
+               isa<Constant>(I->getOperand(OpndIdx));
+      };
+      auto FuncHashInfo = StructuralHashWithDifferences(F, IgnoreOp);
+      OS << "Function " << F.getName()
+         << " Hash: " << format("%016" PRIx64, FuncHashInfo.FunctionHash)
+         << "\n";
+      for (auto &[IndexPair, OpndHash] : *FuncHashInfo.IndexOperandHashMap) {
+        auto [InstIndex, OpndIndex] = IndexPair;
+        OS << "\tIgnored Operand Hash: " << format("%016" PRIx64, OpndHash)
+           << " at (" << InstIndex << "," << OpndIndex << ")\n";
+      }
+    } else {
+      OS << "Function " << F.getName() << " Hash: "
+         << format(
+                "%016" PRIx64,
+                StructuralHash(F, Options == StructuralHashOptions::Detailed))
+         << "\n";
+    }
   }
   return PreservedAnalyses::all();
 }

llvm/lib/IR/StructuralHash.cpp

@@ -113,11 +113,6 @@ class StructuralHashImpl {
     }
 
     switch (C->getValueID()) {
-    case Value::UndefValueVal:
-    case Value::PoisonValueVal:
-    case Value::ConstantTokenNoneVal: {
-      return stable_hash_combine(Hashes);
-    }
     case Value::ConstantIntVal: {
       const APInt &Int = cast<ConstantInt>(C)->getValue();
       Hashes.emplace_back(hashAPInt(Int));
@@ -128,33 +123,11 @@ class StructuralHashImpl {
       Hashes.emplace_back(hashAPFloat(APF));
       return stable_hash_combine(Hashes);
     }
-    case Value::ConstantArrayVal: {
-      const ConstantArray *A = cast<ConstantArray>(C);
-      for (auto &Op : A->operands()) {
-        auto H = hashConstant(cast<Constant>(Op));
-        Hashes.emplace_back(H);
-      }
-      return stable_hash_combine(Hashes);
-    }
-    case Value::ConstantStructVal: {
-      const ConstantStruct *S = cast<ConstantStruct>(C);
-      for (auto &Op : S->operands()) {
-        auto H = hashConstant(cast<Constant>(Op));
-        Hashes.emplace_back(H);
-      }
-      return stable_hash_combine(Hashes);
-    }
-    case Value::ConstantVectorVal: {
-      const ConstantVector *V = cast<ConstantVector>(C);
-      for (auto &Op : V->operands()) {
-        auto H = hashConstant(cast<Constant>(Op));
-        Hashes.emplace_back(H);
-      }
-      return stable_hash_combine(Hashes);
-    }
+    case Value::ConstantArrayVal:
+    case Value::ConstantStructVal:
+    case Value::ConstantVectorVal:
     case Value::ConstantExprVal: {
-      const ConstantExpr *E = cast<ConstantExpr>(C);
-      for (auto &Op : E->operands()) {
+      for (const auto &Op : C->operands()) {
         auto H = hashConstant(cast<Constant>(Op));
         Hashes.emplace_back(H);
       }
@@ -313,9 +286,11 @@ class StructuralHashImpl {
   }
 
   uint64_t getHash() const { return Hash; }
+
   std::unique_ptr<IndexInstrMap> getIndexInstrMap() {
     return std::move(IndexInstruction);
   }
+
   std::unique_ptr<IndexOperandHashMapType> getIndexPairOpndHashMap() {
     return std::move(IndexOperandHashMap);
   }

llvm/lib/Passes/PassBuilder.cpp

@@ -1168,9 +1168,19 @@ Expected<std::string> parseMemProfUsePassOptions(StringRef Params) {
   return Result;
 }
 
-Expected<bool> parseStructuralHashPrinterPassOptions(StringRef Params) {
-  return PassBuilder::parseSinglePassOption(Params, "detailed",
-                                            "StructuralHashPrinterPass");
+Expected<StructuralHashOptions>
+parseStructuralHashPrinterPassOptions(StringRef Params) {
+  if (Params.empty())
+    return StructuralHashOptions::None;
+  else if (Params == "detailed")
+    return StructuralHashOptions::Detailed;
+  else if (Params == "call-target-ignored")
+    return StructuralHashOptions::CallTargetIgnored;
+  else
+    return make_error<StringError>(
+        formatv("invalid structural hash printer parameter '{0}' ", Params)
+            .str(),
+        inconvertibleErrorCode());
 }
 
 Expected<bool> parseWinEHPrepareOptions(StringRef Params) {

llvm/lib/Passes/PassRegistry.def

@@ -220,10 +220,11 @@ MODULE_PASS_WITH_PARAMS(
     parseMSanPassOptions, "recover;kernel;eager-checks;track-origins=N")
 MODULE_PASS_WITH_PARAMS(
     "print<structural-hash>", "StructuralHashPrinterPass",
-    [](bool EnableDetailedStructuralHash) {
-      return StructuralHashPrinterPass(dbgs(), EnableDetailedStructuralHash);
+    [](StructuralHashOptions Options) {
+      return StructuralHashPrinterPass(dbgs(), Options);
     },
-    parseStructuralHashPrinterPassOptions, "detailed")
+    parseStructuralHashPrinterPassOptions, "detailed;call-target-ignored")
+
 #undef MODULE_PASS_WITH_PARAMS
 
 #ifndef CGSCC_ANALYSIS

llvm/test/Analysis/StructuralHash/structural-hash-printer.ll

@@ -1,17 +1,21 @@
 ; RUN: opt -passes='print<structural-hash>' -disable-output %s 2>&1 | FileCheck %s
 ; RUN: opt -passes='print<structural-hash><detailed>' -disable-output %s 2>&1 | FileCheck %s -check-prefix=DETAILED-HASH
+; RUN: opt -passes='print<structural-hash><call-target-ignored>' -disable-output %s 2>&1 | FileCheck %s -check-prefix=CALLTARGETIGNORED-HASH
 
 ; Add a declaration so that we can test we skip it.
-declare i64 @d1()
+declare i64 @d1(i64)
+declare i64 @e1(i64)
 
 define i64 @f1(i64 %a) {
 	%b = add i64 %a, 1
-	ret i64 %b
+	%c = call i64 @d1(i64 %b)
+	ret i64 %c
 }
 
-define i32 @f2(i32 %a) {
-	%b = add i32 %a, 2
-	ret i32 %b
+define i64 @f2(i64 %a) {
+	%b = add i64 %a, 1
+	%c = call i64 @e1(i64 %b)
+	ret i64 %c
 }
 
 ; CHECK: Module Hash: {{([a-f0-9]{16,})}}
@@ -22,3 +26,13 @@ define i32 @f2(i32 %a) {
 ; DETAILED-HASH-NEXT: Function f1 Hash: [[DF1H:([a-f0-9]{16,})]]
 ; DETAILED-HASH-NOT: [[DF1H]]
 ; DETAILED-HASH-NEXT: Function f2 Hash: {{([a-f0-9]{16,})}}
+
+; When ignoring the call target, check if `f1` and `f2` produce the same function hash.
+; The index for the call instruction is 1, and the index of the call target operand is 1.
+; The ignored operand hashes for different call targets should be different.
+; CALLTARGETIGNORED-HASH: Module Hash: {{([a-f0-9]{16,})}}
+; CALLTARGETIGNORED-HASH-NEXT: Function f1 Hash: [[IF1H:([a-f0-9]{16,})]]
+; CALLTARGETIGNORED-HASH-NEXT:   Ignored Operand Hash: [[IO1H:([a-f0-9]{16,})]] at (1,1)
+; CALLTARGETIGNORED-HASH-NEXT: Function f2 Hash: [[IF1H]]
+; CALLTARGETIGNORED-HASH-NOT: [[IO1H]]
+; CALLTARGETIGNORED-HASH-NEXT:   Ignored Operand Hash: {{([a-f0-9]{16,})}} at (1,1)