[PGO] profile runtime naming cleanups

[davidxl]

Summary

In this patch a couple of naming cleanups are made:

1. Value profile enumerator change to match LLVM code
2. ProfData new member field name change to match LLVM code
3. ProfData member type change to match LLVM code
4. Do not use lower case for types that are internal to implementation (not exposed to APIs)

There is no functional change. This is a preparation patch to enable more code sharing in follow up patches.

[betulb]

lib/profile/InstrProfiling.h

40 ↗

(On Diff #40697)

Extra line. Please remove.

51 ↗

(On Diff #40697)

Please remove the __llvm_profile_value_node struct.

123 ↗

(On Diff #40697)

Remove the reference to __llvm_profile_value_node.

[davidxl]

All addressed.

[davidxl]

Updated patch addressing Betul's comments.

[betulb]

LGTM

compiler-rt/trunk/lib/profile/InstrProfiling.h

 
 #else /* defined(__FreeBSD__) && defined(__i386__) */
 
 #include <inttypes.h>
 #include <stdint.h>
 
 #endif /* defined(__FreeBSD__) && defined(__i386__) */
 
-typedef enum ValueKind {
-  VK_IndirectCallTarget = 0,
-  VK_FIRST = VK_IndirectCallTarget,
-  VK_LAST = VK_IndirectCallTarget
-} __llvm_profile_value_kind;
+enum ValueKind {
+  IPVK_IndirectCallTarget = 0,
+  IPVK_First = IPVK_IndirectCallTarget,
+  IPVK_Last = IPVK_IndirectCallTarget
+};
 
 typedef struct __llvm_profile_value_data {
   uint64_t TargetValue;
   uint64_t NumTaken;
 } __llvm_profile_value_data;
 
-typedef struct __llvm_profile_value_node {
-  __llvm_profile_value_data VData;
-  struct __llvm_profile_value_node *Next;
-} __llvm_profile_value_node;
-
+typedef void *IntPtrT;
 typedef struct LLVM_ALIGNAS(8) __llvm_profile_data {
   const uint32_t NameSize;
   const uint32_t NumCounters;
   const uint64_t FuncHash;
-  const char *const NamePtr;
-  uint64_t *const CounterPtr;
-  const uint8_t *FunctionPointer;
-  __llvm_profile_value_node **ValueCounters;
-  const uint16_t NumValueSites[VK_LAST + 1];
+  const IntPtrT NamePtr;
+  const IntPtrT CounterPtr;
+  const IntPtrT FunctionPointer;
+  IntPtrT Values;
+  const uint16_t NumValueSites[IPVK_Last + 1];
 } __llvm_profile_data;
 
 typedef struct __llvm_profile_header {
   uint64_t Magic;
   uint64_t Version;
   uint64_t DataSize;
   uint64_t CountersSize;
   uint64_t NamesSize;

 void __llvm_profile_reset_counters(void);
 
 /*!
  * \brief Counts the number of times a target value is seen.
  *
  * Records the target value for the CounterIndex if not seen before. Otherwise,
  * increments the counter associated w/ the target value.
  */
-void __llvm_profile_instrument_target(uint64_t TargetValue,
-  void *Data_, uint32_t CounterIndex);
+void __llvm_profile_instrument_target(uint64_t TargetValue, void *Data,
+                                      uint32_t CounterIndex);
 
 /*!
  * \brief Prepares the value profiling data for output.
  *
  * Prepares a single __llvm_profile_value_data array out of the many
- * __llvm_profile_value_node trees (one per instrumented function).
+ * ValueProfNode trees (one per instrumented function).
  */
 uint64_t __llvm_profile_gather_value_data(uint8_t **DataArray);
 
 /*!
  * \brief Write instrumentation data to the current file.
  *
  * Writes to the file with the last name given to \a __llvm_profile_set_filename(),
  * or if it hasn't been called, the \c LLVM_PROFILE_FILE environment variable,

compiler-rt/trunk/lib/profile/InstrProfiling.c

 /*===- InstrProfiling.c - Support library for PGO instrumentation ---------===*\
 |*
 |*                     The LLVM Compiler Infrastructure
 |*
 |* This file is distributed under the University of Illinois Open Source
 |* License. See LICENSE.TXT for details.
 |*
 \*===----------------------------------------------------------------------===*/
 
 #include "InstrProfiling.h"
 #include <limits.h>
 #include <stdlib.h>
 #include <string.h>
 
+typedef struct ValueProfNode {
+  __llvm_profile_value_data VData;
+  struct ValueProfNode *Next;
+} ValueProfNode;
+
 __attribute__((visibility("hidden"))) uint64_t __llvm_profile_get_magic(void) {
   /* Magic number to detect file format and endianness.
    *
    * Use 255 at one end, since no UTF-8 file can use that character.  Avoid 0,
    * so that utilities, like strings, don't grab it as a string.  129 is also
    * invalid UTF-8, and high enough to be interesting.
    *
    * Use "lprofr" in the centre to stand for "LLVM Profile Raw", or "lprofR"
__attribute__((visibility("hidden"))) void __llvm_profile_reset_counters(void) {
   memset(I, 0, sizeof(uint64_t) * (E - I));
 
   const __llvm_profile_data *DataBegin = __llvm_profile_begin_data();
   const __llvm_profile_data *DataEnd = __llvm_profile_end_data();
   const __llvm_profile_data *DI;
   for (DI = DataBegin; DI != DataEnd; ++DI) {
     uint64_t CurrentVSiteCount = 0;
     uint32_t VKI, i;
-    if (!DI->ValueCounters)
+    if (!DI->Values)
       continue;
 
-    for (VKI = VK_FIRST; VKI <= VK_LAST; ++VKI)
+    ValueProfNode **ValueCounters = (ValueProfNode **)DI->Values;
+
+    for (VKI = IPVK_First; VKI <= IPVK_Last; ++VKI)
       CurrentVSiteCount += DI->NumValueSites[VKI];
 
     for (i = 0; i < CurrentVSiteCount; ++i) {
-      __llvm_profile_value_node *CurrentVNode = DI->ValueCounters[i];
+      ValueProfNode *CurrentVNode = ValueCounters[i];
 
       while (CurrentVNode) {
         CurrentVNode->VData.NumTaken = 0;
         CurrentVNode = CurrentVNode->Next;
       }
     }
   }
 }

  * value profile counter nodes. The number of element of the array
  * is the total number of value profile sites instrumented. Returns
  *  0 if allocation fails.
  */
 
 static int allocateValueProfileCounters(__llvm_profile_data *Data) {
   uint64_t NumVSites = 0;
   uint32_t VKI;
-  for (VKI = VK_FIRST; VKI <= VK_LAST; ++VKI)
+  for (VKI = IPVK_First; VKI <= IPVK_Last; ++VKI)
     NumVSites += Data->NumValueSites[VKI];
 
-  __llvm_profile_value_node **Mem = (__llvm_profile_value_node **)calloc(
-      NumVSites, sizeof(__llvm_profile_value_node *));
+  ValueProfNode **Mem =
+      (ValueProfNode **)calloc(NumVSites, sizeof(ValueProfNode *));
   if (!Mem)
     return 0;
-  if (!__sync_bool_compare_and_swap(&Data->ValueCounters, 0, Mem)) {
+  if (!__sync_bool_compare_and_swap(&Data->Values, 0, Mem)) {
     free(Mem);
     return 0;
   }
   /*  In the raw format, there will be an value count array preceding
    *  the value profile data. The element type of the array is uint8_t,
    *  and there is one element in array per value site. The element
    *  stores the number of values profiled for the corresponding site.
    */
   uint8_t Padding = __llvm_profile_get_num_padding_bytes(NumVSites);
   __sync_fetch_and_add(&TotalValueDataSize, NumVSites + Padding);
   return 1;
 }
 
 __attribute__((visibility("hidden"))) void
-__llvm_profile_instrument_target(uint64_t TargetValue, void *Data_,
+__llvm_profile_instrument_target(uint64_t TargetValue, void *Data,
                                  uint32_t CounterIndex) {
 
-  __llvm_profile_data *Data = (__llvm_profile_data *)Data_;
-  if (!Data)
+  __llvm_profile_data *VData = (__llvm_profile_data *)Data;
+  if (!VData)
     return;
 
-  if (!Data->ValueCounters) {
-    if (!allocateValueProfileCounters(Data))
+  if (!VData->Values) {
+    if (!allocateValueProfileCounters(VData))
       return;
   }
 
-  __llvm_profile_value_node *PrevVNode = NULL;
-  __llvm_profile_value_node *CurrentVNode = Data->ValueCounters[CounterIndex];
+  ValueProfNode **ValueCounters = (ValueProfNode **)VData->Values;
+  ValueProfNode *PrevVNode = NULL;
+  ValueProfNode *CurrentVNode = ValueCounters[CounterIndex];
 
   uint8_t VDataCount = 0;
   while (CurrentVNode) {
     if (TargetValue == CurrentVNode->VData.TargetValue) {
       CurrentVNode->VData.NumTaken++;
       return;
     }
     PrevVNode = CurrentVNode;
     CurrentVNode = CurrentVNode->Next;
     ++VDataCount;
   }
 
   if (VDataCount >= UCHAR_MAX)
     return;
 
-  CurrentVNode =
-      (__llvm_profile_value_node *)calloc(1, sizeof(__llvm_profile_value_node));
+  CurrentVNode = (ValueProfNode *)calloc(1, sizeof(ValueProfNode));
   if (!CurrentVNode)
     return;
 
   CurrentVNode->VData.TargetValue = TargetValue;
   CurrentVNode->VData.NumTaken++;
 
   uint32_t Success = 0;
-  if (!Data->ValueCounters[CounterIndex])
-    Success = __sync_bool_compare_and_swap(&(Data->ValueCounters[CounterIndex]),
-                                           0, CurrentVNode);
+  if (!ValueCounters[CounterIndex])
+    Success = __sync_bool_compare_and_swap(&ValueCounters[CounterIndex], 0,
+                                           CurrentVNode);
   else if (PrevVNode && !PrevVNode->Next)
     Success = __sync_bool_compare_and_swap(&(PrevVNode->Next), 0, CurrentVNode);
 
   if (!Success) {
     free(CurrentVNode);
     return;
   }
-  __sync_fetch_and_add(&TotalValueDataSize,
-                       Success * sizeof(__llvm_profile_value_data));
+  __sync_fetch_and_add(&TotalValueDataSize, Success * sizeof(ValueProfNode));
 }
 #endif
 
 __attribute__((visibility("hidden"))) uint64_t
 __llvm_profile_gather_value_data(uint8_t **VDataArray) {
 
   if (!VDataArray || 0 == TotalValueDataSize)
     return 0;
 
   uint64_t NumData = TotalValueDataSize;
   *VDataArray = (uint8_t *)calloc(NumData, sizeof(uint8_t));
   if (!*VDataArray)
     return 0;
 
   uint8_t *VDataEnd = *VDataArray + NumData;
   uint8_t *PerSiteCountsHead = *VDataArray;
   const __llvm_profile_data *DataEnd = __llvm_profile_end_data();
   const __llvm_profile_data *DataBegin = __llvm_profile_begin_data();
   __llvm_profile_data *I;
   for (I = (__llvm_profile_data *)DataBegin; I != DataEnd; ++I) {
 
     uint64_t NumVSites = 0;
     uint32_t VKI, i;
 
-    if (!I->ValueCounters)
+    if (!I->Values)
       continue;
 
-    for (VKI = VK_FIRST; VKI <= VK_LAST; ++VKI)
+    ValueProfNode **ValueCounters = (ValueProfNode **)I->Values;
+
+    for (VKI = IPVK_First; VKI <= IPVK_Last; ++VKI)
       NumVSites += I->NumValueSites[VKI];
     uint8_t Padding = __llvm_profile_get_num_padding_bytes(NumVSites);
 
     uint8_t *PerSiteCountPtr = PerSiteCountsHead;
     __llvm_profile_value_data *VDataPtr =
         (__llvm_profile_value_data *)(PerSiteCountPtr + NumVSites + Padding);
 
     for (i = 0; i < NumVSites; ++i) {
 
-      __llvm_profile_value_node *VNode = I->ValueCounters[i];
+      ValueProfNode *VNode = ValueCounters[i];
 
       uint8_t VDataCount = 0;
       while (VNode && ((uint8_t *)(VDataPtr + 1) <= VDataEnd)) {
         *VDataPtr = VNode->VData;
         VNode = VNode->Next;
         ++VDataPtr;
         if (++VDataCount == UCHAR_MAX)
           break;
       }
       *PerSiteCountPtr = VDataCount;
       ++PerSiteCountPtr;
     }
-    I->ValueCounters = (void *)PerSiteCountsHead;
+    I->Values = (void *)PerSiteCountsHead;
     PerSiteCountsHead = (uint8_t *)VDataPtr;
   }
   return PerSiteCountsHead - *VDataArray;
 }

compiler-rt/trunk/lib/profile/InstrProfilingWriter.c

__attribute__((visibility("hidden"))) int llvmWriteProfDataImpl(
 
   Header.Magic = __llvm_profile_get_magic();
   Header.Version = __llvm_profile_get_version();
   Header.DataSize = DataSize;
   Header.CountersSize = CountersSize;
   Header.NamesSize = NamesSize;
   Header.CountersDelta = (uintptr_t)CountersBegin;
   Header.NamesDelta = (uintptr_t)NamesBegin;
-  Header.ValueKindLast = VK_LAST;
+  Header.ValueKindLast = IPVK_Last;
   Header.ValueDataSize = ValueDataSize;
   Header.ValueDataDelta = (uintptr_t)ValueDataBegin;
 
 /* Write the data. */
 #define CHECK_write(Data, Size, Length, BuffOrFile)                            \
   do {                                                                         \
     if (Writer(Data, Size, Length, &BuffOrFile) != Length)                     \
       return -1;                                                               \