[llvm-objdump] Rename --disassemble-functions to --disassemble-symbols

[MaskRay]

Summary

https://bugs.llvm.org/show_bug.cgi?id=41910

The feature can disassemble data and the new option name reflects its
more generic usage.

[jhenderson]

LGTM. Thanks for doing this!

llvm/docs/CommandGuide/llvm-objdump.rst

 .. option:: -d, --disassemble
 
   Disassemble all text sections found in the input files.
 
 .. option:: -D, --disassemble-all
 
   Disassemble all sections found in the input files.
   
-.. option:: --disassemble-functions=<symbol1[,symbol2,...]>
+.. option:: --disassemble-symbols=<symbol1[,symbol2,...]>
 
   Disassemble only the specified symbols. Takes demangled symbol names when
   :option:`--demangle` is specified, otherwise takes mangled symbol names.
   Implies :option:`--disassemble`.
 
 .. option:: --dwarf=<value>
 
   Dump the specified DWARF debug sections. The supported values are:

llvm/test/tools/llvm-objdump/X86/disassemble-functions-mangling.test

-## Show that the --disassemble-functions switch takes demangled names when
+## Show that the --disassemble-symbols switch takes demangled names when
 ## --demangle is specified, otherwise the switch takes mangled names.
 
 # RUN: yaml2obj %s -o %t.o
 
-## --disassemble-functions without --demangle.
-# RUN: llvm-objdump --disassemble-functions=_Z3foov %t.o | FileCheck %s --check-prefix=MANGLED
-# RUN: llvm-objdump --disassemble-functions='foo()' %t.o 2>&1 \
+## --disassemble-symbols without --demangle.
+# RUN: llvm-objdump --disassemble-symbols=_Z3foov %t.o | FileCheck %s --check-prefix=MANGLED
+# RUN: llvm-objdump --disassemble-symbols='foo()' %t.o 2>&1 \
 # RUN:   | FileCheck %s --check-prefix=MANGLED-MISS
-# RUN: llvm-objdump --disassemble-functions=foo %t.o 2>&1 \
+# RUN: llvm-objdump --disassemble-symbols=foo %t.o 2>&1 \
 # RUN:   | FileCheck %s --check-prefix=MANGLED-MISS
-# RUN: llvm-objdump --disassemble-functions='i,f' %t.o | FileCheck %s --check-prefix=NOMANGLE
+# RUN: llvm-objdump --disassemble-symbols='i,f' %t.o | FileCheck %s --check-prefix=NOMANGLE
 
-## --disassemble-functions with --demangle.
-# RUN: llvm-objdump -C --disassemble-functions='foo()' %t.o | FileCheck %s --check-prefix=DEMANGLED
-# RUN: llvm-objdump -C --disassemble-functions='_Z3foov' %t.o 2>&1 \
+## --disassemble-symbols with --demangle.
+# RUN: llvm-objdump -C --disassemble-symbols='foo()' %t.o | FileCheck %s --check-prefix=DEMANGLED
+# RUN: llvm-objdump -C --disassemble-symbols='_Z3foov' %t.o 2>&1 \
 # RUN:   | FileCheck %s --check-prefix=DEMANGLED-MISS
-# RUN: llvm-objdump -C --disassemble-functions='i,f' %t.o | FileCheck %s --check-prefix=NOMANGLE
-# RUN: llvm-objdump -C --disassemble-functions='std::allocator<wchar_t>::allocator()' %t.o 2>&1 \
+# RUN: llvm-objdump -C --disassemble-symbols='i,f' %t.o | FileCheck %s --check-prefix=NOMANGLE
+# RUN: llvm-objdump -C --disassemble-symbols='std::allocator<wchar_t>::allocator()' %t.o 2>&1 \
 # RUN:   | FileCheck %s --check-prefix=DEMANGLED-MULTI
 
 # MANGLED: <_Z3foov>:
-# MANGLED-MISS: warning: '{{.*}}': failed to disassemble missing function foo
+# MANGLED-MISS: warning: '{{.*}}': failed to disassemble missing symbol foo
 
 # DEMANGLED: <foo()>:
-# DEMANGLED-MISS: warning: '{{.*}}': failed to disassemble missing function _Z3foov
+# DEMANGLED-MISS: warning: '{{.*}}': failed to disassemble missing symbol _Z3foov
 
 # NOMANGLE: <i>:
 # NOMANGLE: <f>:
 
 # DEMANGLED-MULTI: <std::allocator<wchar_t>::allocator()>:
 # DEMANGLED-MULTI: <std::allocator<wchar_t>::allocator()>:
 
 --- !ELF

llvm/test/tools/llvm-objdump/X86/disassemble-functions.test

 ## Show that the --diassemble-functions switch disassembles only the specified
 ## functions.
 
 # RUN: yaml2obj -o %t.out %p/Inputs/simple-executable-x86_64.yaml
-# RUN: llvm-objdump -d %t.out --disassemble-functions=main \
+# RUN: llvm-objdump -d %t.out --disassemble-symbols=main \
 # RUN:   | FileCheck %s --check-prefix=MAIN --implicit-check-not=foo --implicit-check-not=somedata
-# RUN: llvm-objdump -d %t.out --disassemble-functions=main,foo \
+# RUN: llvm-objdump -d %t.out --disassemble-symbols=main,foo \
 # RUN:   | FileCheck %s --check-prefixes=MAIN,FOO --implicit-check-not=somedata
 
 # FOO: <foo>:
 # MAIN: <main>:
 
 ## Unknown symbol name.
-# RUN: llvm-objdump -d %t.out --disassemble-functions=baz \
+# RUN: llvm-objdump -d %t.out --disassemble-symbols=baz \
 # RUN:   | FileCheck %s --implicit-check-not=Disassembly
 
 ## Data symbol.
-# RUN: llvm-objdump -d %t.out --disassemble-functions=a \
+# RUN: llvm-objdump -d %t.out --disassemble-symbols=a \
 # RUN:   | FileCheck %s --implicit-check-not=Disassembly
 
 ## Data symbol + --disassemble-all.
-# RUN: llvm-objdump -D %t.out --disassemble-functions=a \
+# RUN: llvm-objdump -D %t.out --disassemble-symbols=a \
 # RUN:   | FileCheck %s --check-prefix=DATA
 
 # DATA: a:

llvm/test/tools/llvm-objdump/X86/disassemble-implied-by-disassemble-functions.test

-## Check that --disassemble-functions implies --disassemble.
-# RUN: yaml2obj %s | llvm-objdump - --disassemble-functions=main | FileCheck %s
+## Check that --disassemble-symbols implies --disassemble.
+# RUN: yaml2obj %s | llvm-objdump - --disassemble-symbols=main | FileCheck %s
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_X86_64
 Sections:

llvm/test/tools/llvm-objdump/X86/warn-missing-disasm-func.test

-## Warn if --disassemble-functions specifies an unknown symbol.
+## Warn if --disassemble-symbols specifies an unknown symbol.
 
 # RUN: yaml2obj -o %t.o %s
 # RUN: rm -f %t.a
 # RUN: llvm-ar qc %t.a %t.o %t.o
-# RUN: llvm-objdump --disassemble-functions=foo %t.o 2>&1 | FileCheck %s
-# RUN: llvm-objdump --disassemble-functions=foo %t.a 2>&1 | FileCheck %s --check-prefix=MULTI
+# RUN: llvm-objdump --disassemble-symbols=foo %t.o 2>&1 | FileCheck %s
+# RUN: llvm-objdump --disassemble-symbols=foo %t.a 2>&1 | FileCheck %s --check-prefix=MULTI
 
 --- !ELF
 FileHeader:
   Class:   ELFCLASS64
   Data:    ELFDATA2LSB
   Type:    ET_REL
   Machine: EM_X86_64
 
-# CHECK: warning: {{.*}}: failed to disassemble missing function foo
+# CHECK: warning: {{.*}}: failed to disassemble missing symbol foo
 
 # MULTI: file format elf64-x86-64
-# MULTI: warning: {{.*}}: failed to disassemble missing function foo
+# MULTI: warning: {{.*}}: failed to disassemble missing symbol foo
 # MULTI: file format elf64-x86-64
-# MULTI: warning: {{.*}}: failed to disassemble missing function foo
+# MULTI: warning: {{.*}}: failed to disassemble missing symbol foo

llvm/tools/llvm-objdump/llvm-objdump.cpp

cl::opt<bool> DisassembleAll(
     cl::desc("Display assembler mnemonics for the machine instructions"),
     cl::cat(ObjdumpCat));
 static cl::alias DisassembleAllShort("D",
                                      cl::desc("Alias for --disassemble-all"),
                                      cl::NotHidden, cl::Grouping,
                                      cl::aliasopt(DisassembleAll));
 
 static cl::list<std::string>
-    DisassembleFunctions("disassemble-functions", cl::CommaSeparated,
-                         cl::desc("List of functions to disassemble. "
-                                  "Accept demangled names when --demangle is "
-                                  "specified, otherwise accept mangled names"),
-                         cl::cat(ObjdumpCat));
+    DisassembleSymbols("disassemble-symbols", cl::CommaSeparated,
+                       cl::desc("List of symbols to disassemble. "
 
 static cl::opt<bool> DisassembleZeroes(
     "disassemble-zeroes",
     cl::desc("Do not skip blocks of zeroes when disassembling"),
     cl::cat(ObjdumpCat));
 static cl::alias
     DisassembleZeroesShort("z", cl::desc("Alias for --disassemble-zeroes"),
                            cl::NotHidden, cl::Grouping,

 static cl::opt<bool>
     Wide("wide", cl::desc("Ignored for compatibility with GNU objdump"),
          cl::cat(ObjdumpCat));
 static cl::alias WideShort("w", cl::Grouping, cl::aliasopt(Wide));
 
 static cl::extrahelp
     HelpResponse("\nPass @FILE as argument to read options from FILE.\n");
 
-static StringSet<> DisasmFuncsSet;
+static StringSet<> DisasmSymbolSet;
 StringSet<> FoundSectionSet;
 static StringRef ToolName;
 
 namespace {
 struct FilterResult {
   // True if the section should not be skipped.
   bool Keep;
 
for (const auto &ExportEntry : COFFObj->export_directories()) {
         AllSymbols[Sec->second].emplace_back(VA, Name, ELF::STT_NOTYPE);
       } else
         AbsoluteSymbols.emplace_back(VA, Name, ELF::STT_NOTYPE);
     }
   }
 
   // Sort all the symbols, this allows us to use a simple binary search to find
   // a symbol near an address.
-  StringSet<> FoundDisasmFuncsSet;
+  StringSet<> FoundDisasmSymbolSet;
   for (std::pair<const SectionRef, SectionSymbolsTy> &SecSyms : AllSymbols)
     array_pod_sort(SecSyms.second.begin(), SecSyms.second.end());
   array_pod_sort(AbsoluteSymbols.begin(), AbsoluteSymbols.end());
 
   for (const SectionRef &Section : ToolSectionFilter(*Obj)) {
     if (FilterSections.empty() && !DisassembleAll &&
         (!Section.isText() || Section.isVirtual()))
       continue;
for (const SectionRef &Section : ToolSectionFilter(*Obj)) {
     std::vector<RelocationRef>::const_iterator RelCur = Rels.begin();
     std::vector<RelocationRef>::const_iterator RelEnd = Rels.end();
     // Disassemble symbol by symbol.
     for (unsigned SI = 0, SE = Symbols.size(); SI != SE; ++SI) {
       std::string SymbolName = Symbols[SI].Name.str();
       if (Demangle)
         SymbolName = demangle(SymbolName);
 
-      // Skip if --disassemble-functions is not empty and the symbol is not in
+      // Skip if --disassemble-symbols is not empty and the symbol is not in
       // the list.
-      if (!DisasmFuncsSet.empty() && !DisasmFuncsSet.count(SymbolName))
+      if (!DisasmSymbolSet.empty() && !DisasmSymbolSet.count(SymbolName))
         continue;
 
       uint64_t Start = Symbols[SI].Addr;
       if (Start < SectionAddr || StopAddress <= Start)
         continue;
       else
-        FoundDisasmFuncsSet.insert(SymbolName);
+        FoundDisasmSymbolSet.insert(SymbolName);
 
       // The end is the section end, the beginning of the next symbol, or
       // --stop-address.
       uint64_t End = std::min<uint64_t>(SectionAddr + SectSize, StopAddress);
       if (SI + 1 < SE)
         End = std::min(End, Symbols[SI + 1].Addr);
       if (Start >= End || End <= StartAddress)
         continue;
for (unsigned SI = 0, SE = Symbols.size(); SI != SE; ++SI) {
             ++RelCur;
           }
         }
 
         Index += Size;
       }
     }
   }
-  StringSet<> MissingDisasmFuncsSet =
-      set_difference(DisasmFuncsSet, FoundDisasmFuncsSet);
-  for (StringRef MissingDisasmFunc : MissingDisasmFuncsSet.keys())
-    reportWarning("failed to disassemble missing function " + MissingDisasmFunc,
-                  FileName);
+  StringSet<> MissingDisasmSymbolSet =
+      set_difference(DisasmSymbolSet, FoundDisasmSymbolSet);
+  for (StringRef Sym : MissingDisasmSymbolSet.keys())
+    reportWarning("failed to disassemble missing symbol " + Sym, FileName);
 }
 
 static void disassembleObject(const ObjectFile *Obj, bool InlineRelocs) {
   const Target *TheTarget = getTarget(Obj);
 
   // Package up features to be passed to target/subtarget
   SubtargetFeatures Features = Obj->getFeatures();
   if (!MAttrs.empty())
int main(int argc, char **argv) {
   if (InputFilenames.empty())
     InputFilenames.push_back("a.out");
 
   if (AllHeaders)
     ArchiveHeaders = FileHeaders = PrivateHeaders = Relocations =
         SectionHeaders = SymbolTable = true;
 
   if (DisassembleAll || PrintSource || PrintLines ||
-      (!DisassembleFunctions.empty()))
+      !DisassembleSymbols.empty())
     Disassemble = true;
 
   if (!ArchiveHeaders && !Disassemble && DwarfDumpType == DIDT_Null &&
       !DynamicRelocations && !FileHeaders && !PrivateHeaders && !RawClangAST &&
       !Relocations && !SectionHeaders && !SectionContents && !SymbolTable &&
       !UnwindInfo && !FaultMapSection &&
       !(MachOOpt &&
         (Bind || DataInCode || DylibId || DylibsUsed || ExportsTrie ||
          FirstPrivateHeader || IndirectSymbols || InfoPlist || LazyBind ||
          LinkOptHints || ObjcMetaData || Rebase || UniversalHeaders ||
          WeakBind || !FilterSections.empty()))) {
     cl::PrintHelpMessage();
     return 2;
   }
 
-  DisasmFuncsSet.insert(DisassembleFunctions.begin(),
-                        DisassembleFunctions.end());
+  DisasmSymbolSet.insert(DisassembleSymbols.begin(), DisassembleSymbols.end());
 
   llvm::for_each(InputFilenames, dumpInput);
 
   warnOnNoMatchForSections();
 
   return EXIT_SUCCESS;
 }