[NFC] Run clang-format on llvm-objcopy.

[rupprecht]

Summary

This runs clang-format on the few files in llvm-objcopy that aren't fully formatted. It also fixes some tablegen files -- clang-format is less robust on tablegen, but the change here seems ok.

[MaskRay]

It is subjective but it seems to me that clang-format is making bad decisions for .td files. Many people don't format .td files (various lib/Target/*/*.td and include/clang/Driver/Options.td)

Formatting C++ files is fine but it seems that we run into some discrepancy between clang-format versions. Formatting with latest clang-format is probably fine.

llvm/tools/llvm-objcopy/CopyConfig.cpp

210–213

I suspect the difference is due to changed heuristics of clang-format (of different versions).

490

Pre-merge checks may suggest that this is due to different versions of clang-format.

I wonder whether we want to format the block.

[MyDeveloperDay]

llvm/tools/llvm-objcopy/CopyConfig.cpp

490

I do believe there were some changes made recently in this area @krasimir, @Typz might like to comment

[jhenderson]

No issue in principle with this, but we do need to figure out the canonical version of clang-format we want to use for this if we are going to do it. I have no personal opinion on it, but suspect my installed clang-format version is out-of-date, and that if I were to do the same thing you did I'd get different results.

llvm/tools/llvm-objcopy/CopyConfig.cpp

210–213

Actually, I suspect it just wasn't formatted before - the "invalid argument for..." string below in the original is over the 80 character limit.

[rupprecht]

Reformat with clang-format-10 to avoid clang-format version skew leading to premerge clang-format warnings

[rupprecht]

In D82980#2125967, @MaskRay wrote:

It is subjective but it seems to me that clang-format is making bad decisions for .td files. Many people don't format .td files (various lib/Target/*/*.td and include/clang/Driver/Options.td)

The td formatting is less robust, but works well for simple CLI option files. I'm not particularly tied to the format it chooses, but I do find the options files easier to read when consistently formatted.

The other td files you mentioned are much more complex, and I've tried using clang-format on them. It totally botches them and I don't think we should bother with complex files.

Formatting C++ files is fine but it seems that we run into some discrepancy between clang-format versions. Formatting with latest clang-format is probably fine.

Yep

In D82980#2127279, @jhenderson wrote:

No issue in principle with this, but we do need to figure out the canonical version of clang-format we want to use for this if we are going to do it. I have no personal opinion on it, but suspect my installed clang-format version is out-of-date, and that if I were to do the same thing you did I'd get different results.

What does clang-format --version look like on your machine? The one on my machine seems to be updated on a rolling basis (built from trunk on a regular basis), but sudo apt install clang-format-10 is available to use a more stable version.

llvm/tools/llvm-objcopy/CopyConfig.cpp

210–213

Yep, this is the reason why. FWIW I also tried an old version (clang-format-7) and it still formats this block.

490

This is using clang-format from head (7d9518c8000bcd742b364a390bc79560f736dc96 at the time). Using clang-format-10 restores it.

I agree the version of clang-format to use is an important choice. I'll revert these portions for now and punt the question for later.

[jhenderson]

In D82980#2133616, @rupprecht wrote:

In D82980#2125967, @MaskRay wrote:

It is subjective but it seems to me that clang-format is making bad decisions for .td files. Many people don't format .td files (various lib/Target/*/*.td and include/clang/Driver/Options.td)

The td formatting is less robust, but works well for simple CLI option files. I'm not particularly tied to the format it chooses, but I do find the options files easier to read when consistently formatted.

The other td files you mentioned are much more complex, and I've tried using clang-format on them. It totally botches them and I don't think we should bother with complex files.

Formatting C++ files is fine but it seems that we run into some discrepancy between clang-format versions. Formatting with latest clang-format is probably fine.

Yep

In D82980#2127279, @jhenderson wrote:

No issue in principle with this, but we do need to figure out the canonical version of clang-format we want to use for this if we are going to do it. I have no personal opinion on it, but suspect my installed clang-format version is out-of-date, and that if I were to do the same thing you did I'd get different results.

What does clang-format --version look like on your machine? The one on my machine seems to be updated on a rolling basis (built from trunk on a regular basis), but sudo apt install clang-format-10 is available to use a more stable version.

I'm primarily a Windows-based developer, so don't expect me to be sudo-ing or apt-getting anything. I actually have 3 different clang-formats installed on my machine, it looks like, partly because it comes as part of our downstream toolchain installation package. The one that appears to be used under my most frequent usage is based on clang v8, since that seems to be the one tied to our Visual Studio extension that hooks it into the IDE, but I also have two v9 versions kicking around. I update the toolchain installation maybe once or at most twice a year, and there's usually some lag between that and the current LLVM version, so I'm always likely to be a year or two out-of-date.

llvm/tools/llvm-objcopy/COFF/Object.h

 #include <vector>
 
 namespace llvm {
 namespace objcopy {
 namespace coff {
 
 struct Relocation {
   Relocation() = default;
-  Relocation(const object::coff_relocation& R) : Reloc(R) {}
+  Relocation(const object::coff_relocation &R) : Reloc(R) {}
 
   object::coff_relocation Reloc;
   size_t Target = 0;
   StringRef TargetName; // Used for diagnostics only
 };
 
 struct Section {
   object::coff_section Header;

llvm/tools/llvm-objcopy/CommonOpts.td

 def allow_broken_links
     : Flag<["--"], "allow-broken-links">,
       HelpText<"Allow the tool to remove sections even if it would leave "
                "invalid section references. The appropriate sh_link fields "
                "will be set to zero.">;
 
 def enable_deterministic_archives
     : Flag<["--"], "enable-deterministic-archives">,
-      HelpText<"Enable deterministic mode when operating on archives (use "
-               "zero for UIDs, GIDs, and timestamps).">;
+      HelpText<"Enable deterministic mode when operating on archives (use zero "
+               "for UIDs, GIDs, and timestamps).">;
 def D : Flag<["-"], "D">,
         Alias<enable_deterministic_archives>,
         HelpText<"Alias for --enable-deterministic-archives">;
 
 def disable_deterministic_archives
     : Flag<["--"], "disable-deterministic-archives">,
       HelpText<"Disable deterministic mode when operating on archives (use "
                "real values for UIDs, GIDs, and timestamps).">;
 def U : Flag<["-"], "U">,
         Alias<disable_deterministic_archives>,
         HelpText<"Alias for --disable-deterministic-archives">;
 
 def preserve_dates : Flag<["--"], "preserve-dates">,
                      HelpText<"Preserve access and modification timestamps">;
 def p : Flag<["-"], "p">,
         Alias<preserve_dates>,
         HelpText<"Alias for --preserve-dates">;
 
-def strip_all : Flag<["--"], "strip-all">,
-                HelpText<"Remove non-allocated sections outside segments. "
-                         ".gnu.warning* and .ARM.attribute sections are not "
-                         "removed">;
+def strip_all
+    : Flag<["--"], "strip-all">,
+      HelpText<"Remove non-allocated sections outside segments. .gnu.warning* "
+               "and .ARM.attribute sections are not removed">;
 
-def strip_all_gnu
-    : Flag<["--"], "strip-all-gnu">,
+def strip_all_gnu : Flag<["--"], "strip-all-gnu">,
                     HelpText<"Compatible with GNU's --strip-all">;
 
 def strip_debug : Flag<["--"], "strip-debug">,
                   HelpText<"Remove all debug sections">;
 def g : Flag<["-"], "g">,
         Alias<strip_debug>,
         HelpText<"Alias for --strip-debug">;
 
 def strip_unneeded : Flag<["--"], "strip-unneeded">,
                      HelpText<"Remove all symbols not needed by relocations">;
 
 defm remove_section : Eq<"remove-section", "Remove <section>">,
                       MetaVarName<"section">;
 def R : JoinedOrSeparate<["-"], "R">,
         Alias<remove_section>,
         HelpText<"Alias for --remove-section">;
 
 def strip_sections
     : Flag<["--"], "strip-sections">,
       HelpText<"Remove all section headers and all sections not in segments">;
 
-defm strip_symbol : Eq<"strip-symbol", "Strip <symbol>">,
-                    MetaVarName<"symbol">;
+defm strip_symbol : Eq<"strip-symbol", "Strip <symbol>">, MetaVarName<"symbol">;
 def N : JoinedOrSeparate<["-"], "N">,
         Alias<strip_symbol>,
         HelpText<"Alias for --strip-symbol">;
 
 defm keep_section : Eq<"keep-section", "Keep <section>">,
                     MetaVarName<"section">;
 
 defm keep_symbol : Eq<"keep-symbol", "Do not remove symbol <symbol>">,
                    MetaVarName<"symbol">;
 def K : JoinedOrSeparate<["-"], "K">,
         Alias<keep_symbol>,
         HelpText<"Alias for --keep-symbol">;
 
 def keep_file_symbols : Flag<["--"], "keep-file-symbols">,
                         HelpText<"Do not remove file symbols">;
 
 def only_keep_debug
     : Flag<["--"], "only-keep-debug">,
-      HelpText<
-          "Produce a debug file as the output that only preserves contents of "
-          "sections useful for debugging purposes">;
+      HelpText<"Produce a debug file as the output that only preserves "
+               "contents of sections useful for debugging purposes">;
 
 def discard_locals : Flag<["--"], "discard-locals">,
                      HelpText<"Remove compiler-generated local symbols, (e.g. "
                               "symbols starting with .L)">;
 def X : Flag<["-"], "X">,
         Alias<discard_locals>,
         HelpText<"Alias for --discard-locals">;
 
 def discard_all
     : Flag<["--"], "discard-all">,
       HelpText<"Remove all local symbols except file and section symbols">;
 def x : Flag<["-"], "x">,
         Alias<discard_all>,
         HelpText<"Alias for --discard-all">;
 
-def regex
-    : Flag<["--"], "regex">,
+def regex : Flag<["--"], "regex">,
             HelpText<"Permit regular expressions in name comparison">;
 
-def version : Flag<["--"], "version">,
-              HelpText<"Print the version and exit.">;
-def V : Flag<["-"], "V">,
-        Alias<version>,
-        HelpText<"Alias for --version">;
+def version : Flag<["--"], "version">, HelpText<"Print the version and exit.">;
+def V : Flag<["-"], "V">, Alias<version>, HelpText<"Alias for --version">;
 
 def wildcard
     : Flag<["--"], "wildcard">,
       HelpText<"Allow wildcard syntax for symbol-related flags. Incompatible "
                "with --regex. Allows using '*' to match any number of "
                "characters, '?' to match any single character, '\' to escape "
                "special characters, and '[]' to define character classes. "
                "Wildcards beginning with '!' will prevent a match, for example "
                "\"-N '*' -N '!x'\" will strip all symbols except for \"x\".">;
 def w : Flag<["-"], "w">, Alias<wildcard>, HelpText<"Alias for --wildcard">;

llvm/tools/llvm-objcopy/CopyConfig.cpp

return createStringError(
         "bad format for --set-section-alignment: missing '='");
   auto Split = StringRef(FlagValue).split('=');
   if (Split.first.empty())
     return createStringError(
         errc::invalid_argument,
         "bad format for --set-section-alignment: missing section name");
   uint64_t NewAlign;
   if (Split.second.getAsInteger(0, NewAlign))
-    return createStringError(errc::invalid_argument,
-                             "invalid alignment for --set-section-alignment: '%s'",
-                             Split.second.str().c_str());
+    return createStringError(
+        errc::invalid_argument,
   return std::make_pair(Split.first, NewAlign);
 }
 
 static Expected<SectionFlagsUpdate>
 parseSetSectionFlagValue(StringRef FlagValue) {
   if (!StringRef(FlagValue).contains('='))
     return createStringError(errc::invalid_argument,
                              "bad format for --set-section-flags: missing '='");
parseObjcopyOptions(ArrayRef<const char *> ArgsArr,
 
   if (InputArgs.hasArg(OBJCOPY_regex) && InputArgs.hasArg(OBJCOPY_wildcard))
     return createStringError(errc::invalid_argument,
                              "--regex and --wildcard are incompatible");
 
   MatchStyle SectionMatchStyle = InputArgs.hasArg(OBJCOPY_regex)
                                      ? MatchStyle::Regex
                                      : MatchStyle::Wildcard;
-  MatchStyle SymbolMatchStyle = InputArgs.hasArg(OBJCOPY_regex)
-                                    ? MatchStyle::Regex
-                                    : InputArgs.hasArg(OBJCOPY_wildcard)
-                                          ? MatchStyle::Wildcard
+  MatchStyle SymbolMatchStyle =
+      InputArgs.hasArg(OBJCOPY_regex)      ? MatchStyle::Regex
+      : InputArgs.hasArg(OBJCOPY_wildcard) ? MatchStyle::Wildcard
                                            : MatchStyle::Literal;
   StringRef InputFormat, OutputFormat;
   if (InputArgs.hasArg(OBJCOPY_target)) {
     InputFormat = InputArgs.getLastArgValue(OBJCOPY_target);
     OutputFormat = InputArgs.getLastArgValue(OBJCOPY_target);
   } else {
     InputFormat = InputArgs.getLastArgValue(OBJCOPY_input_target);
     OutputFormat = InputArgs.getLastArgValue(OBJCOPY_output_target);
   }
parseStripOptions(ArrayRef<const char *> ArgsArr,
 
   CopyConfig Config;
 
   if (InputArgs.hasArg(STRIP_regex) && InputArgs.hasArg(STRIP_wildcard))
     return createStringError(errc::invalid_argument,
                              "--regex and --wildcard are incompatible");
   MatchStyle SectionMatchStyle =
       InputArgs.hasArg(STRIP_regex) ? MatchStyle::Regex : MatchStyle::Wildcard;
-  MatchStyle SymbolMatchStyle = InputArgs.hasArg(STRIP_regex)
-                                    ? MatchStyle::Regex
-                                    : InputArgs.hasArg(STRIP_wildcard)
-                                          ? MatchStyle::Wildcard
-                                          : MatchStyle::Literal;
+  MatchStyle SymbolMatchStyle =
+      InputArgs.hasArg(STRIP_regex)      ? MatchStyle::Regex
+      : InputArgs.hasArg(STRIP_wildcard) ? MatchStyle::Wildcard
   Config.AllowBrokenLinks = InputArgs.hasArg(STRIP_allow_broken_links);
   Config.StripDebug = InputArgs.hasArg(STRIP_strip_debug);
 
   if (InputArgs.hasArg(STRIP_discard_all, STRIP_discard_locals))
     Config.DiscardMode =
         InputArgs.hasFlag(STRIP_discard_all, STRIP_discard_locals)
             ? DiscardType::All
             : DiscardType::Locals;

llvm/tools/llvm-objcopy/ELF/ELFObjcopy.cpp

for (const auto &Phdr : *PhdrsOrErr) {
     Error Err = Error::success();
     for (auto Note : In.notes(Phdr, Err))
       if (Note.getType() == NT_GNU_BUILD_ID && Note.getName() == ELF_NOTE_GNU)
         return Note.getDesc();
     if (Err)
       return createFileError(Config.InputFilename, std::move(Err));
   }
 
-  return createFileError(
-      Config.InputFilename,
+  return createFileError(Config.InputFilename,
                          createStringError(llvm::errc::invalid_argument,
                                            "could not find build ID"));
 }
 
 static Expected<ArrayRef<uint8_t>>
 findBuildID(const CopyConfig &Config, const object::ELFObjectFileBase &In) {
   if (auto *O = dyn_cast<ELFObjectFile<ELF32LE>>(&In))
     return findBuildID(Config, *O->getELFFile());
   else if (auto *O = dyn_cast<ELFObjectFile<ELF64LE>>(&In))
     return findBuildID(Config, *O->getELFFile());
   else if (auto *O = dyn_cast<ELFObjectFile<ELF32BE>>(&In))
     return findBuildID(Config, *O->getELFFile());
   else if (auto *O = dyn_cast<ELFObjectFile<ELF64BE>>(&In))
     return findBuildID(Config, *O->getELFFile());
 
   llvm_unreachable("Bad file format");
 }
 
 template <class... Ts>
-static Error makeStringError(std::error_code EC, const Twine &Msg, Ts &&... Args) {
+static Error makeStringError(std::error_code EC, const Twine &Msg,
+                             Ts &&... Args) {
   std::string FullMsg = (EC.message() + ": " + Msg).str();
   return createStringError(EC, FullMsg.c_str(), std::forward<Ts>(Args)...);
 }
 
 #define MODEL_8 "%%%%%%%%"
 #define MODEL_16 MODEL_8 MODEL_8
 #define MODEL_32 (MODEL_16 MODEL_16)
 

 }
 
 static Error splitDWOToFile(const CopyConfig &Config, const Reader &Reader,
                             StringRef File, ElfType OutputElfType) {
   auto DWOFile = Reader.create(false);
   auto OnlyKeepDWOPred = [&DWOFile](const SectionBase &Sec) {
     return onlyKeepDWOPred(*DWOFile, Sec);
   };
-  if (Error E = DWOFile->removeSections(Config.AllowBrokenLinks,
-                                        OnlyKeepDWOPred))
+  if (Error E =
+          DWOFile->removeSections(Config.AllowBrokenLinks, OnlyKeepDWOPred))
     return E;
   if (Config.OutputArch) {
     DWOFile->Machine = Config.OutputArch.getValue().EMachine;
     DWOFile->OSABI = Config.OutputArch.getValue().OSABI;
   }
   FileBuffer FB(File);
   auto Writer = createWriter(Config, *DWOFile, FB, OutputElfType);
   if (Error E = Writer->finalize())
if ((!Config.SymbolsToKeep.empty() || Config.KeepFileSymbols) &&
     RemovePred = [&Obj, RemovePred](const SectionBase &Sec) {
       if (&Sec == Obj.SymbolTable || &Sec == Obj.SymbolTable->getStrTab())
         return false;
       return RemovePred(Sec);
     };
   }
 
   if (Config.CompressionType != DebugCompressionType::None)
-    replaceDebugSections(Obj, RemovePred, isCompressable,
-                         [&Config, &Obj](const SectionBase *S) {
-                           return &Obj.addSection<CompressedSection>(
-                                *S, Config.CompressionType);
-                         });
+    replaceDebugSections(
+        Obj, RemovePred, isCompressable, [&Config, &Obj](const SectionBase *S) {
+          return &Obj.addSection<CompressedSection>(*S, Config.CompressionType);
   else if (Config.DecompressDebugSections)
     replaceDebugSections(
         Obj, RemovePred,
         [](const SectionBase &S) { return isa<CompressedSection>(&S); },
         [&Obj](const SectionBase *S) {
           auto CS = cast<CompressedSection>(S);
           return &Obj.addSection<DecompressedSection>(*CS);
         });
static Error writeOutput(const CopyConfig &Config, Object &Obj, Buffer &Out,
   return Writer->write();
 }
 
 Error executeObjcopyOnIHex(const CopyConfig &Config, MemoryBuffer &In,
                            Buffer &Out) {
   IHexReader Reader(&In);
   std::unique_ptr<Object> Obj = Reader.create(true);
   const ElfType OutputElfType =
       getOutputElfType(Config.OutputArch.getValueOr(MachineInfo()));
   if (Error E = handleArgs(Config, *Obj, Reader, OutputElfType))
     return E;
   return writeOutput(Config, *Obj, Out, OutputElfType);
 }
 
 Error executeObjcopyOnRawBinary(const CopyConfig &Config, MemoryBuffer &In,
                                 Buffer &Out) {
   uint8_t NewSymbolVisibility =

llvm/tools/llvm-objcopy/ELF/Object.h

class Section : public SectionBase {
   ArrayRef<uint8_t> Contents;
   SectionBase *LinkSection = nullptr;
 
 public:
   explicit Section(ArrayRef<uint8_t> Data) : Contents(Data) {}
 
   void accept(SectionVisitor &Visitor) const override;
   void accept(MutableSectionVisitor &Visitor) override;
-  Error removeSectionReferences(bool AllowBrokenLinks,
+  Error removeSectionReferences(
+      bool AllowBrokenLinks,
       function_ref<bool(const SectionBase *)> ToRemove) override;
   void initialize(SectionTableRef SecTable) override;
   void finalize() override;
 };
 
 class OwnedDataSection : public SectionBase {
   MAKE_SEC_WRITER_FRIEND
 

 private:
   std::vector<uint32_t> Indexes;
   SymbolTableSection *Symbols = nullptr;
 
 public:
   virtual ~SectionIndexSection() {}
   void addIndex(uint32_t Index) {
     assert(Size > 0);
-    Indexes.push_back(Index);    
+    Indexes.push_back(Index);
   }
 
   void reserve(size_t NumSymbols) {
     Indexes.reserve(NumSymbols);
     Size = NumSymbols * 4;
-  }  
+  }
   void setSymTab(SymbolTableSection *SymTab) { Symbols = SymTab; }
   void initialize(SectionTableRef SecTable) override;
   void finalize() override;
   void accept(SectionVisitor &Visitor) const override;
   void accept(MutableSectionVisitor &Visitor) override;
 
   SectionIndexSection() {
     Name = ".symtab_shndx";
public:
   }
   const SectionIndexSection *getShndxTable() const { return SectionIndexTable; }
   void fillShndxTable();
   const SectionBase *getStrTab() const { return SymbolNames; }
   const Symbol *getSymbolByIndex(uint32_t Index) const;
   Symbol *getSymbolByIndex(uint32_t Index);
   void updateSymbols(function_ref<void(Symbol &)> Callable);
 
-  Error removeSectionReferences(bool AllowBrokenLinks,
+  Error removeSectionReferences(
+      bool AllowBrokenLinks,
       function_ref<bool(const SectionBase *)> ToRemove) override;
   void initialize(SectionTableRef SecTable) override;
   void finalize() override;
   void accept(SectionVisitor &Visitor) const override;
   void accept(MutableSectionVisitor &Visitor) override;
   Error removeSymbols(function_ref<bool(const Symbol &)> ToRemove) override;
   void replaceSectionReferences(
       const DenseMap<SectionBase *, SectionBase *> &FromTo) override;
class RelocationSection
   MAKE_SEC_WRITER_FRIEND
 
   std::vector<Relocation> Relocations;
 
 public:
   void addRelocation(Relocation Rel) { Relocations.push_back(Rel); }
   void accept(SectionVisitor &Visitor) const override;
   void accept(MutableSectionVisitor &Visitor) override;
-  Error removeSectionReferences(bool AllowBrokenLinks,
+  Error removeSectionReferences(
+      bool AllowBrokenLinks,
       function_ref<bool(const SectionBase *)> ToRemove) override;
   Error removeSymbols(function_ref<bool(const Symbol &)> ToRemove) override;
   void markSymbols() override;
   void replaceSectionReferences(
       const DenseMap<SectionBase *, SectionBase *> &FromTo) override;
 
   static bool classof(const SectionBase *S) {
     if (S->OriginalFlags & ELF::SHF_ALLOC)

llvm/tools/llvm-objcopy/ELF/Object.cpp

template <class ELFT> void ELFWriter<ELFT>::writePhdr(const Segment &Seg) {
   Phdr.p_vaddr = Seg.VAddr;
   Phdr.p_paddr = Seg.PAddr;
   Phdr.p_filesz = Seg.FileSize;
   Phdr.p_memsz = Seg.MemSize;
   Phdr.p_align = Seg.Align;
 }
 
 Error SectionBase::removeSectionReferences(
-    bool AllowBrokenLinks,
-    function_ref<bool(const SectionBase *)> ToRemove) {
+    bool AllowBrokenLinks, function_ref<bool(const SectionBase *)> ToRemove) {
   return Error::success();
 }
 
 Error SectionBase::removeSymbols(function_ref<bool(const Symbol &)> ToRemove) {
   return Error::success();
 }
 
 void SectionBase::initialize(SectionTableRef SecTable) {}
void SymbolTableSection::addSymbol(Twine Name, uint8_t Bind, uint8_t Type,
   Sym.Visibility = Visibility;
   Sym.Size = SymbolSize;
   Sym.Index = Symbols.size();
   Symbols.emplace_back(std::make_unique<Symbol>(Sym));
   Size += this->EntrySize;
 }
 
 Error SymbolTableSection::removeSectionReferences(
-    bool AllowBrokenLinks,
-    function_ref<bool(const SectionBase *)> ToRemove) {
+    bool AllowBrokenLinks, function_ref<bool(const SectionBase *)> ToRemove) {
   if (ToRemove(SectionIndexTable))
     SectionIndexTable = nullptr;
   if (ToRemove(SymbolNames)) {
     if (!AllowBrokenLinks)
       return createStringError(
           llvm::errc::invalid_argument,
           "string table '%s' cannot be removed because it is "
           "referenced by the symbol table '%s'",
void SymbolTableSection::finalize() {
   Link = SymbolNames == nullptr ? 0 : SymbolNames->Index;
   Info = MaxLocalIndex + 1;
 }
 
 void SymbolTableSection::prepareForLayout() {
   // Reserve proper amount of space in section index table, so we can
   // layout sections correctly. We will fill the table with correct
   // indexes later in fillShdnxTable.
-  if (SectionIndexTable)  
+  if (SectionIndexTable)
     SectionIndexTable->reserve(Symbols.size());
 
   // Add all of our strings to SymbolNames so that SymbolNames has the right
   // size before layout is decided.
   // If the symbol names section has been removed, don't try to add strings to
   // the table.
   if (SymbolNames != nullptr)
     for (std::unique_ptr<Symbol> &Sym : Symbols)
void SymbolTableSection::accept(SectionVisitor &Visitor) const {
   Visitor.visit(*this);
 }
 
 void SymbolTableSection::accept(MutableSectionVisitor &Visitor) {
   Visitor.visit(*this);
 }
 
 Error RelocationSection::removeSectionReferences(
-    bool AllowBrokenLinks,
-    function_ref<bool(const SectionBase *)> ToRemove) {
+    bool AllowBrokenLinks, function_ref<bool(const SectionBase *)> ToRemove) {
   if (ToRemove(Symbols)) {
     if (!AllowBrokenLinks)
       return createStringError(
           llvm::errc::invalid_argument,
           "symbol table '%s' cannot be removed because it is "
           "referenced by the relocation section '%s'",
           Symbols->Name.data(), this->Name.data());
     Symbols = nullptr;
auto Data = ArrayRef<uint8_t>(
       MemBuf->getBufferSize());
   auto &DataSection = Obj->addSection<Section>(Data);
   DataSection.Name = ".data";
   DataSection.Type = ELF::SHT_PROGBITS;
   DataSection.Size = Data.size();
   DataSection.Flags = ELF::SHF_ALLOC | ELF::SHF_WRITE;
 
   std::string SanitizedFilename = MemBuf->getBufferIdentifier().str();
-  std::replace_if(std::begin(SanitizedFilename), std::end(SanitizedFilename),
-                  [](char C) { return !isalnum(C); }, '_');
+  std::replace_if(
+      std::begin(SanitizedFilename), std::end(SanitizedFilename),
   Twine Prefix = Twine("_binary_") + SanitizedFilename;
 
   SymTab->addSymbol(Prefix + "_start", STB_GLOBAL, STT_NOTYPE, &DataSection,
                     /*Value=*/0, NewSymbolVisibility, 0, 0);
   SymTab->addSymbol(Prefix + "_end", STB_GLOBAL, STT_NOTYPE, &DataSection,
                     /*Value=*/DataSection.Size, NewSymbolVisibility, 0, 0);
   SymTab->addSymbol(Prefix + "_size", STB_GLOBAL, STT_NOTYPE, nullptr,
                     /*Value=*/DataSection.Size, NewSymbolVisibility, SHN_ABS,
for (Segment &Child : Obj.segments())
     setParentSegment(Child);
   setParentSegment(ElfHdr);
   setParentSegment(PrHdr);
 }
 
 template <class ELFT>
 void ELFBuilder<ELFT>::initGroupSection(GroupSection *GroupSec) {
   if (GroupSec->Align % sizeof(ELF::Elf32_Word) != 0)
-    error("invalid alignment " + Twine(GroupSec->Align) + " of group section '" +
-          GroupSec->Name + "'");
+    error("invalid alignment " + Twine(GroupSec->Align) +
+          " of group section '" + GroupSec->Name + "'");
   SectionTableRef SecTable = Obj.sections();
   if (GroupSec->Link != SHN_UNDEF) {
     auto SymTab = SecTable.template getSectionOfType<SymbolTableSection>(
         GroupSec->Link,
         "link field value '" + Twine(GroupSec->Link) + "' in section '" +
             GroupSec->Name + "' is invalid",
         "link field value '" + Twine(GroupSec->Link) + "' in section '" +
             GroupSec->Name + "' is not a symbol table");

 }
 
 template <class ELFT>
 ELFWriter<ELFT>::ELFWriter(Object &Obj, Buffer &Buf, bool WSH,
                            bool OnlyKeepDebug)
     : Writer(Obj, Buf), WriteSectionHeaders(WSH && Obj.HadShdrs),
       OnlyKeepDebug(OnlyKeepDebug) {}
 
-Error Object::removeSections(bool AllowBrokenLinks,
-    std::function<bool(const SectionBase &)> ToRemove) {
+Error Object::removeSections(
+    bool AllowBrokenLinks, std::function<bool(const SectionBase &)> ToRemove) {
 
   auto Iter = std::stable_partition(
       std::begin(Sections), std::end(Sections), [=](const SecPtr &Sec) {
         if (ToRemove(*Sec))
           return false;
         if (auto RelSec = dyn_cast<RelocationSectionBase>(Sec.get())) {
           if (auto ToRelSec = RelSec->getSection())
             return !ToRemove(*ToRelSec);
Error Object::removeSections(
   }
 
   // For each section that remains alive, we want to remove the dead references.
   // This either might update the content of the section (e.g. remove symbols
   // from symbol table that belongs to removed section) or trigger an error if
   // a live section critically depends on a section being removed somehow
   // (e.g. the removed section is referenced by a relocation).
   for (auto &KeepSec : make_range(std::begin(Sections), Iter)) {
-    if (Error E = KeepSec->removeSectionReferences(AllowBrokenLinks,
-            [&RemoveSections](const SectionBase *Sec) {
+    if (Error E = KeepSec->removeSectionReferences(
+            AllowBrokenLinks, [&RemoveSections](const SectionBase *Sec) {
               return RemoveSections.find(Sec) != RemoveSections.end();
             }))
       return E;
   }
 
   // Transfer removed sections into the Object RemovedSections container for use
   // later.
   std::move(Iter, Sections.end(), std::back_inserter(RemovedSections));
Error IHexWriter::write() {
   return Buf.commit();
 }
 
 Error IHexWriter::checkSection(const SectionBase &Sec) {
   uint64_t Addr = sectionPhysicalAddr(&Sec);
   if (addressOverflows32bit(Addr) || addressOverflows32bit(Addr + Sec.Size - 1))
     return createStringError(
         errc::invalid_argument,
-        "Section '%s' address range [0x%llx, 0x%llx] is not 32 bit", Sec.Name.c_str(),
-        Addr, Addr + Sec.Size - 1);
+        "Section '%s' address range [0x%llx, 0x%llx] is not 32 bit",
+        Sec.Name.c_str(), Addr, Addr + Sec.Size - 1);
   return Error::success();
 }
 
 Error IHexWriter::finalize() {
   bool UseSegments = false;
   auto ShouldWrite = [](const SectionBase &Sec) {
     return (Sec.Flags & ELF::SHF_ALLOC) && (Sec.Type != ELF::SHT_NOBITS);
   };

llvm/tools/llvm-objcopy/InstallNameToolOpts.td

 include "llvm/Option/OptParser.td"
 
 def help : Flag<["--"], "help">;
 def h : Flag<["-"], "h">, Alias<help>;
 
 def add_rpath : Option<["-", "--"], "add_rpath", KIND_SEPARATE>,
                 HelpText<"Add new rpath">;
 
-def delete_rpath: Option<["-", "--"], "delete_rpath", KIND_SEPARATE>,
+def delete_rpath : Option<["-", "--"], "delete_rpath", KIND_SEPARATE>,
                    HelpText<"Delete specified rpath">;
 
-def rpath: MultiArg<["-", "--"], "rpath", 2>,
+def rpath : MultiArg<["-", "--"], "rpath", 2>,
             HelpText<"Change rpath path name">;
 
-def id : Option<["-","--"], "id", KIND_SEPARATE>,
-                 HelpText<"Change dynamic shared library id">;
+def id : Option<["-", "--"], "id", KIND_SEPARATE>,
 
-def change: MultiArg<["-", "--"], "change", 2>,
+def change : MultiArg<["-", "--"], "change", 2>,
              HelpText<"Change dependent shared library install name">;
 
-def version : Flag<["--"], "version">,
-              HelpText<"Print the version and exit.">;
+def version : Flag<["--"], "version">, HelpText<"Print the version and exit.">;

llvm/tools/llvm-objcopy/ObjcopyOpts.td

def I : JoinedOrSeparate<["-"], "I">,
         HelpText<"Alias for --input-target">;
 
 defm output_target : Eq<"output-target", "Format of the output file">,
                      Values<"binary">;
 def O : JoinedOrSeparate<["-"], "O">,
         Alias<output_target>,
         HelpText<"Alias for --output-target">;
 
-defm new_symbol_visibility : Eq<"new-symbol-visibility", "Visibility of "
-                                "symbols generated for binary input or added"
-                                " with --add-symbol unless otherwise"
-                                " specified. The default value is 'default'.">;
+defm new_symbol_visibility
+    : Eq<"new-symbol-visibility",
+         "Visibility of symbols generated for binary input or added with "
+         "--add-symbol unless otherwise specified. The default value is "
+         "'default'.">;
 
 def compress_debug_sections : Flag<["--"], "compress-debug-sections">;
 def compress_debug_sections_eq
     : Joined<["--"], "compress-debug-sections=">,
       MetaVarName<"[ zlib | zlib-gnu ]">,
       HelpText<"Compress DWARF debug sections using specified style. Supported "
                "styles: 'zlib-gnu' and 'zlib'">;
 def decompress_debug_sections : Flag<["--"], "decompress-debug-sections">,
: Eq<"rename-section",
          "readonly, debug, code, data, rom, share, contents, merge, strings.">,
       MetaVarName<"old=new[,flag1,...]">;
 defm redefine_symbol
     : Eq<"redefine-sym", "Change the name of a symbol old to new">,
       MetaVarName<"old=new">;
 defm redefine_symbols
     : Eq<"redefine-syms",
          "Reads a list of symbol pairs from <filename> and runs as if "
-         "--redefine-sym=<old>=<new> is set for each one. <filename> "
-         "contains two symbols per line separated with whitespace and may "
-         "contain comments beginning with '#'. Leading and trailing "
-         "whitespace is stripped from each line. May be repeated to read "
-         "symbols from many files.">,         
+         "--redefine-sym=<old>=<new> is set for each one. <filename> contains "
+         "two symbols per line separated with whitespace and may contain "
+         "comments beginning with '#'. Leading and trailing whitespace is "
+         "stripped from each line. May be repeated to read symbols from many "
+         "files.">,
       MetaVarName<"filename">;
 
 defm only_section : Eq<"only-section", "Remove all but <section>">,
                     MetaVarName<"section">;
 def j : JoinedOrSeparate<["-"], "j">,
         Alias<only_section>,
         HelpText<"Alias for --only-section">;
 defm add_section
     : Eq<"add-section",
          "Make a section named <section> with the contents of <file>.">,
       MetaVarName<"section=file">;
 
 defm set_section_alignment
     : Eq<"set-section-alignment", "Set alignment for a given section.">,
       MetaVarName<"section=align">;
 
 defm set_section_flags
     : Eq<"set-section-flags",
          "Set section flags for a given section. Flags supported for GNU "
          "compatibility: alloc, load, noload, readonly, debug, code, data, "
          "rom, share, contents, merge, strings.">,
       MetaVarName<"section=flag1[,flag2,...]">;
 
-def S : Flag<["-"], "S">,
-        Alias<strip_all>,
-        HelpText<"Alias for --strip-all">;
+def S : Flag<["-"], "S">, Alias<strip_all>, HelpText<"Alias for --strip-all">;
 def strip_dwo : Flag<["--"], "strip-dwo">,
                 HelpText<"Remove all DWARF .dwo sections from file">;
 def strip_non_alloc
     : Flag<["--"], "strip-non-alloc">,
       HelpText<"Remove all non-allocated sections outside segments">;
 defm strip_unneeded_symbol
     : Eq<"strip-unneeded-symbol",
          "Remove symbol <symbol> if it is not needed by relocations">,
       MetaVarName<"symbol">;
 defm strip_unneeded_symbols
     : Eq<"strip-unneeded-symbols",
-         "Reads a list of symbols from <filename> and removes them "
-         "if they are not needed by relocations">,
+         "Reads a list of symbols from <filename> and removes them if they are "
+         "not needed by relocations">,
       MetaVarName<"filename">;
 
 def extract_dwo
     : Flag<["--"], "extract-dwo">,
       HelpText<
           "Remove all sections that are not DWARF .dwo sections from file">;
 
 defm extract_partition

 defm strip_symbols
     : Eq<"strip-symbols",
          "Reads a list of symbols from <filename> and removes them.">,
       MetaVarName<"filename">;
 
 defm keep_symbols
     : Eq<"keep-symbols",
          "Reads a list of symbols from <filename> and runs as if "
-         "--keep-symbol=<symbol> is set for each one. <filename> "
-         "contains one symbol per line and may contain comments beginning with "
-         "'#'. Leading and trailing whitespace is stripped from each line. May "
-         "be repeated to read symbols from many files.">,
+         "--keep-symbol=<symbol> is set for each one. <filename> contains one "
+         "symbol per line and may contain comments beginning with '#'. Leading "
+         "and trailing whitespace is stripped from each line. May be repeated "
+         "to read symbols from many files.">,
       MetaVarName<"filename">;
 
 defm dump_section
     : Eq<"dump-section",
          "Dump contents of section named <section> into file <file>">,
       MetaVarName<"section=file">;
 defm prefix_symbols
     : Eq<"prefix-symbols", "Add <prefix> to the start of every symbol name">,
       MetaVarName<"prefix">;
 
 defm prefix_alloc_sections
-    : Eq<"prefix-alloc-sections", "Add <prefix> to the start of every allocated section name">,
+    : Eq<"prefix-alloc-sections",
+         "Add <prefix> to the start of every allocated section name">,
       MetaVarName<"prefix">;
 
 defm build_id_link_dir
     : Eq<"build-id-link-dir", "Set directory for --build-id-link-input and "
                               "--build-id-link-output to <dir>">,
       MetaVarName<"dir">;
 defm build_id_link_input
     : Eq<"build-id-link-input", "Hard-link the input to <dir>/xx/xxx<suffix> "
                                 "name derived from hex build ID">,
       MetaVarName<"suffix">;
 defm build_id_link_output
     : Eq<"build-id-link-output", "Hard-link the output to <dir>/xx/xxx<suffix> "
                                  "name derived from hex build ID">,
       MetaVarName<"suffix">;
 
-defm set_start : Eq<"set-start", "Set the start address to <addr>. Overrides "
-                    "any previous --change-start or --adjust-start values.">,
-                 MetaVarName<"addr">;
-defm change_start : Eq<"change-start", "Add <incr> to the start address. Can be "                        
-                       "specified multiple times, all values will be applied "
-                       "cumulatively.">,
-                    MetaVarName<"incr">;
+defm set_start
+    : Eq<"set-start", "Set the start address to <addr>. Overrides any previous "
+                      "--change-start or --adjust-start values.">,
+defm change_start
+    : Eq<"change-start",
+         "Add <incr> to the start address. Can be specified multiple times, "
+         "all values will be applied cumulatively.">,
 def adjust_start : JoinedOrSeparate<["--"], "adjust-start">,
                    Alias<change_start>,
                    HelpText<"Alias for --change-start">;
 
 defm add_symbol
-    : Eq<"add-symbol", "Add new symbol <name> to .symtab. Accepted flags: "
-         "global, local, weak, default, hidden, protected, file, section, object, "
-         "function, indirect-function. Accepted but ignored for "
-         "compatibility: debug, constructor, warning, indirect, synthetic, "
-         "unique-object, before.">,
+    : Eq<"add-symbol",
+         "Add new symbol <name> to .symtab. Accepted flags: global, local, "
+         "weak, default, hidden, protected, file, section, object, function, "
+         "indirect-function. Accepted but ignored for compatibility: debug, "
+         "constructor, warning, indirect, synthetic, unique-object, before.">,
       MetaVarName<"name=[section:]value[,flags]">;

llvm/tools/llvm-objcopy/StripOpts.td

 include "CommonOpts.td"
 
-def output : JoinedOrSeparate<["-"], "o">, HelpText<"Write output to <file>">,
+def output : JoinedOrSeparate<["-"], "o">,
+             HelpText<"Write output to <file>">,
              MetaVarName<"<file>">;
 
-def s : Flag<["-"], "s">,
-        Alias<strip_all>,
-        HelpText<"Alias for --strip-all">;
+def s : Flag<["-"], "s">, Alias<strip_all>, HelpText<"Alias for --strip-all">;
 def no_strip_all : Flag<["--"], "no-strip-all">,
                    HelpText<"Disable --strip-all">;
 
 def d : Flag<["-"], "d">,
         Alias<strip_debug>,
         HelpText<"Alias for --strip-debug">;
 def S : Flag<["-"], "S">,
         Alias<strip_debug>,
         HelpText<"Alias for --strip-debug">;
 
-def strip_swift_symbols : Flag<["-"], "T">,
-                          HelpText<"Remove Swift symbols">;
+def strip_swift_symbols : Flag<["-"], "T">, HelpText<"Remove Swift symbols">;

llvm/tools/llvm-objcopy/llvm-objcopy.cpp

int main(int argc, char **argv) {
   cl::ExpandResponseFiles(Saver,
                           Triple(sys::getProcessTriple()).isOSWindows()
                               ? cl::TokenizeWindowsCommandLine
                               : cl::TokenizeGNUCommandLine,
                           NewArgv);
 
   auto Args = makeArrayRef(NewArgv).drop_front();
   Expected<DriverConfig> DriverConfig =
-      (Tool == ToolType::Strip) ? parseStripOptions(Args, reportWarning)
-                                : ((Tool == ToolType::InstallNameTool)
-                                       ? parseInstallNameToolOptions(Args)
-                                       : parseObjcopyOptions(Args, reportWarning));
+      (Tool == ToolType::Strip)
+          ? parseStripOptions(Args, reportWarning)
   if (!DriverConfig) {
     logAllUnhandledErrors(DriverConfig.takeError(),
                           WithColor::error(errs(), ToolName));
     return 1;
   }
   for (CopyConfig &CopyConfig : DriverConfig->CopyConfigs) {
     if (Error E = executeObjcopy(CopyConfig)) {
       logAllUnhandledErrors(std::move(E), WithColor::error(errs(), ToolName));
       return 1;
     }
   }
 
   return 0;
 }