scudo: Add a dump of primary allocation sizes to malloc_info output.

[pcc]

Summary

This will be useful for optimizing the size class map.

[merge_guards_bot]

Unit tests: pass. 62518 tests passed, 0 failed and 844 were skipped.

clang-tidy: pass.

clang-format: fail. Please format your changes with clang-format by running git-clang-format HEAD^ or applying this patch.

Build artifacts: clang-tidy.txt, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

Pre-merge checks is in beta. Report issue. Please join beta or enable it for your project.

[cryptoad]

compiler-rt/lib/scudo/standalone/wrappers_c.inc

185

Isn't this going to be huge? 128k*sizeof(uptr), so like 1mb of stack?

[pcc]

compiler-rt/lib/scudo/standalone/wrappers_c.inc

185

Yeah, I'll move it to the heap.

[pcc]

• Use heap

[pcc]

• Zero initialize array

compiler-rt/lib/scudo/standalone/tests/wrappers_c_test.cpp

EXPECT_DEATH(
       },
       "");
 }
 
 // Fuchsia doesn't have fork or malloc_info.
 #if !SCUDO_FUCHSIA
 
 TEST(ScudoWrappersCTest, MallocInfo) {
-  char Buffer[64];
+  // Use volatile so that the allocations don't get optimized away.
+  void *volatile P1 = malloc(1234);
+  void *volatile P2 = malloc(4321);
+
+  char Buffer[16384];
   FILE *F = fmemopen(Buffer, sizeof(Buffer), "w+");
   EXPECT_NE(F, nullptr);
   errno = 0;
   EXPECT_EQ(malloc_info(0, F), 0);
   EXPECT_EQ(errno, 0);
   fclose(F);
   EXPECT_EQ(strncmp(Buffer, "<malloc version=\"scudo-", 23), 0);
+  EXPECT_NE(nullptr, strstr(Buffer, "<alloc size=\"1234\" count=\""));
+  EXPECT_NE(nullptr, strstr(Buffer, "<alloc size=\"4321\" count=\""));
+
+  free(P1);
+  free(P2);
 }
 
 TEST(ScudoWrappersCTest, Fork) {
   void *P;
   pid_t Pid = fork();
   EXPECT_GE(Pid, 0);
   if (Pid == 0) {
     P = malloc(Size);

compiler-rt/lib/scudo/standalone/wrappers_c.inc

if (UNLIKELY(scudo::checkAlignedAllocAlignmentAndSize(alignment, size))) {
     }
     scudo::reportInvalidAlignedAllocAlignment(alignment, size);
   }
   return scudo::setErrnoOnNull(
       SCUDO_ALLOCATOR.allocate(size, scudo::Chunk::Origin::Malloc, alignment));
 }
 
 INTERFACE WEAK int SCUDO_PREFIX(malloc_info)(UNUSED int options, FILE *stream) {
-  fputs("<malloc version=\"scudo-1\">", stream);
-  fputs("</malloc>", stream);
+  const scudo::uptr max_size =
+      decltype(SCUDO_ALLOCATOR)::PrimaryT::SizeClassMap::MaxSize;
+  auto *sizes =
+      static_cast<scudo::uptr *>(calloc(max_size, sizeof(scudo::uptr)));
+  auto callback = [](uintptr_t, size_t size, void* arg) {
+    auto *sizes = reinterpret_cast<scudo::uptr *>(arg);
+    if (size < max_size)
+      sizes[size]++;
+  };
+  SCUDO_ALLOCATOR.iterateOverChunks(0, -1ul, callback, sizes);
+
+  fputs("<malloc version=\"scudo-1\">\n", stream);
+  for (scudo::uptr i = 0; i != max_size; ++i)
+    if (sizes[i])
+      fprintf(stream, "<alloc size=\"%lu\" count=\"%lu\"/>\n", i, sizes[i]);
+  fputs("</malloc>\n", stream);
+  free(sizes);
   return 0;
 }
 
 // Disable memory tagging for the heap. The caller must disable memory tag
 // checks globally (e.g. by clearing TCF0 on aarch64) before calling this
 // function, and may not re-enable them after calling the function. The program
 // must be single threaded at the point when the function is called.
 INTERFACE WEAK void SCUDO_PREFIX(malloc_disable_memory_tagging)() {
   SCUDO_ALLOCATOR.disableMemoryTagging();
 }
 
 } // extern "C"