Address 2nd comments from boomanaiden154

Author: kyulee-com

llvm/include/llvm/IR/StructuralHash.h

@@ -22,20 +22,18 @@ namespace llvm {
 class Function;
 class Module;
 
-using IRHash = stable_hash;
-
 /// Returns a hash of the function \p F.
 /// \param F The function to hash.
 /// \param DetailedHash Whether or not to encode additional information in the
 /// hash. The additional information added into the hash when this flag is set
 /// to true includes instruction and operand type information.
-IRHash StructuralHash(const Function &F, bool DetailedHash = false);
+stable_hash StructuralHash(const Function &F, bool DetailedHash = false);
 
 /// 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
 /// composed the module hash.
-IRHash StructuralHash(const Module &M, bool DetailedHash = false);
+stable_hash StructuralHash(const Module &M, bool DetailedHash = false);
 
 } // end namespace llvm
 

llvm/lib/IR/StructuralHash.cpp

@@ -28,9 +28,11 @@ class StructuralHashImpl {
 
   bool DetailedHash;
 
-  const stable_hash GlobalHeaderHash = stable_hash_name("Global Header");
-  const stable_hash FunctionHeaderHash = stable_hash_name("Function Header");
-  const stable_hash BlockHeaderHash = stable_hash_name("Block Header");
+  // This random value acts as a block header, as otherwise the partition of
+  // opcodes into BBs wouldn't affect the hash, only the order of the opcodes.
+  static constexpr stable_hash BlockHeaderHash = 45798;
+  static constexpr stable_hash FunctionHeaderHash = 0x62642d6b6b2d6b72;
+  static constexpr stable_hash GlobalHeaderHash = 23456;
 
   // This will produce different values on 32-bit and 64-bit systens as
   // hash_combine returns a size_t. However, this is only used for
@@ -150,9 +152,6 @@ class StructuralHashImpl {
     while (!BBs.empty()) {
       const BasicBlock *BB = BBs.pop_back_val();
 
-      // This random value acts as a block header, as otherwise the partition of
-      // opcodes into BBs wouldn't affect the hash, only the order of the
-      // opcodes
       Hashes.emplace_back(BlockHeaderHash);
       for (auto &Inst : *BB)
         Hashes.emplace_back(hashInstruction(Inst));
@@ -193,13 +192,13 @@ class StructuralHashImpl {
 
 } // namespace
 
-IRHash llvm::StructuralHash(const Function &F, bool DetailedHash) {
+stable_hash llvm::StructuralHash(const Function &F, bool DetailedHash) {
   StructuralHashImpl H(DetailedHash);
   H.update(F);
   return H.getHash();
 }
 
-IRHash llvm::StructuralHash(const Module &M, bool DetailedHash) {
+stable_hash llvm::StructuralHash(const Module &M, bool DetailedHash) {
   StructuralHashImpl H(DetailedHash);
   H.update(M);
   return H.getHash();

llvm/lib/Transforms/IPO/MergeFunctions.cpp

@@ -172,14 +172,14 @@ namespace {
 
 class FunctionNode {
   mutable AssertingVH<Function> F;
-  IRHash Hash;
+  stable_hash Hash;
 
 public:
   // Note the hash is recalculated potentially multiple times, but it is cheap.
   FunctionNode(Function *F) : F(F), Hash(StructuralHash(*F)) {}
 
   Function *getFunc() const { return F; }
-  IRHash getHash() const { return Hash; }
+  stable_hash getHash() const { return Hash; }
 
   /// Replace the reference to the function F by the function G, assuming their
   /// implementations are equal.
@@ -420,7 +420,7 @@ bool MergeFunctions::runOnModule(Module &M) {
 
   // All functions in the module, ordered by hash. Functions with a unique
   // hash value are easily eliminated.
-  std::vector<std::pair<IRHash, Function *>> HashedFuncs;
+  std::vector<std::pair<stable_hash, Function *>> HashedFuncs;
   for (Function &Func : M) {
     if (isEligibleForMerging(Func)) {
       HashedFuncs.push_back({StructuralHash(Func), &Func});

llvm/test/Transforms/MergeFunc/call-and-invoke-with-ranges-attr.ll

@@ -79,20 +79,6 @@ lpad:
   resume { ptr, i32 } zeroinitializer
 }
 
-define i8 @call_with_same_range_attr(i8 range(i8 0, 2) %v) {
-; CHECK-LABEL: @call_with_same_range_attr
-; CHECK: tail call i8 @call_with_range_attr
-  %out = call i8 @dummy2(i8 %v)
-  ret i8 %out
-}
-
-define i8 @call_with_same_range() {
-; CHECK-LABEL: @call_with_same_range
-; CHECK: tail call i8 @call_with_range
-  %out = call range(i8 0, 2) i8 @dummy()
-  ret i8 %out
-}
-
 define i8 @invoke_with_same_range() personality ptr undef {
 ; CHECK-LABEL: @invoke_with_same_range()
 ; CHECK: tail call i8 @invoke_with_range()
@@ -106,6 +92,20 @@ lpad:
   resume { ptr, i32 } zeroinitializer
 }
 
+define i8 @call_with_same_range() {
+; CHECK-LABEL: @call_with_same_range
+; CHECK: tail call i8 @call_with_range
+  %out = call range(i8 0, 2) i8 @dummy()
+  ret i8 %out
+}
+
+define i8 @call_with_same_range_attr(i8 range(i8 0, 2) %v) {
+; CHECK-LABEL: @call_with_same_range_attr
+; CHECK: tail call i8 @call_with_range_attr
+  %out = call i8 @dummy2(i8 %v)
+  ret i8 %out
+}
+
 declare i8 @dummy();
 declare i8 @dummy2(i8);
 declare i32 @__gxx_personality_v0(...)

llvm/test/Transforms/MergeFunc/inline-asm.ll

@@ -3,12 +3,12 @@
 ; CHECK-LABEL: @int_ptr_arg_different
 ; CHECK-NEXT: call void asm
 
-; CHECK-LABEL: @int_ptr_arg_same
-; CHECK-NEXT: tail call void @float_ptr_arg_same(ptr %0)
-
 ; CHECK-LABEL: @int_ptr_null
 ; CHECK-NEXT: tail call void @float_ptr_null()
 
+; CHECK-LABEL: @int_ptr_arg_same
+; CHECK-NEXT: tail call void @float_ptr_arg_same(ptr %0)
+
 ; Used to satisfy minimum size limit
 declare void @stuff()