[MemProf] Use updated version of hot/cold operator new

[tejohnson]

Summary

Switch to the just updated versions of the API in tcmalloc that change
the name of the hot cold paramter to a reserved identifier __hot_cold_t.
This was based on feedback from Richard Smith, as I also need to add
some follow-on handling to clang so they are annotated properly.

[snehasish]

lgtm

Should we update this too https://github.com/llvm/llvm-project/blob/main/llvm/test/tools/llvm-tli-checker/ps4-tli-check.yaml#L41

[tejohnson]

In D149475#4306282, @snehasish wrote:

lgtm

Should we update this too https://github.com/llvm/llvm-project/blob/main/llvm/test/tools/llvm-tli-checker/ps4-tli-check.yaml#L41

Yeah I'll do that. It won't fail with this change due to the wildcard, but it's probably best to be consistent and explicit.

[tejohnson]

Address comments

llvm/include/llvm/Analysis/TargetLibraryInfo.def

 TLI_DEFINE_STRING_INTERNAL("_ZnajSt11align_val_tRKSt9nothrow_t")
 TLI_DEFINE_SIG_INTERNAL(Ptr, Int, Int, Ptr)
 
 /// void *operator new[](unsigned long);
 TLI_DEFINE_ENUM_INTERNAL(Znam)
 TLI_DEFINE_STRING_INTERNAL("_Znam")
 TLI_DEFINE_SIG_INTERNAL(Ptr, Long)
 
-/// void *operator new[](unsigned long, hot_cold_t)
-/// Currently this and other operator new interfaces that take a hot_cold_t
+/// void *operator new[](unsigned long, __hot_cold_t)
+/// Currently this and other operator new interfaces that take a __hot_cold_t
 /// hint are supported by the open source version of tcmalloc, see:
 /// https://github.com/google/tcmalloc/blob/master/tcmalloc/new_extension.h
-/// and for the definition of the hot_cold_t parameter see:
+/// and for the definition of the __hot_cold_t parameter see:
 /// https://github.com/google/tcmalloc/blob/master/tcmalloc/malloc_extension.h
-TLI_DEFINE_ENUM_INTERNAL(Znam10hot_cold_t)
-TLI_DEFINE_STRING_INTERNAL("_Znam10hot_cold_t")
+TLI_DEFINE_ENUM_INTERNAL(Znam12__hot_cold_t)
+TLI_DEFINE_STRING_INTERNAL("_Znam12__hot_cold_t")
 TLI_DEFINE_SIG_INTERNAL(Ptr, Long, Bool)
 
 /// void *operator new[](unsigned long, const std::nothrow_t&);
 TLI_DEFINE_ENUM_INTERNAL(ZnamRKSt9nothrow_t)
 TLI_DEFINE_STRING_INTERNAL("_ZnamRKSt9nothrow_t")
 TLI_DEFINE_SIG_INTERNAL(Ptr, Long, Ptr)
 
-/// void *operator new[](unsigned long, const std::nothrow_t&, hot_cold_t)
-TLI_DEFINE_ENUM_INTERNAL(ZnamRKSt9nothrow_t10hot_cold_t)
-TLI_DEFINE_STRING_INTERNAL("_ZnamRKSt9nothrow_t10hot_cold_t")
+/// void *operator new[](unsigned long, const std::nothrow_t&, __hot_cold_t)
+TLI_DEFINE_ENUM_INTERNAL(ZnamRKSt9nothrow_t12__hot_cold_t)
+TLI_DEFINE_STRING_INTERNAL("_ZnamRKSt9nothrow_t12__hot_cold_t")
 TLI_DEFINE_SIG_INTERNAL(Ptr, Long, Ptr, Bool)
 
 /// void *operator new[](unsigned long, std::align_val_t)
 TLI_DEFINE_ENUM_INTERNAL(ZnamSt11align_val_t)
 TLI_DEFINE_STRING_INTERNAL("_ZnamSt11align_val_t")
 TLI_DEFINE_SIG_INTERNAL(Ptr, Long, Long)
 
-/// void *operator new[](unsigned long, std::align_val_t, hot_cold_t)
-TLI_DEFINE_ENUM_INTERNAL(ZnamSt11align_val_t10hot_cold_t)
-TLI_DEFINE_STRING_INTERNAL("_ZnamSt11align_val_t10hot_cold_t")
+/// void *operator new[](unsigned long, std::align_val_t, __hot_cold_t)
+TLI_DEFINE_ENUM_INTERNAL(ZnamSt11align_val_t12__hot_cold_t)
+TLI_DEFINE_STRING_INTERNAL("_ZnamSt11align_val_t12__hot_cold_t")
 TLI_DEFINE_SIG_INTERNAL(Ptr, Long, Long, Bool)
 
 /// void *operator new[](unsigned long, std::align_val_t, const std::nothrow_t&)
 TLI_DEFINE_ENUM_INTERNAL(ZnamSt11align_val_tRKSt9nothrow_t)
 TLI_DEFINE_STRING_INTERNAL("_ZnamSt11align_val_tRKSt9nothrow_t")
 TLI_DEFINE_SIG_INTERNAL(Ptr, Long, Long, Ptr)
 
-/// void *operator new[](unsigned long, std::align_val_t, const std::nothrow_t&, hot_cold_t)
-TLI_DEFINE_ENUM_INTERNAL(ZnamSt11align_val_tRKSt9nothrow_t10hot_cold_t)
-TLI_DEFINE_STRING_INTERNAL("_ZnamSt11align_val_tRKSt9nothrow_t10hot_cold_t")
+/// void *operator new[](unsigned long, std::align_val_t, const std::nothrow_t&, __hot_cold_t)
+TLI_DEFINE_ENUM_INTERNAL(ZnamSt11align_val_tRKSt9nothrow_t12__hot_cold_t)
+TLI_DEFINE_STRING_INTERNAL("_ZnamSt11align_val_tRKSt9nothrow_t12__hot_cold_t")
 TLI_DEFINE_SIG_INTERNAL(Ptr, Long, Long, Ptr, Bool)
 
 /// void *operator new(unsigned int);
 TLI_DEFINE_ENUM_INTERNAL(Znwj)
 TLI_DEFINE_STRING_INTERNAL("_Znwj")
 TLI_DEFINE_SIG_INTERNAL(Ptr, Int)
 
 /// void *operator new(unsigned int, const std::nothrow_t&);

 TLI_DEFINE_STRING_INTERNAL("_ZnwjSt11align_val_tRKSt9nothrow_t")
 TLI_DEFINE_SIG_INTERNAL(Ptr, Int, Int, Ptr)
 
 /// void *operator new(unsigned long);
 TLI_DEFINE_ENUM_INTERNAL(Znwm)
 TLI_DEFINE_STRING_INTERNAL("_Znwm")
 TLI_DEFINE_SIG_INTERNAL(Ptr, Long)
 
-/// void *operator new(unsigned long, hot_cold_t)
-TLI_DEFINE_ENUM_INTERNAL(Znwm10hot_cold_t)
-TLI_DEFINE_STRING_INTERNAL("_Znwm10hot_cold_t")
+/// void *operator new(unsigned long, __hot_cold_t)
+TLI_DEFINE_ENUM_INTERNAL(Znwm12__hot_cold_t)
+TLI_DEFINE_STRING_INTERNAL("_Znwm12__hot_cold_t")
 TLI_DEFINE_SIG_INTERNAL(Ptr, Long, Bool)
 
 /// void *operator new(unsigned long, const std::nothrow_t&);
 TLI_DEFINE_ENUM_INTERNAL(ZnwmRKSt9nothrow_t)
 TLI_DEFINE_STRING_INTERNAL("_ZnwmRKSt9nothrow_t")
 TLI_DEFINE_SIG_INTERNAL(Ptr, Long, Ptr)
 
-/// void *operator new(unsigned long, const std::nothrow_t&, hot_cold_t)
-TLI_DEFINE_ENUM_INTERNAL(ZnwmRKSt9nothrow_t10hot_cold_t)
-TLI_DEFINE_STRING_INTERNAL("_ZnwmRKSt9nothrow_t10hot_cold_t")
+/// void *operator new(unsigned long, const std::nothrow_t&, __hot_cold_t)
+TLI_DEFINE_ENUM_INTERNAL(ZnwmRKSt9nothrow_t12__hot_cold_t)
+TLI_DEFINE_STRING_INTERNAL("_ZnwmRKSt9nothrow_t12__hot_cold_t")
 TLI_DEFINE_SIG_INTERNAL(Ptr, Long, Ptr, Bool)
 
 /// void *operator new(unsigned long, std::align_val_t)
 TLI_DEFINE_ENUM_INTERNAL(ZnwmSt11align_val_t)
 TLI_DEFINE_STRING_INTERNAL("_ZnwmSt11align_val_t")
 TLI_DEFINE_SIG_INTERNAL(Ptr, Long, Long)
 
-/// void *operator new(unsigned long, std::align_val_t, hot_cold_t)
-TLI_DEFINE_ENUM_INTERNAL(ZnwmSt11align_val_t10hot_cold_t)
-TLI_DEFINE_STRING_INTERNAL("_ZnwmSt11align_val_t10hot_cold_t")
+/// void *operator new(unsigned long, std::align_val_t, __hot_cold_t)
+TLI_DEFINE_ENUM_INTERNAL(ZnwmSt11align_val_t12__hot_cold_t)
+TLI_DEFINE_STRING_INTERNAL("_ZnwmSt11align_val_t12__hot_cold_t")
 TLI_DEFINE_SIG_INTERNAL(Ptr, Long, Long, Bool)
 
 /// void *operator new(unsigned long, std::align_val_t, const std::nothrow_t&)
 TLI_DEFINE_ENUM_INTERNAL(ZnwmSt11align_val_tRKSt9nothrow_t)
 TLI_DEFINE_STRING_INTERNAL("_ZnwmSt11align_val_tRKSt9nothrow_t")
 TLI_DEFINE_SIG_INTERNAL(Ptr, Long, Long, Ptr)
 
-/// void *operator new(unsigned long, std::align_val_t, const std::nothrow_t&, hot_cold_t)
-TLI_DEFINE_ENUM_INTERNAL(ZnwmSt11align_val_tRKSt9nothrow_t10hot_cold_t)
-TLI_DEFINE_STRING_INTERNAL("_ZnwmSt11align_val_tRKSt9nothrow_t10hot_cold_t")
+/// void *operator new(unsigned long, std::align_val_t, const std::nothrow_t&, __hot_cold_t)
+TLI_DEFINE_ENUM_INTERNAL(ZnwmSt11align_val_tRKSt9nothrow_t12__hot_cold_t)
+TLI_DEFINE_STRING_INTERNAL("_ZnwmSt11align_val_tRKSt9nothrow_t12__hot_cold_t")
 TLI_DEFINE_SIG_INTERNAL(Ptr, Long, Long, Ptr, Bool)
 
 /// double __acos_finite(double x);
 TLI_DEFINE_ENUM_INTERNAL(acos_finite)
 TLI_DEFINE_STRING_INTERNAL("__acos_finite")
 TLI_DEFINE_SIG_INTERNAL(Dbl, Dbl)
 
 /// float __acosf_finite(float x);

llvm/lib/Analysis/MemoryBuiltins.cpp

 // FIXME: certain users need more information. E.g., SimplifyLibCalls needs to
 // know which functions are nounwind, noalias, nocapture parameters, etc.
 static const std::pair<LibFunc, AllocFnsTy> AllocationFnData[] = {
     {LibFunc_Znwj,                              {OpNewLike,        1,  0, -1, -1, MallocFamily::CPPNew}},             // new(unsigned int)
     {LibFunc_ZnwjRKSt9nothrow_t,                {MallocLike,       2,  0, -1, -1, MallocFamily::CPPNew}},             // new(unsigned int, nothrow)
     {LibFunc_ZnwjSt11align_val_t,               {OpNewLike,        2,  0, -1,  1, MallocFamily::CPPNewAligned}},      // new(unsigned int, align_val_t)
     {LibFunc_ZnwjSt11align_val_tRKSt9nothrow_t, {MallocLike,       3,  0, -1,  1, MallocFamily::CPPNewAligned}},      // new(unsigned int, align_val_t, nothrow)
     {LibFunc_Znwm,                              {OpNewLike,        1,  0, -1, -1, MallocFamily::CPPNew}},             // new(unsigned long)
-    {LibFunc_Znwm10hot_cold_t,                  {OpNewLike,        2, 0,  -1, -1, MallocFamily::CPPNew}},             // new(unsigned long, hot_cold_t)
+    {LibFunc_Znwm12__hot_cold_t,                  {OpNewLike,        2, 0,  -1, -1, MallocFamily::CPPNew}},             // new(unsigned long, __hot_cold_t)
     {LibFunc_ZnwmRKSt9nothrow_t,                {MallocLike,       2,  0, -1, -1, MallocFamily::CPPNew}},             // new(unsigned long, nothrow)
-    {LibFunc_ZnwmRKSt9nothrow_t10hot_cold_t,      {MallocLike,       3, 0,  -1, -1, MallocFamily::CPPNew}},             // new(unsigned long, nothrow, hot_cold_t)
+    {LibFunc_ZnwmRKSt9nothrow_t12__hot_cold_t,      {MallocLike,       3, 0,  -1, -1, MallocFamily::CPPNew}},             // new(unsigned long, nothrow, __hot_cold_t)
     {LibFunc_ZnwmSt11align_val_t,               {OpNewLike,        2,  0, -1,  1, MallocFamily::CPPNewAligned}},      // new(unsigned long, align_val_t)
-    {LibFunc_ZnwmSt11align_val_t10hot_cold_t,   {OpNewLike,        3, 0,  -1, 1, MallocFamily::CPPNewAligned}},       // new(unsigned long, align_val_t, hot_cold_t)
+    {LibFunc_ZnwmSt11align_val_t12__hot_cold_t,   {OpNewLike,        3, 0,  -1, 1, MallocFamily::CPPNewAligned}},       // new(unsigned long, align_val_t, __hot_cold_t)
     {LibFunc_ZnwmSt11align_val_tRKSt9nothrow_t, {MallocLike,       3,  0, -1,  1, MallocFamily::CPPNewAligned}},      // new(unsigned long, align_val_t, nothrow)
-    {LibFunc_ZnwmSt11align_val_tRKSt9nothrow_t10hot_cold_t, {MallocLike,  4, 0,  -1, 1, MallocFamily::CPPNewAligned}},            // new(unsigned long, align_val_t, nothrow, hot_cold_t)
+    {LibFunc_ZnwmSt11align_val_tRKSt9nothrow_t12__hot_cold_t, {MallocLike,  4, 0,  -1, 1, MallocFamily::CPPNewAligned}},            // new(unsigned long, align_val_t, nothrow, __hot_cold_t)
     {LibFunc_Znaj,                              {OpNewLike,        1,  0, -1, -1, MallocFamily::CPPNewArray}},        // new[](unsigned int)
     {LibFunc_ZnajRKSt9nothrow_t,                {MallocLike,       2,  0, -1, -1, MallocFamily::CPPNewArray}},        // new[](unsigned int, nothrow)
     {LibFunc_ZnajSt11align_val_t,               {OpNewLike,        2,  0, -1,  1, MallocFamily::CPPNewArrayAligned}}, // new[](unsigned int, align_val_t)
     {LibFunc_ZnajSt11align_val_tRKSt9nothrow_t, {MallocLike,       3,  0, -1,  1, MallocFamily::CPPNewArrayAligned}}, // new[](unsigned int, align_val_t, nothrow)
     {LibFunc_Znam,                              {OpNewLike,        1,  0, -1, -1, MallocFamily::CPPNewArray}},        // new[](unsigned long)
-    {LibFunc_Znam10hot_cold_t,                  {OpNewLike,        2, 0,  -1, -1, MallocFamily::CPPNew}},             // new[](unsigned long, hot_cold_t)
+    {LibFunc_Znam12__hot_cold_t,                  {OpNewLike,        2, 0,  -1, -1, MallocFamily::CPPNew}},             // new[](unsigned long, __hot_cold_t)
     {LibFunc_ZnamRKSt9nothrow_t,                {MallocLike,       2,  0, -1, -1, MallocFamily::CPPNewArray}},        // new[](unsigned long, nothrow)
-    {LibFunc_ZnamRKSt9nothrow_t10hot_cold_t,      {MallocLike,       3, 0,  -1, -1, MallocFamily::CPPNew}},             // new[](unsigned long, nothrow, hot_cold_t)
+    {LibFunc_ZnamRKSt9nothrow_t12__hot_cold_t,      {MallocLike,       3, 0,  -1, -1, MallocFamily::CPPNew}},             // new[](unsigned long, nothrow, __hot_cold_t)
     {LibFunc_ZnamSt11align_val_t,               {OpNewLike,        2,  0, -1,  1, MallocFamily::CPPNewArrayAligned}}, // new[](unsigned long, align_val_t)
-    {LibFunc_ZnamSt11align_val_t10hot_cold_t,   {OpNewLike,        3, 0,  -1, 1, MallocFamily::CPPNewAligned}},       // new[](unsigned long, align_val_t, hot_cold_t)
+    {LibFunc_ZnamSt11align_val_t12__hot_cold_t,   {OpNewLike,        3, 0,  -1, 1, MallocFamily::CPPNewAligned}},       // new[](unsigned long, align_val_t, __hot_cold_t)
     {LibFunc_ZnamSt11align_val_tRKSt9nothrow_t, {MallocLike,       3,  0, -1,  1, MallocFamily::CPPNewArrayAligned}}, // new[](unsigned long, align_val_t, nothrow)
-    {LibFunc_ZnamSt11align_val_tRKSt9nothrow_t10hot_cold_t, {MallocLike,  4, 0,  -1, 1, MallocFamily::CPPNewAligned}},            // new[](unsigned long, align_val_t, nothrow, hot_cold_t)
+    {LibFunc_ZnamSt11align_val_tRKSt9nothrow_t12__hot_cold_t, {MallocLike,  4, 0,  -1, 1, MallocFamily::CPPNewAligned}},            // new[](unsigned long, align_val_t, nothrow, __hot_cold_t)
     {LibFunc_msvc_new_int,                      {OpNewLike,        1,  0, -1, -1, MallocFamily::MSVCNew}},            // new(unsigned int)
     {LibFunc_msvc_new_int_nothrow,              {MallocLike,       2,  0, -1, -1, MallocFamily::MSVCNew}},            // new(unsigned int, nothrow)
     {LibFunc_msvc_new_longlong,                 {OpNewLike,        1,  0, -1, -1, MallocFamily::MSVCNew}},            // new(unsigned long long)
     {LibFunc_msvc_new_longlong_nothrow,         {MallocLike,       2,  0, -1, -1, MallocFamily::MSVCNew}},            // new(unsigned long long, nothrow)
     {LibFunc_msvc_new_array_int,                {OpNewLike,        1,  0, -1, -1, MallocFamily::MSVCArrayNew}},       // new[](unsigned int)
     {LibFunc_msvc_new_array_int_nothrow,        {MallocLike,       2,  0, -1, -1, MallocFamily::MSVCArrayNew}},       // new[](unsigned int, nothrow)
     {LibFunc_msvc_new_array_longlong,           {OpNewLike,        1,  0, -1, -1, MallocFamily::MSVCArrayNew}},       // new[](unsigned long long)
     {LibFunc_msvc_new_array_longlong_nothrow,   {MallocLike,       2,  0, -1, -1, MallocFamily::MSVCArrayNew}},       // new[](unsigned long long, nothrow)

llvm/lib/Analysis/TargetLibraryInfo.cpp

if (T.isOSMSVCRT()) {
     TLI.setUnavailable(LibFunc_ZdlPvm);
     TLI.setUnavailable(LibFunc_ZdlPvmSt11align_val_t);
     TLI.setUnavailable(LibFunc_Znaj);
     TLI.setUnavailable(LibFunc_ZnajRKSt9nothrow_t);
     TLI.setUnavailable(LibFunc_ZnajSt11align_val_t);
     TLI.setUnavailable(LibFunc_ZnajSt11align_val_tRKSt9nothrow_t);
     TLI.setUnavailable(LibFunc_Znam);
     TLI.setUnavailable(LibFunc_ZnamRKSt9nothrow_t);
-    TLI.setUnavailable(LibFunc_ZnamRKSt9nothrow_t10hot_cold_t);
+    TLI.setUnavailable(LibFunc_ZnamRKSt9nothrow_t12__hot_cold_t);
     TLI.setUnavailable(LibFunc_ZnamSt11align_val_t);
     TLI.setUnavailable(LibFunc_ZnamSt11align_val_tRKSt9nothrow_t);
     TLI.setUnavailable(LibFunc_Znwj);
     TLI.setUnavailable(LibFunc_ZnwjRKSt9nothrow_t);
     TLI.setUnavailable(LibFunc_ZnwjSt11align_val_t);
     TLI.setUnavailable(LibFunc_ZnwjSt11align_val_tRKSt9nothrow_t);
     TLI.setUnavailable(LibFunc_Znwm);
     TLI.setUnavailable(LibFunc_ZnwmRKSt9nothrow_t);
-    TLI.setUnavailable(LibFunc_ZnwmRKSt9nothrow_t10hot_cold_t);
+    TLI.setUnavailable(LibFunc_ZnwmRKSt9nothrow_t12__hot_cold_t);
     TLI.setUnavailable(LibFunc_ZnwmSt11align_val_t);
     TLI.setUnavailable(LibFunc_ZnwmSt11align_val_tRKSt9nothrow_t);
-    TLI.setUnavailable(LibFunc_Znwm10hot_cold_t);
-    TLI.setUnavailable(LibFunc_ZnwmSt11align_val_t10hot_cold_t);
-    TLI.setUnavailable(LibFunc_ZnwmSt11align_val_tRKSt9nothrow_t10hot_cold_t);
-    TLI.setUnavailable(LibFunc_Znam10hot_cold_t);
-    TLI.setUnavailable(LibFunc_ZnamSt11align_val_t10hot_cold_t);
-    TLI.setUnavailable(LibFunc_ZnamSt11align_val_tRKSt9nothrow_t10hot_cold_t);
+    TLI.setUnavailable(LibFunc_Znwm12__hot_cold_t);
+    TLI.setUnavailable(LibFunc_ZnwmSt11align_val_t12__hot_cold_t);
+    TLI.setUnavailable(LibFunc_ZnwmSt11align_val_tRKSt9nothrow_t12__hot_cold_t);
+    TLI.setUnavailable(LibFunc_Znam12__hot_cold_t);
+    TLI.setUnavailable(LibFunc_ZnamSt11align_val_t12__hot_cold_t);
+    TLI.setUnavailable(LibFunc_ZnamSt11align_val_tRKSt9nothrow_t12__hot_cold_t);
   } else {
     // Not MSVC, assume it's Itanium.
     TLI.setUnavailable(LibFunc_msvc_new_int);
     TLI.setUnavailable(LibFunc_msvc_new_int_nothrow);
     TLI.setUnavailable(LibFunc_msvc_new_longlong);
     TLI.setUnavailable(LibFunc_msvc_new_longlong_nothrow);
     TLI.setUnavailable(LibFunc_msvc_delete_ptr32);
     TLI.setUnavailable(LibFunc_msvc_delete_ptr32_nothrow);

llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp

 Value *LibCallSimplifier::optimizeRealloc(CallInst *CI, IRBuilderBase &B) {
   if (isa<ConstantPointerNull>(CI->getArgOperand(0)))
     return copyFlags(*CI, emitMalloc(CI->getArgOperand(1), B, DL, TLI));
 
   return nullptr;
 }
 
 // When enabled, replace operator new() calls marked with a hot or cold memprof
-// attribute with an operator new() call that takes a hot_cold_t parameter.
+// attribute with an operator new() call that takes a __hot_cold_t parameter.
 // Currently this is supported by the open source version of tcmalloc, see:
 // https://github.com/google/tcmalloc/blob/master/tcmalloc/new_extension.h
 Value *LibCallSimplifier::optimizeNew(CallInst *CI, IRBuilderBase &B,
                                       LibFunc &Func) {
   if (!OptimizeHotColdNew)
     return nullptr;
 
   uint8_t HotCold;
   if (CI->getAttributes().getFnAttr("memprof").getValueAsString() == "cold")
     HotCold = 0; // Coldest setting.
   else if (CI->getAttributes().getFnAttr("memprof").getValueAsString() == "hot")
     HotCold = 255; // Hottest setting.
   else
     return nullptr;
 
   switch (Func) {
   case LibFunc_Znwm:
     return emitHotColdNew(CI->getArgOperand(0), B, TLI,
-                          LibFunc_Znwm10hot_cold_t, HotCold);
+                          LibFunc_Znwm12__hot_cold_t, HotCold);
   case LibFunc_Znam:
     return emitHotColdNew(CI->getArgOperand(0), B, TLI,
-                          LibFunc_Znam10hot_cold_t, HotCold);
+                          LibFunc_Znam12__hot_cold_t, HotCold);
   case LibFunc_ZnwmRKSt9nothrow_t:
     return emitHotColdNewNoThrow(CI->getArgOperand(0), CI->getArgOperand(1), B,
-                                 TLI, LibFunc_ZnwmRKSt9nothrow_t10hot_cold_t,
+                                 TLI, LibFunc_ZnwmRKSt9nothrow_t12__hot_cold_t,
                                  HotCold);
   case LibFunc_ZnamRKSt9nothrow_t:
     return emitHotColdNewNoThrow(CI->getArgOperand(0), CI->getArgOperand(1), B,
-                                 TLI, LibFunc_ZnamRKSt9nothrow_t10hot_cold_t,
+                                 TLI, LibFunc_ZnamRKSt9nothrow_t12__hot_cold_t,
                                  HotCold);
   case LibFunc_ZnwmSt11align_val_t:
     return emitHotColdNewAligned(CI->getArgOperand(0), CI->getArgOperand(1), B,
-                                 TLI, LibFunc_ZnwmSt11align_val_t10hot_cold_t,
+                                 TLI, LibFunc_ZnwmSt11align_val_t12__hot_cold_t,
                                  HotCold);
   case LibFunc_ZnamSt11align_val_t:
     return emitHotColdNewAligned(CI->getArgOperand(0), CI->getArgOperand(1), B,
-                                 TLI, LibFunc_ZnamSt11align_val_t10hot_cold_t,
+                                 TLI, LibFunc_ZnamSt11align_val_t12__hot_cold_t,
                                  HotCold);
   case LibFunc_ZnwmSt11align_val_tRKSt9nothrow_t:
     return emitHotColdNewAlignedNoThrow(
         CI->getArgOperand(0), CI->getArgOperand(1), CI->getArgOperand(2), B,
-        TLI, LibFunc_ZnwmSt11align_val_tRKSt9nothrow_t10hot_cold_t, HotCold);
+        TLI, LibFunc_ZnwmSt11align_val_tRKSt9nothrow_t12__hot_cold_t, HotCold);
   case LibFunc_ZnamSt11align_val_tRKSt9nothrow_t:
     return emitHotColdNewAlignedNoThrow(
         CI->getArgOperand(0), CI->getArgOperand(1), CI->getArgOperand(2), B,
-        TLI, LibFunc_ZnamSt11align_val_tRKSt9nothrow_t10hot_cold_t, HotCold);
+        TLI, LibFunc_ZnamSt11align_val_tRKSt9nothrow_t12__hot_cold_t, HotCold);
   default:
     return nullptr;
   }
 }
 
 //===----------------------------------------------------------------------===//
 // Math Library Optimizations
 //===----------------------------------------------------------------------===//

llvm/test/Transforms/InstCombine/simplify-libcalls-new.ll

 ; RUN: opt < %s -passes=instcombine -S | FileCheck %s --implicit-check-not=hot_cold_t
 ; RUN: opt < %s -passes=instcombine -optimize-hot-cold-new -S | FileCheck %s --check-prefix=HOTCOLD
 
 ;; Check that operator new(unsigned long) converted to
-;; operator new(unsigned long, hot_cold_t) with a hot or cold attribute.
+;; operator new(unsigned long, __hot_cold_t) with a hot or cold attribute.
 ; HOTCOLD-LABEL: @new()
 define void @new() {
-  ;; Attribute cold converted to hot_cold_t value 0 (coldest).
-  ; HOTCOLD: @_Znwm10hot_cold_t(i64 10, i8 0)
+  ;; Attribute cold converted to __hot_cold_t value 0 (coldest).
+  ; HOTCOLD: @_Znwm12__hot_cold_t(i64 10, i8 0)
   %call = call ptr @_Znwm(i64 10) #0
   call void @dummy(ptr %call)
   ;; Attribute notcold has no effect.
   ; HOTCOLD: @_Znwm(i64 10)
   %call1 = call ptr @_Znwm(i64 10) #1
   call void @dummy(ptr %call1)
-  ;; Attribute hot converted to hot_cold_t value 255 (-1) (hottest).
-  ; HOTCOLD: @_Znwm10hot_cold_t(i64 10, i8 -1)
+  ;; Attribute hot converted to __hot_cold_t value 255 (-1) (hottest).
+  ; HOTCOLD: @_Znwm12__hot_cold_t(i64 10, i8 -1)
   %call2 = call ptr @_Znwm(i64 10) #2
   call void @dummy(ptr %call2)
   ret void
 }
 
 ;; Check that operator new(unsigned long, std::align_val_t) converted to
-;; operator new(unsigned long, std::align_val_t, hot_cold_t) with a hot or
+;; operator new(unsigned long, std::align_val_t, __hot_cold_t) with a hot or
 ;; cold attribute.
 ; HOTCOLD-LABEL: @new_align()
 define void @new_align() {
-  ;; Attribute cold converted to hot_cold_t value 0 (coldest).
-  ; HOTCOLD: @_ZnwmSt11align_val_t10hot_cold_t(i64 10, i64 8, i8 0)
+  ;; Attribute cold converted to __hot_cold_t value 0 (coldest).
+  ; HOTCOLD: @_ZnwmSt11align_val_t12__hot_cold_t(i64 10, i64 8, i8 0)
   %call = call ptr @_ZnwmSt11align_val_t(i64 10, i64 8) #0
   call void @dummy(ptr %call)
   ;; Attribute notcold has no effect.
   ; HOTCOLD: @_ZnwmSt11align_val_t(i64 10, i64 8)
   %call1 = call ptr @_ZnwmSt11align_val_t(i64 10, i64 8) #1
   call void @dummy(ptr %call1)
-  ;; Attribute hot converted to hot_cold_t value 255 (-1) (hottest).
-  ; HOTCOLD: @_ZnwmSt11align_val_t10hot_cold_t(i64 10, i64 8, i8 -1)
+  ;; Attribute hot converted to __hot_cold_t value 255 (-1) (hottest).
+  ; HOTCOLD: @_ZnwmSt11align_val_t12__hot_cold_t(i64 10, i64 8, i8 -1)
   %call2 = call ptr @_ZnwmSt11align_val_t(i64 10, i64 8) #2
   call void @dummy(ptr %call2)
   ret void
 }
 
 ;; Check that operator new(unsigned long, const std::nothrow_t&) converted to
-;; operator new(unsigned long, const std::nothrow_t&, hot_cold_t) with a hot or
+;; operator new(unsigned long, const std::nothrow_t&, __hot_cold_t) with a hot or
 ;; cold attribute.
 ; HOTCOLD-LABEL: @new_nothrow()
 define void @new_nothrow() {
   %nt = alloca i8
-  ;; Attribute cold converted to hot_cold_t value 0 (coldest).
-  ; HOTCOLD: @_ZnwmRKSt9nothrow_t10hot_cold_t(i64 10, ptr nonnull %nt, i8 0)
+  ;; Attribute cold converted to __hot_cold_t value 0 (coldest).
+  ; HOTCOLD: @_ZnwmRKSt9nothrow_t12__hot_cold_t(i64 10, ptr nonnull %nt, i8 0)
   %call = call ptr @_ZnwmRKSt9nothrow_t(i64 10, ptr %nt) #0
   call void @dummy(ptr %call)
   ;; Attribute notcold has no effect.
   ; HOTCOLD: @_ZnwmRKSt9nothrow_t(i64 10, ptr nonnull %nt)
   %call1 = call ptr @_ZnwmRKSt9nothrow_t(i64 10, ptr %nt) #1
   call void @dummy(ptr %call1)
-  ;; Attribute hot converted to hot_cold_t value 255 (-1) (hottest).
-  ; HOTCOLD: @_ZnwmRKSt9nothrow_t10hot_cold_t(i64 10, ptr nonnull %nt, i8 -1)
+  ;; Attribute hot converted to __hot_cold_t value 255 (-1) (hottest).
+  ; HOTCOLD: @_ZnwmRKSt9nothrow_t12__hot_cold_t(i64 10, ptr nonnull %nt, i8 -1)
   %call2 = call ptr @_ZnwmRKSt9nothrow_t(i64 10, ptr %nt) #2
   call void @dummy(ptr %call2)
   ret void
 }
 
 ;; Check that operator new(unsigned long, std::align_val_t, const std::nothrow_t&)
 ;; converted to
-;; operator new(unsigned long, std::align_val_t, const std::nothrow_t&, hot_cold_t)
+;; operator new(unsigned long, std::align_val_t, const std::nothrow_t&, __hot_cold_t)
 ;; with a hot or cold attribute.
 ; HOTCOLD-LABEL: @new_align_nothrow()
 define void @new_align_nothrow() {
   %nt = alloca i8
-  ;; Attribute cold converted to hot_cold_t value 0 (coldest).
-  ; HOTCOLD: @_ZnwmSt11align_val_tRKSt9nothrow_t10hot_cold_t(i64 10, i64 8, ptr nonnull %nt, i8 0)
+  ;; Attribute cold converted to __hot_cold_t value 0 (coldest).
+  ; HOTCOLD: @_ZnwmSt11align_val_tRKSt9nothrow_t12__hot_cold_t(i64 10, i64 8, ptr nonnull %nt, i8 0)
   %call = call ptr @_ZnwmSt11align_val_tRKSt9nothrow_t(i64 10, i64 8, ptr %nt) #0
   call void @dummy(ptr %call)
   ;; Attribute notcold has no effect.
   ; HOTCOLD: @_ZnwmSt11align_val_tRKSt9nothrow_t(i64 10, i64 8, ptr nonnull %nt)
   %call1 = call ptr @_ZnwmSt11align_val_tRKSt9nothrow_t(i64 10, i64 8, ptr %nt) #1
   call void @dummy(ptr %call1)
-  ;; Attribute hot converted to hot_cold_t value 255 (-1) (hottest).
-  ; HOTCOLD: @_ZnwmSt11align_val_tRKSt9nothrow_t10hot_cold_t(i64 10, i64 8, ptr nonnull %nt, i8 -1)
+  ;; Attribute hot converted to __hot_cold_t value 255 (-1) (hottest).
+  ; HOTCOLD: @_ZnwmSt11align_val_tRKSt9nothrow_t12__hot_cold_t(i64 10, i64 8, ptr nonnull %nt, i8 -1)
   %call2 = call ptr @_ZnwmSt11align_val_tRKSt9nothrow_t(i64 10, i64 8, ptr %nt) #2
   call void @dummy(ptr %call2)
   ret void
 }
 
 ;; Check that operator new[](unsigned long) converted to
-;; operator new[](unsigned long, hot_cold_t) with a hot or cold attribute.
+;; operator new[](unsigned long, __hot_cold_t) with a hot or cold attribute.
 ; HOTCOLD-LABEL: @array_new()
 define void @array_new() {
-  ;; Attribute cold converted to hot_cold_t value 0 (coldest).
-  ; HOTCOLD: @_Znam10hot_cold_t(i64 10, i8 0)
+  ;; Attribute cold converted to __hot_cold_t value 0 (coldest).
+  ; HOTCOLD: @_Znam12__hot_cold_t(i64 10, i8 0)
   %call = call ptr @_Znam(i64 10) #0
   call void @dummy(ptr %call)
   ;; Attribute notcold has no effect.
   ; HOTCOLD: @_Znam(i64 10)
   %call1 = call ptr @_Znam(i64 10) #1
   call void @dummy(ptr %call1)
-  ;; Attribute hot converted to hot_cold_t value 255 (-1) (hottest).
-  ; HOTCOLD: @_Znam10hot_cold_t(i64 10, i8 -1)
+  ;; Attribute hot converted to __hot_cold_t value 255 (-1) (hottest).
+  ; HOTCOLD: @_Znam12__hot_cold_t(i64 10, i8 -1)
   %call2 = call ptr @_Znam(i64 10) #2
   call void @dummy(ptr %call2)
   ret void
 }
 
 ;; Check that operator new[](unsigned long, std::align_val_t) converted to
-;; operator new[](unsigned long, std::align_val_t, hot_cold_t) with a hot or
+;; operator new[](unsigned long, std::align_val_t, __hot_cold_t) with a hot or
 ;; cold attribute.
 ; HOTCOLD-LABEL: @array_new_align()
 define void @array_new_align() {
-  ;; Attribute cold converted to hot_cold_t value 0 (coldest).
-  ; HOTCOLD: @_ZnamSt11align_val_t10hot_cold_t(i64 10, i64 8, i8 0)
+  ;; Attribute cold converted to __hot_cold_t value 0 (coldest).
+  ; HOTCOLD: @_ZnamSt11align_val_t12__hot_cold_t(i64 10, i64 8, i8 0)
   %call = call ptr @_ZnamSt11align_val_t(i64 10, i64 8) #0
   call void @dummy(ptr %call)
   ;; Attribute notcold has no effect.
   ; HOTCOLD: @_ZnamSt11align_val_t(i64 10, i64 8)
   %call1 = call ptr @_ZnamSt11align_val_t(i64 10, i64 8) #1
   call void @dummy(ptr %call1)
-  ;; Attribute hot converted to hot_cold_t value 255 (-1) (hottest).
-  ; HOTCOLD: @_ZnamSt11align_val_t10hot_cold_t(i64 10, i64 8, i8 -1)
+  ;; Attribute hot converted to __hot_cold_t value 255 (-1) (hottest).
+  ; HOTCOLD: @_ZnamSt11align_val_t12__hot_cold_t(i64 10, i64 8, i8 -1)
   %call2 = call ptr @_ZnamSt11align_val_t(i64 10, i64 8) #2
   call void @dummy(ptr %call2)
   ret void
 }
 
 ;; Check that operator new[](unsigned long, const std::nothrow_t&) converted to
-;; operator new[](unsigned long, const std::nothrow_t&, hot_cold_t) with a hot or
+;; operator new[](unsigned long, const std::nothrow_t&, __hot_cold_t) with a hot or
 ;; cold attribute.
 ; HOTCOLD-LABEL: @array_new_nothrow()
 define void @array_new_nothrow() {
   %nt = alloca i8
-  ;; Attribute cold converted to hot_cold_t value 0 (coldest).
-  ; HOTCOLD: @_ZnamRKSt9nothrow_t10hot_cold_t(i64 10, ptr nonnull %nt, i8 0)
+  ;; Attribute cold converted to __hot_cold_t value 0 (coldest).
+  ; HOTCOLD: @_ZnamRKSt9nothrow_t12__hot_cold_t(i64 10, ptr nonnull %nt, i8 0)
   %call = call ptr @_ZnamRKSt9nothrow_t(i64 10, ptr %nt) #0
   call void @dummy(ptr %call)
   ;; Attribute notcold has no effect.
   ; HOTCOLD: @_ZnamRKSt9nothrow_t(i64 10, ptr nonnull %nt)
   %call1 = call ptr @_ZnamRKSt9nothrow_t(i64 10, ptr %nt) #1
   call void @dummy(ptr %call1)
-  ;; Attribute hot converted to hot_cold_t value 255 (-1) (hottest).
-  ; HOTCOLD: @_ZnamRKSt9nothrow_t10hot_cold_t(i64 10, ptr nonnull %nt, i8 -1)
+  ;; Attribute hot converted to __hot_cold_t value 255 (-1) (hottest).
+  ; HOTCOLD: @_ZnamRKSt9nothrow_t12__hot_cold_t(i64 10, ptr nonnull %nt, i8 -1)
   %call2 = call ptr @_ZnamRKSt9nothrow_t(i64 10, ptr %nt) #2
   call void @dummy(ptr %call2)
   ret void
 }
 
 ;; Check that operator new[](unsigned long, std::align_val_t, const std::nothrow_t&)
 ;; converted to
-;; operator new[](unsigned long, std::align_val_t, const std::nothrow_t&, hot_cold_t)
+;; operator new[](unsigned long, std::align_val_t, const std::nothrow_t&, __hot_cold_t)
 ;; with a hot or cold attribute.
 ; HOTCOLD-LABEL: @array_new_align_nothrow()
 define void @array_new_align_nothrow() {
   %nt = alloca i8
-  ;; Attribute cold converted to hot_cold_t value 0 (coldest).
-  ; HOTCOLD: @_ZnamSt11align_val_tRKSt9nothrow_t10hot_cold_t(i64 10, i64 8, ptr nonnull %nt, i8 0)
+  ;; Attribute cold converted to __hot_cold_t value 0 (coldest).
+  ; HOTCOLD: @_ZnamSt11align_val_tRKSt9nothrow_t12__hot_cold_t(i64 10, i64 8, ptr nonnull %nt, i8 0)
   %call = call ptr @_ZnamSt11align_val_tRKSt9nothrow_t(i64 10, i64 8, ptr %nt) #0
   call void @dummy(ptr %call)
   ;; Attribute notcold has no effect.
   ; HOTCOLD: @_ZnamSt11align_val_tRKSt9nothrow_t(i64 10, i64 8, ptr nonnull %nt)
   %call1 = call ptr @_ZnamSt11align_val_tRKSt9nothrow_t(i64 10, i64 8, ptr %nt) #1
   call void @dummy(ptr %call1)
-  ;; Attribute hot converted to hot_cold_t value 255 (-1) (hottest).
-  ; HOTCOLD: @_ZnamSt11align_val_tRKSt9nothrow_t10hot_cold_t(i64 10, i64 8, ptr nonnull %nt, i8 -1)
+  ;; Attribute hot converted to __hot_cold_t value 255 (-1) (hottest).
+  ; HOTCOLD: @_ZnamSt11align_val_tRKSt9nothrow_t12__hot_cold_t(i64 10, i64 8, ptr nonnull %nt, i8 -1)
   %call2 = call ptr @_ZnamSt11align_val_tRKSt9nothrow_t(i64 10, i64 8, ptr %nt) #2
   call void @dummy(ptr %call2)
   ret void
 }
 
 ;; So that instcombine doesn't optimize out the call.
 declare void @dummy(ptr)
 

llvm/test/tools/llvm-tli-checker/ps4-tli-check.yaml

 # RUN: FileCheck %s --check-prefix=UNAVAIL --input-file %t3.txt
 #
 # CHECK: << Total TLI yes SDK no:  8
 # CHECK: >> Total TLI no  SDK yes: 0
 # CHECK: == Total TLI yes SDK yes: 235
 #
 # WRONG_DETAIL: << TLI yes SDK no : '_ZdaPv' aka operator delete[](void*)
 # WRONG_DETAIL: >> TLI no  SDK yes: '_ZdaPvj' aka operator delete[](void*, unsigned int)
-# WRONG_DETAIL-COUNT-8: << TLI yes SDK no : {{.*}}hot_cold_t
+# WRONG_DETAIL-COUNT-8: << TLI yes SDK no : {{.*}}__hot_cold_t
 # WRONG_SUMMARY: << Total TLI yes SDK no:  9{{$}}
 # WRONG_SUMMARY: >> Total TLI no  SDK yes: 1{{$}}
 # WRONG_SUMMARY: == Total TLI yes SDK yes: 234
 #
 ## The -COUNT suffix doesn't care if there are too many matches, so check
 ## the exact count first; the two directives should add up to that.
 ## Yes, this means additions to TLI will fail this test, but the argument
 ## to -COUNT can't be an expression.

llvm/unittests/Analysis/TargetLibraryInfoTest.cpp

parseAssembly(
       "declare void @_ZdlPvjSt11align_val_t(i8*, i32, i32)\n"
       "declare void @_ZdlPvm(i8*, i64)\n"
       "declare void @_ZdlPvmSt11align_val_t(i8*, i64, i64)\n"
       "declare i8* @_Znaj(i32)\n"
       "declare i8* @_ZnajRKSt9nothrow_t(i32, %struct*)\n"
       "declare i8* @_ZnajSt11align_val_t(i32, i32)\n"
       "declare i8* @_ZnajSt11align_val_tRKSt9nothrow_t(i32, i32, %struct*)\n"
       "declare i8* @_Znam(i64)\n"
-      "declare i8* @_Znam10hot_cold_t(i64, i8)\n"
+      "declare i8* @_Znam12__hot_cold_t(i64, i8)\n"
       "declare i8* @_ZnamRKSt9nothrow_t(i64, %struct*)\n"
-      "declare i8* @_ZnamRKSt9nothrow_t10hot_cold_t(i64, %struct*, i8)\n"
+      "declare i8* @_ZnamRKSt9nothrow_t12__hot_cold_t(i64, %struct*, i8)\n"
       "declare i8* @_ZnamSt11align_val_t(i64, i64)\n"
-      "declare i8* @_ZnamSt11align_val_t10hot_cold_t(i64, i64, i8)\n"
+      "declare i8* @_ZnamSt11align_val_t12__hot_cold_t(i64, i64, i8)\n"
       "declare i8* @_ZnamSt11align_val_tRKSt9nothrow_t(i64, i64, %struct*)\n"
-      "declare i8* @_ZnamSt11align_val_tRKSt9nothrow_t10hot_cold_t(i64, i64, "
+      "declare i8* @_ZnamSt11align_val_tRKSt9nothrow_t12__hot_cold_t(i64, i64, "
       "%struct*, i8)\n"
       "declare i8* @_Znwj(i32)\n"
       "declare i8* @_ZnwjRKSt9nothrow_t(i32, %struct*)\n"
       "declare i8* @_ZnwjSt11align_val_t(i32, i32)\n"
       "declare i8* @_ZnwjSt11align_val_tRKSt9nothrow_t(i32, i32, %struct*)\n"
       "declare i8* @_Znwm(i64)\n"
-      "declare i8* @_Znwm10hot_cold_t(i64, i8)\n"
+      "declare i8* @_Znwm12__hot_cold_t(i64, i8)\n"
       "declare i8* @_ZnwmRKSt9nothrow_t(i64, %struct*)\n"
-      "declare i8* @_ZnwmRKSt9nothrow_t10hot_cold_t(i64, %struct*, i8)\n"
+      "declare i8* @_ZnwmRKSt9nothrow_t12__hot_cold_t(i64, %struct*, i8)\n"
       "declare i8* @_ZnwmSt11align_val_t(i64, i64)\n"
-      "declare i8* @_ZnwmSt11align_val_t10hot_cold_t(i64, i64, i8)\n"
+      "declare i8* @_ZnwmSt11align_val_t12__hot_cold_t(i64, i64, i8)\n"
       "declare i8* @_ZnwmSt11align_val_tRKSt9nothrow_t(i64, i64, %struct*)\n"
-      "declare i8* @_ZnwmSt11align_val_tRKSt9nothrow_t10hot_cold_t(i64, i64, "
+      "declare i8* @_ZnwmSt11align_val_tRKSt9nothrow_t12__hot_cold_t(i64, i64, "
       "%struct*, i8)\n"
 
       "declare void @\"??3@YAXPEAX@Z\"(i8*)\n"
       "declare void @\"??3@YAXPEAXAEBUnothrow_t@std@@@Z\"(i8*, %struct*)\n"
       "declare void @\"??3@YAXPEAX_K@Z\"(i8*, i64)\n"
       "declare void @\"??_V@YAXPEAX@Z\"(i8*)\n"
       "declare void @\"??_V@YAXPEAXAEBUnothrow_t@std@@@Z\"(i8*, %struct*)\n"
       "declare void @\"??_V@YAXPEAX_K@Z\"(i8*, i64)\n"