[llvm-objdump-macho] print per-second-level-page encodings for option --unwind-info

[gkm]

Summary

Compact unwind entries have 8 bits for the encoding-table offset:

• offsets 0..126 reference the global commmon-encodings table, while
• offsets 127..255 reference a per-second-level-page table.

This diff teaches llvm-objdump to print this per-page encodings table.

[int3]

Should we have a test?

[gkm]

• add test case

[MaskRay]

llvm/test/tools/llvm-objdump/MachO/unwind-info-excess-x86_64.test

2

A prebuilt binary is difficult to inspect and update. Can you rewrite the input with yaml2obj?

There are plenty of examples in the ELF/ folder (and in various test/tools/*/ELF directories)

The test should also include a file level comment documenting its purpose.

[gkm]

llvm/test/tools/llvm-objdump/MachO/unwind-info-excess-x86_64.test

2

Very good. FYI, I was following prior practice, where there are already 71 binaries and not even one *.yaml in llvm/test/tools/llvm-objdump/MachO/Inputs/.

Yaml isn't so great either: it's text, but nearly as opaque as a binary. I favor using llvm-mc on assembler inputs. My compact-unwind test in lld/test/MachO goes further: Because the assembler input is 1 MiB, I have a python script (which also serves as a fuzzer) to generate it. The downside is significant CPU time for llvm-mc to process the test. It's not so bad on a release tree (approx 1s), but slow on a debug tree (approx 10s). I could solve that by preferring the installed llvm-mc, but all the existing tests just do RUN: llvm-mc ... and get the build tree's version, so I'm not sure how to do that.

Please advise.

[gkm]

@MaskRay?

[gkm]

• Pare CHECK lines to the essentials. Add comments to the test: purpose, plus rationale for binary input.

[int3]

seems legit

llvm/test/tools/llvm-objdump/MachO/unwind-info-excess-x86_64.test

+## Ensure that per-page compact encodings (indexes 127 and greater)
+## appear in the output of llvm-objdump --unwind-info
+## Verify that the common encodings table is full at 0x7f (127) entries.
+##
+## TODO(gkm): The input is a binary object file constructed from a
+## large generated assembler file. For sake of expediency and
+## test-time performance, I am following the unfortunate precedent
+## that MachO test inputs are binary.
+##
+## Non-MachO tests largely use YAML inputs. As I understand it, the
+## rationale is that these MachO tests were written prior to
+## availability of sufficiently-expressive YAML processors.
+##
+## I consider YAML a submoptimal input format. Better would be
+## assembler language inputs convertable to binary via llvm-mc.  In
+## the case of this test however, the input is very large and the
+## overhead of llvm-mc is terrible (~10s) on a debug build. Overhead
+## for a release build of llvm-mc is acceptable at ~1s. It would be
+## good if there were a way to prefer an installed version of llvm-mc
+## to process tests in debug build trees when not testing llvm-mc
+## itself.
+
+# RUN: llvm-objdump --unwind-info %p/Inputs/unwind-info-excess.macho-x86_64 2>/dev/null | FileCheck %s
+
+# CHECK:Contents of __unwind_info section:
+# CHECK-NEXT:  Version:                                   0x1
+# CHECK-NEXT:  Common encodings array section offset:     0x1c
+# CHECK-NEXT:  Number of common encodings in array:       0x7f
+
+# CHECK:  Second level indices:
+# CHECK:    Second level index[0]: offset in section
+# CHECK:      Page encodings: (count = 17)
+# CHECK:        encoding[127]: 0x01010003
+# CHECK:        encoding[128]: 0x01010002
+# CHECK:        encoding[129]: 0x01010001
+# CHECK:        encoding[130]: 0x0102001d
+# CHECK:        encoding[131]: 0x01020015
+# CHECK:        encoding[132]: 0x0102000d
+# CHECK:        encoding[133]: 0x0102001c
+# CHECK:        encoding[134]: 0x01020014
+# CHECK:        encoding[135]: 0x0102000c
+# CHECK:        encoding[136]: 0x01020013
+# CHECK:        encoding[137]: 0x0102000b
+# CHECK:        encoding[138]: 0x01020022
+# CHECK:        encoding[139]: 0x0102001a
+# CHECK:        encoding[140]: 0x0102000a
+# CHECK:        encoding[141]: 0x01020021
+# CHECK:        encoding[142]: 0x01020019
+# CHECK:        encoding[143]: 0x01020011
+
+# CHECK:      [{{[0-9]+}}]: function offset={{[x0-9a-f]+}}, encoding[127]=0x01010003
+# CHECK:      [{{[0-9]+}}]: function offset={{[x0-9a-f]+}}, encoding[128]=0x01010002
+# CHECK:      [{{[0-9]+}}]: function offset={{[x0-9a-f]+}}, encoding[129]=0x01010001
+# CHECK:      [{{[0-9]+}}]: function offset={{[x0-9a-f]+}}, encoding[130]=0x0102001d
+# CHECK:      [{{[0-9]+}}]: function offset={{[x0-9a-f]+}}, encoding[131]=0x01020015
+# CHECK:      [{{[0-9]+}}]: function offset={{[x0-9a-f]+}}, encoding[132]=0x0102000d
+# CHECK:      [{{[0-9]+}}]: function offset={{[x0-9a-f]+}}, encoding[133]=0x0102001c
+# CHECK:      [{{[0-9]+}}]: function offset={{[x0-9a-f]+}}, encoding[134]=0x01020014
+# CHECK:      [{{[0-9]+}}]: function offset={{[x0-9a-f]+}}, encoding[135]=0x0102000c
+# CHECK:      [{{[0-9]+}}]: function offset={{[x0-9a-f]+}}, encoding[136]=0x01020013
+# CHECK:      [{{[0-9]+}}]: function offset={{[x0-9a-f]+}}, encoding[137]=0x0102000b
+# CHECK:      [{{[0-9]+}}]: function offset={{[x0-9a-f]+}}, encoding[138]=0x01020022
+# CHECK:      [{{[0-9]+}}]: function offset={{[x0-9a-f]+}}, encoding[139]=0x0102001a
+# CHECK:      [{{[0-9]+}}]: function offset={{[x0-9a-f]+}}, encoding[140]=0x0102000a
+# CHECK:      [{{[0-9]+}}]: function offset={{[x0-9a-f]+}}, encoding[141]=0x01020021
+# CHECK:      [{{[0-9]+}}]: function offset={{[x0-9a-f]+}}, encoding[142]=0x01020019
+# CHECK:      [{{[0-9]+}}]: function offset={{[x0-9a-f]+}}, encoding[143]=0x01020011

llvm/tools/llvm-objdump/MachODump.cpp

 static void printCompressedSecondLevelUnwindPage(
     StringRef PageData, uint32_t FunctionBase,
     const SmallVectorImpl<uint32_t> &CommonEncodings) {
   ptrdiff_t Pos = 0;
   uint32_t Kind = readNext<uint32_t>(PageData, Pos);
   (void)Kind;
   assert(Kind == 3 && "kind for a compressed 2nd level index should be 3");
 
+  uint32_t NumCommonEncodings = CommonEncodings.size();
   uint16_t EntriesStart = readNext<uint16_t>(PageData, Pos);
   uint16_t NumEntries = readNext<uint16_t>(PageData, Pos);
 
-  uint16_t EncodingsStart = readNext<uint16_t>(PageData, Pos);
-  readNext<uint16_t>(PageData, Pos);
-  StringRef PageEncodings = PageData.substr(EncodingsStart, StringRef::npos);
+  uint16_t PageEncodingsStart = readNext<uint16_t>(PageData, Pos);
+  uint16_t NumPageEncodings = readNext<uint16_t>(PageData, Pos);
+  SmallVector<uint32_t, 64> PageEncodings;
+  if (NumPageEncodings) {
+    outs() << "      Page encodings: (count = " << NumPageEncodings << ")\n";
+    Pos = PageEncodingsStart;
+    for (unsigned i = 0; i < NumPageEncodings; ++i) {
+      uint32_t Encoding = readNext<uint32_t>(PageData, Pos);
+      PageEncodings.push_back(Encoding);
+      outs() << "        encoding[" << (i + NumCommonEncodings)
+             << "]: " << format("0x%08" PRIx32, Encoding) << '\n';
+    }
+  }
 
   Pos = EntriesStart;
   for (unsigned i = 0; i < NumEntries; ++i) {
     uint32_t Entry = readNext<uint32_t>(PageData, Pos);
     uint32_t FunctionOffset = FunctionBase + (Entry & 0xffffff);
     uint32_t EncodingIdx = Entry >> 24;
 
     uint32_t Encoding;
-    if (EncodingIdx < CommonEncodings.size())
+    if (EncodingIdx < NumCommonEncodings)
       Encoding = CommonEncodings[EncodingIdx];
     else
-      Encoding = read<uint32_t>(PageEncodings,
-                                sizeof(uint32_t) *
-                                    (EncodingIdx - CommonEncodings.size()));
+      Encoding = PageEncodings[EncodingIdx - NumCommonEncodings];
 
     outs() << "      [" << i << "]: "
            << "function offset=" << format("0x%08" PRIx32, FunctionOffset)
            << ", "
            << "encoding[" << EncodingIdx
            << "]=" << format("0x%08" PRIx32, Encoding) << '\n';
   }
 }