[IR] Add an option to preserve llvm prefix for global identifier

[steven_wu]

Summary

Provide an option to preserve llvm prefix for global identifier so "\01"
prefix can be preserved when computing GUID. With "\01" prefix
preserved, we can get different GUID for "_NAME" and "\01_NAME", which
are different symbols.

llvm/include/llvm/IR/GlobalValue.h

public:
   }
 
   /// Return the modified name for a global value suitable to be
   /// used as the key for a global lookup (e.g. profile or ThinLTO).
   /// The value's original name is \c Name and has linkage of type
   /// \c Linkage. The value is defined in module \c FileName.
   static std::string getGlobalIdentifier(StringRef Name,
                                          GlobalValue::LinkageTypes Linkage,
-                                         StringRef FileName);
+                                         StringRef FileName,
+                                         bool PreservePrefix = true);
 
   /// Return the modified name for this global value suitable to be
   /// used as the key for a global lookup (e.g. profile or ThinLTO).
   std::string getGlobalIdentifier() const;
 
   /// Declare a type to represent a global unique identifier for a global value.
   /// This is a 64 bits hash that is used by PGO and ThinLTO to have a compact
   /// unique way to identify a symbol.

llvm/lib/IR/Globals.cpp

 void GlobalObject::copyAttributesFrom(const GlobalObject *Src) {
   GlobalValue::copyAttributesFrom(Src);
   setAlignment(MaybeAlign(Src->getAlignment()));
   setSection(Src->getSection());
 }
 
 std::string GlobalValue::getGlobalIdentifier(StringRef Name,
                                              GlobalValue::LinkageTypes Linkage,
-                                             StringRef FileName) {
+                                             StringRef FileName,
+                                             bool PreservePrefix) {
 
   // Value names may be prefixed with a binary '1' to indicate
   // that the backend should not modify the symbols due to any platform
   // naming convention. Do not include that '1' in the PGO profile name.
-  if (Name[0] == '\1')
+  if (!PreservePrefix && Name[0] == '\1')
     Name = Name.substr(1);
 
   std::string NewName = std::string(Name);
   if (llvm::GlobalValue::isLocalLinkage(Linkage)) {
     // For local symbols, prepend the main file name to distinguish them.
     // Do not include the full path in the file name since there's no guarantee
     // that it will stay the same, e.g., if the files are checked out from
     // version control in different locations.
     if (FileName.empty())
       NewName = NewName.insert(0, "<unknown>:");
     else
       NewName = NewName.insert(0, FileName.str() + ":");
   }
   return NewName;
 }
 
 std::string GlobalValue::getGlobalIdentifier() const {
   return getGlobalIdentifier(getName(), getLinkage(),
-                             getParent()->getSourceFileName());
+                             getParent()->getSourceFileName(),
+                             /*PreservePrefix=*/true);
 }
 
 StringRef GlobalValue::getSection() const {
   if (auto *GA = dyn_cast<GlobalAlias>(this)) {
     // In general we cannot compute this at the IR level, but we try.
     if (const GlobalObject *GO = GA->getBaseObject())
       return GO->getSection();
     return "";

llvm/lib/ProfileData/InstrProf.cpp

 }
 
 char InstrProfError::ID = 0;
 
 std::string getPGOFuncName(StringRef RawFuncName,
                            GlobalValue::LinkageTypes Linkage,
                            StringRef FileName,
                            uint64_t Version LLVM_ATTRIBUTE_UNUSED) {
-  return GlobalValue::getGlobalIdentifier(RawFuncName, Linkage, FileName);
+  return GlobalValue::getGlobalIdentifier(RawFuncName, Linkage, FileName,
+                                          /*PreservePrefix=*/false);
 }
 
 // Strip NumPrefix level of directory name from PathNameStr. If the number of
 // directory separators is less than NumPrefix, strip all the directories and
 // leave base file name only.
 static StringRef stripDirPrefix(StringRef PathNameStr, uint32_t NumPrefix) {
   uint32_t Count = NumPrefix;
   uint32_t Pos = 0, LastPos = 0;

llvm/test/ThinLTO/X86/mangled_symbol.ll

 ; RUN: opt -module-summary %s -o %t1.bc
 ; RUN: llvm-lto -thinlto-action=thinlink -o %t.index.bc %t1.bc
 ;; Check baseline when both of them internalized when not exported.
 ; RUN: llvm-lto -thinlto-action=internalize -thinlto-index %t.index.bc %t1.bc -o - --exported-symbol=_exported | llvm-dis -o - | FileCheck %s --check-prefix=INTERNALIZED
 ;; Check symbols are exported, including the ones with `\01` prefix.
 ; RUN: llvm-lto -thinlto-action=internalize -thinlto-index %t.index.bc %t1.bc -o - --exported-symbol=_exported --exported-symbol=_extern_not_mangled --exported-symbol=_extern_mangled | llvm-dis -o - | FileCheck %s --check-prefix=EXPORTED
 
 ; INTERNALIZED: define internal void @extern_not_mangled
 ; INTERNALIZED: define internal void @"\01_extern_mangled"
+; INTERNALIZED: define internal void @_extern_mangled
 ; EXPORTED: define void @extern_not_mangled
 ; EXPORTED: define void @"\01_extern_mangled"
+; EXPORTED: define internal void @_extern_mangled
 
 target datalayout = "e-m:o-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.11.0"
 
 define void @exported() {
   ret void
 }
 
 define void @extern_not_mangled() {
   ret void
 }
 
 define void @"\01_extern_mangled"() {
   ret void
 }
+
+; _extern_mangled is different from "\01_extern_mangled"
+define void @_extern_mangled() {
+  ret void
+}