llvm-nm: Add -radix option

[khemant]

Summary

nm can print symbol values in different radixes. This option enables llvm-nm to output similarly.

[echristo]

LGTM.

-eric

[khemant]

I will modify the test to have source instead of binary and assemble it.

[echristo]

Any reason? (Personally I don't mind and prefer that, but I'm also not
going to insist on it because other people like it the other way)

-eric

docs/CommandGuide/llvm-nm.rst

 .. option:: --size-sort
 
  Sort symbols by size.
 
 .. option:: --undefined-only, -u
 
  Print only symbols referenced but not defined in this file.
 
+.. option:: --radix=RADIX, -t
+
+ Specify the radix of the symbol address(es). Values accepted d(decimal),
+ x(hexadecomal) and o(octal).
+
 BUGS
 ----
 
  * :program:`llvm-nm` cannot demangle C++ mangled names, like GNU :program:`nm`
    can.
 
  * :program:`llvm-nm` does not support the full set of arguments that GNU
    :program:`nm` does.

test/tools/llvm-nm/X86/radix.test

+#Source generated as :
+#while [[ $i -ne 25 ]] ; do echo "int i$i = $i;" >> 1.c; ((i=i+1)); done
+#clang -c -O0 1.c
+# RUN: llvm-nm -radix=d %p/Inputs/x86.radix-object | FileCheck  %s
+# RUN: llvm-nm -radix=o %p/Inputs/x86.radix-object | FileCheck --check-prefix="OCTAL" %s
+# RUN: llvm-nm -t=x %p/Inputs/x86.radix-object | FileCheck --check-prefix="HEX" %s
+#
+CHECK:    0000000000000000 B i0
+CHECK:    0000000000000000 D i1
+CHECK:    0000000000000036 D i10
+CHECK:    0000000000000040 D i11
+CHECK:    0000000000000044 D i12
+CHECK:    0000000000000048 D i13
+CHECK:    0000000000000052 D i14
+CHECK:    0000000000000056 D i15
+CHECK:    0000000000000060 D i16
+CHECK:    0000000000000064 D i17
+CHECK:    0000000000000068 D i18
+CHECK:    0000000000000072 D i19
+CHECK:    0000000000000004 D i2
+CHECK:    0000000000000076 D i20
+CHECK:    0000000000000080 D i21
+CHECK:    0000000000000084 D i22
+CHECK:    0000000000000088 D i23
+CHECK:    0000000000000092 D i24
+CHECK:    0000000000000008 D i3
+CHECK:    0000000000000012 D i4
+CHECK:    0000000000000016 D i5
+CHECK:    0000000000000020 D i6
+CHECK:    0000000000000024 D i7
+CHECK:    0000000000000028 D i8
+CHECK:    0000000000000032 D i9
+
+OCTAL:    0000000000000000 B i0
+OCTAL:    0000000000000000 D i1
+OCTAL:    0000000000000044 D i10
+OCTAL:    0000000000000050 D i11
+OCTAL:    0000000000000054 D i12
+OCTAL:    0000000000000060 D i13
+OCTAL:    0000000000000064 D i14
+OCTAL:    0000000000000070 D i15
+OCTAL:    0000000000000074 D i16
+OCTAL:    0000000000000100 D i17
+OCTAL:    0000000000000104 D i18
+OCTAL:    0000000000000110 D i19
+OCTAL:    0000000000000004 D i2
+OCTAL:    0000000000000114 D i20
+OCTAL:    0000000000000120 D i21
+OCTAL:    0000000000000124 D i22
+OCTAL:    0000000000000130 D i23
+OCTAL:    0000000000000134 D i24
+OCTAL:    0000000000000010 D i3
+OCTAL:    0000000000000014 D i4
+OCTAL:    0000000000000020 D i5
+OCTAL:    0000000000000024 D i6
+OCTAL:    0000000000000030 D i7
+OCTAL:    0000000000000034 D i8
+OCTAL:    0000000000000040 D i9
+
+HEX:    0000000000000000 B i0
+HEX:    0000000000000000 D i1
+HEX:    0000000000000024 D i10
+HEX:    0000000000000028 D i11
+HEX:    000000000000002c D i12
+HEX:    0000000000000030 D i13
+HEX:    0000000000000034 D i14
+HEX:    0000000000000038 D i15
+HEX:    000000000000003c D i16
+HEX:    0000000000000040 D i17
+HEX:    0000000000000044 D i18
+HEX:    0000000000000048 D i19
+HEX:    0000000000000004 D i2
+HEX:    000000000000004c D i20
+HEX:    0000000000000050 D i21
+HEX:    0000000000000054 D i22
+HEX:    0000000000000058 D i23
+HEX:    000000000000005c D i24
+HEX:    0000000000000008 D i3
+HEX:    000000000000000c D i4
+HEX:    0000000000000010 D i5
+HEX:    0000000000000014 D i6
+HEX:    0000000000000018 D i7
+HEX:    000000000000001c D i8
+HEX:    0000000000000020 D i9
+
+

tools/llvm-nm/llvm-nm.cpp

 
 cl::opt<bool> WithoutAliases("without-aliases", cl::Hidden,
                              cl::desc("Exclude aliases from output"));
 
 cl::opt<bool> ArchiveMap("print-armap", cl::desc("Print the archive map"));
 cl::alias ArchiveMaps("M", cl::desc("Alias for --print-armap"),
                       cl::aliasopt(ArchiveMap), cl::Grouping);
 
+enum Radix { d, o, x };
+cl::opt<Radix>
+    AddressRadix("radix", cl::desc("Radix (o/d/x) for printing symbol Values"),
+                 cl::values(clEnumVal(d, "decimal"), clEnumVal(o, "octal"),
+                            clEnumVal(x, "hexadecimal"), clEnumValEnd),
+                 cl::init(x));
+cl::alias RadixAlias("t", cl::desc("Alias for --radix"),
+                     cl::aliasopt(AddressRadix));
+
 cl::opt<bool> JustSymbolName("just-symbol-name",
                              cl::desc("Print just the symbol's name"));
 cl::alias JustSymbolNames("j", cl::desc("Alias for --just-symbol-name"),
                           cl::aliasopt(JustSymbolName), cl::Grouping);
 
 // FIXME: This option takes exactly two strings and should be allowed anywhere
 // on the command line.  Such that "llvm-nm -s __TEXT __text foo.o" would work.
 // But that does not as the CommandLine Library does not have a way to make
if (OutputFormat == posix && MultipleFiles && printName) {
              << "         Size   Line  Section\n";
     }
   }
 
   const char *printBlanks, *printDashes, *printFormat;
   if (isSymbolList64Bit(Obj)) {
     printBlanks = "                ";
     printDashes = "----------------";
+    switch (AddressRadix) {
+    case Radix::o:
+      printFormat = "%016" PRIo64;
+      break;
+    case Radix::x:
       printFormat = "%016" PRIx64;
+      break;
+    default:
+      printFormat = "%016" PRId64;
+    }
   } else {
     printBlanks = "        ";
     printDashes = "--------";
+    switch (AddressRadix) {
+    case Radix::o:
+      printFormat = "%08" PRIo64;
+      break;
+    case Radix::x:
       printFormat = "%08" PRIx64;
+      break;
+    default:
+      printFormat = "%08" PRId64;
+    }
   }
 
   for (SymbolListT::iterator I = SymbolList.begin(), E = SymbolList.end();
        I != E; ++I) {
     uint32_t SymFlags = I->Sym.getFlags();
     bool Undefined = SymFlags & SymbolRef::SF_Undefined;
     bool Global = SymFlags & SymbolRef::SF_Global;
     if ((!Undefined && UndefinedOnly) || (Undefined && DefinedOnly) ||
if (PrintAddress && isa<ObjectFile>(Obj)) {
       if (error(AddressOrErr.getError()))
         break;
       S.Address = *AddressOrErr;
     }
     S.TypeChar = getNMTypeChar(Obj, Sym);
     std::error_code EC = Sym.printName(OS);
     if (EC && MachO)
       OS << "bad string index";
-    else 
+    else
       error(EC);
     OS << '\0';
     S.Sym = Sym;
     SymbolList.push_back(S);
   }
 
   OS.flush();
   const char *P = NameBuffer.c_str();