Revert "[StructuralHash] Global Variable (#118412)"

This reverts commit 1afb81d.

Author: kyulee-com

llvm/include/llvm/IR/StructuralHash.h

@@ -31,9 +31,6 @@ class Module;
 /// to true includes instruction and operand type information.
 stable_hash StructuralHash(const Function &F, bool DetailedHash = false);
 
-/// Returns a hash of the global variable \p G.
-stable_hash StructuralHash(const GlobalVariable &G);
-
 /// Returns a hash of the module \p M by hashing all functions and global
 /// variables contained within. \param M The module to hash. \param DetailedHash
 /// Whether or not to encode additional information in the function hashes that

llvm/lib/CodeGen/MachineStableHash.cpp

@@ -27,8 +27,6 @@
 #include "llvm/CodeGen/Register.h"
 #include "llvm/Config/llvm-config.h"
 #include "llvm/IR/Constants.h"
-#include "llvm/IR/GlobalVariable.h"
-#include "llvm/IR/StructuralHash.h"
 #include "llvm/MC/MCSymbol.h"
 #include "llvm/Support/Alignment.h"
 #include "llvm/Support/ErrorHandling.h"
@@ -95,19 +93,13 @@ stable_hash llvm::stableHashValue(const MachineOperand &MO) {
     return 0;
   case MachineOperand::MO_GlobalAddress: {
     const GlobalValue *GV = MO.getGlobal();
-    stable_hash GVHash = 0;
-    if (auto *GVar = dyn_cast<GlobalVariable>(GV))
-      GVHash = StructuralHash(*GVar);
-    if (!GVHash) {
-      if (!GV->hasName()) {
-        ++StableHashBailingGlobalAddress;
-        return 0;
-      }
-      GVHash = stable_hash_name(GV->getName());
+    if (!GV->hasName()) {
+      ++StableHashBailingGlobalAddress;
+      return 0;
     }
-
-    return stable_hash_combine(MO.getType(), MO.getTargetFlags(), GVHash,
-                               MO.getOffset());
+    auto Name = GV->getName();
+    return stable_hash_combine(MO.getType(), MO.getTargetFlags(),
+                               stable_hash_name(Name), MO.getOffset());
   }
 
   case MachineOperand::MO_TargetIndex: {

llvm/lib/IR/StructuralHash.cpp

@@ -46,7 +46,7 @@ class StructuralHashImpl {
   /// Assign a unique ID to each Value in the order they are first seen.
   DenseMap<const Value *, int> ValueToId;
 
-  static stable_hash hashType(Type *ValueType) {
+  stable_hash hashType(Type *ValueType) {
     SmallVector<stable_hash> Hashes;
     Hashes.emplace_back(ValueType->getTypeID());
     if (ValueType->isIntegerTy())
@@ -65,47 +65,19 @@ class StructuralHashImpl {
     }
   }
 
-  static stable_hash hashAPInt(const APInt &I) {
+  stable_hash hashAPInt(const APInt &I) {
     SmallVector<stable_hash> Hashes;
     Hashes.emplace_back(I.getBitWidth());
     auto RawVals = ArrayRef<uint64_t>(I.getRawData(), I.getNumWords());
     Hashes.append(RawVals.begin(), RawVals.end());
     return stable_hash_combine(Hashes);
   }
 
-  static stable_hash hashAPFloat(const APFloat &F) {
+  stable_hash hashAPFloat(const APFloat &F) {
     return hashAPInt(F.bitcastToAPInt());
   }
 
-  static stable_hash hashGlobalVariable(const GlobalVariable &GVar) {
-    if (!GVar.hasInitializer())
-      return hashGlobalValue(&GVar);
-
-    // Hash the contents of a string.
-    if (GVar.getName().starts_with(".str")) {
-      auto *C = GVar.getInitializer();
-      if (const auto *Seq = dyn_cast<ConstantDataSequential>(C))
-        if (Seq->isString())
-          return stable_hash_name(Seq->getAsString());
-    }
-
-    // Hash structural contents of Objective-C metadata in specific sections.
-    // This can be extended to other metadata if needed.
-    static constexpr const char *SectionNames[] = {
-        "__cfstring",      "__cstring",      "__objc_classrefs",
-        "__objc_methname", "__objc_selrefs",
-    };
-    if (GVar.hasSection()) {
-      StringRef SectionName = GVar.getSection();
-      for (const char *Name : SectionNames)
-        if (SectionName.contains(Name))
-          return hashConstant(GVar.getInitializer());
-    }
-
-    return hashGlobalValue(&GVar);
-  }
-
-  static stable_hash hashGlobalValue(const GlobalValue *GV) {
+  stable_hash hashGlobalValue(const GlobalValue *GV) {
     if (!GV->hasName())
       return 0;
     return stable_hash_name(GV->getName());
@@ -115,7 +87,7 @@ class StructuralHashImpl {
   // FunctionComparator::cmpConstants() in FunctionComparator.cpp, but here
   // we're interested in computing a hash rather than comparing two Constants.
   // Some of the logic is simplified, e.g, we don't expand GEPOperator.
-  static stable_hash hashConstant(const Constant *C) {
+  stable_hash hashConstant(Constant *C) {
     SmallVector<stable_hash> Hashes;
 
     Type *Ty = C->getType();
@@ -126,21 +98,14 @@ class StructuralHashImpl {
       return stable_hash_combine(Hashes);
     }
 
-    if (auto *GVar = dyn_cast<GlobalVariable>(C)) {
-      Hashes.emplace_back(hashGlobalVariable(*GVar));
-      return stable_hash_combine(Hashes);
-    }
-
     if (auto *G = dyn_cast<GlobalValue>(C)) {
       Hashes.emplace_back(hashGlobalValue(G));
       return stable_hash_combine(Hashes);
     }
 
     if (const auto *Seq = dyn_cast<ConstantDataSequential>(C)) {
-      if (Seq->isString()) {
-        Hashes.emplace_back(stable_hash_name(Seq->getAsString()));
-        return stable_hash_combine(Hashes);
-      }
+      Hashes.emplace_back(xxh3_64bits(Seq->getRawDataValues()));
+      return stable_hash_combine(Hashes);
     }
 
     switch (C->getValueID()) {
@@ -301,7 +266,6 @@ class StructuralHashImpl {
     Hashes.emplace_back(Hash);
     Hashes.emplace_back(GlobalHeaderHash);
     Hashes.emplace_back(GV.getValueType()->getTypeID());
-    Hashes.emplace_back(hashGlobalVariable(GV));
 
     // Update the combined hash in place.
     Hash = stable_hash_combine(Hashes);
@@ -333,10 +297,6 @@ stable_hash llvm::StructuralHash(const Function &F, bool DetailedHash) {
   return H.getHash();
 }
 
-stable_hash llvm::StructuralHash(const GlobalVariable &GVar) {
-  return StructuralHashImpl::hashGlobalVariable(GVar);
-}
-
 stable_hash llvm::StructuralHash(const Module &M, bool DetailedHash) {
   StructuralHashImpl H(DetailedHash);
   H.update(M);