[esan|cfrag] Minor cfrag report adjustment

[zhaoqin]

Summary

Reports the struct field access info only if it has been used at least
once.

Adds type printing size limit.

Formats the cache_frag.cpp with clang-format.

[zhaoqin]

add type printing size limit

[bruening]

lib/esan/cache_frag.cpp

102 ↗

(On Diff #60771)

Please make this a named constant

[zhaoqin]

PTAL

compiler-rt/trunk/lib/esan/cache_frag.cpp

 struct CacheFragInfo {
   const char *UnitName;
   u32 NumStructs;
   StructInfo *Structs;
 };
 
 struct StructCounter {
   StructInfo *Struct;
-  u64 Count;      // The total access count of the struct.
-  u64 Ratio;      // Difference ratio for the struct layout access.
+  u64 Count; // The total access count of the struct.
+  u64 Ratio; // Difference ratio for the struct layout access.
 };
 
 // We use StructHashMap to keep track of an unique copy of StructCounter.
 typedef AddrHashMap<StructCounter, 31051> StructHashMap;
 struct Context {
   StructHashMap StructMap;
   u32 NumStructs;
   u64 TotalCount; // The total access count of all structs.
 };
 static Context *Ctx;
 
 static void reportStructSummary() {
   // FIXME: provide a better struct field access summary report.
-  Report("%s: total struct field access count = %llu\n",
-         SanitizerToolName, Ctx->TotalCount);
+  Report("%s: total struct field access count = %llu\n", SanitizerToolName,
+         Ctx->TotalCount);
 }
 
 // FIXME: we are still exploring proper ways to evaluate the difference between
 // struct field counts.  Currently, we use a simple formula to calculate the
 // difference ratio: V1/V2.
 static inline u64 computeDifferenceRatio(u64 Val1, u64 Val2) {
-  if (Val2 > Val1) { Swap(Val1, Val2); }
-  if (Val2 == 0) Val2 = 1;
+  if (Val2 > Val1) {
+    Swap(Val1, Val2);
+  }
+  if (Val2 == 0)
+    Val2 = 1;
   return (Val1 / Val2);
 }
 
 static void reportStructCounter(StructHashMap::Handle &Handle) {
+  const u32 TypePrintLimit = 512;
   const char *type, *start, *end;
   StructInfo *Struct = Handle->Struct;
   // Union field address calculation is done via bitcast instead of GEP,
   // so the count for union is always 0.
   // We skip the union report to avoid confusion.
   if (strncmp(Struct->StructName, "union.", 6) == 0)
     return;
   // Remove the '.' after class/struct during print.
   if (strncmp(Struct->StructName, "class.", 6) == 0) {
     type = "class";
     start = &Struct->StructName[6];
   } else {
     type = "struct";
     start = &Struct->StructName[7];
   }
   // Remove the suffixes with '#' during print.
   end = strchr(start, '#');
   CHECK(end != nullptr);
   Report("  %s %.*s\n", type, end - start, start);
-  Report("   size = %u, count = %llu, ratio = %llu\n",
-         Struct->Size, Handle->Count, Handle->Ratio);
+  Report("   size = %u, count = %llu, ratio = %llu\n", Struct->Size,
+         Handle->Count, Handle->Ratio);
   for (u32 i = 0; i < Struct->NumFields; ++i) {
-    Report("   #%2u: offset = %u,\t count = %llu,\t type = %s\n", i,
+    Report("   #%2u: offset = %u,\t count = %llu,\t type = %.*s\n", i,
            Struct->FieldOffsets[i], Struct->FieldCounters[i],
-           Struct->FieldTypeNames[i]);
+           TypePrintLimit, Struct->FieldTypeNames[i]);
   }
 }
 
 static void computeStructRatio(StructHashMap::Handle &Handle) {
   Handle->Ratio = 0;
   Handle->Count = Handle->Struct->FieldCounters[0];
   for (u32 i = 1; i < Handle->Struct->NumFields; ++i) {
     Handle->Count += Handle->Struct->FieldCounters[i];
     Handle->Ratio += computeDifferenceRatio(
         Handle->Struct->FieldCounters[i - 1], Handle->Struct->FieldCounters[i]);
   }
   Ctx->TotalCount += Handle->Count;
-  if (Handle->Ratio >= (u64)getFlags()->report_threshold || Verbosity() >= 1)
+  if (Handle->Ratio >= (u64)getFlags()->report_threshold ||
+      (Verbosity() >= 1 && Handle->Count > 0))
     reportStructCounter(Handle);
 }
 
 static void registerStructInfo(CacheFragInfo *CacheFrag) {
   for (u32 i = 0; i < CacheFrag->NumStructs; ++i) {
     StructInfo *Struct = &CacheFrag->Structs[i];
     StructHashMap::Handle H(&Ctx->StructMap, (uptr)Struct->FieldCounters);
     if (H.created()) {