[llvm-objdump] Add -dyld_info to llvm-otool

[BertalanD]

Summary

This option outputs the location, encoded value and target of chained
fixups, using the same format as otool -dyld_info.

This initial implementation only supports the DYLD_CHAINED_PTR_64 and
DYLD_CHAINED_PTR_64_OFFSET pointer encodings, which are used in x86_64
and arm64 userspace binaries.

When Apple's effort to upstream their chained fixups code continues,
we'll replace this code with the then-upstreamed code. But we need
something in the meantime for testing ld64.lld's chained fixups code.

[thakis]

llvm/tools/llvm-objdump/OtoolOpts.td

44 ↗

(On Diff #453299)

(this needs rebasing across 164266739298b39d3eac8d79ad12d1d654e2825e)

[jhenderson]

Please remember to add new options to the CommandGuide(s) at llvm/docs/CommandGuide.

[BertalanD]

Rebased onto 164266739298b39d3eac8d79ad12d1d654e2825e; which added the docs for this flag.

[BertalanD]

llvm/lib/Object/MachOObjectFile.cpp

3402–3404

reminder to self: simplify this with maskTrailingOnes.

llvm/test/tools/llvm-objdump/MachO/dyld-info.test

10–16

All the {{0*}} are a bit awkward, but I want this test to pass with cctools otool as well. It has a bunch of extra logic in the printing code to use the width of the largest number, while this patch always uses a fixed width; so the test needs to accept an arbitrary number of leading zeros.

[BertalanD]

ping!

I cleaned the patch up a bit and rebased it. D132560 depends on this for tests.

[BertalanD]

llvm/lib/Object/MachOObjectFile.cpp

3402–3404

nevermind. That wouldn't make the code any clearer.

This weird lambda is needed because bitfields are a pain to work with when endianness is involved.

[thakis]

Sorry for the delay.

llvm/lib/Object/MachOObjectFile.cpp

2116

The name-based version of this has to loop, but couldn't this version just do:

auto &LoadCmd = LoadCommands[SegmentIndex];

instead of the loop? (Range check before that, of course.)

3402–3404

My opinion here is the same as on D131982 (but I agree it makes sense to do the same thing here as over there, and we currently do the manual bit fiddling there).

3409

Put this comment up with the struct definitions too.

3450

We have this loop three times. Maybe move it into a FindNextPageWithFixups() helper?

llvm/test/tools/llvm-objdump/MachO/dyld-info.test

4

Should we have a test for llvm-otool -dyld_info running on a file with opcode fixups (instead of chained fixups) too? (ok to punt this to a follow-up)

10–16

Maybe just do the FIXME: Align the columns properly? That's what, like 6 lines?

llvm/tools/llvm-objdump/MachODump.cpp

1190–1191

We should probably rename this function to printMachODyldInfo now.

[thakis]

llvm/lib/Object/MachOObjectFile.cpp

2116

Please ignore, I just realized SegmentIndex, not LoadCommandIndex.

[BertalanD]

• Moved code for finding the next fixup into a helper function (findNextPageWithFixups).
• Folded printMachOChainedFixups into PrintDyldInfo.
• Added test to ensure that we can handle objects that don't use chained fixups.
• Minor comment tweaks.

[BertalanD]

llvm/lib/Object/MachOObjectFile.cpp

3409

oops, missed this in Diff 4.
fixed

[thakis]

llvm/test/tools/llvm-objdump/MachO/dyld-info.test

10–16

Thoughts on doing this fixme before landing?

[BertalanD]

pretty-print the table with proper column alignment

[thakis]

Thanks! Looks ready go to :)

[thakis]

(once CI is fixed; https://reviews.llvm.org/harbormaster/unit/view/4889067/ looks like it might be failing due to this patch)

[BertalanD]

Fix CI by properly ignoring error during the first iteration in PrintDyldInfo().

[thakis]

llvm/tools/llvm-objdump/MachODump.cpp

1362

nit: Not sure if this line is necessary; Error's move ctor comment sounds a bit like it already does this to the moved-from value: http://llvm-cs.pcc.me.uk/include/llvm/Support/Error.h#190

[BertalanD]

llvm/tools/llvm-objdump/MachODump.cpp

1362

But then, we'd do a use-after-move later in the function, which is a bit dodgy.

[thakis]

llvm/tools/llvm-objdump/MachODump.cpp

1362

Up to you. But it's up to classes if they want to have defined after use semantics, and this one does have defined semantics. *Shrug*

llvm/include/llvm/BinaryFormat/MachO.h

 struct dyld_chained_import_addend64 {
   uint64_t lib_ordinal : 16;
   uint64_t weak_import : 1;
   uint64_t reserved : 15;
   uint64_t name_offset : 32;
   uint64_t addend;
 };
 
+// The `bind` field (most significant bit) of the encoded fixup determines
+// whether it is dyld_chained_ptr_64_bind or dyld_chained_ptr_64_rebase.
+
+// DYLD_CHAINED_PTR_64/DYLD_CHAINED_PTR_64_OFFSET
+struct dyld_chained_ptr_64_bind {
+  uint64_t ordinal : 24;
+  uint64_t addend : 8;
+  uint64_t reserved : 19;
+  uint64_t next : 12;
+  uint64_t bind : 1; // set to 1
+};
+
+// DYLD_CHAINED_PTR_64/DYLD_CHAINED_PTR_64_OFFSET
+struct dyld_chained_ptr_64_rebase {
+  uint64_t target : 36;
+  uint64_t high8 : 8;
+  uint64_t reserved : 7;
+  uint64_t next : 12;
+  uint64_t bind : 1; // set to 0
+};
+
 // Byte order swapping functions for MachO structs
 
 inline void swapStruct(fat_header &mh) {
   sys::swapByteOrder(mh.magic);
   sys::swapByteOrder(mh.nfat_arch);
 }
 
 inline void swapStruct(fat_arch &mh) {

llvm/include/llvm/Object/MachO.h

 private:
   int LibOrdinal;
   uint32_t NameOffset;
   StringRef SymbolName;
   uint64_t Addend;
   bool WeakImport;
 };
 
+struct ChainedFixupsSegment {
+  ChainedFixupsSegment(uint8_t SegIdx, uint32_t Offset,
+                       const MachO::dyld_chained_starts_in_segment &Header,
+                       std::vector<uint16_t> &&PageStarts)
+      : SegIdx(SegIdx), Offset(Offset), Header(Header),
+        PageStarts(PageStarts){};
+
+  uint32_t SegIdx;
+  uint32_t Offset; // dyld_chained_starts_in_image::seg_info_offset[SegIdx]
+  MachO::dyld_chained_starts_in_segment Header;
+  std::vector<uint16_t> PageStarts; // page_start[] entries, host endianness
+};
+
 /// MachOAbstractFixupEntry is an abstract class representing a fixup in a
 /// MH_DYLDLINK file. Fixups generally represent rebases and binds. Binds also
 /// subdivide into additional subtypes (weak, lazy, reexport).
 ///
 /// The two concrete subclasses of MachOAbstractFixupEntry are:
 ///
 ///   MachORebaseBindEntry   - for dyld opcode-based tables, including threaded-
 ///                            rebase, where rebases are mixed in with other
protected:
   uint64_t textAddress() const { return TextAddress; }
 
 private:
   uint64_t TextAddress;
 };
 
 class MachOChainedFixupEntry : public MachOAbstractFixupEntry {
 public:
-  enum class FixupKind { All, Bind, WeakBind, Rebase };
+  enum class FixupKind { Bind, Rebase };
 
   MachOChainedFixupEntry(Error *Err, const MachOObjectFile *O, bool Parse);
 
   bool operator==(const MachOChainedFixupEntry &) const;
 
+  bool isBind() const { return Kind == FixupKind::Bind; }
+  bool isRebase() const { return Kind == FixupKind::Rebase; }
+
   void moveNext();
   void moveToFirst();
   void moveToEnd();
 
 private:
+  void findNextPageWithFixups();
+
   std::vector<ChainedFixupTarget> FixupTargets;
-  uint32_t FixupIndex = 0;
+  std::vector<ChainedFixupsSegment> Segments;
+  ArrayRef<uint8_t> SegmentData;
+  FixupKind Kind;
+  uint32_t InfoSegIndex = 0; // Index into Segments
+  uint32_t PageIndex = 0;    // Index into Segments[InfoSegIdx].PageStarts
+  uint32_t PageOffset = 0;   // Page offset of the current fixup
 };
 using fixup_iterator = content_iterator<MachOChainedFixupEntry>;
 
 class MachOObjectFile : public ObjectFile {
 public:
   struct LoadCommandInfo {
     const char *Ptr;      // Where in memory the load command is.
     MachO::load_command C; // The command itself.
public:
   bool isSectionData(DataRefImpl Sec) const override;
   bool isSectionBSS(DataRefImpl Sec) const override;
   bool isSectionVirtual(DataRefImpl Sec) const override;
   bool isSectionBitcode(DataRefImpl Sec) const override;
   bool isDebugSection(DataRefImpl Sec) const override;
 
   /// Return the raw contents of an entire segment.
   ArrayRef<uint8_t> getSegmentContents(StringRef SegmentName) const;
+  ArrayRef<uint8_t> getSegmentContents(size_t SegmentIndex) const;
 
   /// When dsymutil generates the companion file, it strips all unnecessary
   /// sections (e.g. everything in the _TEXT segment) by omitting their body
   /// and setting the offset in their corresponding load command to zero.
   ///
   /// While the load command itself is valid, reading the section corresponds
   /// to reading the number of bytes specified in the load command, starting
   /// from offset 0 (i.e. the Mach-O header at the beginning of the file).
public:
   Expected<Optional<MachO::dyld_chained_fixups_header>>
   getChainedFixupsHeader() const;
   Expected<std::vector<ChainedFixupTarget>> getDyldChainedFixupTargets() const;
 
   // Note: This is a limited, temporary API, which will be removed when Apple
   // upstreams their implementation. Please do not rely on this.
   Expected<Optional<MachO::linkedit_data_command>>
   getChainedFixupsLoadCommand() const;
-  struct ChainedFixupsSegment {
-    ChainedFixupsSegment(uint8_t SegIdx, uint32_t Offset,
-                         const MachO::dyld_chained_starts_in_segment &Header,
-                         std::vector<uint16_t> &&PageStarts)
-        : SegIdx(SegIdx), Offset(Offset), Header(Header),
-          PageStarts(PageStarts){};
-
-    uint32_t SegIdx;
-    uint32_t Offset; // dyld_chained_starts_in_image::seg_info_offset[SegIdx]
-    MachO::dyld_chained_starts_in_segment Header;
-    std::vector<uint16_t> PageStarts; // page_start[] entries, host endianness
-  };
   // Returns the number of sections listed in dyld_chained_starts_in_image, and
   // a ChainedFixupsSegment for each segment that has fixups.
   Expected<std::pair<size_t, std::vector<ChainedFixupsSegment>>>
   getChainedFixupsSegments() const;
 
   ArrayRef<uint8_t> getDyldInfoExportsTrie() const;
   SmallVector<uint64_t> getFunctionStarts() const;
   ArrayRef<uint8_t> getUuid() const;

llvm/lib/Object/MachOObjectFile.cpp

if (!SegmentOrErr) {
     return {};
   }
   auto &Segment = SegmentOrErr.get();
   if (StringRef(Segment.segname, 16).startswith(SegmentName))
     return arrayRefFromStringRef(Obj.getData().slice(
         Segment.fileoff, Segment.fileoff + Segment.filesize));
   return {};
 }
+
+template <typename LoadCommandType>
+ArrayRef<uint8_t> getSegmentContents(const MachOObjectFile &Obj,
+                                     MachOObjectFile::LoadCommandInfo LoadCmd) {
+  auto SegmentOrErr = getStructOrErr<LoadCommandType>(Obj, LoadCmd.Ptr);
+  if (!SegmentOrErr) {
+    consumeError(SegmentOrErr.takeError());
+    return {};
+  }
+  auto &Segment = SegmentOrErr.get();
+  return arrayRefFromStringRef(
+      Obj.getData().slice(Segment.fileoff, Segment.fileoff + Segment.filesize));
+}
 } // namespace
 
 ArrayRef<uint8_t>
 MachOObjectFile::getSegmentContents(StringRef SegmentName) const {
   for (auto LoadCmd : load_commands()) {
     ArrayRef<uint8_t> Contents;
     switch (LoadCmd.C.cmd) {
     case MachO::LC_SEGMENT:
       Contents = ::getSegmentContents<MachO::segment_command>(*this, LoadCmd,
                                                               SegmentName);
       break;
     case MachO::LC_SEGMENT_64:
       Contents = ::getSegmentContents<MachO::segment_command_64>(*this, LoadCmd,
                                                                  SegmentName);
       break;
     default:
       continue;
     }
     if (!Contents.empty())
       return Contents;
   }
   return {};
 }
 
+ArrayRef<uint8_t>
+MachOObjectFile::getSegmentContents(size_t SegmentIndex) const {
+  size_t Idx = 0;
+  for (auto LoadCmd : load_commands()) {
+    switch (LoadCmd.C.cmd) {
+    case MachO::LC_SEGMENT:
+      if (Idx == SegmentIndex)
+        return ::getSegmentContents<MachO::segment_command>(*this, LoadCmd);
+      ++Idx;
+      break;
+    case MachO::LC_SEGMENT_64:
+      if (Idx == SegmentIndex)
+        return ::getSegmentContents<MachO::segment_command_64>(*this, LoadCmd);
+      ++Idx;
+      break;
+    default:
+      continue;
+    }
+  }
+  return {};
+}
+
 unsigned MachOObjectFile::getSectionID(SectionRef Sec) const {
   return Sec.getRawDataRefImpl().d.a;
 }
 
 bool MachOObjectFile::isSectionVirtual(DataRefImpl Sec) const {
   uint32_t Flags = getSectionFlags(*this, Sec);
   unsigned SectionType = Flags & MachO::SECTION_TYPE;
   return SectionType == MachO::S_ZEROFILL ||
void MachOAbstractFixupEntry::moveToFirst() {
   Ordinal = 0;
   Flags = 0;
   Addend = 0;
   Done = false;
 }
 
 void MachOAbstractFixupEntry::moveToEnd() { Done = true; }
 
+void MachOAbstractFixupEntry::moveNext() {}
+
 MachOChainedFixupEntry::MachOChainedFixupEntry(Error *E,
                                                const MachOObjectFile *O,
                                                bool Parse)
     : MachOAbstractFixupEntry(E, O) {
   ErrorAsOutParameter e(E);
   if (!Parse)
     return;
-  if (auto FixupTargetsOrErr = O->getDyldChainedFixupTargets())
+
+  if (auto FixupTargetsOrErr = O->getDyldChainedFixupTargets()) {
     FixupTargets = *FixupTargetsOrErr;
-  else {
+  } else {
     *E = FixupTargetsOrErr.takeError();
     return;
   }
+
+  if (auto SegmentsOrErr = O->getChainedFixupsSegments()) {
+    Segments = std::move(SegmentsOrErr->second);
+  } else {
+    *E = SegmentsOrErr.takeError();
+    return;
+  }
+}
+
+void MachOChainedFixupEntry::findNextPageWithFixups() {
+  auto FindInSegment = [this]() {
+    const ChainedFixupsSegment &SegInfo = Segments[InfoSegIndex];
+    while (PageIndex < SegInfo.PageStarts.size() &&
+           SegInfo.PageStarts[PageIndex] == MachO::DYLD_CHAINED_PTR_START_NONE)
+      ++PageIndex;
+    return PageIndex < SegInfo.PageStarts.size();
+  };
+
+  while (InfoSegIndex < Segments.size()) {
+    if (FindInSegment()) {
+      PageOffset = Segments[InfoSegIndex].PageStarts[PageIndex];
+      SegmentData = O->getSegmentContents(Segments[InfoSegIndex].SegIdx);
+      return;
+    }
+
+    InfoSegIndex++;
+    PageIndex = 0;
+  }
 }
 
 void MachOChainedFixupEntry::moveToFirst() {
   MachOAbstractFixupEntry::moveToFirst();
-  FixupIndex = 0;
+  if (Segments.empty()) {
+    Done = true;
+    return;
+  }
+
+  InfoSegIndex = 0;
+  PageIndex = 0;
+
+  findNextPageWithFixups();
   moveNext();
 }
 
 void MachOChainedFixupEntry::moveToEnd() {
   MachOAbstractFixupEntry::moveToEnd();
 }
 
-void MachOChainedFixupEntry::moveNext() { Done = true; }
+void MachOChainedFixupEntry::moveNext() {
+  ErrorAsOutParameter ErrAsOutParam(E);
+
+  if (InfoSegIndex == Segments.size()) {
+    Done = true;
+    return;
+  }
+
+  const ChainedFixupsSegment &SegInfo = Segments[InfoSegIndex];
+  SegmentIndex = SegInfo.SegIdx;
+  SegmentOffset = SegInfo.Header.page_size * PageIndex + PageOffset;
+
+  // FIXME: Handle other pointer formats.
+  uint16_t PointerFormat = SegInfo.Header.pointer_format;
+  if (PointerFormat != MachO::DYLD_CHAINED_PTR_64 &&
+      PointerFormat != MachO::DYLD_CHAINED_PTR_64_OFFSET) {
+    *E = createError("segment " + Twine(SegmentIndex) +
+                     " has unsupported chained fixup pointer_format " +
+                     Twine(PointerFormat));
+    moveToEnd();
+    return;
+  }
+
+  Ordinal = 0;
+  Flags = 0;
+  Addend = 0;
+  PointerValue = 0;
+  SymbolName = {};
+
+  if (SegmentOffset + sizeof(RawValue) > SegmentData.size()) {
+    *E = malformedError("fixup in segment " + Twine(SegmentIndex) +
+                        " at offset " + Twine(SegmentOffset) +
+                        " extends past segment's end");
+    moveToEnd();
+    return;
+  }
+
+  static_assert(sizeof(RawValue) == sizeof(MachO::dyld_chained_import_addend));
+  memcpy(&RawValue, SegmentData.data() + SegmentOffset, sizeof(RawValue));
+  if (O->isLittleEndian() != sys::IsLittleEndianHost)
+    sys::swapByteOrder(RawValue);
+
+  // The bit extraction below assumes little-endian fixup entries.
+  assert(O->isLittleEndian() && "big-endian object should have been rejected "
+                                "by getDyldChainedFixupTargets()");
+  auto Field = [this](uint8_t Right, uint8_t Count) {
+    return (RawValue >> Right) & ((1ULL << Count) - 1);
+  };
+
+  // The `bind` field (most significant bit) of the encoded fixup determines
+  // whether it is dyld_chained_ptr_64_bind or dyld_chained_ptr_64_rebase.
+  bool IsBind = Field(63, 1);
+  Kind = IsBind ? FixupKind::Bind : FixupKind::Rebase;
+  uint32_t Next = Field(51, 12);
+  if (IsBind) {
+    uint32_t ImportOrdinal = Field(0, 24);
+    uint8_t InlineAddend = Field(24, 8);
+
+    if (ImportOrdinal >= FixupTargets.size()) {
+      *E = malformedError("fixup in segment " + Twine(SegmentIndex) +
+                          " at offset " + Twine(SegmentOffset) +
+                          "  has out-of range import ordinal " +
+                          Twine(ImportOrdinal));
+      moveToEnd();
+      return;
+    }
+
+    ChainedFixupTarget &Target = FixupTargets[ImportOrdinal];
+    Ordinal = Target.libOrdinal();
+    Addend = InlineAddend ? InlineAddend : Target.addend();
+    Flags = Target.weakImport() ? MachO::BIND_SYMBOL_FLAGS_WEAK_IMPORT : 0;
+    SymbolName = Target.symbolName();
+  } else {
+    uint64_t Target = Field(0, 36);
+    uint64_t High8 = Field(36, 8);
+
+    PointerValue = Target | (High8 << 56);
+    if (PointerFormat == MachO::DYLD_CHAINED_PTR_64_OFFSET)
+      PointerValue += textAddress();
+  }
+
+  // The stride is 4 bytes for DYLD_CHAINED_PTR_64(_OFFSET).
+  if (Next != 0) {
+    PageOffset += 4 * Next;
+  } else {
+    ++PageIndex;
+    findNextPageWithFixups();
+  }
+}
 
 bool MachOChainedFixupEntry::operator==(
     const MachOChainedFixupEntry &Other) const {
-  if (Done == Other.Done)
-    return true;
-  if ((FixupIndex == Other.FixupIndex))
+  if (Done && Other.Done)
     return true;
+  if (Done != Other.Done)
     return false;
+  return InfoSegIndex == Other.InfoSegIndex && PageIndex == Other.PageIndex &&
+         PageOffset == Other.PageOffset;
 }
 
 MachORebaseEntry::MachORebaseEntry(Error *E, const MachOObjectFile *O,
                                    ArrayRef<uint8_t> Bytes, bool is64Bit)
     : E(E), O(O), Opcodes(Bytes), Ptr(Bytes.begin()),
       PointerSize(is64Bit ? 8 : 4) {}
 
 void MachORebaseEntry::moveToFirst() {

 }
 
 iterator_range<bind_iterator> MachOObjectFile::weakBindTable(Error &Err) {
   return bindTable(Err, this, getDyldInfoWeakBindOpcodes(), is64Bit(),
                    MachOBindEntry::Kind::Weak);
 }
 
 iterator_range<fixup_iterator> MachOObjectFile::fixupTable(Error &Err) {
+  if (BindRebaseSectionTable == nullptr)
+    BindRebaseSectionTable = std::make_unique<BindRebaseSegInfo>(this);
+
   MachOChainedFixupEntry Start(&Err, this, true);
   Start.moveToFirst();
 
   MachOChainedFixupEntry Finish(&Err, this, false);
   Finish.moveToEnd();
 
   return make_range(fixup_iterator(Start), fixup_iterator(Finish));
 }
return malformedError(Twine("bad chained fixups: image starts end ") +
                           Twine(CFImageStartsOffset +
                                 sizeof(MachO::dyld_chained_starts_in_image)) +
                           " extends past end " + Twine(EndOffset));
   }
 
   return CFHeader;
 }
 
-Expected<std::pair<size_t, std::vector<MachOObjectFile::ChainedFixupsSegment>>>
+Expected<std::pair<size_t, std::vector<ChainedFixupsSegment>>>
 MachOObjectFile::getChainedFixupsSegments() const {
   auto CFOrErr = getChainedFixupsLoadCommand();
   if (!CFOrErr)
     return CFOrErr.takeError();
 
-  std::vector<MachOObjectFile::ChainedFixupsSegment> Segments;
+  std::vector<ChainedFixupsSegment> Segments;
   if (!CFOrErr->has_value())
     return std::make_pair(0, Segments);
 
   const MachO::linkedit_data_command &DyldChainedFixups = **CFOrErr;
 
   auto HeaderOrErr = getChainedFixupsHeader();
   if (!HeaderOrErr)
     return HeaderOrErr.takeError();

llvm/test/tools/llvm-objdump/MachO/dyld-info.test

-RUN: llvm-objdump --macho --dyld-info %p/Inputs/bind.macho-x86_64 \
-RUN:   | FileCheck %s --match-full-lines --strict-whitespace \
-RUN:     --implicit-check-not={{.}}
-RUN: llvm-otool -dyld_info %p/Inputs/bind.macho-x86_64 \
-RUN:   | FileCheck %s --match-full-lines --strict-whitespace \
-RUN:     --implicit-check-not={{.}}
+RUN: llvm-objdump --macho --dyld-info %p/Inputs/chained-fixups.macho-x86_64 | \
+RUN:     FileCheck -DNAME=%p/Inputs/chained-fixups.macho-x86_64 %s
+RUN: llvm-otool -dyld_info %p/Inputs/chained-fixups.macho-x86_64 | \
+RUN:     FileCheck -DNAME=%p/Inputs/chained-fixups.macho-x86_64 %s
 
-CHECK:{{.*}}bind.macho-x86_64:
-CHECK:dyld information:
+
+## See chained-fixups.test for how the test input was generated.
+CHECK:      [[NAME]]:
+CHECK-NEXT: dyld information:
+CHECK-NEXT: segment      section address       pointer      type   addend dylib          symbol/vm address
+CHECK-NEXT: __DATA_CONST __const 0x3E0   0x8010000000000001 bind   0x0    libdylib       _weakImport (weak import)
+CHECK-NEXT: __DATA_CONST __const 0x3E8   0x8000000000000000 bind   0x0    flat-namespace _dynamicLookup
+CHECK-NEXT: __DATA       __data  0x3F0   0x00200000000003F0 rebase                       0x3F0
+CHECK-NEXT: __DATA       __data  0x400   0x8000000000000004 bind   0x0     weak          _weak
+CHECK-NEXT: __DATA       __data  0x1410  0x8000000000000003 bind   0x0     weak          _weakLocal
+CHECK-NEXT: __DATA       __data  0x3410  0x8010000000000002 bind   0x0     libdylib      _dylib
+CHECK-NEXT: __DATA       __data  0x3418  0x800000002A000002 bind   0x2A    libdylib      _dylib
+
+## TODO: Print opcode-based fixups/binds as well
+## For now, test that execution doesn't fail if the input uses those.
+RUN: llvm-objdump --macho --dyld-info %p/Inputs/bind.macho-x86_64
+RUN: llvm-objdump --macho --dyld-info %p/Inputs/bind.macho-x86_64

llvm/tools/llvm-objdump/MachODump.cpp

for (uint32_t j = 0; j < narguments; j++) {
       uint64_t value = decodeULEB128((const uint8_t *)(loh + i), &n);
       i += n;
       outs() << "\tvalue " << format("0x%" PRIx64, value) << "\n";
       if (i >= nloh)
         return;
     }
   }
 }
 
-static void printMachOChainedFixups(object::MachOObjectFile *Obj) {
-  Error Err = Error::success();
-  for (const object::MachOChainedFixupEntry &Entry : Obj->fixupTable(Err)) {
-    (void)Entry;
-  }
-  if (Err)
-    reportError(std::move(Err), Obj->getFileName());
-}
-
 static SmallVector<std::string> GetSegmentNames(object::MachOObjectFile *O) {
   SmallVector<std::string> Ret;
   for (const MachOObjectFile::LoadCommandInfo &Command : O->load_commands()) {
     if (Command.C.cmd == MachO::LC_SEGMENT) {
       MachO::segment_command SLC = O->getSegmentLoadCommand(Command);
       Ret.push_back(SLC.segname);
     } else if (Command.C.cmd == MachO::LC_SEGMENT_64) {
       MachO::segment_command_64 SLC = O->getSegment64LoadCommand(Command);
       Ret.push_back(SLC.segname);
static constexpr std::array<StringRef, 13> PointerFormats{
     "DYLD_CHAINED_PTR_ARM64E_KERNEL",
     "DYLD_CHAINED_PTR_64_KERNEL_CACHE",
     "DYLD_CHAINED_PTR_ARM64E_USERLAND",
     "DYLD_CHAINED_PTR_ARM64E_FIRMWARE",
     "DYLD_CHAINED_PTR_X86_64_KERNEL_CACHE",
     "DYLD_CHAINED_PTR_ARM64E_USERLAND24",
 };
 
-static void
-PrintChainedFixupsSegment(const MachOObjectFile::ChainedFixupsSegment &Segment,
+static void PrintChainedFixupsSegment(const ChainedFixupsSegment &Segment,
                                       StringRef SegName) {
   outs() << "chained starts in segment " << Segment.SegIdx << " (" << SegName
          << ")\n";
   outs() << "  size = " << Segment.Header.size << '\n';
   outs() << "  page_size = " << format("0x%0" PRIx16, Segment.Header.page_size)
          << '\n';
 
   outs() << "  pointer_format = " << Segment.Header.pointer_format;
   if ((Segment.Header.pointer_format - 1) <
if (StartsIdx < Segments.size() && I == Segments[StartsIdx].SegIdx) {
       SegOffset = Segments[StartsIdx].Offset;
       ++StartsIdx;
     }
 
     outs() << "    seg_offset[" << I << "] = " << SegOffset << " ("
            << SegNames[I] << ")\n";
   }
 
-  for (const MachOObjectFile::ChainedFixupsSegment &S : Segments)
+  for (const ChainedFixupsSegment &S : Segments)
     PrintChainedFixupsSegment(S, SegNames[S.SegIdx]);
 
   auto FixupTargets =
       unwrapOrError(O->getDyldChainedFixupTargets(), O->getFileName());
 
   uint32_t ImportsFormat = ChainedFixupHeader->imports_format;
   for (auto [Idx, Target] : enumerate(FixupTargets))
     PrintChainedFixupTarget(Target, Idx, ImportsFormat, O);
 }
 
 static void PrintDyldInfo(MachOObjectFile *O) {
-  outs() << "dyld information:" << '\n';
-  printMachOChainedFixups(O);
+  Error Err = Error::success();
+
+  size_t SegmentWidth = strlen("segment");
+  size_t SectionWidth = strlen("section");
+  size_t AddressWidth = strlen("address");
+  size_t AddendWidth = strlen("addend");
+  size_t DylibWidth = strlen("dylib");
+  const size_t PointerWidth = 2 + O->getBytesInAddress() * 2;
+
+  auto HexLength = [](uint64_t Num) {
+    return Num ? (size_t)divideCeil(Log2_64(Num), 4) : 1;
+  };
+  for (const object::MachOChainedFixupEntry &Entry : O->fixupTable(Err)) {
+    SegmentWidth = std::max(SegmentWidth, Entry.segmentName().size());
+    SectionWidth = std::max(SectionWidth, Entry.sectionName().size());
+    AddressWidth = std::max(AddressWidth, HexLength(Entry.address()) + 2);
+    if (Entry.isBind()) {
+      AddendWidth = std::max(AddendWidth, HexLength(Entry.addend()) + 2);
+      DylibWidth = std::max(DylibWidth, Entry.symbolName().size());
+    }
+  }
+  // Errors will be handled when printing the table.
+  if (Err)
+    consumeError(std::move(Err));
+
+  outs() << "dyld information:\n";
+  outs() << left_justify("segment", SegmentWidth) << ' '
+         << left_justify("section", SectionWidth) << ' '
+         << left_justify("address", AddressWidth) << ' '
+         << left_justify("pointer", PointerWidth) << " type   "
+         << left_justify("addend", AddendWidth) << ' '
+         << left_justify("dylib", DylibWidth) << " symbol/vm address\n";
+  for (const object::MachOChainedFixupEntry &Entry : O->fixupTable(Err)) {
+    outs() << left_justify(Entry.segmentName(), SegmentWidth) << ' '
+           << left_justify(Entry.sectionName(), SectionWidth) << ' ' << "0x"
+           << left_justify(utohexstr(Entry.address()), AddressWidth - 2) << ' '
+           << format_hex(Entry.rawValue(), PointerWidth, true) << ' ';
+    if (Entry.isBind()) {
+      outs() << "bind   "
+             << "0x" << left_justify(utohexstr(Entry.addend()), AddendWidth - 2)
+             << ' ' << left_justify(ordinalName(O, Entry.ordinal()), DylibWidth)
+             << ' ' << Entry.symbolName();
+      if (Entry.flags() & MachO::BIND_SYMBOL_FLAGS_WEAK_IMPORT)
+        outs() << " (weak import)";
+      outs() << '\n';
+    } else {
+      assert(Entry.isRebase());
+      outs() << "rebase";
+      outs().indent(AddendWidth + DylibWidth + 2);
+      outs() << format("0x%" PRIX64, Entry.pointerValue()) << '\n';
+    }
+  }
+  if (Err)
+    reportError(std::move(Err), O->getFileName());
+
+  // TODO: Print opcode-based fixups if the object uses those.
 }
 
 static void PrintDylibs(MachOObjectFile *O, bool JustId) {
   unsigned Index = 0;
   for (const auto &Load : O->load_commands()) {
     if ((JustId && Load.C.cmd == MachO::LC_ID_DYLIB) ||
         (!JustId && (Load.C.cmd == MachO::LC_ID_DYLIB ||
                      Load.C.cmd == MachO::LC_LOAD_DYLIB ||