[scudo] [standalone] [NFC] clang-format code.

[hctim]

Summary

clang-format the scudo standalone codebase.

compiler-rt/lib/scudo/standalone/fuzz/get_error_info_fuzzer.cpp

 
 extern "C" int LLVMFuzzerTestOneInput(uint8_t *Data, size_t Size) {
   using AllocatorT = scudo::Allocator<scudo::AndroidConfig>;
   FuzzedDataProvider FDP(Data, Size);
 
   uintptr_t FaultAddr = FDP.ConsumeIntegral<uintptr_t>();
   uintptr_t MemoryAddr = FDP.ConsumeIntegral<uintptr_t>();
 
-  std::string MemoryAndTags = FDP.ConsumeRandomLengthString(FDP.remaining_bytes());
+  std::string MemoryAndTags =
+      FDP.ConsumeRandomLengthString(FDP.remaining_bytes());
   const char *Memory = MemoryAndTags.c_str();
   // Assume 16-byte alignment.
   size_t MemorySize = (MemoryAndTags.length() / 17) * 16;
   const char *MemoryTags = Memory + MemorySize;
 
-  std::string StackDepotBytes = FDP.ConsumeRandomLengthString(FDP.remaining_bytes());
+  std::string StackDepotBytes =
+      FDP.ConsumeRandomLengthString(FDP.remaining_bytes());
   std::vector<char> StackDepot(sizeof(scudo::StackDepot), 0);
-  for (size_t i = 0; i < StackDepotBytes.length() && i < StackDepot.size(); ++i) {
+  for (size_t i = 0; i < StackDepotBytes.length() && i < StackDepot.size();
+       ++i) {
     StackDepot[i] = StackDepotBytes[i];
   }
 
   std::string RegionInfoBytes = FDP.ConsumeRemainingBytesAsString();
   std::vector<char> RegionInfo(AllocatorT::getRegionInfoArraySize(), 0);
-  for (size_t i = 0; i < RegionInfoBytes.length() && i < RegionInfo.size(); ++i) {
+  for (size_t i = 0; i < RegionInfoBytes.length() && i < RegionInfo.size();
+       ++i) {
     RegionInfo[i] = RegionInfoBytes[i];
   }
 
   scudo_error_info ErrorInfo;
   AllocatorT::getErrorInfo(&ErrorInfo, FaultAddr, StackDepot.data(),
                            RegionInfo.data(), Memory, MemoryTags, MemoryAddr,
                            MemorySize);
   return 0;
 }

compiler-rt/lib/scudo/standalone/tools/compute_size_class_config.cpp

 #include <algorithm>
 #include <vector>
 
 struct Alloc {
   size_t size, count;
 };
 
 size_t measureWastage(const std::vector<Alloc> &allocs,
-                       const std::vector<size_t> &classes,
-                       size_t pageSize,
-                       size_t headerSize) {
+                      const std::vector<size_t> &classes, size_t pageSize,
   size_t totalWastage = 0;
   for (auto &a : allocs) {
     size_t sizePlusHeader = a.size + headerSize;
     size_t wastage = -1ull;
     for (auto c : classes)
       if (c >= sizePlusHeader && c - sizePlusHeader < wastage)
         wastage = c - sizePlusHeader;
     if (wastage == -1ull)
void readAllocs(std::vector<Alloc> &allocs, const char *path) {
   char buf[sizeof(header) - 1];
   if (fread(buf, 1, sizeof(header) - 1, f) != sizeof(header) - 1 ||
       memcmp(buf, header, sizeof(header) - 1) != 0) {
     fprintf(stderr, "compute_size_class_config: invalid input format\n");
     exit(1);
   }
 
   Alloc a;
-  while (fscanf(f, "<alloc size=\"%zu\" count=\"%zu\"/>\n", &a.size, &a.count) == 2)
+  while (fscanf(f, "<alloc size=\"%zu\" count=\"%zu\"/>\n", &a.size,
+                &a.count) == 2)
     allocs.push_back(a);
   fclose(f);
 }
 
 size_t log2Floor(size_t x) { return sizeof(long) * 8 - 1 - __builtin_clzl(x); }
 
 void usage() {
   fprintf(stderr,
for (size_t i = 0; i != classes.size(); ++i) {
     else
       printf(" ");
     printf("0x%05zx,", classes[i]);
   }
   printf(R"(
   };
   static const uptr SizeDelta = %zu;
 };
-)", headerSize);
+)",
+         headerSize);
 }