Subversion Repositories open8_urisc

/* od-macho.c -- dump information about an Mach-O object file.

   Copyright 2011, 2012 Free Software Foundation, Inc.

   Written by Tristan Gingold, Adacore.

   This file is part of GNU Binutils.

   This program is free software; you can redistribute it and/or modify

   it under the terms of the GNU General Public License as published by

   the Free Software Foundation; either version 3, or (at your option)

   any later version.

   This program is distributed in the hope that it will be useful,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License

   along with this program; if not, write to the Free Software

   Foundation, 51 Franklin Street - Fifth Floor, Boston,

   MA 02110-1301, USA.  */

#include "sysdep.h"

#include <stddef.h>

#include <time.h>

#include "safe-ctype.h"

#include "bfd.h"

#include "objdump.h"

#include "bucomm.h"

#include "bfdlink.h"

#include "libbfd.h"

#include "mach-o.h"

#include "mach-o/external.h"

#include "mach-o/codesign.h"

/* Index of the options in the options[] array.  */

#define OPT_HEADER 0

#define OPT_SECTION 1

#define OPT_MAP 2

#define OPT_LOAD 3

#define OPT_DYSYMTAB 4

#define OPT_CODESIGN 5

#define OPT_SEG_SPLIT_INFO 6

/* List of actions.  */

static struct objdump_private_option options[] =

  {

    { "header", 0 },

    { "section", 0 },

    { "map", 0 },

    { "load", 0 },

    { "dysymtab", 0 },

    { "codesign", 0 },

    { "seg_split_info", 0 },

    { NULL, 0 }

  };

/* Display help.  */

static void

mach_o_help (FILE *stream)

{

  fprintf (stream, _("\

For Mach-O files:\n\

  header         Display the file header\n\

  section        Display the segments and sections commands\n\

  map            Display the section map\n\

  load           Display the load commands\n\

  dysymtab       Display the dynamic symbol table\n\

  codesign       Display code signature\n\

  seg_split_info Display segment split info\n\

"));

}

/* Return TRUE if ABFD is handled.  */

static int

mach_o_filter (bfd *abfd)

{

  return bfd_get_flavour (abfd) == bfd_target_mach_o_flavour;

}

static const bfd_mach_o_xlat_name bfd_mach_o_cpu_name[] =

{

  { "vax", BFD_MACH_O_CPU_TYPE_VAX },

  { "mc680x0", BFD_MACH_O_CPU_TYPE_MC680x0 },

  { "i386", BFD_MACH_O_CPU_TYPE_I386 },

  { "mips", BFD_MACH_O_CPU_TYPE_MIPS },

  { "mc98000", BFD_MACH_O_CPU_TYPE_MC98000 },

  { "hppa", BFD_MACH_O_CPU_TYPE_HPPA },

  { "arm", BFD_MACH_O_CPU_TYPE_ARM },

  { "mc88000", BFD_MACH_O_CPU_TYPE_MC88000 },

  { "sparc", BFD_MACH_O_CPU_TYPE_SPARC },

  { "i860", BFD_MACH_O_CPU_TYPE_I860 },

  { "alpha", BFD_MACH_O_CPU_TYPE_ALPHA },

  { "powerpc", BFD_MACH_O_CPU_TYPE_POWERPC },

  { "powerpc_64", BFD_MACH_O_CPU_TYPE_POWERPC_64 },

  { "x86_64", BFD_MACH_O_CPU_TYPE_X86_64 },

  { NULL, 0}

};

static const bfd_mach_o_xlat_name bfd_mach_o_filetype_name[] =

{

  { "object", BFD_MACH_O_MH_OBJECT },

  { "execute", BFD_MACH_O_MH_EXECUTE },

  { "fvmlib", BFD_MACH_O_MH_FVMLIB },

  { "core", BFD_MACH_O_MH_CORE },

  { "preload", BFD_MACH_O_MH_PRELOAD },

  { "dylib", BFD_MACH_O_MH_DYLIB },

  { "dylinker", BFD_MACH_O_MH_DYLINKER },

  { "bundle", BFD_MACH_O_MH_BUNDLE },

  { "dylib_stub", BFD_MACH_O_MH_DYLIB_STUB },

  { "dym", BFD_MACH_O_MH_DSYM },

  { "kext_bundle", BFD_MACH_O_MH_KEXT_BUNDLE },

  { NULL, 0}

};

static const bfd_mach_o_xlat_name bfd_mach_o_header_flags_name[] =

{

  { "noundefs", BFD_MACH_O_MH_NOUNDEFS },

  { "incrlink", BFD_MACH_O_MH_INCRLINK },

  { "dyldlink", BFD_MACH_O_MH_DYLDLINK },

  { "bindatload", BFD_MACH_O_MH_BINDATLOAD },

  { "prebound", BFD_MACH_O_MH_PREBOUND },

  { "split_segs", BFD_MACH_O_MH_SPLIT_SEGS },

  { "lazy_init", BFD_MACH_O_MH_LAZY_INIT },

  { "twolevel", BFD_MACH_O_MH_TWOLEVEL },

  { "force_flat", BFD_MACH_O_MH_FORCE_FLAT },

  { "nomultidefs", BFD_MACH_O_MH_NOMULTIDEFS },

  { "nofixprebinding", BFD_MACH_O_MH_NOFIXPREBINDING },

  { "prebindable", BFD_MACH_O_MH_PREBINDABLE },

  { "allmodsbound", BFD_MACH_O_MH_ALLMODSBOUND },

  { "subsections_via_symbols", BFD_MACH_O_MH_SUBSECTIONS_VIA_SYMBOLS },

  { "canonical", BFD_MACH_O_MH_CANONICAL },

  { "weak_defines", BFD_MACH_O_MH_WEAK_DEFINES },

  { "binds_to_weak", BFD_MACH_O_MH_BINDS_TO_WEAK },

  { "allow_stack_execution", BFD_MACH_O_MH_ALLOW_STACK_EXECUTION },

  { "root_safe", BFD_MACH_O_MH_ROOT_SAFE },

  { "setuid_safe", BFD_MACH_O_MH_SETUID_SAFE },

  { "no_reexported_dylibs", BFD_MACH_O_MH_NO_REEXPORTED_DYLIBS },

  { "pie", BFD_MACH_O_MH_PIE },

  { NULL, 0}

};

static const bfd_mach_o_xlat_name bfd_mach_o_load_command_name[] =

{

  { "segment", BFD_MACH_O_LC_SEGMENT},

  { "symtab", BFD_MACH_O_LC_SYMTAB},

  { "symseg", BFD_MACH_O_LC_SYMSEG},

  { "thread", BFD_MACH_O_LC_THREAD},

  { "unixthread", BFD_MACH_O_LC_UNIXTHREAD},

  { "loadfvmlib", BFD_MACH_O_LC_LOADFVMLIB},

  { "idfvmlib", BFD_MACH_O_LC_IDFVMLIB},

  { "ident", BFD_MACH_O_LC_IDENT},

  { "fvmfile", BFD_MACH_O_LC_FVMFILE},

  { "prepage", BFD_MACH_O_LC_PREPAGE},

  { "dysymtab", BFD_MACH_O_LC_DYSYMTAB},

  { "load_dylib", BFD_MACH_O_LC_LOAD_DYLIB},

  { "id_dylib", BFD_MACH_O_LC_ID_DYLIB},

  { "load_dylinker", BFD_MACH_O_LC_LOAD_DYLINKER},

  { "id_dylinker", BFD_MACH_O_LC_ID_DYLINKER},

  { "prebound_dylib", BFD_MACH_O_LC_PREBOUND_DYLIB},

  { "routines", BFD_MACH_O_LC_ROUTINES},

  { "sub_framework", BFD_MACH_O_LC_SUB_FRAMEWORK},

  { "sub_umbrella", BFD_MACH_O_LC_SUB_UMBRELLA},

  { "sub_client", BFD_MACH_O_LC_SUB_CLIENT},

  { "sub_library", BFD_MACH_O_LC_SUB_LIBRARY},

  { "twolevel_hints", BFD_MACH_O_LC_TWOLEVEL_HINTS},

  { "prebind_cksum", BFD_MACH_O_LC_PREBIND_CKSUM},

  { "load_weak_dylib", BFD_MACH_O_LC_LOAD_WEAK_DYLIB},

  { "segment_64", BFD_MACH_O_LC_SEGMENT_64},

  { "routines_64", BFD_MACH_O_LC_ROUTINES_64},

  { "uuid", BFD_MACH_O_LC_UUID},

  { "rpath", BFD_MACH_O_LC_RPATH},

  { "code_signature", BFD_MACH_O_LC_CODE_SIGNATURE},

  { "segment_split_info", BFD_MACH_O_LC_SEGMENT_SPLIT_INFO},

  { "reexport_dylib", BFD_MACH_O_LC_REEXPORT_DYLIB},

  { "lazy_load_dylib", BFD_MACH_O_LC_LAZY_LOAD_DYLIB},

  { "encryption_info", BFD_MACH_O_LC_ENCRYPTION_INFO},

  { "dyld_info", BFD_MACH_O_LC_DYLD_INFO},

  { "load_upward_lib", BFD_MACH_O_LC_LOAD_UPWARD_DYLIB},

  { "version_min_macosx", BFD_MACH_O_LC_VERSION_MIN_MACOSX},

  { "version_min_iphoneos", BFD_MACH_O_LC_VERSION_MIN_IPHONEOS},

  { "function_starts", BFD_MACH_O_LC_FUNCTION_STARTS},

  { "dyld_environment", BFD_MACH_O_LC_DYLD_ENVIRONMENT},

  { NULL, 0}

};

static const bfd_mach_o_xlat_name bfd_mach_o_thread_x86_name[] =

{

  { "thread_state32", BFD_MACH_O_x86_THREAD_STATE32},

  { "float_state32", BFD_MACH_O_x86_FLOAT_STATE32},

  { "exception_state32", BFD_MACH_O_x86_EXCEPTION_STATE32},

  { "thread_state64", BFD_MACH_O_x86_THREAD_STATE64},

  { "float_state64", BFD_MACH_O_x86_FLOAT_STATE64},

  { "exception_state64", BFD_MACH_O_x86_EXCEPTION_STATE64},

  { "thread_state", BFD_MACH_O_x86_THREAD_STATE},

  { "float_state", BFD_MACH_O_x86_FLOAT_STATE},

  { "exception_state", BFD_MACH_O_x86_EXCEPTION_STATE},

  { "debug_state32", BFD_MACH_O_x86_DEBUG_STATE32},

  { "debug_state64", BFD_MACH_O_x86_DEBUG_STATE64},

  { "debug_state", BFD_MACH_O_x86_DEBUG_STATE},

  { "state_none", BFD_MACH_O_x86_THREAD_STATE_NONE},

  { NULL, 0 }

};

static void

bfd_mach_o_print_flags (const bfd_mach_o_xlat_name *table,

                        unsigned long val)

{

  int first = 1;

  for (; table->name; table++)

    {

      if (table->val & val)

        {

          if (!first)

            printf ("+");

          printf ("%s", table->name);

          val &= ~table->val;

          first = 0;

        }

    }

  if (val)

    {

      if (!first)

        printf ("+");

      printf ("0x%lx", val);

      return;

    }

  if (first)

    printf ("-");

}

static const char *

bfd_mach_o_get_name_or_null (const bfd_mach_o_xlat_name *table,

                             unsigned long val)

{

  for (; table->name; table++)

    if (table->val == val)

      return table->name;

  return NULL;

}

static const char *

bfd_mach_o_get_name (const bfd_mach_o_xlat_name *table, unsigned long val)

{

  const char *res = bfd_mach_o_get_name_or_null (table, val);

  if (res == NULL)

    return "*UNKNOWN*";

  else

    return res;

}

static void

dump_header (bfd *abfd)

{

  bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);

  bfd_mach_o_header *h = &mdata->header;

  fputs (_("Mach-O header:\n"), stdout);

  printf (_(" magic     : %08lx\n"), h->magic);

  printf (_(" cputype   : %08lx (%s)\n"), h->cputype,

          bfd_mach_o_get_name (bfd_mach_o_cpu_name, h->cputype));

  printf (_(" cpusubtype: %08lx\n"), h->cpusubtype);

  printf (_(" filetype  : %08lx (%s)\n"),

          h->filetype,

          bfd_mach_o_get_name (bfd_mach_o_filetype_name, h->filetype));

  printf (_(" ncmds     : %08lx (%lu)\n"), h->ncmds, h->ncmds);

  printf (_(" sizeofcmds: %08lx\n"), h->sizeofcmds);

  printf (_(" flags     : %08lx ("), h->flags);

  bfd_mach_o_print_flags (bfd_mach_o_header_flags_name, h->flags);

  fputs (_(")\n"), stdout);

  printf (_(" reserved  : %08x\n"), h->reserved);

}

static void

dump_section_map (bfd *abfd)

{

  bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);

  unsigned int i;

  unsigned int sec_nbr = 0;

  fputs (_("Segments and Sections:\n"), stdout);

  fputs (_(" #: Segment name     Section name     Address\n"), stdout);

  for (i = 0; i < mdata->header.ncmds; i++)

    {

      bfd_mach_o_segment_command *seg;

      bfd_mach_o_section *sec;

      if (mdata->commands[i].type != BFD_MACH_O_LC_SEGMENT

          && mdata->commands[i].type != BFD_MACH_O_LC_SEGMENT_64)

        continue;

      seg = &mdata->commands[i].command.segment;

      printf ("[Segment %-16s ", seg->segname);

      printf_vma (seg->vmaddr);

      putchar ('-');

      printf_vma  (seg->vmaddr + seg->vmsize - 1);

      putchar (' ');

      putchar (seg->initprot & BFD_MACH_O_PROT_READ ? 'r' : '-');

      putchar (seg->initprot & BFD_MACH_O_PROT_WRITE ? 'w' : '-');

      putchar (seg->initprot & BFD_MACH_O_PROT_EXECUTE ? 'x' : '-');

      printf ("]\n");

      for (sec = seg->sect_head; sec != NULL; sec = sec->next)

        {

          printf ("%02u: %-16s %-16s ", ++sec_nbr,

                  sec->segname, sec->sectname);

          printf_vma (sec->addr);

          putchar (' ');

          printf_vma  (sec->size);

          printf (" %08lx\n", sec->flags);

        }

    }

}

static void

dump_section (bfd *abfd ATTRIBUTE_UNUSED, bfd_mach_o_section *sec)

{

  printf (" Section: %-16s %-16s (bfdname: %s)\n",

           sec->sectname, sec->segname, sec->bfdsection->name);

  printf ("  addr: ");

  printf_vma (sec->addr);

  printf (" size: ");

  printf_vma (sec->size);

  printf (" offset: ");

  printf_vma (sec->offset);

  printf ("\n");

  printf ("  align: %ld", sec->align);

  printf ("  nreloc: %lu  reloff: ", sec->nreloc);

  printf_vma (sec->reloff);

  printf ("\n");

  printf ("  flags: %08lx (type: %s", sec->flags,

          bfd_mach_o_get_name (bfd_mach_o_section_type_name,

                               sec->flags & BFD_MACH_O_SECTION_TYPE_MASK));

  printf (" attr: ");

  bfd_mach_o_print_flags (bfd_mach_o_section_attribute_name,

                          sec->flags & BFD_MACH_O_SECTION_ATTRIBUTES_MASK);

  printf (")\n");

  switch (sec->flags & BFD_MACH_O_SECTION_TYPE_MASK)

    {

    case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS:

    case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS:

    case BFD_MACH_O_S_SYMBOL_STUBS:

      printf ("  first indirect sym: %lu", sec->reserved1);

      printf (" (%u entries)",

               bfd_mach_o_section_get_nbr_indirect (abfd, sec));

      break;

    default:

      printf ("  reserved1: 0x%lx", sec->reserved1);

      break;

    }

  switch (sec->flags & BFD_MACH_O_SECTION_TYPE_MASK)

    {

    case BFD_MACH_O_S_SYMBOL_STUBS:

      printf ("  stub size: %lu", sec->reserved2);

      break;

    default:

      printf ("  reserved2: 0x%lx", sec->reserved2);

      break;

    }

  printf ("  reserved3: 0x%lx\n", sec->reserved3);

}

static void

dump_segment (bfd *abfd ATTRIBUTE_UNUSED, bfd_mach_o_load_command *cmd)

{

  bfd_mach_o_segment_command *seg = &cmd->command.segment;

  bfd_mach_o_section *sec;

  printf (" name: %s\n", *seg->segname ? seg->segname : "*none*");

  printf ("    vmaddr: ");

  printf_vma (seg->vmaddr);

  printf ("   vmsize: ");

  printf_vma  (seg->vmsize);

  printf ("\n");

  printf ("   fileoff: ");

  printf_vma (seg->fileoff);

  printf (" filesize: ");

  printf_vma ((bfd_vma)seg->filesize);

  printf (" endoff: ");

  printf_vma ((bfd_vma)(seg->fileoff + seg->filesize));

  printf ("\n");

  printf ("   nsects: %lu  ", seg->nsects);

  printf (" flags: %lx\n", seg->flags);

  for (sec = seg->sect_head; sec != NULL; sec = sec->next)

    dump_section (abfd, sec);

}

static void

dump_dysymtab (bfd *abfd, bfd_mach_o_load_command *cmd, bfd_boolean verbose)

{

  bfd_mach_o_dysymtab_command *dysymtab = &cmd->command.dysymtab;

  bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);

  unsigned int i;

  printf ("              local symbols: idx: %10lu  num: %-8lu",

          dysymtab->ilocalsym, dysymtab->nlocalsym);

  printf (" (nxtidx: %lu)\n",

          dysymtab->ilocalsym + dysymtab->nlocalsym);

  printf ("           external symbols: idx: %10lu  num: %-8lu",

          dysymtab->iextdefsym, dysymtab->nextdefsym);

  printf (" (nxtidx: %lu)\n",

          dysymtab->iextdefsym + dysymtab->nextdefsym);

  printf ("          undefined symbols: idx: %10lu  num: %-8lu",

          dysymtab->iundefsym, dysymtab->nundefsym);

  printf (" (nxtidx: %lu)\n",

          dysymtab->iundefsym + dysymtab->nundefsym);

  printf ("           table of content: off: 0x%08lx  num: %-8lu",

          dysymtab->tocoff, dysymtab->ntoc);

  printf (" (endoff: 0x%08lx)\n",

          dysymtab->tocoff + dysymtab->ntoc * BFD_MACH_O_TABLE_OF_CONTENT_SIZE);

  printf ("               module table: off: 0x%08lx  num: %-8lu",

          dysymtab->modtaboff, dysymtab->nmodtab);

  printf (" (endoff: 0x%08lx)\n",

          dysymtab->modtaboff + dysymtab->nmodtab

          * (mdata->header.version == 2 ?

             BFD_MACH_O_DYLIB_MODULE_64_SIZE : BFD_MACH_O_DYLIB_MODULE_SIZE));

  printf ("   external reference table: off: 0x%08lx  num: %-8lu",

          dysymtab->extrefsymoff, dysymtab->nextrefsyms);

  printf (" (endoff: 0x%08lx)\n",

          dysymtab->extrefsymoff

          + dysymtab->nextrefsyms * BFD_MACH_O_REFERENCE_SIZE);

  printf ("      indirect symbol table: off: 0x%08lx  num: %-8lu",

          dysymtab->indirectsymoff, dysymtab->nindirectsyms);

  printf (" (endoff: 0x%08lx)\n",

          dysymtab->indirectsymoff

          + dysymtab->nindirectsyms * BFD_MACH_O_INDIRECT_SYMBOL_SIZE);

  printf ("  external relocation table: off: 0x%08lx  num: %-8lu",

          dysymtab->extreloff, dysymtab->nextrel);

  printf (" (endoff: 0x%08lx)\n",

          dysymtab->extreloff + dysymtab->nextrel * BFD_MACH_O_RELENT_SIZE);

  printf ("     local relocation table: off: 0x%08lx  num: %-8lu",

          dysymtab->locreloff, dysymtab->nlocrel);

  printf (" (endoff: 0x%08lx)\n",

          dysymtab->locreloff + dysymtab->nlocrel * BFD_MACH_O_RELENT_SIZE);

  if (!verbose)

    return;

  if (dysymtab->ntoc > 0

      || dysymtab->nindirectsyms > 0

      || dysymtab->nextrefsyms > 0)

    {

      /* Try to read the symbols to display the toc or indirect symbols.  */

      bfd_mach_o_read_symtab_symbols (abfd);

    }

  else if (dysymtab->nmodtab > 0)

    {

      /* Try to read the strtab to display modules name.  */

      bfd_mach_o_read_symtab_strtab (abfd);

    }

  for (i = 0; i < dysymtab->nmodtab; i++)

    {

      bfd_mach_o_dylib_module *module = &dysymtab->dylib_module[i];

      printf ("  module %u:\n", i);

      printf ("   name: %lu", module->module_name_idx);

      if (mdata->symtab && mdata->symtab->strtab)

        printf (": %s",

                 mdata->symtab->strtab + module->module_name_idx);

      printf ("\n");

      printf ("   extdefsym: idx: %8lu  num: %lu\n",

               module->iextdefsym, module->nextdefsym);

      printf ("      refsym: idx: %8lu  num: %lu\n",

               module->irefsym, module->nrefsym);

      printf ("    localsym: idx: %8lu  num: %lu\n",

               module->ilocalsym, module->nlocalsym);

      printf ("      extrel: idx: %8lu  num: %lu\n",

               module->iextrel, module->nextrel);

      printf ("        init: idx: %8u  num: %u\n",

               module->iinit, module->ninit);

      printf ("        term: idx: %8u  num: %u\n",

               module->iterm, module->nterm);

      printf ("   objc_module_info: addr: ");

      printf_vma (module->objc_module_info_addr);

      printf ("  size: %lu\n", module->objc_module_info_size);

    }

  if (dysymtab->ntoc > 0)

    {

      bfd_mach_o_symtab_command *symtab = mdata->symtab;

      printf ("  table of content: (symbol/module)\n");

      for (i = 0; i < dysymtab->ntoc; i++)

        {

          bfd_mach_o_dylib_table_of_content *toc = &dysymtab->dylib_toc[i];

          printf ("   %4u: ", i);

          if (symtab && symtab->symbols && toc->symbol_index < symtab->nsyms)

            {

              const char *name = symtab->symbols[toc->symbol_index].symbol.name;

              printf ("%s (%lu)", name ? name : "*invalid*",

                       toc->symbol_index);

            }

          else

            printf ("%lu", toc->symbol_index);

          printf (" / ");

          if (symtab && symtab->strtab

              && toc->module_index < dysymtab->nmodtab)

            {

              bfd_mach_o_dylib_module *mod;

              mod = &dysymtab->dylib_module[toc->module_index];

              printf ("%s (%lu)",

                       symtab->strtab + mod->module_name_idx,

                       toc->module_index);

            }

          else

            printf ("%lu", toc->module_index);

          printf ("\n");

        }

    }

  if (dysymtab->nindirectsyms != 0)

    {

      printf ("  indirect symbols:\n");

      for (i = 0; i < mdata->nsects; i++)

        {

          bfd_mach_o_section *sec = mdata->sections[i];

          unsigned int j, first, last;

          bfd_mach_o_symtab_command *symtab = mdata->symtab;

          bfd_vma addr;

          bfd_vma entry_size;

          switch (sec->flags & BFD_MACH_O_SECTION_TYPE_MASK)

            {

            case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS:

            case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS:

            case BFD_MACH_O_S_SYMBOL_STUBS:

              first = sec->reserved1;

              last = first + bfd_mach_o_section_get_nbr_indirect (abfd, sec);

              addr = sec->addr;

              entry_size = bfd_mach_o_section_get_entry_size (abfd, sec);

              printf ("  for section %s.%s:\n",

                       sec->segname, sec->sectname);

              for (j = first; j < last; j++)

                {

                  unsigned int isym = dysymtab->indirect_syms[j];

                  printf ("   ");

                  printf_vma (addr);

                  printf (" %5u: 0x%08x", j, isym);

                  if (isym & BFD_MACH_O_INDIRECT_SYMBOL_LOCAL)

                    printf (" LOCAL");

                  if (isym & BFD_MACH_O_INDIRECT_SYMBOL_ABS)

                    printf (" ABSOLUTE");

                  if (symtab && symtab->symbols

                      && isym < symtab->nsyms

                      && symtab->symbols[isym].symbol.name)

                    printf (" %s", symtab->symbols[isym].symbol.name);

                  printf ("\n");

                  addr += entry_size;

                }

              break;

            default:

              break;

            }

        }

    }

  if (dysymtab->nextrefsyms > 0)

    {

      bfd_mach_o_symtab_command *symtab = mdata->symtab;

      printf ("  external reference table: (symbol flags)\n");

      for (i = 0; i < dysymtab->nextrefsyms; i++)

        {

          bfd_mach_o_dylib_reference *ref = &dysymtab->ext_refs[i];

          printf ("   %4u: %5lu 0x%02lx", i, ref->isym, ref->flags);

          if (symtab && symtab->symbols

              && ref->isym < symtab->nsyms

              && symtab->symbols[ref->isym].symbol.name)

            printf (" %s", symtab->symbols[ref->isym].symbol.name);

          printf ("\n");

        }

    }

}

static void

dump_dyld_info (bfd *abfd ATTRIBUTE_UNUSED, bfd_mach_o_load_command *cmd)

{

  bfd_mach_o_dyld_info_command *info = &cmd->command.dyld_info;

  printf ("       rebase: off: 0x%08x  size: %-8u\n",

           info->rebase_off, info->rebase_size);

  printf ("         bind: off: 0x%08x  size: %-8u\n",

           info->bind_off, info->bind_size);

  printf ("    weak bind: off: 0x%08x  size: %-8u\n",

           info->weak_bind_off, info->weak_bind_size);

  printf ("    lazy bind: off: 0x%08x  size: %-8u\n",

           info->lazy_bind_off, info->lazy_bind_size);

  printf ("       export: off: 0x%08x  size: %-8u\n",

           info->export_off, info->export_size);