Revert "Reland "[pgo] Avoid introducing relocations by using private alias""

This reverts commit 3cfaea2.

The runtime test fails on Mac.

Author: ilovepi

compiler-rt/test/profile/instrprof-discarded-comdat.cpp

@@ -823,36 +823,6 @@ static inline bool shouldRecordFunctionAddr(Function *F) {
   return F->hasAddressTaken() || F->hasLinkOnceLinkage();
 }
 
-static inline Constant *getFuncAddrForProfData(Function *Fn) {
-  auto *Int8PtrTy = Type::getInt8PtrTy(Fn->getContext());
-  // Store a nullptr in __llvm_profd, if we shouldn't use a real address
-  if (!shouldRecordFunctionAddr(Fn))
-    return ConstantPointerNull::get(Int8PtrTy);
-
-  // If we can't use an alias, we must use the public symbol, even though this
-  // may require a symbolic relocation. When the function has local linkage, we
-  // can use the symbol directly without introducing relocations.
-  if (Fn->isDeclarationForLinker() || Fn->hasLocalLinkage())
-    return ConstantExpr::getBitCast(Fn, Int8PtrTy);
-
-  // When possible use a private alias to avoid symbolic relocations.
-  auto *GA = GlobalAlias::create(GlobalValue::LinkageTypes::PrivateLinkage,
-                                 Fn->getName(), Fn);
-
-  // When the instrumented function is a COMDAT function, we cannot use a
-  // private alias. If we did, we would create reference to a local label in
-  // this function's section. If this version of the function isn't selected by
-  // the linker, then the metadata would introduce a reference to a discarded
-  // section. So, for COMDAT functions, we need to adjust the linkage of the
-  // alias. Using hidden visibility avoids a dynamic relocation and an entry in
-  // the dynamic symbol table.
-  if (Fn->hasComdat()) {
-    GA->setLinkage(Fn->getLinkage());
-    GA->setVisibility(GlobalValue::VisibilityTypes::HiddenVisibility);
-  }
-  return ConstantExpr::getBitCast(GA, Int8PtrTy);
-}
-
 static bool needsRuntimeRegistrationOfSectionRange(const Triple &TT) {
   // Don't do this for Darwin.  compiler-rt uses linker magic.
   if (TT.isOSDarwin())
@@ -1044,7 +1014,9 @@ InstrProfiling::getOrCreateRegionCounters(InstrProfInstBase *Inc) {
   };
   auto *DataTy = StructType::get(Ctx, makeArrayRef(DataTypes));
 
-  Constant *FunctionAddr = getFuncAddrForProfData(Fn);
+  Constant *FunctionAddr = shouldRecordFunctionAddr(Fn)
+                               ? ConstantExpr::getBitCast(Fn, Int8PtrTy)
+                               : ConstantPointerNull::get(Int8PtrTy);
 
   Constant *Int16ArrayVals[IPVK_Last + 1];
   for (uint32_t Kind = IPVK_First; Kind <= IPVK_Last; ++Kind)

llvm/lib/Transforms/Instrumentation/InstrProfiling.cpp

@@ -4,8 +4,6 @@
 
 $linkonceodr = comdat any
 $weakodr = comdat any
-$weak = comdat any
-$linkonce = comdat any
 
 ;; profc/profd have hash suffixes. This definition doesn't have value profiling,
 ;; so definitions with the same name in other modules must have the same CFG and
@@ -29,32 +27,3 @@ define linkonce_odr void @linkonceodr() comdat {
 define weak_odr void @weakodr() comdat {
   ret void
 }
-
-;; weak in a comdat is not renamed. There is no guarantee that definitions in
-;; other modules don't have value profiling. profd should be conservatively
-;; non-private to prevent a caller from referencing a non-prevailing profd,
-;; causing a linker error.
-; ELF:   @__profc_weak = weak hidden global {{.*}} comdat, align 8
-; ELF:   @__profd_weak = weak hidden global {{.*}} comdat($__profc_weak), align 8
-; COFF:  @__profc_weak = weak hidden global {{.*}} comdat, align 8
-; COFF:  @__profd_weak = weak hidden global {{.*}} comdat, align 8
-define weak void @weak() comdat {
-  ret void
-}
-
-;; profc/profd have hash suffixes. This definition doesn't have value profiling,
-;; so definitions with the same name in other modules must have the same CFG and
-;; cannot have value profiling, either. profd can be made private for ELF.
-; ELF:   @__profc_linkonce.[[#]] = linkonce hidden global {{.*}} comdat, align 8
-; ELF:   @__profd_linkonce.[[#]] = private global {{.*}} comdat($__profc_linkonce.[[#]]), align 8
-; COFF:  @__profc_linkonce.[[#]] = linkonce hidden global {{.*}} comdat, align 8
-; COFF:  @__profd_linkonce.[[#]] = linkonce hidden global {{.*}} comdat, align 8
-define linkonce void @linkonce() comdat {
-  ret void
-}
-
-; Check that comdat aliases are hidden for all linkage types
-; ELF:   @linkonceodr.1 = linkonce_odr hidden alias void (), ptr @linkonceodr
-; ELF:   @weakodr.2 = weak_odr hidden alias void (), ptr @weakodr
-; ELF:   @weak.3 = weak hidden alias void (), ptr @weak
-; ELF:   @linkonce.4 = linkonce hidden alias void (), ptr @linkonce