fixing formatting that was messed up due to VSC format on save getting turned on somehow

Author: Alexander Yermolovich

bolt/lib/Passes/IdenticalCodeFolding.cpp

@@ -38,9 +38,12 @@ static cl::opt<bool>
     ICFUseDFS("icf-dfs", cl::desc("use DFS ordering when using -icf option"),
               cl::ReallyHidden, cl::cat(BoltOptCategory));
 
-static cl::opt<bool> TimeICF("time-icf", cl::desc("time icf steps"),
-                             cl::ReallyHidden, cl::ZeroOrMore,
-                             cl::cat(BoltOptCategory));
+static cl::opt<bool>
+TimeICF("time-icf",
+  cl::desc("time icf steps"),
+  cl::ReallyHidden,
+  cl::ZeroOrMore,
+  cl::cat(BoltOptCategory));
 } // namespace opts
 
 /// Compare two jump tables in 2 functions. The function relies on consistent

bolt/lib/Rewrite/RewriteInstance.cpp

@@ -63,7 +63,7 @@
 #include <optional>
 #include <system_error>
 
-#undef DEBUG_TYPE
+#undef  DEBUG_TYPE
 #define DEBUG_TYPE "bolt"
 
 using namespace llvm;
@@ -109,15 +109,19 @@ cl::opt<bool> DumpDotAll(
              "enable '-print-loops' for color-coded blocks"),
     cl::Hidden, cl::cat(BoltCategory));
 
-static cl::list<std::string> ForceFunctionNames(
-    "funcs", cl::CommaSeparated,
-    cl::desc("limit optimizations to functions from the list"),
-    cl::value_desc("func1,func2,func3,..."), cl::Hidden, cl::cat(BoltCategory));
+static cl::list<std::string>
+ForceFunctionNames("funcs",
+  cl::CommaSeparated,
+  cl::desc("limit optimizations to functions from the list"),
+  cl::value_desc("func1,func2,func3,..."),
+  cl::Hidden,
+  cl::cat(BoltCategory));
 
 static cl::opt<std::string>
-    FunctionNamesFile("funcs-file",
-                      cl::desc("file with list of functions to optimize"),
-                      cl::Hidden, cl::cat(BoltCategory));
+FunctionNamesFile("funcs-file",
+  cl::desc("file with list of functions to optimize"),
+  cl::Hidden,
+  cl::cat(BoltCategory));
 
 static cl::list<std::string> ForceFunctionNamesNR(
     "funcs-no-regex", cl::CommaSeparated,
@@ -129,17 +133,22 @@ static cl::opt<std::string> FunctionNamesFileNR(
     cl::desc("file with list of functions to optimize (non-regex)"), cl::Hidden,
     cl::cat(BoltCategory));
 
-cl::opt<bool> KeepTmp("keep-tmp", cl::desc("preserve intermediate .o file"),
-                      cl::Hidden, cl::cat(BoltCategory));
+cl::opt<bool>
+KeepTmp("keep-tmp",
+  cl::desc("preserve intermediate .o file"),
+  cl::Hidden,
+  cl::cat(BoltCategory));
 
-static cl::opt<unsigned> LiteThresholdPct(
-    "lite-threshold-pct",
-    cl::desc(
-        "threshold (in percent) for selecting functions to process in lite "
-        "mode. Higher threshold means fewer functions to process. E.g "
-        "threshold of 90 means only top 10 percent of functions with "
-        "profile will be processed."),
-    cl::init(0), cl::ZeroOrMore, cl::Hidden, cl::cat(BoltOptCategory));
+static cl::opt<unsigned>
+LiteThresholdPct("lite-threshold-pct",
+  cl::desc("threshold (in percent) for selecting functions to process in lite "
+            "mode. Higher threshold means fewer functions to process. E.g "
+            "threshold of 90 means only top 10 percent of functions with "
+            "profile will be processed."),
+  cl::init(0),
+  cl::ZeroOrMore,
+  cl::Hidden,
+  cl::cat(BoltOptCategory));
 
 static cl::opt<unsigned> LiteThresholdCount(
     "lite-threshold-count",
@@ -191,35 +200,43 @@ static cl::opt<cl::boolOrDefault> RelocationMode(
 
 extern cl::opt<std::string> SaveProfile;
 
-static cl::list<std::string> SkipFunctionNames(
-    "skip-funcs", cl::CommaSeparated, cl::desc("list of functions to skip"),
-    cl::value_desc("func1,func2,func3,..."), cl::Hidden, cl::cat(BoltCategory));
+static cl::list<std::string>
+SkipFunctionNames("skip-funcs",
+  cl::CommaSeparated,
+  cl::desc("list of functions to skip"),
+  cl::value_desc("func1,func2,func3,..."),
+  cl::Hidden,
+  cl::cat(BoltCategory));
 
 static cl::opt<std::string>
-    SkipFunctionNamesFile("skip-funcs-file",
-                          cl::desc("file with list of functions to skip"),
-                          cl::Hidden, cl::cat(BoltCategory));
+SkipFunctionNamesFile("skip-funcs-file",
+  cl::desc("file with list of functions to skip"),
+  cl::Hidden,
+  cl::cat(BoltCategory));
 
-cl::opt<bool> TrapOldCode(
-    "trap-old-code",
-    cl::desc("insert traps in old function bodies (relocation mode)"),
-    cl::Hidden, cl::cat(BoltCategory));
+cl::opt<bool>
+TrapOldCode("trap-old-code",
+  cl::desc("insert traps in old function bodies (relocation mode)"),
+  cl::Hidden,
+  cl::cat(BoltCategory));
 
 static cl::opt<std::string> DWPPathName("dwp",
                                         cl::desc("Path and name to DWP file."),
                                         cl::Hidden, cl::init(""),
                                         cl::cat(BoltCategory));
 
-static cl::opt<bool> UseGnuStack(
-    "use-gnu-stack",
-    cl::desc("use GNU_STACK program header for new segment (workaround for "
-             "issues with strip/objcopy)"),
-    cl::ZeroOrMore, cl::cat(BoltCategory));
+static cl::opt<bool>
+UseGnuStack("use-gnu-stack",
+  cl::desc("use GNU_STACK program header for new segment (workaround for "
+           "issues with strip/objcopy)"),
+  cl::ZeroOrMore,
+  cl::cat(BoltCategory));
 
 static cl::opt<bool>
-    SequentialDisassembly("sequential-disassembly",
-                          cl::desc("performs disassembly sequentially"),
-                          cl::init(false), cl::cat(BoltOptCategory));
+SequentialDisassembly("sequential-disassembly",
+  cl::desc("performs disassembly sequentially"),
+  cl::init(false),
+  cl::cat(BoltOptCategory));
 
 static cl::opt<bool> WriteBoltInfoSection(
     "bolt-info", cl::desc("write bolt info section in the output binary"),
@@ -502,12 +519,12 @@ Error RewriteInstance::discoverStorage() {
   for (const ELF64LE::Phdr &Phdr : PHs) {
     switch (Phdr.p_type) {
     case ELF::PT_LOAD:
-      BC->FirstAllocAddress =
-          std::min(BC->FirstAllocAddress, static_cast<uint64_t>(Phdr.p_vaddr));
-      NextAvailableAddress =
-          std::max(NextAvailableAddress, Phdr.p_vaddr + Phdr.p_memsz);
-      NextAvailableOffset =
-          std::max(NextAvailableOffset, Phdr.p_offset + Phdr.p_filesz);
+      BC->FirstAllocAddress = std::min(BC->FirstAllocAddress,
+                                       static_cast<uint64_t>(Phdr.p_vaddr));
+      NextAvailableAddress = std::max(NextAvailableAddress,
+                                      Phdr.p_vaddr + Phdr.p_memsz);
+      NextAvailableOffset = std::max(NextAvailableOffset,
+                                     Phdr.p_offset + Phdr.p_filesz);
 
       BC->SegmentMapInfo[Phdr.p_vaddr] = SegmentInfo{
           Phdr.p_vaddr,  Phdr.p_memsz, Phdr.p_offset,
@@ -1507,7 +1524,7 @@ void RewriteInstance::registerFragments() {
       }
     }
 
-  registerParent:
+registerParent:
     // No local parent is found, use global parent function.
     if (!ParentAddress)
       if (BinaryData *ParentBD = BC->getBinaryDataByName(ParentName))
@@ -2340,12 +2357,14 @@ void RewriteInstance::readDynamicRelocations(const SectionRef &Section,
       (void)SymbolAddress;
     }
 
-    LLVM_DEBUG(SmallString<16> TypeName; Rel.getTypeName(TypeName);
-               dbgs() << "BOLT-DEBUG: dynamic relocation at 0x"
-                      << Twine::utohexstr(Rel.getOffset()) << " : " << TypeName
-                      << " : " << SymbolName << " : "
-                      << Twine::utohexstr(SymbolAddress) << " : + 0x"
-                      << Twine::utohexstr(Addend) << '\n');
+    LLVM_DEBUG(
+      SmallString<16> TypeName;
+      Rel.getTypeName(TypeName);
+      dbgs() << "BOLT-DEBUG: dynamic relocation at 0x"
+             << Twine::utohexstr(Rel.getOffset()) << " : " << TypeName
+             << " : " << SymbolName << " : " <<  Twine::utohexstr(SymbolAddress)
+             << " : + 0x" << Twine::utohexstr(Addend) << '\n'
+    );
 
     if (IsJmpRel)
       IsJmpRelocation[RType] = true;
@@ -3648,8 +3667,9 @@ void RewriteInstance::mapCodeSections(BOLTLinker::SectionMapper MapSection) {
       return Section->getOutputAddress();
     });
     LLVM_DEBUG(dbgs() << "Code sections in the order of output:\n";
-               for (const BinarySection *Section : CodeSections) dbgs()
-               << Section->getName() << '\n';);
+      for (const BinarySection *Section : CodeSections)
+        dbgs() << Section->getName() << '\n';
+    );
 
     uint64_t PaddingSize = 0; // size of padding required at the end
 
@@ -3816,9 +3836,13 @@ void RewriteInstance::mapCodeSections(BOLTLinker::SectionMapper MapSection) {
     const unsigned Flags = BinarySection::getFlags(/*IsReadOnly=*/true,
                                                    /*IsText=*/true,
                                                    /*IsAllocatable=*/true);
-    BinarySection &Section = BC->registerOrUpdateSection(
-        getBOLTTextSectionName(), ELF::SHT_PROGBITS, Flags,
-        /*Data=*/nullptr, NewTextSectionSize, 16);
+    BinarySection &Section =
+      BC->registerOrUpdateSection(getBOLTTextSectionName(),
+                                  ELF::SHT_PROGBITS,
+                                  Flags,
+                                  /*Data=*/nullptr,
+                                  NewTextSectionSize,
+                                  16);
     Section.setOutputAddress(NewTextSectionStartAddress);
     Section.setOutputFileOffset(
         getFileOffsetForAddress(NewTextSectionStartAddress));
@@ -4069,7 +4093,7 @@ uint64_t appendPadding(raw_pwrite_stream &OS, uint64_t Offset,
   return Offset + PaddingSize;
 }
 
-} // namespace
+}
 
 void RewriteInstance::rewriteNoteSections() {
   auto ELF64LEFile = cast<ELF64LEObjectFile>(InputFile);
@@ -4189,9 +4213,12 @@ void RewriteInstance::finalizeSectionStringTable(ELFObjectFile<ELFT> *File) {
   uint8_t *DataCopy = new uint8_t[SHStrTabSize];
   memset(DataCopy, 0, SHStrTabSize);
   SHStrTab.write(DataCopy);
-  BC->registerOrUpdateNoteSection(".shstrtab", DataCopy, SHStrTabSize,
+  BC->registerOrUpdateNoteSection(".shstrtab",
+                                  DataCopy,
+                                  SHStrTabSize,
                                   /*Alignment=*/1,
-                                  /*IsReadOnly=*/true, ELF::SHT_STRTAB);
+                                  /*IsReadOnly=*/true,
+                                  ELF::SHT_STRTAB);
 }
 
 void RewriteInstance::addBoltInfoSection() {
@@ -4447,9 +4474,11 @@ void RewriteInstance::patchELFSectionHeaderTable(ELFObjectFile<ELFT> *File) {
   std::vector<uint32_t> NewSectionIndex;
   std::vector<ELFShdrTy> OutputSections =
       getOutputSections(File, NewSectionIndex);
-  LLVM_DEBUG(dbgs() << "BOLT-DEBUG: old to new section index mapping:\n";
-             for (uint64_t I = 0; I < NewSectionIndex.size(); ++I) dbgs()
-             << "  " << I << " -> " << NewSectionIndex[I] << '\n';);
+  LLVM_DEBUG(
+    dbgs() << "BOLT-DEBUG: old to new section index mapping:\n";
+    for (uint64_t I = 0; I < NewSectionIndex.size(); ++I)
+      dbgs() << "  " << I << " -> " << NewSectionIndex[I] << '\n';
+  );
 
   // Align starting address for section header table. There's no architecutal
   // need to align this, it is just for pleasant human readability.
@@ -4944,12 +4973,15 @@ void RewriteInstance::patchELFSymTabs(ELFObjectFile<ELFT> *File) {
   if (DynSymSection) {
     updateELFSymbolTable(
         File,
-        /*IsDynSym=*/true, *DynSymSection, NewSectionIndex,
+        /*IsDynSym=*/true,
+        *DynSymSection,
+        NewSectionIndex,
         [&](size_t Offset, const ELFSymTy &Sym) {
           Out->os().pwrite(reinterpret_cast<const char *>(&Sym),
-                           sizeof(ELFSymTy), DynSymSection->sh_offset + Offset);
+                           sizeof(ELFSymTy),
+                           DynSymSection->sh_offset + Offset);
         },
-        [](StringRef) -> size_t { return 0; });
+        [](StringRef) -> size_t { return 0; });;
   }
 
   if (opts::RemoveSymtab)
@@ -4979,7 +5011,9 @@ void RewriteInstance::patchELFSymTabs(ELFObjectFile<ELFT> *File) {
   NumLocalSymbols = 0;
   updateELFSymbolTable(
       File,
-      /*IsDynSym=*/false, *SymTabSection, NewSectionIndex,
+      /*IsDynSym=*/false,
+      *SymTabSection,
+      NewSectionIndex,
       [&](size_t Offset, const ELFSymTy &Sym) {
         if (Sym.getBinding() == ELF::STB_LOCAL)
           ++NumLocalSymbols;
@@ -4993,15 +5027,19 @@ void RewriteInstance::patchELFSymTabs(ELFObjectFile<ELFT> *File) {
         return Idx;
       });
 
-  BC->registerOrUpdateNoteSection(SecName, copyByteArray(NewContents),
+  BC->registerOrUpdateNoteSection(SecName,
+                                  copyByteArray(NewContents),
                                   NewContents.size(),
                                   /*Alignment=*/1,
-                                  /*IsReadOnly=*/true, ELF::SHT_SYMTAB);
+                                  /*IsReadOnly=*/true,
+                                  ELF::SHT_SYMTAB);
 
-  BC->registerOrUpdateNoteSection(StrSecName, copyByteArray(NewStrTab),
+  BC->registerOrUpdateNoteSection(StrSecName,
+                                  copyByteArray(NewStrTab),
                                   NewStrTab.size(),
                                   /*Alignment=*/1,
-                                  /*IsReadOnly=*/true, ELF::SHT_STRTAB);
+                                  /*IsReadOnly=*/true,
+                                  ELF::SHT_STRTAB);
 }
 
 template <typename ELFT>
@@ -5097,8 +5135,8 @@ void RewriteInstance::patchELFAllocatableRelrSection(
 }
 
 template <typename ELFT>
-void RewriteInstance::patchELFAllocatableRelaSections(
-    ELFObjectFile<ELFT> *File) {
+void
+RewriteInstance::patchELFAllocatableRelaSections(ELFObjectFile<ELFT> *File) {
   using Elf_Rela = typename ELFT::Rela;
   raw_fd_ostream &OS = Out->os();
   const ELFFile<ELFT> &EF = File->getELFFile();