New pass to make internal linkage symbol names unique

[tmsriram]

Summary

This is the parent pass of D73307.

This adds a new pass to make internal linkage symbol names unique with clang option -funique-internal-linkage-symbols.

[mtrofin]

llvm/lib/Transforms/Utils/UniqueInternalLinkageNames.cpp

44

when are you returning false?

[rnk]

Code looks good, but I think this needs a test in llvm/test/Transforms. I think it should be registered by the INITIALIZE_PASS macros, so opt -unique-internal-linkage-names should find it and run it...

[tmsriram]

In D78243#1989248, @rnk wrote:

Code looks good, but I think this needs a test in llvm/test/Transforms. I think it should be registered by the INITIALIZE_PASS macros, so opt -unique-internal-linkage-names should find it and run it...

Done.

[tmsriram]

Add test to llvm/test/Transforms

[rnk]

lgtm, plus improvement to test.

llvm/test/Transforms/UniqueInternalLinkageNames/unique_symbol_names.ll

3

I suspect Module::getSourceFilename in this example returns "", so you are adding a hash of the empty string. I think it would be better to add source_filename = "foo.cpp" here, and then explicitly check for the hex bits in the names. That ensures that everyone gets the same results everywhere, and will detect changes in the hashing.

[tmsriram]

llvm/test/Transforms/UniqueInternalLinkageNames/unique_symbol_names.ll

3

Great catch! You are right. I wrongly assumed that the module name would be .ll file name but since I use '<' it is the empty string. I will fix it.

[tmsriram]

Add source_filename to test and make the hash explicit.

[MaskRay]

llvm/lib/Transforms/Utils/UniqueInternalLinkageNames.cpp

1

http://llvm.org/docs/CodingStandards.html#file-headers

[tmsriram]

Fix file header.

[tmsriram]

Fix header.

[MaskRay]

You may need an opt -passes='...' test for the new pass manager and implement the new pass.

We are using -fexperimental-new-pass-manager heavily.

llvm/include/llvm/Transforms/Utils/UniqueInternalLinkageNames.h

27

The defaulted default constructor can be deleted.

llvm/lib/Transforms/Utils/UniqueInternalLinkageNames.cpp

30

(Twine('.') + Twine(Str))

[tmsriram]

In D78243#1990057, @MaskRay wrote:

You may need an opt -passes='...' test for the new pass manager and implement the new pass.

We are using -fexperimental-new-pass-manager heavily.

I am already testing -fexperimental-new-pass-manager in D73307, need to do it here?

[echristo]

In D78243#1990101, @tmsriram wrote:

In D78243#1990057, @MaskRay wrote:

You may need an opt -passes='...' test for the new pass manager and implement the new pass.

We are using -fexperimental-new-pass-manager heavily.

I am already testing -fexperimental-new-pass-manager in D73307, need to do it here?

Probably wouldn't hurt to have both an explicit test for each pass manager.

[tmsriram]

In D78243#1993284, @echristo wrote:

In D78243#1990101, @tmsriram wrote:

In D78243#1990057, @MaskRay wrote:

You may need an opt -passes='...' test for the new pass manager and implement the new pass.

We are using -fexperimental-new-pass-manager heavily.

I am already testing -fexperimental-new-pass-manager in D73307, need to do it here?

Probably wouldn't hurt to have both an explicit test for each pass manager.

I saw this after I pushed. I can follow it up with a test.

llvm/include/llvm/InitializePasses.h

 void initializeMergedLoadStoreMotionLegacyPassPass(PassRegistry&);
 void initializeMetaRenamerPass(PassRegistry&);
 void initializeModuleDebugInfoPrinterPass(PassRegistry&);
 void initializeModuleSummaryIndexWrapperPassPass(PassRegistry&);
 void initializeModuloScheduleTestPass(PassRegistry&);
 void initializeMustExecutePrinterPass(PassRegistry&);
 void initializeMustBeExecutedContextPrinterPass(PassRegistry&);
 void initializeNameAnonGlobalLegacyPassPass(PassRegistry&);
+void initializeUniqueInternalLinkageNamesLegacyPassPass(PassRegistry &);
 void initializeNaryReassociateLegacyPassPass(PassRegistry&);
 void initializeNewGVNLegacyPassPass(PassRegistry&);
 void initializeObjCARCAAWrapperPassPass(PassRegistry&);
 void initializeObjCARCAPElimPass(PassRegistry&);
 void initializeObjCARCContractPass(PassRegistry&);
 void initializeObjCARCExpandPass(PassRegistry&);
 void initializeObjCARCOptPass(PassRegistry&);
 void initializeOptimizationRemarkEmitterWrapperPassPass(PassRegistry&);

llvm/include/llvm/Transforms/Utils.h

 class Pass;
 
 //===----------------------------------------------------------------------===//
 // createMetaRenamerPass - Rename everything with metasyntatic names.
 //
 ModulePass *createMetaRenamerPass();
 
 //===----------------------------------------------------------------------===//
+// createUniqueInternalLinkageNamesPass - Make internal linkage symbol names
+// unique.
+//
+ModulePass *createUniqueInternalLinkageNamesPass();
+
+//===----------------------------------------------------------------------===//
 //
 // LowerInvoke - This pass removes invoke instructions, converting them to call
 // instructions.
 //
 FunctionPass *createLowerInvokePass();
 extern char &LowerInvokePassID;
 
 //===----------------------------------------------------------------------===//

llvm/include/llvm/Transforms/Utils/UniqueInternalLinkageNames.h

+//===-- UniqueInternalLinkageNames.h --------*- C++ -*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements unique naming of internal linkage symbols with option
+// -funique-internal-linkage-symbols.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TRANSFORMS_UTILS_UNIQUEINTERNALLINKAGENAMES_H
+#define LLVM_TRANSFORMS_UTILS_UNIQUEINTERNALLINKAGENAMES_H
+
+#include "llvm/IR/Module.h"
+#include "llvm/IR/PassManager.h"
+
+namespace llvm {
+
+/// Simple pass that provides a name to every anonymous globals.
+class UniqueInternalLinkageNamesPass
+    : public PassInfoMixin<UniqueInternalLinkageNamesPass> {
+
+public:
+  UniqueInternalLinkageNamesPass() = default;
+  PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+};
+
+} // end namespace llvm
+
+#endif // LLVM_TRANSFORMS_UTILS_UNIQUEINTERNALLINKAGENAMES_H

llvm/lib/Transforms/Utils/CMakeLists.txt

add_llvm_component_library(LLVMTransformUtils
   SimplifyIndVar.cpp
   SimplifyLibCalls.cpp
   SizeOpts.cpp
   SplitModule.cpp
   StripNonLineTableDebugInfo.cpp
   SymbolRewriter.cpp
   UnifyFunctionExitNodes.cpp
   UnifyLoopExits.cpp
+  UniqueInternalLinkageNames.cpp
   Utils.cpp
   ValueMapper.cpp
   VNCoercion.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${LLVM_MAIN_INCLUDE_DIR}/llvm/Transforms
   ${LLVM_MAIN_INCLUDE_DIR}/llvm/Transforms/Utils
 
   DEPENDS
   intrinsics_gen
   )

llvm/lib/Transforms/Utils/UniqueInternalLinkageNames.cpp

+//===- UniqueInternalLinkageNames.cpp --------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements unique naming of internal linkage symbols with option
+// -funique-internal-linkage-symbols.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/Transforms/Utils/UniqueInternalLinkageNames.h"
+#include "llvm/ADT/SmallString.h"
+#include "llvm/IR/Module.h"
+#include "llvm/InitializePasses.h"
+#include "llvm/Support/MD5.h"
+#include "llvm/Transforms/Utils/ModuleUtils.h"
+
+using namespace llvm;
+
+static bool uniqueifyInternalLinkageNames(Module &M) {
+  llvm::MD5 Md5;
+  Md5.update(M.getSourceFileName());
+  llvm::MD5::MD5Result R;
+  Md5.final(R);
+  SmallString<32> Str;
+  llvm::MD5::stringifyResult(R, Str);
+  std::string ModuleNameHash = ("." + Str).str();
+  bool Changed = false;
+
+  // Append the module hash to all internal linkage functions.
+  for (auto &F : M) {
+    if (F.hasInternalLinkage()) {
+      F.setName(F.getName() + ModuleNameHash);
+      Changed = true;
+    }
+  }
+
+  // Append the module hash to all internal linkage globals.
+  for (auto &GV : M.globals()) {
+    if (GV.hasInternalLinkage()) {
+      GV.setName(GV.getName() + ModuleNameHash);
+      Changed = true;
+    }
+  }
+  return Changed;
+}
+
+namespace {
+
+// Legacy pass that provides a name to every anon globals.
+class UniqueInternalLinkageNamesLegacyPass : public ModulePass {
+
+public:
+  /// Pass identification, replacement for typeid
+  static char ID;
+
+  /// Specify pass name for debug output
+  StringRef getPassName() const override {
+    return "Unique Internal Linkage Names";
+  }
+
+  explicit UniqueInternalLinkageNamesLegacyPass() : ModulePass(ID) {
+    initializeUniqueInternalLinkageNamesLegacyPassPass(
+        *PassRegistry::getPassRegistry());
+  }
+
+  bool runOnModule(Module &M) override {
+    return uniqueifyInternalLinkageNames(M);
+  }
+};
+
+char UniqueInternalLinkageNamesLegacyPass::ID = 0;
+} // anonymous namespace
+
+PreservedAnalyses
+UniqueInternalLinkageNamesPass::run(Module &M, ModuleAnalysisManager &AM) {
+  if (!uniqueifyInternalLinkageNames(M))
+    return PreservedAnalyses::all();
+
+  return PreservedAnalyses::none();
+}
+
+INITIALIZE_PASS_BEGIN(UniqueInternalLinkageNamesLegacyPass,
+                      "unique-internal-linkage-names",
+                      "Uniqueify internal linkage names", false, false)
+INITIALIZE_PASS_END(UniqueInternalLinkageNamesLegacyPass,
+                    "unique-internal-linkage-names",
+                    "Uniqueify Internal linkage names", false, false)
+
+namespace llvm {
+ModulePass *createUniqueInternalLinkageNamesPass() {
+  return new UniqueInternalLinkageNamesLegacyPass();
+}
+} // namespace llvm

llvm/lib/Transforms/Utils/Utils.cpp

void llvm::initializeTransformUtils(PassRegistry &Registry) {
   initializePromoteLegacyPassPass(Registry);
   initializeStripNonLineTableDebugInfoPass(Registry);
   initializeUnifyFunctionExitNodesPass(Registry);
   initializeMetaRenamerPass(Registry);
   initializeStripGCRelocatesPass(Registry);
   initializePredicateInfoPrinterLegacyPassPass(Registry);
   initializeInjectTLIMappingsLegacyPass(Registry);
   initializeUnifyLoopExitsPass(Registry);
+  initializeUniqueInternalLinkageNamesLegacyPassPass(Registry);
 }
 
 /// LLVMInitializeTransformUtils - C binding for initializeTransformUtilsPasses.
 void LLVMInitializeTransformUtils(LLVMPassRegistryRef R) {
   initializeTransformUtils(*unwrap(R));
 }
 
 void LLVMAddLowerSwitchPass(LLVMPassManagerRef PM) {

llvm/test/Transforms/UniqueInternalLinkageNames/unique_symbol_names.ll

+; RUN: opt -S -unique-internal-linkage-names < %s | FileCheck %s
+
+source_filename = "foo.c"
+
+@glob = internal global i32 0
+
+define internal i32 @foo() {
+entry:
+  ret i32 0
+}
+
+; CHECK: @glob.6ae72bb15a7d1834b42ae042a58f7a4d = internal global
+; CHECK: define internal i32 @foo.6ae72bb15a7d1834b42ae042a58f7a4d()

llvm/utils/gn/secondary/llvm/lib/Transforms/Utils/BUILD.gn

sources = [
     "SimplifyLibCalls.cpp",
     "SizeOpts.cpp",
     "SplitModule.cpp",
     "StripGCRelocates.cpp",
     "StripNonLineTableDebugInfo.cpp",
     "SymbolRewriter.cpp",
     "UnifyFunctionExitNodes.cpp",
     "UnifyLoopExits.cpp",
+    "UniqueInternalLinkageNames.cpp",
     "Utils.cpp",
     "VNCoercion.cpp",
     "ValueMapper.cpp",
   ]
 }