[llvm-objdump] Fix jumptable detection when disassembling Mach-O binaries

[kubamracek]

Summary

1. Add LC_SEGMENT_64 handling in getSectionsAndSymbols to be able to find the base segment address from 64-bit Mach-O binaries.
2. Add "data in code" detection into the !symbolTableWorked case, extract it into a separate function.
3. Fix uninitialized variable usage on BaseSegmentAddress (initialize to 0).

[steven_wu]

Can you add a test case? You can potentially use llc to generate a .o file from .ll and run disassembler on the object file.

[kubamracek]

Adding test

[steven_wu]

LGTM

[mtrent]

LGTM, visual inspection only.

llvm/trunk/test/tools/llvm-objdump/macho-data-in-code.ll

+; RUN: llc -mtriple x86_64-apple-darwin -filetype=obj -O0 %s -o %t.o
+; RUN: llvm-objdump -macho -disassemble -no-show-raw-insn %t.o | FileCheck %s
+
+; CHECK: .long {{[0-9]+}} @ KIND_JUMP_TABLE32
+; CHECK: .long {{[0-9]+}} @ KIND_JUMP_TABLE32
+; CHECK: .long {{[0-9]+}} @ KIND_JUMP_TABLE32
+; CHECK: .long {{[0-9]+}} @ KIND_JUMP_TABLE32
+; CHECK-NOT: invalid instruction encoding
+; CHECK-NOT: <unknown>
+
+; ModuleID = '-'
+target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-apple-macosx10.12.0"
+
+; Function Attrs: noinline nounwind optnone ssp uwtable
+define void @switchfunc(i32 %i) {
+  switch i32 %i, label %out [
+    i32 0, label %case1
+    i32 1, label %case2
+    i32 2, label %case3
+    i32 3, label %case4
+  ]
+
+case1:
+  call void @foo()
+  br label %out
+
+case2:
+  call void @bar()
+  br label %out
+
+case3:
+  call void @foo()
+  br label %out
+
+case4:
+  call void @bar()
+  br label %out
+
+out:
+  ret void
+}
+
+declare void @foo()
+declare void @bar()

llvm/trunk/tools/llvm-objdump/MachODump.cpp

if (Command.C.cmd == MachO::LC_FUNCTION_STARTS) {
       MachOObj->ReadULEB128s(LLC.dataoff, FoundFns);
     } else if (Command.C.cmd == MachO::LC_SEGMENT) {
       MachO::segment_command SLC = MachOObj->getSegmentLoadCommand(Command);
       StringRef SegName = SLC.segname;
       if (!BaseSegmentAddressSet && SegName != "__PAGEZERO") {
         BaseSegmentAddressSet = true;
         BaseSegmentAddress = SLC.vmaddr;
       }
+    } else if (Command.C.cmd == MachO::LC_SEGMENT_64) {
+      MachO::segment_command_64 SLC = MachOObj->getSegment64LoadCommand(Command);
+      StringRef SegName = SLC.segname;
+      if (!BaseSegmentAddressSet && SegName != "__PAGEZERO") {
+        BaseSegmentAddressSet = true;
+        BaseSegmentAddress = SLC.vmaddr;
+      }
     }
   }
 }
 
+static bool DumpAndSkipDataInCode(uint64_t PC, const uint8_t *bytes,
+                                 DiceTable &Dices, uint64_t &InstSize) {
+  // Check the data in code table here to see if this is data not an
+  // instruction to be disassembled.
+  DiceTable Dice;
+  Dice.push_back(std::make_pair(PC, DiceRef()));
+  dice_table_iterator DTI =
+      std::search(Dices.begin(), Dices.end(), Dice.begin(), Dice.end(),
+                  compareDiceTableEntries);
+  if (DTI != Dices.end()) {
+    uint16_t Length;
+    DTI->second.getLength(Length);
+    uint16_t Kind;
+    DTI->second.getKind(Kind);
+    InstSize = DumpDataInCode(bytes, Length, Kind);
+    if ((Kind == MachO::DICE_KIND_JUMP_TABLE8) &&
+        (PC == (DTI->first + Length - 1)) && (Length & 1))
+      InstSize++;
+    return true;
+  }
+  return false;
+}
+
 static void printRelocationTargetName(const MachOObjectFile *O,
                                       const MachO::any_relocation_info &RE,
                                       raw_string_ostream &Fmt) {
   // Target of a scattered relocation is an address.  In the interest of
   // generating pretty output, scan through the symbol table looking for a
   // symbol that aligns with that address.  If we find one, print it.
   // Otherwise, we just print the hex address of the target.
   const StringRef FileName = O->getFileName();
static void DisassembleMachO(StringRef Filename, MachOObjectFile *MachOOF,
 
   // FIXME: Using the -cfg command line option, this code used to be able to
   // annotate relocations with the referenced symbol's name, and if this was
   // inside a __[cf]string section, the data it points to. This is now replaced
   // by the upcoming MCSymbolizer, which needs the appropriate setup done above.
   std::vector<SectionRef> Sections;
   std::vector<SymbolRef> Symbols;
   SmallVector<uint64_t, 8> FoundFns;
-  uint64_t BaseSegmentAddress;
+  uint64_t BaseSegmentAddress = 0;
 
   getSectionsAndSymbols(MachOOF, Sections, Symbols, FoundFns,
                         BaseSegmentAddress);
 
   // Sort the symbols by address, just in case they didn't come in that way.
   llvm::sort(Symbols, SymbolSorter());
 
   // Build a data in code table that is sorted on by the address of each entry.
for (unsigned SymIdx = 0; SymIdx != Symbols.size(); SymIdx++) {
               outs() << format("%08" PRIx64, PC);
           } else {
             outs() << format("%8" PRIx64 ":", PC);
           }
         }
         if (!NoShowRawInsn || Arch == Triple::arm)
           outs() << "\t";
 
-        // Check the data in code table here to see if this is data not an
-        // instruction to be disassembled.
-        DiceTable Dice;
-        Dice.push_back(std::make_pair(PC, DiceRef()));
-        dice_table_iterator DTI =
-            std::search(Dices.begin(), Dices.end(), Dice.begin(), Dice.end(),
-                        compareDiceTableEntries);
-        if (DTI != Dices.end()) {
-          uint16_t Length;
-          DTI->second.getLength(Length);
-          uint16_t Kind;
-          DTI->second.getKind(Kind);
-          Size = DumpDataInCode(Bytes.data() + Index, Length, Kind);
-          if ((Kind == MachO::DICE_KIND_JUMP_TABLE8) &&
-              (PC == (DTI->first + Length - 1)) && (Length & 1))
-            Size++;
+        if (DumpAndSkipDataInCode(PC, Bytes.data() + Index, Dices, Size))
           continue;
-        }
 
         SmallVector<char, 64> AnnotationsBytes;
         raw_svector_ostream Annotations(AnnotationsBytes);
 
         bool gotInst;
         if (UseThumbTarget)
           gotInst = ThumbDisAsm->getInstruction(Inst, Size, Bytes.slice(Index),
                                                 PC, DebugOut, Annotations);
if (!symbolTableWorked) {
       // Reading the symbol table didn't work, disassemble the whole section.
       uint64_t SectAddress = Sections[SectIdx].getAddress();
       uint64_t SectSize = Sections[SectIdx].getSize();
       uint64_t InstSize;
       for (uint64_t Index = 0; Index < SectSize; Index += InstSize) {
         MCInst Inst;
 
         uint64_t PC = SectAddress + Index;
+
+        if (DumpAndSkipDataInCode(PC, Bytes.data() + Index, Dices, InstSize))
+          continue;
+
         SmallVector<char, 64> AnnotationsBytes;
         raw_svector_ostream Annotations(AnnotationsBytes);
         if (DisAsm->getInstruction(Inst, InstSize, Bytes.slice(Index), PC,
                                    DebugOut, Annotations)) {
           if (!NoLeadingAddr) {
             if (FullLeadingAddr) {
               if (MachOOF->is64Bit())
                 outs() << format("%016" PRIx64, PC);