gdb/machoread.c

   1 /* Darwin support for GDB, the GNU debugger.
   2    Copyright (C) 2008, 2009 Free Software Foundation, Inc.
   3
   4    Contributed by AdaCore.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20  */
  21
  22 #include "defs.h"
  23 #include "symtab.h"
  24 #include "gdbtypes.h"
  25 #include "bfd.h"
  26 #include "symfile.h"
  27 #include "objfiles.h"
  28 #include "buildsym.h"
  29 #include "gdbcmd.h"
  30 #include "gdbcore.h"
  31 #include "mach-o.h"
  32 #include "gdb_assert.h"
  33 #include "aout/stab_gnu.h"
  34 #include "vec.h"
  35
  36 #include <string.h>
  37
  38 /* If non-zero displays debugging message.  */
  39 static int mach_o_debug_level = 0;
  40
  41 static void
  42 macho_new_init (struct objfile *objfile)
  43 {
  44 }
  45
  46 static void
  47 macho_symfile_init (struct objfile *objfile)
  48 {
  49   objfile->flags |= OBJF_REORDERED;
  50   init_entry_point_info (objfile);
  51 }
  52
  53 /* Dwarf debugging information are never in the final executable.  They stay
  54    in object files and the executable contains the list of object files read
  55    during the link.
  56    Each time an oso (other source) is found in the executable, the reader
  57    creates such a structure.  They are read after the processing of the
  58    executable.
  59 */
  60 typedef struct oso_el
  61 {
  62   /* Object file name.  */
  63   const char *name;
  64
  65   /* Associated time stamp.  */
  66   unsigned long mtime;
  67
  68   /* Number of sections.  This is the length of SYMBOLS and OFFSETS array.  */
  69   int num_sections;
  70
  71   /* Each seaction of the object file is represented by a symbol and its
  72      offset.  If the offset is 0, we assume that the symbol is at offset 0
  73      in the OSO object file and a symbol lookup in the main file is
  74      required to get the offset.  */
  75   asymbol **symbols;
  76   bfd_vma *offsets;
  77 }
  78 oso_el;
  79
  80 /* Vector of object files to be read after the executable.  */
  81 DEF_VEC_O (oso_el);
  82 static VEC (oso_el) *oso_vector;
  83
  84 /*  Add a new OSO to the vector.  */
  85
  86 static void
  87 macho_add_oso (const asymbol *oso_sym, int nbr_sections,
  88                asymbol **symbols, bfd_vma *offsets)
  89 {
  90   oso_el el;
  91
  92   el.name = oso_sym->name;
  93   el.mtime = oso_sym->value;
  94   el.num_sections = nbr_sections;
  95   el.symbols = symbols;
  96   el.offsets = offsets;
  97   VEC_safe_push (oso_el, oso_vector, &el);
  98 }
  99
 100 /* Build the minimal symbol table from SYMBOL_TABLE of length
 101    NUMBER_OF_SYMBOLS for OBJFILE.
 102    Read OSO files at the end.  */
 103
 104 static void
 105 macho_symtab_read (struct objfile *objfile,
 106                    long number_of_symbols, asymbol **symbol_table)
 107 {
 108   struct gdbarch *gdbarch = get_objfile_arch (objfile);
 109   long storage_needed;
 110   long i, j;
 111   CORE_ADDR offset;
 112   enum minimal_symbol_type ms_type;
 113   unsigned int nbr_sections = bfd_count_sections (objfile->obfd);
 114   asymbol **first_symbol = NULL;
 115   bfd_vma *first_offset = NULL;
 116   const asymbol *oso_file = NULL;
 117
 118   for (i = 0; i < number_of_symbols; i++)
 119     {
 120       asymbol *sym = symbol_table[i];
 121       bfd_mach_o_asymbol *mach_o_sym = (bfd_mach_o_asymbol *)sym;
 122
 123       offset = ANOFFSET (objfile->section_offsets, sym->section->index);
 124
 125       if (sym->flags & BSF_DEBUGGING)
 126         {
 127           bfd_vma addr;
 128
 129           /* Debugging symbols are used to collect OSO file names as well
 130              as section offsets.  */
 131
 132           switch (mach_o_sym->n_type)
 133             {
 134             case N_SO:
 135               /* An empty SO entry terminates a chunk for an OSO file.  */
 136               if ((sym->name == NULL || sym->name[0] == 0) && oso_file != NULL)
 137                 {
 138                   macho_add_oso (oso_file, nbr_sections,
 139                                  first_symbol, first_offset);
 140                   first_symbol = NULL;
 141                   first_offset = NULL;
 142                   oso_file = NULL;
 143                 }
 144               break;
 145             case N_FUN:
 146             case N_STSYM:
 147               if (sym->name == NULL || sym->name[0] == '\0')
 148                 break;
 149               /* Fall through.  */
 150             case N_BNSYM:
 151               gdb_assert (oso_file != NULL);
 152               addr = sym->value
 153                 + bfd_get_section_vma (sym->section->bfd, sym->section);
 154               if (addr != 0
 155                   && first_symbol[sym->section->index] == NULL)
 156                 {
 157                   /* These STAB entries can directly relocate a section.  */
 158                   first_symbol[sym->section->index] = sym;
 159                   first_offset[sym->section->index] = addr + offset;
 160                 }
 161               break;
 162             case N_GSYM:
 163               gdb_assert (oso_file != NULL);
 164               if (first_symbol[sym->section->index] == NULL)
 165                 {
 166                   /* This STAB entry needs a symbol look-up to relocate
 167                      the section.  */
 168                   first_symbol[sym->section->index] = sym;
 169                   first_offset[sym->section->index] = 0;
 170                 }
 171               break;
 172             case N_OSO:
 173               /* New OSO file.  */
 174               gdb_assert (oso_file == NULL);
 175               first_symbol = (asymbol **)xmalloc (nbr_sections
 176                                                   * sizeof (asymbol *));
 177               first_offset = (bfd_vma *)xmalloc (nbr_sections
 178                                                  * sizeof (bfd_vma));
 179               for (j = 0; j < nbr_sections; j++)
 180                 first_symbol[j] = NULL;
 181               oso_file = sym;
 182               break;
 183             }
 184           continue;
 185         }
 186
 187       if (sym->name == NULL || *sym->name == '\0')
 188         {
 189           /* Skip names that don't exist (shouldn't happen), or names
 190              that are null strings (may happen). */
 191           continue;
 192         }
 193
 194       if (sym->flags & (BSF_GLOBAL | BSF_LOCAL | BSF_WEAK))
 195         {
 196           struct minimal_symbol *msym;
 197           CORE_ADDR symaddr;
 198
 199           /* Bfd symbols are section relative. */
 200           symaddr = sym->value + sym->section->vma;
 201
 202           /* Select global/local/weak symbols.  Note that bfd puts abs
 203              symbols in their own section, so all symbols we are
 204              interested in will have a section. */
 205           /* Relocate all non-absolute and non-TLS symbols by the
 206              section offset.  */
 207           if (sym->section != &bfd_abs_section
 208               && !(sym->section->flags & SEC_THREAD_LOCAL))
 209             symaddr += offset;
 210
 211           if (sym->section == &bfd_abs_section)
 212             ms_type = mst_abs;
 213           else if (sym->section->flags & SEC_CODE)
 214             {
 215               if (sym->flags & (BSF_GLOBAL | BSF_WEAK))
 216                 ms_type = mst_text;
 217               else
 218                 ms_type = mst_file_text;
 219             }
 220           else if (sym->section->flags & SEC_ALLOC)
 221             {
 222               if (sym->flags & (BSF_GLOBAL | BSF_WEAK))
 223                 {
 224                   if (sym->section->flags & SEC_LOAD)
 225                     ms_type = mst_data;
 226                   else
 227                     ms_type = mst_bss;
 228                 }
 229               else if (sym->flags & BSF_LOCAL)
 230                 {
 231                   /* Not a special stabs-in-elf symbol, do regular
 232                      symbol processing.  */
 233                   if (sym->section->flags & SEC_LOAD)
 234                     ms_type = mst_file_data;
 235                   else
 236                     ms_type = mst_file_bss;
 237                 }
 238               else
 239                 ms_type = mst_unknown;
 240             }
 241           else
 242             continue;   /* Skip this symbol. */
 243
 244           gdb_assert (sym->section->index < nbr_sections);
 245           if (oso_file != NULL
 246               && first_symbol[sym->section->index] == NULL)
 247             {
 248               /* Standard symbols can directly relocate sections.  */
 249               first_symbol[sym->section->index] = sym;
 250               first_offset[sym->section->index] = symaddr;
 251             }
 252
 253           msym = prim_record_minimal_symbol_and_info
 254             (sym->name, symaddr, ms_type, sym->section->index,
 255              sym->section, objfile);
 256         }
 257     }
 258
 259   /* Just in case there is no trailing SO entry.  */
 260   if (oso_file != NULL)
 261     macho_add_oso (oso_file, nbr_sections, first_symbol, first_offset);
 262 }
 263
 264 /* If NAME describes an archive member (ie: ARCHIVE '(' MEMBER ')'),
 265    returns the length of the archive name.
 266    Returns -1 otherwise.  */
 267
 268 static int
 269 get_archive_prefix_len (const char *name)
 270 {
 271   char *lparen;
 272   int name_len = strlen (name);
 273
 274   if (name_len == 0 || name[name_len - 1] != ')')
 275     return -1;
 276
 277   lparen = strrchr (name, '(');
 278   if (lparen == NULL || lparen == name)
 279     return -1;
 280   return lparen - name;
 281 }
 282
 283 static int
 284 oso_el_compare_name (const void *vl, const void *vr)
 285 {
 286   const oso_el *l = (const oso_el *)vl;
 287   const oso_el *r = (const oso_el *)vr;
 288
 289   return strcmp (l->name, r->name);
 290 }
 291
 292 /* Add an oso file as a symbol file.  */
 293
 294 static void
 295 macho_add_oso_symfile (oso_el *oso, bfd *abfd, struct objfile *main_objfile)
 296 {
 297   struct section_addr_info *addrs;
 298   int len;
 299   int i;
 300   char leading_char;
 301
 302   if (mach_o_debug_level > 0)
 303     printf_unfiltered (_("Loading symbols from oso: %s\n"), oso->name);
 304
 305   if (!bfd_check_format (abfd, bfd_object))
 306     {
 307       warning (_("`%s': can't read symbols: %s."), oso->name,
 308                bfd_errmsg (bfd_get_error ()));
 309       bfd_close (abfd);
 310       return;
 311     }
 312
 313   bfd_set_cacheable (abfd, 1);
 314
 315   /* Compute addr length.  */
 316   len = 0;
 317   for (i = 0; i < oso->num_sections; i++)
 318     if (oso->symbols[i] != NULL)
 319       len++;
 320
 321   addrs = alloc_section_addr_info (len);
 322
 323   leading_char = bfd_get_symbol_leading_char (main_objfile->obfd);
 324
 325   len = 0;
 326   for (i = 0; i < oso->num_sections; i++)
 327     if (oso->symbols[i] != NULL)
 328       {
 329         if (oso->offsets[i])
 330           addrs->other[len].addr = oso->offsets[i];
 331         else
 332           {
 333             struct minimal_symbol *msym;
 334             const char *name = oso->symbols[i]->name;
 335
 336             if (name[0] == leading_char)
 337               ++name;
 338
 339             if (mach_o_debug_level > 3)
 340               printf_unfiltered (_("resolve sect %s with %s\n"),
 341                                  oso->symbols[i]->section->name,
 342                                  oso->symbols[i]->name);
 343             msym = lookup_minimal_symbol (name, NULL, main_objfile);
 344             if (msym == NULL)
 345               {
 346                 warning (_("can't find symbol '%s' in minsymtab"),
 347                          oso->symbols[i]->name);
 348                 addrs->other[len].addr = 0;
 349               }
 350             else
 351               addrs->other[len].addr = SYMBOL_VALUE_ADDRESS (msym);
 352           }
 353         addrs->other[len].name = (char *)oso->symbols[i]->section->name;
 354         len++;
 355       }
 356
 357   if (mach_o_debug_level > 1)
 358     {
 359       int j;
 360       for (j = 0; j < addrs->num_sections; j++)
 361         printf_unfiltered (_("  %s: %s\n"),
 362                            core_addr_to_string (addrs->other[j].addr),
 363                            addrs->other[j].name);
 364     }
 365
 366   symbol_file_add_from_bfd (abfd, 0, addrs, 0);
 367 }
 368
 369 /* Read symbols from the vector of oso files.  */
 370
 371 static void
 372 macho_oso_symfile (struct objfile *main_objfile)
 373 {
 374   int ix;
 375   VEC (oso_el) *vec;
 376   oso_el *oso;
 377
 378   vec = oso_vector;
 379   oso_vector = NULL;
 380
 381   /* Sort oso by name so that files from libraries are gathered.  */
 382   qsort (VEC_address (oso_el, vec), VEC_length (oso_el, vec),
 383          sizeof (oso_el), oso_el_compare_name);
 384
 385   for (ix = 0; VEC_iterate (oso_el, vec, ix, oso);)
 386     {
 387       int pfx_len;
 388
 389       /* Check if this is a library name.  */
 390       pfx_len = get_archive_prefix_len (oso->name);
 391       if (pfx_len > 0)
 392         {
 393           bfd *archive_bfd;
 394           bfd *member_bfd;
 395           char *archive_name = XNEWVEC (char, pfx_len + 1);
 396           int last_ix;
 397           oso_el *oso2;
 398           int ix2;
 399
 400           memcpy (archive_name, oso->name, pfx_len);
 401           archive_name[pfx_len] = '\0';
 402
 403           /* Compute number of oso for this archive.  */
 404           for (last_ix = ix;
 405                VEC_iterate (oso_el, vec, last_ix, oso2); last_ix++)
 406             {
 407               if (strncmp (oso2->name, archive_name, pfx_len) != 0)
 408                 break;
 409             }
 410
 411           /* Open the archive and check the format.  */
 412           archive_bfd = bfd_openr (archive_name, gnutarget);
 413           if (archive_bfd == NULL)
 414             {
 415               warning (_("Could not open OSO archive file \"%s\""),
 416                        archive_name);
 417               ix = last_ix;
 418               continue;
 419             }
 420           if (!bfd_check_format (archive_bfd, bfd_archive))
 421             {
 422               warning (_("OSO archive file \"%s\" not an archive."),
 423                        archive_name);
 424               bfd_close (archive_bfd);
 425               ix = last_ix;
 426               continue;
 427             }
 428           member_bfd = bfd_openr_next_archived_file (archive_bfd, NULL);
 429
 430           if (member_bfd == NULL)
 431             {
 432               warning (_("Could not read archive members out of "
 433                          "OSO archive \"%s\""), archive_name);
 434               bfd_close (archive_bfd);
 435               ix = last_ix;
 436               continue;
 437             }
 438
 439           /* Load all oso in this library.  */
 440           while (member_bfd != NULL)
 441             {
 442               bfd *prev;
 443               const char *member_name = member_bfd->filename;
 444               int member_len = strlen (member_name);
 445
 446               /* If this member is referenced, add it as a symfile.  */
 447               for (ix2 = ix; ix2 < last_ix; ix2++)
 448                 {
 449                   oso2 = VEC_index (oso_el, vec, ix2);
 450
 451                   if (oso2->name
 452                       && strlen (oso2->name) == pfx_len + member_len + 2
 453                       && !memcmp (member_name, oso2->name + pfx_len + 1,
 454                                   member_len))
 455                     {
 456                       macho_add_oso_symfile (oso2, member_bfd, main_objfile);
 457                       oso2->name = NULL;
 458                       break;
 459                     }
 460                 }
 461
 462               prev = member_bfd;
 463               member_bfd = bfd_openr_next_archived_file
 464                 (archive_bfd, member_bfd);
 465
 466               /* Free previous member if not referenced by an oso.  */
 467               if (ix2 >= last_ix)
 468                 bfd_close (prev);
 469             }
 470           for (ix2 = ix; ix2 < last_ix; ix2++)
 471             {
 472               oso_el *oso2 = VEC_index (oso_el, vec, ix2);
 473
 474               if (oso2->name != NULL)
 475                 warning (_("Could not find specified archive member "
 476                            "for OSO name \"%s\""), oso->name);
 477             }
 478           ix = last_ix;
 479         }
 480       else
 481         {
 482           bfd *abfd;
 483
 484           abfd = bfd_openr (oso->name, gnutarget);
 485           if (!abfd)
 486             warning (_("`%s': can't open to read symbols: %s."), oso->name,
 487                      bfd_errmsg (bfd_get_error ()));
 488           else
 489             macho_add_oso_symfile (oso, abfd, main_objfile);
 490
 491           ix++;
 492         }
 493     }
 494
 495   for (ix = 0; VEC_iterate (oso_el, vec, ix, oso); ix++)
 496     {
 497       xfree (oso->symbols);
 498       xfree (oso->offsets);
 499     }
 500   VEC_free (oso_el, vec);
 501 }
 502
 503 /* DSYM (debug symbols) files contain the debug info of an executable.
 504    This is a separate file created by dsymutil(1) and is similar to debug
 505    link feature on ELF.
 506    DSYM files are located in a subdirectory.  Append DSYM_SUFFIX to the
 507    executable name and the executable base name to get the DSYM file name.  */
 508 #define DSYM_SUFFIX ".dSYM/Contents/Resources/DWARF/"
 509
 510 /* Check if a dsym file exists for OBJFILE.  If so, returns a bfd for it.
 511    Return NULL if no valid dsym file is found.  */
 512
 513 static bfd *
 514 macho_check_dsym (struct objfile *objfile)
 515 {
 516   size_t name_len = strlen (objfile->name);
 517   size_t dsym_len = strlen (DSYM_SUFFIX);
 518   const char *base_name = lbasename (objfile->name);
 519   size_t base_len = strlen (base_name);
 520   char *dsym_filename = alloca (name_len + dsym_len + base_len + 1);
 521   bfd *dsym_bfd;
 522   bfd_mach_o_load_command *main_uuid;
 523   bfd_mach_o_load_command *dsym_uuid;
 524
 525   strcpy (dsym_filename, objfile->name);
 526   strcpy (dsym_filename + name_len, DSYM_SUFFIX);
 527   strcpy (dsym_filename + name_len + dsym_len, base_name);
 528
 529   if (access (dsym_filename, R_OK) != 0)
 530     return NULL;
 531
 532   if (bfd_mach_o_lookup_command (objfile->obfd,
 533                                  BFD_MACH_O_LC_UUID, &main_uuid) == 0)
 534     {
 535       warning (_("can't find UUID in %s"), objfile->name);
 536       return NULL;
 537     }
 538   dsym_filename = xstrdup (dsym_filename);
 539   dsym_bfd = bfd_openr (dsym_filename, gnutarget);
 540   if (dsym_bfd == NULL)
 541     {
 542       warning (_("can't open dsym file %s"), dsym_filename);
 543       xfree (dsym_filename);
 544       return NULL;
 545     }
 546
 547   if (!bfd_check_format (dsym_bfd, bfd_object))
 548     {
 549       bfd_close (dsym_bfd);
 550       warning (_("bad dsym file format: %s"), bfd_errmsg (bfd_get_error ()));
 551       xfree (dsym_filename);
 552       return NULL;
 553     }
 554
 555   if (bfd_mach_o_lookup_command (dsym_bfd,
 556                                  BFD_MACH_O_LC_UUID, &dsym_uuid) == 0)
 557     {
 558       warning (_("can't find UUID in %s"), dsym_filename);
 559       bfd_close (dsym_bfd);
 560       xfree (dsym_filename);
 561       return NULL;
 562     }
 563   if (memcmp (dsym_uuid->command.uuid.uuid, main_uuid->command.uuid.uuid,
 564               sizeof (main_uuid->command.uuid.uuid)))
 565     {
 566       warning (_("dsym file UUID doesn't match the one in %s"), objfile->name);
 567       bfd_close (dsym_bfd);
 568       xfree (dsym_filename);
 569       return NULL;
 570     }
 571   return dsym_bfd;
 572 }
 573
 574 static void
 575 macho_symfile_read (struct objfile *objfile, int symfile_flags)
 576 {
 577   bfd *abfd = objfile->obfd;
 578   struct cleanup *back_to;
 579   CORE_ADDR offset;
 580   long storage_needed;
 581   bfd *dsym_bfd;
 582
 583   init_minimal_symbol_collection ();
 584   back_to = make_cleanup_discard_minimal_symbols ();
 585
 586   /* Get symbols from the symbol table only if the file is an executable.
 587      The symbol table of object files is not relocated and is expected to
 588      be in the executable.  */
 589   if (bfd_get_file_flags (abfd) & (EXEC_P | DYNAMIC))
 590     {
 591       /* Process the normal symbol table first.  */
 592       storage_needed = bfd_get_symtab_upper_bound (objfile->obfd);
 593       if (storage_needed < 0)
 594         error (_("Can't read symbols from %s: %s"),
 595                bfd_get_filename (objfile->obfd),
 596                bfd_errmsg (bfd_get_error ()));
 597
 598       if (storage_needed > 0)
 599         {
 600           asymbol **symbol_table;
 601           long symcount;
 602
 603           symbol_table = (asymbol **) xmalloc (storage_needed);
 604           make_cleanup (xfree, symbol_table);
 605           symcount = bfd_canonicalize_symtab (objfile->obfd, symbol_table);
 606
 607           if (symcount < 0)
 608             error (_("Can't read symbols from %s: %s"),
 609                    bfd_get_filename (objfile->obfd),
 610                    bfd_errmsg (bfd_get_error ()));
 611
 612           macho_symtab_read (objfile, symcount, symbol_table);
 613         }
 614
 615       install_minimal_symbols (objfile);
 616
 617       /* Try to read .eh_frame / .debug_frame.  */
 618       /* First, locate these sections.  We ignore the result status
 619          as it only checks for debug info.  */
 620       dwarf2_has_info (objfile);
 621       dwarf2_build_frame_info (objfile);
 622
 623       /* Check for DSYM file.  */
 624       dsym_bfd = macho_check_dsym (objfile);
 625       if (dsym_bfd != NULL)
 626         {
 627           int ix;
 628           oso_el *oso;
 629
 630           if (mach_o_debug_level > 0)
 631             printf_unfiltered (_("dsym file found\n"));
 632
 633           /* Remove oso.  They won't be used.  */
 634           for (ix = 0; VEC_iterate (oso_el, oso_vector, ix, oso); ix++)
 635             {
 636               xfree (oso->symbols);
 637               xfree (oso->offsets);
 638             }
 639           VEC_free (oso_el, oso_vector);
 640           oso_vector = NULL;
 641
 642           /* Add the dsym file as a separate file.  */
 643           symbol_file_add_separate (dsym_bfd, symfile_flags, objfile);
 644
 645           /* Don't try to read dwarf2 from main file or shared libraries.  */
 646           return;
 647         }
 648     }
 649
 650   if (dwarf2_has_info (objfile))
 651     {
 652       /* DWARF 2 sections */
 653       dwarf2_build_psymtabs (objfile);
 654     }
 655
 656   /* Do not try to read .eh_frame/.debug_frame as they are not relocated
 657      and dwarf2_build_frame_info cannot deal with unrelocated sections.  */
 658
 659   /* Then the oso.  */
 660   if (oso_vector != NULL)
 661     macho_oso_symfile (objfile);
 662 }
 663
 664 static void
 665 macho_symfile_finish (struct objfile *objfile)
 666 {
 667 }
 668
 669 static void
 670 macho_symfile_offsets (struct objfile *objfile,
 671                        struct section_addr_info *addrs)
 672 {
 673   unsigned int i;
 674   unsigned int num_sections;
 675   struct obj_section *osect;
 676
 677   /* Allocate section_offsets.  */
 678   objfile->num_sections = bfd_count_sections (objfile->obfd);
 679   objfile->section_offsets = (struct section_offsets *)
 680     obstack_alloc (&objfile->objfile_obstack,
 681                    SIZEOF_N_SECTION_OFFSETS (objfile->num_sections));
 682   memset (objfile->section_offsets, 0,
 683           SIZEOF_N_SECTION_OFFSETS (objfile->num_sections));
 684
 685   /* This code is run when we first add the objfile with
 686      symfile_add_with_addrs_or_offsets, when "addrs" not "offsets" are
 687      passed in.  The place in symfile.c where the addrs are applied
 688      depends on the addrs having section names.  But in the dyld code
 689      we build an anonymous array of addrs, so that code is a no-op.
 690      Because of that, we have to apply the addrs to the sections here.
 691      N.B. if an objfile slides after we've already created it, then it
 692      goes through objfile_relocate.  */
 693
 694   for (i = 0; i < addrs->num_sections; i++)
 695     {
 696       if (addrs->other[i].name == NULL)
 697         continue;
 698
 699       ALL_OBJFILE_OSECTIONS (objfile, osect)
 700         {
 701           const char *bfd_sect_name = osect->the_bfd_section->name;
 702
 703           if (strcmp (bfd_sect_name, addrs->other[i].name) == 0)
 704             {
 705               obj_section_offset (osect) = addrs->other[i].addr;
 706               break;
 707             }
 708         }
 709     }
 710
 711   objfile->sect_index_text = 0;
 712
 713   ALL_OBJFILE_OSECTIONS (objfile, osect)
 714     {
 715       const char *bfd_sect_name = osect->the_bfd_section->name;
 716       int sect_index = osect->the_bfd_section->index;
 717
 718       if (strncmp (bfd_sect_name, "LC_SEGMENT.", 11) == 0)
 719         bfd_sect_name += 11;
 720       if (strcmp (bfd_sect_name, "__TEXT") == 0
 721           || strcmp (bfd_sect_name, "__TEXT.__text") == 0)
 722         objfile->sect_index_text = sect_index;
 723     }
 724 }
 725
 726 static struct sym_fns macho_sym_fns = {
 727   bfd_target_mach_o_flavour,
 728
 729   macho_new_init,               /* sym_new_init: init anything gbl to entire symtab */
 730   macho_symfile_init,           /* sym_init: read initial info, setup for sym_read() */
 731   macho_symfile_read,           /* sym_read: read a symbol file into symtab */
 732   macho_symfile_finish,         /* sym_finish: finished with file, cleanup */
 733   macho_symfile_offsets,        /* sym_offsets:  xlate external to internal form */
 734   default_symfile_segments,     /* sym_segments: Get segment information from
 735                                    a file.  */
 736   NULL                          /* next: pointer to next struct sym_fns */
 737 };
 738
 739 void
 740 _initialize_machoread ()
 741 {
 742   add_symtab_fns (&macho_sym_fns);
 743
 744   add_setshow_zinteger_cmd ("mach-o", class_obscure,
 745                             &mach_o_debug_level, _("\
 746 Set if printing Mach-O symbols processing."), _("\
 747 Show if printing Mach-O symbols processing."), NULL,
 748                             NULL, NULL,
 749                             &setdebuglist, &showdebuglist);
 750 }