Reformat GSYMCreator.cpp

[clayborg]

Was this all fixed by the auto linter?

[simon.giesecke]

In D102483#2760867, @clayborg wrote:

Was this all fixed by the auto linter?

Yes, I was somewhat surprised that the file wasn't properly formatted originally.

[tschuett]

You could put the commit hash into:
https://github.com/llvm/llvm-project/blob/main/.git-blame-ignore-revs

[simon.giesecke]

In D102483#2761272, @tschuett wrote:

You could put the commit hash into:
https://github.com/llvm/llvm-project/blob/main/.git-blame-ignore-revs

I guess this won't be my local git hash, so I can only do that once the patch has landed, right?

[tschuett]

In D102483#2762537, @simon.giesecke wrote:

In D102483#2761272, @tschuett wrote:

You could put the commit hash into:
https://github.com/llvm/llvm-project/blob/main/.git-blame-ignore-revs

I guess this won't be my local git hash, so I can only do that once the patch has landed, right?

That is correct.

[simon.giesecke]

Update using arc

llvm/lib/DebugInfo/GSYM/GsymCreator.cpp

 #include <algorithm>
 #include <cassert>
 #include <functional>
 #include <vector>
 
 using namespace llvm;
 using namespace gsym;
 
-
 GsymCreator::GsymCreator() : StrTab(StringTableBuilder::ELF) {
   insertFile(StringRef());
 }
 
-uint32_t GsymCreator::insertFile(StringRef Path,
-                                 llvm::sys::path::Style Style) {
+uint32_t GsymCreator::insertFile(StringRef Path, llvm::sys::path::Style Style) {
   llvm::StringRef directory = llvm::sys::path::parent_path(Path, Style);
   llvm::StringRef filename = llvm::sys::path::filename(Path, Style);
   // We must insert the strings first, then call the FileEntry constructor.
   // If we inline the insertString() function call into the constructor, the
   // call order is undefined due to parameter lists not having any ordering
   // requirements.
   const uint32_t Dir = insertString(directory);
   const uint32_t Base = insertString(filename);
llvm::Error GsymCreator::encode(FileWriter &O) const {
   if (!Finalized)
     return createStringError(std::errc::invalid_argument,
                              "GsymCreator wasn't finalized prior to encoding");
 
   if (Funcs.size() > UINT32_MAX)
     return createStringError(std::errc::invalid_argument,
                              "too many FunctionInfos");
 
-  const uint64_t MinAddr = BaseAddress ? *BaseAddress : Funcs.front().startAddress();
+  const uint64_t MinAddr =
+      BaseAddress ? *BaseAddress : Funcs.front().startAddress();
   const uint64_t MaxAddr = Funcs.back().startAddress();
   const uint64_t AddrDelta = MaxAddr - MinAddr;
   Header Hdr;
   Hdr.Magic = GSYM_MAGIC;
   Hdr.Version = GSYM_VERSION;
   Hdr.AddrOffSize = 0;
   Hdr.UUIDSize = static_cast<uint8_t>(UUID.size());
   Hdr.BaseAddress = MinAddr;
   Hdr.NumAddresses = static_cast<uint32_t>(Funcs.size());
   Hdr.StrtabOffset = 0; // We will fix this up later.
-  Hdr.StrtabSize = 0; // We will fix this up later.
+  Hdr.StrtabSize = 0;   // We will fix this up later.
   memset(Hdr.UUID, 0, sizeof(Hdr.UUID));
   if (UUID.size() > sizeof(Hdr.UUID))
     return createStringError(std::errc::invalid_argument,
                              "invalid UUID size %u", (uint32_t)UUID.size());
   // Set the address offset size correctly in the GSYM header.
   if (AddrDelta <= UINT8_MAX)
     Hdr.AddrOffSize = 1;
   else if (AddrDelta <= UINT16_MAX)
llvm::Error GsymCreator::encode(FileWriter &O) const {
   llvm::Error Err = Hdr.encode(O);
   if (Err)
     return Err;
 
   // Write out the address offsets.
   O.alignTo(Hdr.AddrOffSize);
   for (const auto &FuncInfo : Funcs) {
     uint64_t AddrOffset = FuncInfo.startAddress() - Hdr.BaseAddress;
-    switch(Hdr.AddrOffSize) {
-      case 1: O.writeU8(static_cast<uint8_t>(AddrOffset)); break;
-      case 2: O.writeU16(static_cast<uint16_t>(AddrOffset)); break;
-      case 4: O.writeU32(static_cast<uint32_t>(AddrOffset)); break;
-      case 8: O.writeU64(AddrOffset); break;
+    switch (Hdr.AddrOffSize) {
+    case 1:
+      O.writeU8(static_cast<uint8_t>(AddrOffset));
+      break;
+    case 2:
+      O.writeU16(static_cast<uint16_t>(AddrOffset));
+      break;
+    case 4:
+      O.writeU32(static_cast<uint32_t>(AddrOffset));
+      break;
+    case 8:
+      O.writeU64(AddrOffset);
+      break;
     }
   }
 
   // Write out all zeros for the AddrInfoOffsets.
   O.alignTo(4);
   const off_t AddrInfoOffsetsOffset = O.tell();
   for (size_t i = 0, n = Funcs.size(); i < n; ++i)
     O.writeU32(0);
 
   // Write out the file table
   O.alignTo(4);
   assert(!Files.empty());
   assert(Files[0].Dir == 0);
   assert(Files[0].Base == 0);
   size_t NumFiles = Files.size();
   if (NumFiles > UINT32_MAX)
-    return createStringError(std::errc::invalid_argument,
-                             "too many files");
+    return createStringError(std::errc::invalid_argument, "too many files");
   O.writeU32(static_cast<uint32_t>(NumFiles));
-  for (auto File: Files) {
-      O.writeU32(File.Dir);
-      O.writeU32(File.Base);
+  for (auto File : Files) {
   }
 
   // Write out the sting table.
   const off_t StrtabOffset = O.tell();
   StrTab.write(O.get_stream());
   const off_t StrtabSize = O.tell() - StrtabOffset;
   std::vector<uint32_t> AddrInfoOffsets;
 
   // Write out the address infos for each function info.
   for (const auto &FuncInfo : Funcs) {
     if (Expected<uint64_t> OffsetOrErr = FuncInfo.encode(O))
-        AddrInfoOffsets.push_back(OffsetOrErr.get());
     else
-        return OffsetOrErr.takeError();
   }
   // Fixup the string table offset and size in the header
   O.fixup32((uint32_t)StrtabOffset, offsetof(Header, StrtabOffset));
   O.fixup32((uint32_t)StrtabSize, offsetof(Header, StrtabSize));
 
   // Fixup all address info offsets
   uint64_t Offset = 0;
-  for (auto AddrInfoOffset: AddrInfoOffsets) {
+  for (auto AddrInfoOffset : AddrInfoOffsets) {
     O.fixup32(AddrInfoOffset, AddrInfoOffsetsOffset + Offset);
     Offset += 4;
   }
   return ErrorSuccess();
 }
 
 // Similar to std::remove_if, but the predicate is binary and it is passed both
 // the previous and the current element.
if (FirstIt != LastIt)
         }
   }
   return FirstIt;
 }
 
 llvm::Error GsymCreator::finalize(llvm::raw_ostream &OS) {
   std::lock_guard<std::recursive_mutex> Guard(Mutex);
   if (Finalized)
-    return createStringError(std::errc::invalid_argument,
-                             "already finalized");
+    return createStringError(std::errc::invalid_argument, "already finalized");
   Finalized = true;
 
   // Sort function infos so we can emit sorted functions.
   llvm::sort(Funcs);
 
   // Don't let the string table indexes change by finalizing in order.
   StrTab.finalizeInOrder();
 
Funcs.erase(
       Funcs.end());
 
   // If our last function info entry doesn't have a size and if we have valid
   // text ranges, we should set the size of the last entry since any search for
   // a high address might match our last entry. By fixing up this size, we can
   // help ensure we don't cause lookups to always return the last symbol that
   // has no size when doing lookups.
   if (!Funcs.empty() && Funcs.back().Range.size() == 0 && ValidTextRanges) {
-    if (auto Range = ValidTextRanges->getRangeThatContains(
-          Funcs.back().Range.Start)) {
+    if (auto Range =
+            ValidTextRanges->getRangeThatContains(Funcs.back().Range.Start)) {
       Funcs.back().Range.End = Range->End;
     }
   }
   OS << "Pruned " << NumBefore - Funcs.size() << " functions, ended with "
      << Funcs.size() << " total\n";
   return Error::success();
 }
 
void GsymCreator::forEachFunctionInfo(
     std::function<bool(const FunctionInfo &)> const &Callback) const {
   std::lock_guard<std::recursive_mutex> Guard(Mutex);
   for (const auto &FI : Funcs) {
     if (!Callback(FI))
       break;
   }
 }
 
-size_t GsymCreator::getNumFunctionInfos() const{
+size_t GsymCreator::getNumFunctionInfos() const {
   std::lock_guard<std::recursive_mutex> Guard(Mutex);
   return Funcs.size();
 }
 
 bool GsymCreator::IsValidTextAddress(uint64_t Addr) const {
   if (ValidTextRanges)
     return ValidTextRanges->contains(Addr);
   return true; // No valid text ranges has been set, so accept all ranges.
 }
 
 bool GsymCreator::hasFunctionInfoForAddress(uint64_t Addr) const {
   std::lock_guard<std::recursive_mutex> Guard(Mutex);
   return Ranges.contains(Addr);
 }