cocoapods-dependency-html 0.0.1

data/vendor/bundle/gems/ruby-macho-1.4.0/lib/macho/load_commands.rb

@@ -0,0 +1,1790 @@
+module MachO
+  # Classes and constants for parsing load commands in Mach-O binaries.
+  module LoadCommands
+    # load commands added after OS X 10.1 need to be bitwise ORed with
+    # LC_REQ_DYLD to be recognized by the dynamic linker (dyld)
+    # @api private
+    LC_REQ_DYLD = 0x80000000
+
+    # association of load commands to symbol representations
+    # @api private
+    LOAD_COMMANDS = {
+      0x1 => :LC_SEGMENT,
+      0x2 => :LC_SYMTAB,
+      0x3 => :LC_SYMSEG,
+      0x4 => :LC_THREAD,
+      0x5 => :LC_UNIXTHREAD,
+      0x6 => :LC_LOADFVMLIB,
+      0x7 => :LC_IDFVMLIB,
+      0x8 => :LC_IDENT,
+      0x9 => :LC_FVMFILE,
+      0xa => :LC_PREPAGE,
+      0xb => :LC_DYSYMTAB,
+      0xc => :LC_LOAD_DYLIB,
+      0xd => :LC_ID_DYLIB,
+      0xe => :LC_LOAD_DYLINKER,
+      0xf => :LC_ID_DYLINKER,
+      0x10 => :LC_PREBOUND_DYLIB,
+      0x11 => :LC_ROUTINES,
+      0x12 => :LC_SUB_FRAMEWORK,
+      0x13 => :LC_SUB_UMBRELLA,
+      0x14 => :LC_SUB_CLIENT,
+      0x15 => :LC_SUB_LIBRARY,
+      0x16 => :LC_TWOLEVEL_HINTS,
+      0x17 => :LC_PREBIND_CKSUM,
+      (0x18 | LC_REQ_DYLD) => :LC_LOAD_WEAK_DYLIB,
+      0x19 => :LC_SEGMENT_64,
+      0x1a => :LC_ROUTINES_64,
+      0x1b => :LC_UUID,
+      (0x1c | LC_REQ_DYLD) => :LC_RPATH,
+      0x1d => :LC_CODE_SIGNATURE,
+      0x1e => :LC_SEGMENT_SPLIT_INFO,
+      (0x1f | LC_REQ_DYLD) => :LC_REEXPORT_DYLIB,
+      0x20 => :LC_LAZY_LOAD_DYLIB,
+      0x21 => :LC_ENCRYPTION_INFO,
+      0x22 => :LC_DYLD_INFO,
+      (0x22 | LC_REQ_DYLD) => :LC_DYLD_INFO_ONLY,
+      (0x23 | LC_REQ_DYLD) => :LC_LOAD_UPWARD_DYLIB,
+      0x24 => :LC_VERSION_MIN_MACOSX,
+      0x25 => :LC_VERSION_MIN_IPHONEOS,
+      0x26 => :LC_FUNCTION_STARTS,
+      0x27 => :LC_DYLD_ENVIRONMENT,
+      (0x28 | LC_REQ_DYLD) => :LC_MAIN,
+      0x29 => :LC_DATA_IN_CODE,
+      0x2a => :LC_SOURCE_VERSION,
+      0x2b => :LC_DYLIB_CODE_SIGN_DRS,
+      0x2c => :LC_ENCRYPTION_INFO_64,
+      0x2d => :LC_LINKER_OPTION,
+      0x2e => :LC_LINKER_OPTIMIZATION_HINT,
+      0x2f => :LC_VERSION_MIN_TVOS,
+      0x30 => :LC_VERSION_MIN_WATCHOS,
+      0x31 => :LC_NOTE,
+      0x32 => :LC_BUILD_VERSION,
+    }.freeze
+
+    # association of symbol representations to load command constants
+    # @api private
+    LOAD_COMMAND_CONSTANTS = LOAD_COMMANDS.invert.freeze
+
+    # load commands responsible for loading dylibs
+    # @api private
+    DYLIB_LOAD_COMMANDS = %i[
+      LC_LOAD_DYLIB
+      LC_LOAD_WEAK_DYLIB
+      LC_REEXPORT_DYLIB
+      LC_LAZY_LOAD_DYLIB
+      LC_LOAD_UPWARD_DYLIB
+    ].freeze
+
+    # load commands that can be created manually via {LoadCommand.create}
+    # @api private
+    CREATABLE_LOAD_COMMANDS = DYLIB_LOAD_COMMANDS + %i[
+      LC_ID_DYLIB
+      LC_RPATH
+      LC_LOAD_DYLINKER
+    ].freeze
+
+    # association of load command symbols to string representations of classes
+    # @api private
+    LC_STRUCTURES = {
+      :LC_SEGMENT => "SegmentCommand",
+      :LC_SYMTAB => "SymtabCommand",
+      # "obsolete"
+      :LC_SYMSEG => "SymsegCommand",
+      # seems obsolete, but not documented as such
+      :LC_THREAD => "ThreadCommand",
+      :LC_UNIXTHREAD => "ThreadCommand",
+      # "obsolete"
+      :LC_LOADFVMLIB => "FvmlibCommand",
+      # "obsolete"
+      :LC_IDFVMLIB => "FvmlibCommand",
+      # "obsolete"
+      :LC_IDENT => "IdentCommand",
+      # "reserved for internal use only"
+      :LC_FVMFILE => "FvmfileCommand",
+      # "reserved for internal use only", no public struct
+      :LC_PREPAGE => "LoadCommand",
+      :LC_DYSYMTAB => "DysymtabCommand",
+      :LC_LOAD_DYLIB => "DylibCommand",
+      :LC_ID_DYLIB => "DylibCommand",
+      :LC_LOAD_DYLINKER => "DylinkerCommand",
+      :LC_ID_DYLINKER => "DylinkerCommand",
+      :LC_PREBOUND_DYLIB => "PreboundDylibCommand",
+      :LC_ROUTINES => "RoutinesCommand",
+      :LC_SUB_FRAMEWORK => "SubFrameworkCommand",
+      :LC_SUB_UMBRELLA => "SubUmbrellaCommand",
+      :LC_SUB_CLIENT => "SubClientCommand",
+      :LC_SUB_LIBRARY => "SubLibraryCommand",
+      :LC_TWOLEVEL_HINTS => "TwolevelHintsCommand",
+      :LC_PREBIND_CKSUM => "PrebindCksumCommand",
+      :LC_LOAD_WEAK_DYLIB => "DylibCommand",
+      :LC_SEGMENT_64 => "SegmentCommand64",
+      :LC_ROUTINES_64 => "RoutinesCommand64",
+      :LC_UUID => "UUIDCommand",
+      :LC_RPATH => "RpathCommand",
+      :LC_CODE_SIGNATURE => "LinkeditDataCommand",
+      :LC_SEGMENT_SPLIT_INFO => "LinkeditDataCommand",
+      :LC_REEXPORT_DYLIB => "DylibCommand",
+      :LC_LAZY_LOAD_DYLIB => "DylibCommand",
+      :LC_ENCRYPTION_INFO => "EncryptionInfoCommand",
+      :LC_DYLD_INFO => "DyldInfoCommand",
+      :LC_DYLD_INFO_ONLY => "DyldInfoCommand",
+      :LC_LOAD_UPWARD_DYLIB => "DylibCommand",
+      :LC_VERSION_MIN_MACOSX => "VersionMinCommand",
+      :LC_VERSION_MIN_IPHONEOS => "VersionMinCommand",
+      :LC_FUNCTION_STARTS => "LinkeditDataCommand",
+      :LC_DYLD_ENVIRONMENT => "DylinkerCommand",
+      :LC_MAIN => "EntryPointCommand",
+      :LC_DATA_IN_CODE => "LinkeditDataCommand",
+      :LC_SOURCE_VERSION => "SourceVersionCommand",
+      :LC_DYLIB_CODE_SIGN_DRS => "LinkeditDataCommand",
+      :LC_ENCRYPTION_INFO_64 => "EncryptionInfoCommand64",
+      :LC_LINKER_OPTION => "LinkerOptionCommand",
+      :LC_LINKER_OPTIMIZATION_HINT => "LinkeditDataCommand",
+      :LC_VERSION_MIN_TVOS => "VersionMinCommand",
+      :LC_VERSION_MIN_WATCHOS => "VersionMinCommand",
+      :LC_NOTE => "NoteCommand",
+      :LC_BUILD_VERSION => "BuildVersionCommand",
+    }.freeze
+
+    # association of segment name symbols to names
+    # @api private
+    SEGMENT_NAMES = {
+      :SEG_PAGEZERO => "__PAGEZERO",
+      :SEG_TEXT => "__TEXT",
+      :SEG_DATA => "__DATA",
+      :SEG_OBJC => "__OBJC",
+      :SEG_ICON => "__ICON",
+      :SEG_LINKEDIT => "__LINKEDIT",
+      :SEG_UNIXSTACK => "__UNIXSTACK",
+      :SEG_IMPORT => "__IMPORT",
+    }.freeze
+
+    # association of segment flag symbols to values
+    # @api private
+    SEGMENT_FLAGS = {
+      :SG_HIGHVM => 0x1,
+      :SG_FVMLIB => 0x2,
+      :SG_NORELOC => 0x4,
+      :SG_PROTECTED_VERSION_1 => 0x8,
+    }.freeze
+
+    # The top-level Mach-O load command structure.
+    #
+    # This is the most generic load command -- only the type ID and size are
+    # represented. Used when a more specific class isn't available or isn't implemented.
+    class LoadCommand < MachOStructure
+      # @return [MachO::MachOView, nil] the raw view associated with the load command,
+      #  or nil if the load command was created via {create}.
+      attr_reader :view
+
+      # @return [Integer] the load command's type ID
+      attr_reader :cmd
+
+      # @return [Integer] the size of the load command, in bytes
+      attr_reader :cmdsize
+
+      # @see MachOStructure::FORMAT
+      # @api private
+      FORMAT = "L=2".freeze
+
+      # @see MachOStructure::SIZEOF
+      # @api private
+      SIZEOF = 8
+
+      # Instantiates a new LoadCommand given a view into its origin Mach-O
+      # @param view [MachO::MachOView] the load command's raw view
+      # @return [LoadCommand] the new load command
+      # @api private
+      def self.new_from_bin(view)
+        bin = view.raw_data.slice(view.offset, bytesize)
+        format = Utils.specialize_format(self::FORMAT, view.endianness)
+
+        new(view, *bin.unpack(format))
+      end
+
+      # Creates a new (viewless) command corresponding to the symbol provided
+      # @param cmd_sym [Symbol] the symbol of the load command being created
+      # @param args [Array] the arguments for the load command being created
+      def self.create(cmd_sym, *args)
+        raise LoadCommandNotCreatableError, cmd_sym unless CREATABLE_LOAD_COMMANDS.include?(cmd_sym)
+
+        klass = LoadCommands.const_get LC_STRUCTURES[cmd_sym]
+        cmd = LOAD_COMMAND_CONSTANTS[cmd_sym]
+
+        # cmd will be filled in, view and cmdsize will be left unpopulated
+        klass_arity = klass.instance_method(:initialize).arity - 3
+
+        raise LoadCommandCreationArityError.new(cmd_sym, klass_arity, args.size) if klass_arity != args.size
+
+        klass.new(nil, cmd, nil, *args)
+      end
+
+      # @param view [MachO::MachOView] the load command's raw view
+      # @param cmd [Integer] the load command's identifying number
+      # @param cmdsize [Integer] the size of the load command in bytes
+      # @api private
+      def initialize(view, cmd, cmdsize)
+        @view = view
+        @cmd = cmd
+        @cmdsize = cmdsize
+      end
+
+      # @return [Boolean] whether the load command can be serialized
+      def serializable?
+        CREATABLE_LOAD_COMMANDS.include?(LOAD_COMMANDS[cmd])
+      end
+
+      # @param context [SerializationContext] the context
+      #  to serialize into
+      # @return [String, nil] the serialized fields of the load command, or nil
+      #  if the load command can't be serialized
+      # @api private
+      def serialize(context)
+        raise LoadCommandNotSerializableError, LOAD_COMMANDS[cmd] unless serializable?
+
+        format = Utils.specialize_format(FORMAT, context.endianness)
+        [cmd, SIZEOF].pack(format)
+      end
+
+      # @return [Integer] the load command's offset in the source file
+      # @deprecated use {#view} instead
+      def offset
+        view.offset
+      end
+
+      # @return [Symbol, nil] a symbol representation of the load command's
+      #  type ID, or nil if the ID doesn't correspond to a known load command class
+      def type
+        LOAD_COMMANDS[cmd]
+      end
+
+      alias to_sym type
+
+      # @return [String] a string representation of the load command's
+      #  identifying number
+      def to_s
+        type.to_s
+      end
+
+      # @return [Hash] a hash representation of this load command
+      # @note Children should override this to include additional information.
+      def to_h
+        {
+          "view" => view.to_h,
+          "cmd" => cmd,
+          "cmdsize" => cmdsize,
+          "type" => type,
+        }.merge super
+      end
+
+      # Represents a Load Command string. A rough analogue to the lc_str
+      # struct used internally by OS X. This class allows ruby-macho to
+      # pretend that strings stored in LCs are immediately available without
+      # explicit operations on the raw Mach-O data.
+      class LCStr
+        # @param lc [LoadCommand] the load command
+        # @param lc_str [Integer, String] the offset to the beginning of the
+        #  string, or the string itself if not being initialized with a view.
+        # @raise [MachO::LCStrMalformedError] if the string is malformed
+        # @todo devise a solution such that the `lc_str` parameter is not
+        #  interpreted differently depending on `lc.view`. The current behavior
+        #  is a hack to allow viewless load command creation.
+        # @api private
+        def initialize(lc, lc_str)
+          view = lc.view
+
+          if view
+            lc_str_abs = view.offset + lc_str
+            lc_end = view.offset + lc.cmdsize - 1
+            raw_string = view.raw_data.slice(lc_str_abs..lc_end)
+            @string, null_byte, _padding = raw_string.partition("\x00")
+
+            raise LCStrMalformedError, lc if null_byte.empty?
+
+            @string_offset = lc_str
+          else
+            @string = lc_str
+            @string_offset = 0
+          end
+        end
+
+        # @return [String] a string representation of the LCStr
+        def to_s
+          @string
+        end
+
+        # @return [Integer] the offset to the beginning of the string in the
+        #  load command
+        def to_i
+          @string_offset
+        end
+
+        # @return [Hash] a hash representation of this {LCStr}.
+        def to_h
+          {
+            "string" => to_s,
+            "offset" => to_i,
+          }
+        end
+      end
+
+      # Represents the contextual information needed by a load command to
+      # serialize itself correctly into a binary string.
+      class SerializationContext
+        # @return [Symbol] the endianness of the serialized load command
+        attr_reader :endianness
+
+        # @return [Integer] the constant alignment value used to pad the
+        #  serialized load command
+        attr_reader :alignment
+
+        # @param macho [MachO::MachOFile] the file to contextualize
+        # @return [SerializationContext] the
+        #  resulting context
+        def self.context_for(macho)
+          new(macho.endianness, macho.alignment)
+        end
+
+        # @param endianness [Symbol] the endianness of the context
+        # @param alignment [Integer] the alignment of the context
+        # @api private
+        def initialize(endianness, alignment)
+          @endianness = endianness
+          @alignment = alignment
+        end
+      end
+    end
+
+    # A load command containing a single 128-bit unique random number
+    # identifying an object produced by static link editor. Corresponds to
+    # LC_UUID.
+    class UUIDCommand < LoadCommand
+      # @return [Array<Integer>] the UUID
+      attr_reader :uuid
+
+      # @see MachOStructure::FORMAT
+      # @api private
+      FORMAT = "L=2a16".freeze
+
+      # @see MachOStructure::SIZEOF
+      # @api private
+      SIZEOF = 24
+
+      # @api private
+      def initialize(view, cmd, cmdsize, uuid)
+        super(view, cmd, cmdsize)
+        @uuid = uuid.unpack("C16") # re-unpack for the actual UUID array
+      end
+
+      # @return [String] a string representation of the UUID
+      def uuid_string
+        hexes = uuid.map { |e| "%02x" % e }
+        segs = [
+          hexes[0..3].join, hexes[4..5].join, hexes[6..7].join,
+          hexes[8..9].join, hexes[10..15].join
+        ]
+
+        segs.join("-")
+      end
+
+      # @return [Hash] returns a hash representation of this {UUIDCommand}
+      def to_h
+        {
+          "uuid" => uuid,
+          "uuid_string" => uuid_string,
+        }.merge super
+      end
+    end
+
+    # A load command indicating that part of this file is to be mapped into
+    # the task's address space. Corresponds to LC_SEGMENT.
+    class SegmentCommand < LoadCommand
+      # @return [String] the name of the segment
+      attr_reader :segname
+
+      # @return [Integer] the memory address of the segment
+      attr_reader :vmaddr
+
+      # @return [Integer] the memory size of the segment
+      attr_reader :vmsize
+
+      # @return [Integer] the file offset of the segment
+      attr_reader :fileoff
+
+      # @return [Integer] the amount to map from the file
+      attr_reader :filesize
+
+      # @return [Integer] the maximum VM protection
+      attr_reader :maxprot
+
+      # @return [Integer] the initial VM protection
+      attr_reader :initprot
+
+      # @return [Integer] the number of sections in the segment
+      attr_reader :nsects
+
+      # @return [Integer] any flags associated with the segment
+      attr_reader :flags
+
+      # @see MachOStructure::FORMAT
+      # @api private
+      FORMAT = "L=2Z16L=4l=2L=2".freeze
+
+      # @see MachOStructure::SIZEOF
+      # @api private
+      SIZEOF = 56
+
+      # @api private
+      def initialize(view, cmd, cmdsize, segname, vmaddr, vmsize, fileoff,
+                     filesize, maxprot, initprot, nsects, flags)
+        super(view, cmd, cmdsize)
+        @segname = segname
+        @vmaddr = vmaddr
+        @vmsize = vmsize
+        @fileoff = fileoff
+        @filesize = filesize
+        @maxprot = maxprot
+        @initprot = initprot
+        @nsects = nsects
+        @flags = flags
+      end
+
+      # All sections referenced within this segment.
+      # @return [Array<MachO::Sections::Section>] if the Mach-O is 32-bit
+      # @return [Array<MachO::Sections::Section64>] if the Mach-O is 64-bit
+      def sections
+        klass = case self
+        when SegmentCommand64
+          MachO::Sections::Section64
+        when SegmentCommand
+          MachO::Sections::Section
+        end
+
+        offset = view.offset + self.class.bytesize
+        length = nsects * klass.bytesize
+
+        bins = view.raw_data[offset, length]
+        bins.unpack("a#{klass.bytesize}" * nsects).map do |bin|
+          klass.new_from_bin(view.endianness, bin)
+        end
+      end
+
+      # @example
+      #  puts "this segment relocated in/to it" if sect.flag?(:SG_NORELOC)
+      # @param flag [Symbol] a segment flag symbol
+      # @return [Boolean] true if `flag` is present in the segment's flag field
+      def flag?(flag)
+        flag = SEGMENT_FLAGS[flag]
+
+        return false if flag.nil?
+
+        flags & flag == flag
+      end
+
+      # Guesses the alignment of the segment.
+      # @return [Integer] the guessed alignment, as a power of 2
+      # @note See `guess_align` in `cctools/misc/lipo.c`
+      def guess_align
+        return Sections::MAX_SECT_ALIGN if vmaddr.zero?
+
+        align = 0
+        segalign = 1
+
+        while (segalign & vmaddr).zero?
+          segalign <<= 1
+          align += 1
+        end
+
+        return 2 if align < 2
+        return Sections::MAX_SECT_ALIGN if align > Sections::MAX_SECT_ALIGN
+
+        align
+      end
+
+      # @return [Hash] a hash representation of this {SegmentCommand}
+      def to_h
+        {
+          "segname" => segname,
+          "vmaddr" => vmaddr,
+          "vmsize" => vmsize,
+          "fileoff" => fileoff,
+          "filesize" => filesize,
+          "maxprot" => maxprot,
+          "initprot" => initprot,
+          "nsects" => nsects,
+          "flags" => flags,
+          "sections" => sections.map(&:to_h),
+        }.merge super
+      end
+    end
+
+    # A load command indicating that part of this file is to be mapped into
+    # the task's address space. Corresponds to LC_SEGMENT_64.
+    class SegmentCommand64 < SegmentCommand
+      # @see MachOStructure::FORMAT
+      # @api private
+      FORMAT = "L=2Z16Q=4l=2L=2".freeze
+
+      # @see MachOStructure::SIZEOF
+      # @api private
+      SIZEOF = 72
+    end
+
+    # A load command representing some aspect of shared libraries, depending
+    # on filetype. Corresponds to LC_ID_DYLIB, LC_LOAD_DYLIB,
+    # LC_LOAD_WEAK_DYLIB, and LC_REEXPORT_DYLIB.
+    class DylibCommand < LoadCommand
+      # @return [LCStr] the library's path
+      #  name as an LCStr
+      attr_reader :name
+
+      # @return [Integer] the library's build time stamp
+      attr_reader :timestamp
+
+      # @return [Integer] the library's current version number
+      attr_reader :current_version
+
+      # @return [Integer] the library's compatibility version number
+      attr_reader :compatibility_version
+
+      # @see MachOStructure::FORMAT
+      # @api private
+      FORMAT = "L=6".freeze
+
+      # @see MachOStructure::SIZEOF
+      # @api private
+      SIZEOF = 24
+
+      # @api private
+      def initialize(view, cmd, cmdsize, name, timestamp, current_version,
+                     compatibility_version)
+        super(view, cmd, cmdsize)
+        @name = LCStr.new(self, name)
+        @timestamp = timestamp
+        @current_version = current_version
+        @compatibility_version = compatibility_version
+      end
+
+      # @param context [SerializationContext]
+      #  the context
+      # @return [String] the serialized fields of the load command
+      # @api private
+      def serialize(context)
+        format = Utils.specialize_format(FORMAT, context.endianness)
+        string_payload, string_offsets = Utils.pack_strings(SIZEOF,
+                                                            context.alignment,
+                                                            :name => name.to_s)
+        cmdsize = SIZEOF + string_payload.bytesize
+        [cmd, cmdsize, string_offsets[:name], timestamp, current_version,
+         compatibility_version].pack(format) + string_payload
+      end
+
+      # @return [Hash] a hash representation of this {DylibCommand}
+      def to_h
+        {
+          "name" => name.to_h,
+          "timestamp" => timestamp,
+          "current_version" => current_version,
+          "compatibility_version" => compatibility_version,
+        }.merge super
+      end
+    end
+
+    # A load command representing some aspect of the dynamic linker, depending
+    # on filetype. Corresponds to LC_ID_DYLINKER, LC_LOAD_DYLINKER, and
+    # LC_DYLD_ENVIRONMENT.
+    class DylinkerCommand < LoadCommand
+      # @return [LCStr] the dynamic linker's
+      #  path name as an LCStr
+      attr_reader :name
+
+      # @see MachOStructure::FORMAT
+      # @api private
+      FORMAT = "L=3".freeze
+
+      # @see MachOStructure::SIZEOF
+      # @api private
+      SIZEOF = 12
+
+      # @api private
+      def initialize(view, cmd, cmdsize, name)
+        super(view, cmd, cmdsize)
+        @name = LCStr.new(self, name)
+      end
+
+      # @param context [SerializationContext]
+      #  the context
+      # @return [String] the serialized fields of the load command
+      # @api private
+      def serialize(context)
+        format = Utils.specialize_format(FORMAT, context.endianness)
+        string_payload, string_offsets = Utils.pack_strings(SIZEOF,
+                                                            context.alignment,
+                                                            :name => name.to_s)
+        cmdsize = SIZEOF + string_payload.bytesize
+        [cmd, cmdsize, string_offsets[:name]].pack(format) + string_payload
+      end
+
+      # @return [Hash] a hash representation of this {DylinkerCommand}
+      def to_h
+        {
+          "name" => name.to_h,
+        }.merge super
+      end
+    end
+
+    # A load command used to indicate dynamic libraries used in prebinding.
+    # Corresponds to LC_PREBOUND_DYLIB.
+    class PreboundDylibCommand < LoadCommand
+      # @return [LCStr] the library's path
+      #  name as an LCStr
+      attr_reader :name
+
+      # @return [Integer] the number of modules in the library
+      attr_reader :nmodules
+
+      # @return [Integer] a bit vector of linked modules
+      attr_reader :linked_modules
+
+      # @see MachOStructure::FORMAT
+      # @api private
+      FORMAT = "L=5".freeze
+
+      # @see MachOStructure::SIZEOF
+      # @api private
+      SIZEOF = 20
+
+      # @api private
+      def initialize(view, cmd, cmdsize, name, nmodules, linked_modules)
+        super(view, cmd, cmdsize)
+        @name = LCStr.new(self, name)
+        @nmodules = nmodules
+        @linked_modules = linked_modules
+      end
+
+      # @return [Hash] a hash representation of this {PreboundDylibCommand}
+      def to_h
+        {
+          "name" => name.to_h,
+          "nmodules" => nmodules,
+          "linked_modules" => linked_modules,
+        }.merge super
+      end
+    end
+
+    # A load command used to represent threads.
+    # @note cctools-870 and onwards have all fields of thread_command commented
+    # out except the common ones (cmd, cmdsize)
+    class ThreadCommand < LoadCommand
+      # @see MachOStructure::FORMAT
+      # @api private
+      FORMAT = "L=2".freeze
+
+      # @see MachOStructure::SIZEOF
+      # @api private
+      SIZEOF = 8
+    end
+
+    # A load command containing the address of the dynamic shared library
+    # initialization routine and an index into the module table for the module
+    # that defines the routine. Corresponds to LC_ROUTINES.
+    class RoutinesCommand < LoadCommand
+      # @return [Integer] the address of the initialization routine
+      attr_reader :init_address
+
+      # @return [Integer] the index into the module table that the init routine
+      #  is defined in
+      attr_reader :init_module
+
+      # @return [void]
+      attr_reader :reserved1
+
+      # @return [void]
+      attr_reader :reserved2
+
+      # @return [void]
+      attr_reader :reserved3
+
+      # @return [void]
+      attr_reader :reserved4
+
+      # @return [void]
+      attr_reader :reserved5
+
+      # @return [void]
+      attr_reader :reserved6
+
+      # @see MachOStructure::FORMAT
+      # @api private
+      FORMAT = "L=10".freeze
+
+      # @see MachOStructure::SIZEOF
+      # @api private
+      SIZEOF = 40
+
+      # @api private
+      def initialize(view, cmd, cmdsize, init_address, init_module, reserved1,
+                     reserved2, reserved3, reserved4, reserved5, reserved6)
+        super(view, cmd, cmdsize)
+        @init_address = init_address
+        @init_module = init_module
+        @reserved1 = reserved1
+        @reserved2 = reserved2
+        @reserved3 = reserved3
+        @reserved4 = reserved4
+        @reserved5 = reserved5
+        @reserved6 = reserved6
+      end
+
+      # @return [Hash] a hash representation of this {RoutinesCommand}
+      def to_h
+        {
+          "init_address" => init_address,
+          "init_module" => init_module,
+          "reserved1" => reserved1,
+          "reserved2" => reserved2,
+          "reserved3" => reserved3,
+          "reserved4" => reserved4,
+          "reserved5" => reserved5,
+          "reserved6" => reserved6,
+        }.merge super
+      end
+    end
+
+    # A load command containing the address of the dynamic shared library
+    # initialization routine and an index into the module table for the module
+    # that defines the routine. Corresponds to LC_ROUTINES_64.
+    class RoutinesCommand64 < RoutinesCommand
+      # @see MachOStructure::FORMAT
+      # @api private
+      FORMAT = "L=2Q=8".freeze
+
+      # @see MachOStructure::SIZEOF
+      # @api private
+      SIZEOF = 72
+    end
+
+    # A load command signifying membership of a subframework containing the name
+    # of an umbrella framework. Corresponds to LC_SUB_FRAMEWORK.
+    class SubFrameworkCommand < LoadCommand
+      # @return [LCStr] the umbrella framework name as an LCStr
+      attr_reader :umbrella
+
+      # @see MachOStructure::FORMAT
+      # @api private
+      FORMAT = "L=3".freeze
+
+      # @see MachOStructure::SIZEOF
+      # @api private
+      SIZEOF = 12
+
+      # @api private
+      def initialize(view, cmd, cmdsize, umbrella)
+        super(view, cmd, cmdsize)
+        @umbrella = LCStr.new(self, umbrella)
+      end
+
+      # @return [Hash] a hash representation of this {SubFrameworkCommand}
+      def to_h
+        {
+          "umbrella" => umbrella.to_h,
+        }.merge super
+      end
+    end
+
+    # A load command signifying membership of a subumbrella containing the name
+    # of an umbrella framework. Corresponds to LC_SUB_UMBRELLA.
+    class SubUmbrellaCommand < LoadCommand
+      # @return [LCStr] the subumbrella framework name as an LCStr
+      attr_reader :sub_umbrella
+
+      # @see MachOStructure::FORMAT
+      # @api private
+      FORMAT = "L=3".freeze
+
+      # @see MachOStructure::SIZEOF
+      # @api private
+      SIZEOF = 12
+
+      # @api private
+      def initialize(view, cmd, cmdsize, sub_umbrella)
+        super(view, cmd, cmdsize)
+        @sub_umbrella = LCStr.new(self, sub_umbrella)
+      end
+
+      # @return [Hash] a hash representation of this {SubUmbrellaCommand}
+      def to_h
+        {
+          "sub_umbrella" => sub_umbrella.to_h,
+        }.merge super
+      end
+    end
+
+    # A load command signifying a sublibrary of a shared library. Corresponds
+    # to LC_SUB_LIBRARY.
+    class SubLibraryCommand < LoadCommand
+      # @return [LCStr] the sublibrary name as an LCStr
+      attr_reader :sub_library
+
+      # @see MachOStructure::FORMAT
+      # @api private
+      FORMAT = "L=3".freeze
+
+      # @see MachOStructure::SIZEOF
+      # @api private
+      SIZEOF = 12
+
+      # @api private
+      def initialize(view, cmd, cmdsize, sub_library)
+        super(view, cmd, cmdsize)
+        @sub_library = LCStr.new(self, sub_library)
+      end
+
+      # @return [Hash] a hash representation of this {SubLibraryCommand}
+      def to_h
+        {
+          "sub_library" => sub_library.to_h,
+        }.merge super
+      end
+    end
+
+    # A load command signifying a shared library that is a subframework of
+    # an umbrella framework. Corresponds to LC_SUB_CLIENT.
+    class SubClientCommand < LoadCommand
+      # @return [LCStr] the subclient name as an LCStr
+      attr_reader :sub_client
+
+      # @see MachOStructure::FORMAT
+      # @api private
+      FORMAT = "L=3".freeze
+
+      # @see MachOStructure::SIZEOF
+      # @api private
+      SIZEOF = 12
+
+      # @api private
+      def initialize(view, cmd, cmdsize, sub_client)
+        super(view, cmd, cmdsize)
+        @sub_client = LCStr.new(self, sub_client)
+      end
+
+      # @return [Hash] a hash representation of this {SubClientCommand}
+      def to_h
+        {
+          "sub_client" => sub_client.to_h,
+        }.merge super
+      end
+    end
+
+    # A load command containing the offsets and sizes of the link-edit 4.3BSD
+    # "stab" style symbol table information. Corresponds to LC_SYMTAB.
+    class SymtabCommand < LoadCommand
+      # @return [Integer] the symbol table's offset
+      attr_reader :symoff
+
+      # @return [Integer] the number of symbol table entries
+      attr_reader :nsyms
+
+      # @return [Integer] the string table's offset
+      attr_reader :stroff
+
+      # @return [Integer] the string table size in bytes
+      attr_reader :strsize
+
+      # @see MachOStructure::FORMAT
+      # @api private
+      FORMAT = "L=6".freeze
+
+      # @see MachOStructure::SIZEOF
+      # @api private
+      SIZEOF = 24
+
+      # @api private
+      def initialize(view, cmd, cmdsize, symoff, nsyms, stroff, strsize)
+        super(view, cmd, cmdsize)
+        @symoff = symoff
+        @nsyms = nsyms
+        @stroff = stroff
+        @strsize = strsize
+      end
+
+      # @return [Hash] a hash representation of this {SymtabCommand}
+      def to_h
+        {
+          "symoff" => symoff,
+          "nsyms" => nsyms,
+          "stroff" => stroff,
+          "strsize" => strsize,
+        }.merge super
+      end
+    end
+
+    # A load command containing symbolic information needed to support data
+    # structures used by the dynamic link editor. Corresponds to LC_DYSYMTAB.
+    class DysymtabCommand < LoadCommand
+      # @return [Integer] the index to local symbols
+      attr_reader :ilocalsym
+
+      # @return [Integer] the number of local symbols
+      attr_reader :nlocalsym
+
+      # @return [Integer] the index to externally defined symbols
+      attr_reader :iextdefsym
+
+      # @return [Integer] the number of externally defined symbols
+      attr_reader :nextdefsym
+
+      # @return [Integer] the index to undefined symbols
+      attr_reader :iundefsym
+
+      # @return [Integer] the number of undefined symbols
+      attr_reader :nundefsym
+
+      # @return [Integer] the file offset to the table of contents
+      attr_reader :tocoff
+
+      # @return [Integer] the number of entries in the table of contents
+      attr_reader :ntoc
+
+      # @return [Integer] the file offset to the module table
+      attr_reader :modtaboff
+
+      # @return [Integer] the number of entries in the module table
+      attr_reader :nmodtab
+
+      # @return [Integer] the file offset to the referenced symbol table
+      attr_reader :extrefsymoff
+
+      # @return [Integer] the number of entries in the referenced symbol table
+      attr_reader :nextrefsyms
+
+      # @return [Integer] the file offset to the indirect symbol table
+      attr_reader :indirectsymoff
+
+      # @return [Integer] the number of entries in the indirect symbol table
+      attr_reader :nindirectsyms
+
+      # @return [Integer] the file offset to the external relocation entries
+      attr_reader :extreloff
+
+      # @return [Integer] the number of external relocation entries
+      attr_reader :nextrel
+
+      # @return [Integer] the file offset to the local relocation entries
+      attr_reader :locreloff
+
+      # @return [Integer] the number of local relocation entries
+      attr_reader :nlocrel
+
+      # @see MachOStructure::FORMAT
+      # @api private
+      FORMAT = "L=20".freeze
+
+      # @see MachOStructure::SIZEOF
+      # @api private
+      SIZEOF = 80
+
+      # ugh
+      # @api private
+      def initialize(view, cmd, cmdsize, ilocalsym, nlocalsym, iextdefsym,
+                     nextdefsym, iundefsym, nundefsym, tocoff, ntoc, modtaboff,
+                     nmodtab, extrefsymoff, nextrefsyms, indirectsymoff,
+                     nindirectsyms, extreloff, nextrel, locreloff, nlocrel)
+        super(view, cmd, cmdsize)
+        @ilocalsym = ilocalsym
+        @nlocalsym = nlocalsym
+        @iextdefsym = iextdefsym
+        @nextdefsym = nextdefsym
+        @iundefsym = iundefsym
+        @nundefsym = nundefsym
+        @tocoff = tocoff
+        @ntoc = ntoc
+        @modtaboff = modtaboff
+        @nmodtab = nmodtab
+        @extrefsymoff = extrefsymoff
+        @nextrefsyms = nextrefsyms
+        @indirectsymoff = indirectsymoff
+        @nindirectsyms = nindirectsyms
+        @extreloff = extreloff
+        @nextrel = nextrel
+        @locreloff = locreloff
+        @nlocrel = nlocrel
+      end
+
+      # @return [Hash] a hash representation of this {DysymtabCommand}
+      def to_h
+        {
+          "ilocalsym" => ilocalsym,
+          "nlocalsym" => nlocalsym,
+          "iextdefsym" => iextdefsym,
+          "nextdefsym" => nextdefsym,
+          "iundefsym" => iundefsym,
+          "nundefsym" => nundefsym,
+          "tocoff" => tocoff,
+          "ntoc" => ntoc,
+          "modtaboff" => modtaboff,
+          "nmodtab" => nmodtab,
+          "extrefsymoff" => extrefsymoff,
+          "nextrefsyms" => nextrefsyms,
+          "indirectsymoff" => indirectsymoff,
+          "nindirectsyms" => nindirectsyms,
+          "extreloff" => extreloff,
+          "nextrel" => nextrel,
+          "locreloff" => locreloff,
+          "nlocrel" => nlocrel,
+        }.merge super
+      end
+    end
+
+    # A load command containing the offset and number of hints in the two-level
+    # namespace lookup hints table. Corresponds to LC_TWOLEVEL_HINTS.
+    class TwolevelHintsCommand < LoadCommand
+      # @return [Integer] the offset to the hint table
+      attr_reader :htoffset
+
+      # @return [Integer] the number of hints in the hint table
+      attr_reader :nhints
+
+      # @return [TwolevelHintsTable]
+      #  the hint table
+      attr_reader :table
+
+      # @see MachOStructure::FORMAT
+      # @api private
+      FORMAT = "L=4".freeze
+
+      # @see MachOStructure::SIZEOF
+      # @api private
+      SIZEOF = 16
+
+      # @api private
+      def initialize(view, cmd, cmdsize, htoffset, nhints)
+        super(view, cmd, cmdsize)
+        @htoffset = htoffset
+        @nhints = nhints
+        @table = TwolevelHintsTable.new(view, htoffset, nhints)
+      end
+
+      # @return [Hash] a hash representation of this {TwolevelHintsCommand}
+      def to_h
+        {
+          "htoffset" => htoffset,
+          "nhints" => nhints,
+          "table" => table.hints.map(&:to_h),
+        }.merge super
+      end
+
+      # A representation of the two-level namespace lookup hints table exposed
+      # by a {TwolevelHintsCommand} (`LC_TWOLEVEL_HINTS`).
+      class TwolevelHintsTable
+        # @return [Array<TwolevelHint>] all hints in the table
+        attr_reader :hints
+
+        # @param view [MachO::MachOView] the view into the current Mach-O
+        # @param htoffset [Integer] the offset of the hints table
+        # @param nhints [Integer] the number of two-level hints in the table
+        # @api private
+        def initialize(view, htoffset, nhints)
+          format = Utils.specialize_format("L=#{nhints}", view.endianness)
+          raw_table = view.raw_data[htoffset, nhints * 4]
+          blobs = raw_table.unpack(format)
+
+          @hints = blobs.map { |b| TwolevelHint.new(b) }
+        end
+
+        # An individual two-level namespace lookup hint.
+        class TwolevelHint
+          # @return [Integer] the index into the sub-images
+          attr_reader :isub_image
+
+          # @return [Integer] the index into the table of contents
+          attr_reader :itoc
+
+          # @param blob [Integer] the 32-bit number containing the lookup hint
+          # @api private
+          def initialize(blob)
+            @isub_image = blob >> 24
+            @itoc = blob & 0x00FFFFFF
+          end
+
+          # @return [Hash] a hash representation of this {TwolevelHint}
+          def to_h
+            {
+              "isub_image" => isub_image,
+              "itoc" => itoc,
+            }
+          end
+        end
+      end
+    end
+
+    # A load command containing the value of the original checksum for prebound
+    # files, or zero. Corresponds to LC_PREBIND_CKSUM.
+    class PrebindCksumCommand < LoadCommand
+      # @return [Integer] the checksum or 0
+      attr_reader :cksum
+
+      # @see MachOStructure::FORMAT
+      # @api private
+      FORMAT = "L=3".freeze
+
+      # @see MachOStructure::SIZEOF
+      # @api private
+      SIZEOF = 12
+
+      # @api private
+      def initialize(view, cmd, cmdsize, cksum)
+        super(view, cmd, cmdsize)
+        @cksum = cksum
+      end
+
+      # @return [Hash] a hash representation of this {PrebindCksumCommand}
+      def to_h
+        {
+          "cksum" => cksum,
+        }.merge super
+      end
+    end
+
+    # A load command representing an rpath, which specifies a path that should
+    # be added to the current run path used to find @rpath prefixed dylibs.
+    # Corresponds to LC_RPATH.
+    class RpathCommand < LoadCommand
+      # @return [LCStr] the path to add to the run path as an LCStr
+      attr_reader :path
+
+      # @see MachOStructure::FORMAT
+      # @api private
+      FORMAT = "L=3".freeze
+
+      # @see MachOStructure::SIZEOF
+      # @api private
+      SIZEOF = 12
+
+      # @api private
+      def initialize(view, cmd, cmdsize, path)
+        super(view, cmd, cmdsize)
+        @path = LCStr.new(self, path)
+      end
+
+      # @param context [SerializationContext] the context
+      # @return [String] the serialized fields of the load command
+      # @api private
+      def serialize(context)
+        format = Utils.specialize_format(FORMAT, context.endianness)
+        string_payload, string_offsets = Utils.pack_strings(SIZEOF,
+                                                            context.alignment,
+                                                            :path => path.to_s)
+        cmdsize = SIZEOF + string_payload.bytesize
+        [cmd, cmdsize, string_offsets[:path]].pack(format) + string_payload
+      end
+
+      # @return [Hash] a hash representation of this {RpathCommand}
+      def to_h
+        {
+          "path" => path.to_h,
+        }.merge super
+      end
+    end
+
+    # A load command representing the offsets and sizes of a blob of data in
+    # the __LINKEDIT segment. Corresponds to LC_CODE_SIGNATURE,
+    # LC_SEGMENT_SPLIT_INFO, LC_FUNCTION_STARTS, LC_DATA_IN_CODE,
+    # LC_DYLIB_CODE_SIGN_DRS, and LC_LINKER_OPTIMIZATION_HINT.
+    class LinkeditDataCommand < LoadCommand
+      # @return [Integer] offset to the data in the __LINKEDIT segment
+      attr_reader :dataoff
+
+      # @return [Integer] size of the data in the __LINKEDIT segment
+      attr_reader :datasize
+
+      # @see MachOStructure::FORMAT
+      # @api private
+      FORMAT = "L=4".freeze
+
+      # @see MachOStructure::SIZEOF
+      # @api private
+      SIZEOF = 16
+
+      # @api private
+      def initialize(view, cmd, cmdsize, dataoff, datasize)
+        super(view, cmd, cmdsize)
+        @dataoff = dataoff
+        @datasize = datasize
+      end
+
+      # @return [Hash] a hash representation of this {LinkeditDataCommand}
+      def to_h
+        {
+          "dataoff" => dataoff,
+          "datasize" => datasize,
+        }.merge super
+      end
+    end
+
+    # A load command representing the offset to and size of an encrypted
+    # segment. Corresponds to LC_ENCRYPTION_INFO.
+    class EncryptionInfoCommand < LoadCommand
+      # @return [Integer] the offset to the encrypted segment
+      attr_reader :cryptoff
+
+      # @return [Integer] the size of the encrypted segment
+      attr_reader :cryptsize
+
+      # @return [Integer] the encryption system, or 0 if not encrypted yet
+      attr_reader :cryptid
+
+      # @see MachOStructure::FORMAT
+      # @api private
+      FORMAT = "L=5".freeze
+
+      # @see MachOStructure::SIZEOF
+      # @api private
+      SIZEOF = 20
+
+      # @api private
+      def initialize(view, cmd, cmdsize, cryptoff, cryptsize, cryptid)
+        super(view, cmd, cmdsize)
+        @cryptoff = cryptoff
+        @cryptsize = cryptsize
+        @cryptid = cryptid
+      end
+
+      # @return [Hash] a hash representation of this {EncryptionInfoCommand}
+      def to_h
+        {
+          "cryptoff" => cryptoff,
+          "cryptsize" => cryptsize,
+          "cryptid" => cryptid,
+        }.merge super
+      end
+    end
+
+    # A load command representing the offset to and size of an encrypted
+    # segment. Corresponds to LC_ENCRYPTION_INFO_64.
+    class EncryptionInfoCommand64 < EncryptionInfoCommand
+      # @return [Integer] 64-bit padding value
+      attr_reader :pad
+
+      # @see MachOStructure::FORMAT
+      # @api private
+      FORMAT = "L=6".freeze
+
+      # @see MachOStructure::SIZEOF
+      # @api private
+      SIZEOF = 24
+
+      # @api private
+      def initialize(view, cmd, cmdsize, cryptoff, cryptsize, cryptid, pad)
+        super(view, cmd, cmdsize, cryptoff, cryptsize, cryptid)
+        @pad = pad
+      end
+
+      # @return [Hash] a hash representation of this {EncryptionInfoCommand64}
+      def to_h
+        {
+          "pad" => pad,
+        }.merge super
+      end
+    end
+
+    # A load command containing the minimum OS version on which the binary
+    # was built to run. Corresponds to LC_VERSION_MIN_MACOSX and
+    # LC_VERSION_MIN_IPHONEOS.
+    class VersionMinCommand < LoadCommand
+      # @return [Integer] the version X.Y.Z packed as x16.y8.z8
+      attr_reader :version
+
+      # @return [Integer] the SDK version X.Y.Z packed as x16.y8.z8
+      attr_reader :sdk
+
+      # @see MachOStructure::FORMAT
+      # @api private
+      FORMAT = "L=4".freeze
+
+      # @see MachOStructure::SIZEOF
+      # @api private
+      SIZEOF = 16
+
+      # @api private
+      def initialize(view, cmd, cmdsize, version, sdk)
+        super(view, cmd, cmdsize)
+        @version = version
+        @sdk = sdk
+      end
+
+      # A string representation of the binary's minimum OS version.
+      # @return [String] a string representing the minimum OS version.
+      def version_string
+        binary = "%032b" % version
+        segs = [
+          binary[0..15], binary[16..23], binary[24..31]
+        ].map { |s| s.to_i(2) }
+
+        segs.join(".")
+      end
+
+      # A string representation of the binary's SDK version.
+      # @return [String] a string representing the SDK version.
+      def sdk_string
+        binary = "%032b" % sdk
+        segs = [
+          binary[0..15], binary[16..23], binary[24..31]
+        ].map { |s| s.to_i(2) }
+
+        segs.join(".")
+      end
+
+      # @return [Hash] a hash representation of this {VersionMinCommand}
+      def to_h
+        {
+          "version" => version,
+          "version_string" => version_string,
+          "sdk" => sdk,
+          "sdk_string" => sdk_string,
+        }.merge super
+      end
+    end
+
+    # A load command containing the minimum OS version on which
+    # the binary was built for its platform.
+    # Corresponds to LC_BUILD_VERSION.
+    class BuildVersionCommand < LoadCommand
+      # @return [Integer]
+      attr_reader :platform
+
+      # @return [Integer] the minimum OS version X.Y.Z packed as x16.y8.z8
+      attr_reader :minos
+
+      # @return [Integer] the SDK version X.Y.Z packed as x16.y8.z8
+      attr_reader :sdk
+
+      # @return [ToolEntries] tool entries
+      attr_reader :tool_entries
+
+      # @see MachOStructure::FORMAT
+      # @api private
+      FORMAT = "L=6".freeze
+
+      # @see MachOStructure::SIZEOF
+      # @api private
+      SIZEOF = 24
+
+      # @api private
+      def initialize(view, cmd, cmdsize, platform, minos, sdk, ntools)
+        super(view, cmd, cmdsize)
+        @platform = platform
+        @minos = minos
+        @sdk = sdk
+        @tool_entries = ToolEntries.new(view, ntools)
+      end
+
+      # A string representation of the binary's minimum OS version.
+      # @return [String] a string representing the minimum OS version.
+      def minos_string
+        binary = "%032b" % minos
+        segs = [
+          binary[0..15], binary[16..23], binary[24..31]
+        ].map { |s| s.to_i(2) }
+
+        segs.join(".")
+      end
+
+      # A string representation of the binary's SDK version.
+      # @return [String] a string representing the SDK version.
+      def sdk_string
+        binary = "%032b" % sdk
+        segs = [
+          binary[0..15], binary[16..23], binary[24..31]
+        ].map { |s| s.to_i(2) }
+
+        segs.join(".")
+      end
+
+      # @return [Hash] a hash representation of this {BuildVersionCommand}
+      def to_h
+        {
+          "platform" => platform,
+          "minos" => minos,
+          "minos_string" => minos_string,
+          "sdk" => sdk,
+          "sdk_string" => sdk_string,
+          "tool_entries" => tool_entries.tools.map(&:to_h),
+        }.merge super
+      end
+
+      # A representation of the tool versions exposed
+      # by a {BuildVersionCommand} (`LC_BUILD_VERSION`).
+      class ToolEntries
+        # @return [Array<Tool>] all tools
+        attr_reader :tools
+
+        # @param view [MachO::MachOView] the view into the current Mach-O
+        # @param ntools [Integer] the number of tools
+        # @api private
+        def initialize(view, ntools)
+          format = Utils.specialize_format("L=#{ntools * 2}", view.endianness)
+          raw_table = view.raw_data[view.offset + 24, ntools * 8]
+          blobs = raw_table.unpack(format).each_slice(2).to_a
+
+          @tools = blobs.map { |b| Tool.new(*b) }
+        end
+
+        # An individual tool.
+        class Tool
+          # @return [Integer] the enum for the tool
+          attr_reader :tool
+
+          # @return [Integer] the tool's version number
+          attr_reader :version
+
+          # @param tool [Integer] 32-bit integer
+          # @param version [Integer] 32-bit integer
+          # @api private
+          def initialize(tool, version)
+            @tool = tool
+            @version = version
+          end
+
+          # @return [Hash] a hash representation of this {Tool}
+          def to_h
+            {
+              "tool" => tool,
+              "version" => version,
+            }
+          end
+        end
+      end
+    end
+
+    # A load command containing the file offsets and sizes of the new
+    # compressed form of the information dyld needs to load the image.
+    # Corresponds to LC_DYLD_INFO and LC_DYLD_INFO_ONLY.
+    class DyldInfoCommand < LoadCommand
+      # @return [Integer] the file offset to the rebase information
+      attr_reader :rebase_off
+
+      # @return [Integer] the size of the rebase information
+      attr_reader :rebase_size
+
+      # @return [Integer] the file offset to the binding information
+      attr_reader :bind_off
+
+      # @return [Integer] the size of the binding information
+      attr_reader :bind_size
+
+      # @return [Integer] the file offset to the weak binding information
+      attr_reader :weak_bind_off
+
+      # @return [Integer] the size of the weak binding information
+      attr_reader :weak_bind_size
+
+      # @return [Integer] the file offset to the lazy binding information
+      attr_reader :lazy_bind_off
+
+      # @return [Integer] the size of the lazy binding information
+      attr_reader :lazy_bind_size
+
+      # @return [Integer] the file offset to the export information
+      attr_reader :export_off
+
+      # @return [Integer] the size of the export information
+      attr_reader :export_size
+
+      # @see MachOStructure::FORMAT
+      # @api private
+      FORMAT = "L=12".freeze
+
+      # @see MachOStructure::SIZEOF
+      # @api private
+      SIZEOF = 48
+
+      # @api private
+      def initialize(view, cmd, cmdsize, rebase_off, rebase_size, bind_off,
+                     bind_size, weak_bind_off, weak_bind_size, lazy_bind_off,
+                     lazy_bind_size, export_off, export_size)
+        super(view, cmd, cmdsize)
+        @rebase_off = rebase_off
+        @rebase_size = rebase_size
+        @bind_off = bind_off
+        @bind_size = bind_size
+        @weak_bind_off = weak_bind_off
+        @weak_bind_size = weak_bind_size
+        @lazy_bind_off = lazy_bind_off
+        @lazy_bind_size = lazy_bind_size
+        @export_off = export_off
+        @export_size = export_size
+      end
+
+      # @return [Hash] a hash representation of this {DyldInfoCommand}
+      def to_h
+        {
+          "rebase_off" => rebase_off,
+          "rebase_size" => rebase_size,
+          "bind_off" => bind_off,
+          "bind_size" => bind_size,
+          "weak_bind_off" => weak_bind_off,
+          "weak_bind_size" => weak_bind_size,
+          "lazy_bind_off" => lazy_bind_off,
+          "lazy_bind_size" => lazy_bind_size,
+          "export_off" => export_off,
+          "export_size" => export_size,
+        }.merge super
+      end
+    end
+
+    # A load command containing linker options embedded in object files.
+    # Corresponds to LC_LINKER_OPTION.
+    class LinkerOptionCommand < LoadCommand
+      # @return [Integer] the number of strings
+      attr_reader :count
+
+      # @see MachOStructure::FORMAT
+      # @api private
+      FORMAT = "L=3".freeze
+
+      # @see MachOStructure::SIZEOF
+      # @api private
+      SIZEOF = 12
+
+      # @api private
+      def initialize(view, cmd, cmdsize, count)
+        super(view, cmd, cmdsize)
+        @count = count
+      end
+
+      # @return [Hash] a hash representation of this {LinkerOptionCommand}
+      def to_h
+        {
+          "count" => count,
+        }.merge super
+      end
+    end
+
+    # A load command specifying the offset of main(). Corresponds to LC_MAIN.
+    class EntryPointCommand < LoadCommand
+      # @return [Integer] the file (__TEXT) offset of main()
+      attr_reader :entryoff
+
+      # @return [Integer] if not 0, the initial stack size.
+      attr_reader :stacksize
+
+      # @see MachOStructure::FORMAT
+      # @api private
+      FORMAT = "L=2Q=2".freeze
+
+      # @see MachOStructure::SIZEOF
+      # @api private
+      SIZEOF = 24
+
+      # @api private
+      def initialize(view, cmd, cmdsize, entryoff, stacksize)
+        super(view, cmd, cmdsize)
+        @entryoff = entryoff
+        @stacksize = stacksize
+      end
+
+      # @return [Hash] a hash representation of this {EntryPointCommand}
+      def to_h
+        {
+          "entryoff" => entryoff,
+          "stacksize" => stacksize,
+        }.merge super
+      end
+    end
+
+    # A load command specifying the version of the sources used to build the
+    # binary. Corresponds to LC_SOURCE_VERSION.
+    class SourceVersionCommand < LoadCommand
+      # @return [Integer] the version packed as a24.b10.c10.d10.e10
+      attr_reader :version
+
+      # @see MachOStructure::FORMAT
+      # @api private
+      FORMAT = "L=2Q=1".freeze
+
+      # @see MachOStructure::SIZEOF
+      # @api private
+      SIZEOF = 16
+
+      # @api private
+      def initialize(view, cmd, cmdsize, version)
+        super(view, cmd, cmdsize)
+        @version = version
+      end
+
+      # A string representation of the sources used to build the binary.
+      # @return [String] a string representation of the version
+      def version_string
+        binary = "%064b" % version
+        segs = [
+          binary[0..23], binary[24..33], binary[34..43], binary[44..53],
+          binary[54..63]
+        ].map { |s| s.to_i(2) }
+
+        segs.join(".")
+      end
+
+      # @return [Hash] a hash representation of this {SourceVersionCommand}
+      def to_h
+        {
+          "version" => version,
+          "version_string" => version_string,
+        }.merge super
+      end
+    end
+
+    # An obsolete load command containing the offset and size of the (GNU style)
+    # symbol table information. Corresponds to LC_SYMSEG.
+    class SymsegCommand < LoadCommand
+      # @return [Integer] the offset to the symbol segment
+      attr_reader :offset
+
+      # @return [Integer] the size of the symbol segment in bytes
+      attr_reader :size
+
+      # @see MachOStructure::FORMAT
+      # @api private
+      FORMAT = "L=4".freeze
+
+      # @see MachOStructure::SIZEOF
+      # @api private
+      SIZEOF = 16
+
+      # @api private
+      def initialize(view, cmd, cmdsize, offset, size)
+        super(view, cmd, cmdsize)
+        @offset = offset
+        @size = size
+      end
+
+      # @return [Hash] a hash representation of this {SymsegCommand}
+      def to_h
+        {
+          "offset" => offset,
+          "size" => size,
+        }.merge super
+      end
+    end
+
+    # An obsolete load command containing a free format string table. Each
+    # string is null-terminated and the command is zero-padded to a multiple of
+    # 4. Corresponds to LC_IDENT.
+    class IdentCommand < LoadCommand
+      # @see MachOStructure::FORMAT
+      # @api private
+      FORMAT = "L=2".freeze
+
+      # @see MachOStructure::SIZEOF
+      # @api private
+      SIZEOF = 8
+    end
+
+    # An obsolete load command containing the path to a file to be loaded into
+    # memory. Corresponds to LC_FVMFILE.
+    class FvmfileCommand < LoadCommand
+      # @return [LCStr] the pathname of the file being loaded
+      attr_reader :name
+
+      # @return [Integer] the virtual address being loaded at
+      attr_reader :header_addr
+
+      # @see MachOStructure::FORMAT
+      # @api private
+      FORMAT = "L=4".freeze
+
+      # @see MachOStructure::SIZEOF
+      # @api private
+      SIZEOF = 16
+
+      def initialize(view, cmd, cmdsize, name, header_addr)
+        super(view, cmd, cmdsize)
+        @name = LCStr.new(self, name)
+        @header_addr = header_addr
+      end
+
+      # @return [Hash] a hash representation of this {FvmfileCommand}
+      def to_h
+        {
+          "name" => name.to_h,
+          "header_addr" => header_addr,
+        }.merge super
+      end
+    end
+
+    # An obsolete load command containing the path to a library to be loaded
+    # into memory. Corresponds to LC_LOADFVMLIB and LC_IDFVMLIB.
+    class FvmlibCommand < LoadCommand
+      # @return [LCStr] the library's target pathname
+      attr_reader :name
+
+      # @return [Integer] the library's minor version number
+      attr_reader :minor_version
+
+      # @return [Integer] the library's header address
+      attr_reader :header_addr
+
+      # @see MachOStructure::FORMAT
+      # @api private
+      FORMAT = "L=5".freeze
+
+      # @see MachOStructure::SIZEOF
+      # @api private
+      SIZEOF = 20
+
+      def initialize(view, cmd, cmdsize, name, minor_version, header_addr)
+        super(view, cmd, cmdsize)
+        @name = LCStr.new(self, name)
+        @minor_version = minor_version
+        @header_addr = header_addr
+      end
+
+      # @return [Hash] a hash representation of this {FvmlibCommand}
+      def to_h
+        {
+          "name" => name.to_h,
+          "minor_version" => minor_version,
+          "header_addr" => header_addr,
+        }.merge super
+      end
+    end
+
+    # A load command containing an owner name and offset/size for an arbitrary data region.
+    # Corresponds to LC_NOTE.
+    class NoteCommand < LoadCommand
+      # @return [String] the name of the owner for this note
+      attr_reader :data_owner
+
+      # @return [Integer] the offset, within the file, of the note
+      attr_reader :offset
+
+      # @return [Integer] the size, in bytes, of the note
+      attr_reader :size
+
+      # @see MachOStructure::FORMAT
+      # @api private
+      FORMAT = "L=2Z16Q=2".freeze
+
+      # @see MachOStructure::SIZEOF
+      # @api private
+      SIZEOF = 48
+
+      def initialize(view, cmd, cmdsize, data_owner, offset, size)
+        super(view, cmd, cmdsize)
+        @data_owner = data_owner
+        @offset = offset
+        @size = size
+      end
+
+      # @return [Hash] a hash representation of this {NoteCommand}
+      def to_h
+        {
+          "data_owner" => data_owner,
+          "offset" => offset,
+          "size" => size,
+        }.merge super
+      end
+    end
+  end
+end