OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-stable/] [gdb-7.2/] [bfd/] [mach-o.c] - Blame information for rev 865

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 330 jeremybenn 
/* Mach-O support for BFD.
2 
   Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
3 
   2009, 2010
4 
   Free Software Foundation, Inc.
5 
 
6 
   This file is part of BFD, the Binary File Descriptor library.
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, write to the Free Software
20 
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 
   MA 02110-1301, USA.  */
22 
 
23 
#include "sysdep.h"
24 
#include "mach-o.h"
25 
#include "bfd.h"
26 
#include "libbfd.h"
27 
#include "libiberty.h"
28 
#include "aout/stab_gnu.h"
29 
#include <ctype.h>
30 
 
31 
#define bfd_mach_o_object_p bfd_mach_o_gen_object_p
32 
#define bfd_mach_o_core_p bfd_mach_o_gen_core_p
33 
#define bfd_mach_o_mkobject bfd_mach_o_gen_mkobject
34 
 
35 
#define FILE_ALIGN(off, algn) \
36 
  (((off) + ((file_ptr) 1 << (algn)) - 1) & ((file_ptr) -1 << (algn)))
37 
 
38 
static int bfd_mach_o_read_symtab_symbols (bfd *);
39 
 
40 
unsigned int
41 
bfd_mach_o_version (bfd *abfd)
42 
{
43 
  bfd_mach_o_data_struct *mdata = NULL;
44 
 
45 
  BFD_ASSERT (bfd_mach_o_valid (abfd));
46 
  mdata = bfd_mach_o_get_data (abfd);
47 
 
48 
  return mdata->header.version;
49 
}
50 
 
51 
bfd_boolean
52 
bfd_mach_o_valid (bfd *abfd)
53 
{
54 
  if (abfd == NULL || abfd->xvec == NULL)
55 
    return FALSE;
56 
 
57 
  if (abfd->xvec->flavour != bfd_target_mach_o_flavour)
58 
    return FALSE;
59 
 
60 
  if (bfd_mach_o_get_data (abfd) == NULL)
61 
    return FALSE;
62 
  return TRUE;
63 
}
64 
 
65 
static INLINE bfd_boolean
66 
mach_o_wide_p (bfd_mach_o_header *header)
67 
{
68 
  switch (header->version)
69 
    {
70 
    case 1:
71 
      return FALSE;
72 
    case 2:
73 
      return TRUE;
74 
    default:
75 
      BFD_FAIL ();
76 
      return FALSE;
77 
    }
78 
}
79 
 
80 
static INLINE bfd_boolean
81 
bfd_mach_o_wide_p (bfd *abfd)
82 
{
83 
  return mach_o_wide_p (&bfd_mach_o_get_data (abfd)->header);
84 
}
85 
 
86 
/* Tables to translate well known Mach-O segment/section names to bfd
87 
   names.  Use of canonical names (such as .text or .debug_frame) is required
88 
   by gdb.  */
89 
 
90 
struct mach_o_section_name_xlat
91 
{
92 
  const char *bfd_name;
93 
  const char *mach_o_name;
94 
  flagword flags;
95 
};
96 
 
97 
static const struct mach_o_section_name_xlat dwarf_section_names_xlat[] =
98 
  {
99 
    { ".debug_frame",    "__debug_frame",    SEC_DEBUGGING },
100 
    { ".debug_info",     "__debug_info",     SEC_DEBUGGING },
101 
    { ".debug_abbrev",   "__debug_abbrev",   SEC_DEBUGGING },
102 
    { ".debug_aranges",  "__debug_aranges",  SEC_DEBUGGING },
103 
    { ".debug_macinfo",  "__debug_macinfo",  SEC_DEBUGGING },
104 
    { ".debug_line",     "__debug_line",     SEC_DEBUGGING },
105 
    { ".debug_loc",      "__debug_loc",      SEC_DEBUGGING },
106 
    { ".debug_pubnames", "__debug_pubnames", SEC_DEBUGGING },
107 
    { ".debug_pubtypes", "__debug_pubtypes", SEC_DEBUGGING },
108 
    { ".debug_str",      "__debug_str",      SEC_DEBUGGING },
109 
    { ".debug_ranges",   "__debug_ranges",   SEC_DEBUGGING },
110 
    { NULL, NULL, 0}
111 
  };
112 
 
113 
static const struct mach_o_section_name_xlat text_section_names_xlat[] =
114 
  {
115 
    { ".text",     "__text",      SEC_CODE | SEC_LOAD },
116 
    { ".const",    "__const",     SEC_READONLY | SEC_DATA | SEC_LOAD },
117 
    { ".cstring",  "__cstring",   SEC_READONLY | SEC_DATA | SEC_LOAD },
118 
    { ".eh_frame", "__eh_frame",  SEC_READONLY | SEC_LOAD },
119 
    { NULL, NULL, 0}
120 
  };
121 
 
122 
static const struct mach_o_section_name_xlat data_section_names_xlat[] =
123 
  {
124 
    { ".data",                "__data",          SEC_DATA | SEC_LOAD },
125 
    { ".const_data",          "__const",         SEC_DATA | SEC_LOAD },
126 
    { ".dyld",                "__dyld",          SEC_DATA | SEC_LOAD },
127 
    { ".lazy_symbol_ptr",     "__la_symbol_ptr", SEC_DATA | SEC_LOAD },
128 
    { ".non_lazy_symbol_ptr", "__nl_symbol_ptr", SEC_DATA | SEC_LOAD },
129 
    { ".bss",                 "__bss",           SEC_NO_FLAGS },
130 
    { NULL, NULL, 0}
131 
  };
132 
 
133 
struct mach_o_segment_name_xlat
134 
{
135 
  const char *segname;
136 
  const struct mach_o_section_name_xlat *sections;
137 
};
138 
 
139 
static const struct mach_o_segment_name_xlat segsec_names_xlat[] =
140 
  {
141 
    { "__DWARF", dwarf_section_names_xlat },
142 
    { "__TEXT", text_section_names_xlat },
143 
    { "__DATA", data_section_names_xlat },
144 
    { NULL, NULL }
145 
  };
146 
 
147 
 
148 
/* Mach-O to bfd names.  */
149 
 
150 
static void
151 
bfd_mach_o_convert_section_name_to_bfd (bfd *abfd, bfd_mach_o_section *section,
152 
                                        char **name, flagword *flags)
153 
{
154 
  const struct mach_o_segment_name_xlat *seg;
155 
  char *res;
156 
  unsigned int len;
157 
  const char *pfx = "";
158 
 
159 
  *name = NULL;
160 
  *flags = SEC_NO_FLAGS;
161 
 
162 
  for (seg = segsec_names_xlat; seg->segname; seg++)
163 
    {
164 
      if (strcmp (seg->segname, section->segname) == 0)
165 
        {
166 
          const struct mach_o_section_name_xlat *sec;
167 
 
168 
          for (sec = seg->sections; sec->mach_o_name; sec++)
169 
            {
170 
              if (strcmp (sec->mach_o_name, section->sectname) == 0)
171 
                {
172 
                  len = strlen (sec->bfd_name);
173 
                  res = bfd_alloc (abfd, len + 1);
174 
 
175 
                  if (res == NULL)
176 
                    return;
177 
                  strcpy (res, sec->bfd_name);
178 
                  *name = res;
179 
                  *flags = sec->flags;
180 
                  return;
181 
                }
182 
            }
183 
        }
184 
    }
185 
 
186 
  len = strlen (section->segname) + 1
187 
    + strlen (section->sectname) + 1;
188 
 
189 
  /* Put "LC_SEGMENT." prefix if the segment name is weird (ie doesn't start
190 
     with an underscore.  */
191 
  if (section->segname[0] != '_')
192 
    {
193 
      static const char seg_pfx[] = "LC_SEGMENT.";
194 
 
195 
      pfx = seg_pfx;
196 
      len += sizeof (seg_pfx) - 1;
197 
    }
198 
 
199 
  res = bfd_alloc (abfd, len);
200 
  if (res == NULL)
201 
    return;
202 
  snprintf (res, len, "%s%s.%s", pfx, section->segname, section->sectname);
203 
  *name = res;
204 
}
205 
 
206 
/* Convert a bfd section name to a Mach-O segment + section name.  */
207 
 
208 
static void
209 
bfd_mach_o_convert_section_name_to_mach_o (bfd *abfd ATTRIBUTE_UNUSED,
210 
                                           asection *sect,
211 
                                           bfd_mach_o_section *section)
212 
{
213 
  const struct mach_o_segment_name_xlat *seg;
214 
  const char *name = bfd_get_section_name (abfd, sect);
215 
  const char *dot;
216 
  unsigned int len;
217 
  unsigned int seglen;
218 
  unsigned int seclen;
219 
 
220 
  /* List of well known names.  They all start with a dot.  */
221 
  if (name[0] == '.')
222 
    for (seg = segsec_names_xlat; seg->segname; seg++)
223 
      {
224 
        const struct mach_o_section_name_xlat *sec;
225 
 
226 
        for (sec = seg->sections; sec->mach_o_name; sec++)
227 
          {
228 
            if (strcmp (sec->bfd_name, name) == 0)
229 
              {
230 
                strcpy (section->segname, seg->segname);
231 
                strcpy (section->sectname, sec->mach_o_name);
232 
                return;
233 
              }
234 
          }
235 
      }
236 
 
237 
  /* Strip LC_SEGMENT. prefix.  */
238 
  if (strncmp (name, "LC_SEGMENT.", 11) == 0)
239 
    name += 11;
240 
 
241 
  /* Find a dot.  */
242 
  dot = strchr (name, '.');
243 
  len = strlen (name);
244 
 
245 
  /* Try to split name into segment and section names.  */
246 
  if (dot && dot != name)
247 
    {
248 
      seglen = dot - name;
249 
      seclen = len - (dot + 1 - name);
250 
 
251 
      if (seglen < 16 && seclen < 16)
252 
        {
253 
          memcpy (section->segname, name, seglen);
254 
          section->segname[seglen] = 0;
255 
          memcpy (section->sectname, dot + 1, seclen);
256 
          section->sectname[seclen] = 0;
257 
          return;
258 
        }
259 
    }
260 
 
261 
  if (len > 16)
262 
    len = 16;
263 
  memcpy (section->segname, name, len);
264 
  section->segname[len] = 0;
265 
  memcpy (section->sectname, name, len);
266 
  section->sectname[len] = 0;
267 
}
268 
 
269 
/* Return the size of an entry for section SEC.
270 
   Must be called only for symbol pointer section and symbol stubs
271 
   sections.  */
272 
 
273 
static unsigned int
274 
bfd_mach_o_section_get_entry_size (bfd *abfd, bfd_mach_o_section *sec)
275 
{
276 
  switch (sec->flags & BFD_MACH_O_SECTION_TYPE_MASK)
277 
    {
278 
    case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS:
279 
    case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS:
280 
      return bfd_mach_o_wide_p (abfd) ? 8 : 4;
281 
    case BFD_MACH_O_S_SYMBOL_STUBS:
282 
      return sec->reserved2;
283 
    default:
284 
      BFD_FAIL ();
285 
      return 0;
286 
    }
287 
}
288 
 
289 
/* Return the number of indirect symbols for a section.
290 
   Must be called only for symbol pointer section and symbol stubs
291 
   sections.  */
292 
 
293 
static unsigned int
294 
bfd_mach_o_section_get_nbr_indirect (bfd *abfd, bfd_mach_o_section *sec)
295 
{
296 
  unsigned int elsz;
297 
 
298 
  elsz = bfd_mach_o_section_get_entry_size (abfd, sec);
299 
  if (elsz == 0)
300 
    return 0;
301 
  else
302 
    return sec->size / elsz;
303 
}
304 
 
305 
 
306 
/* Copy any private info we understand from the input symbol
307 
   to the output symbol.  */
308 
 
309 
bfd_boolean
310 
bfd_mach_o_bfd_copy_private_symbol_data (bfd *ibfd ATTRIBUTE_UNUSED,
311 
                                         asymbol *isymbol ATTRIBUTE_UNUSED,
312 
                                         bfd *obfd ATTRIBUTE_UNUSED,
313 
                                         asymbol *osymbol ATTRIBUTE_UNUSED)
314 
{
315 
  return TRUE;
316 
}
317 
 
318 
/* Copy any private info we understand from the input section
319 
   to the output section.  */
320 
 
321 
bfd_boolean
322 
bfd_mach_o_bfd_copy_private_section_data (bfd *ibfd ATTRIBUTE_UNUSED,
323 
                                          asection *isection ATTRIBUTE_UNUSED,
324 
                                          bfd *obfd ATTRIBUTE_UNUSED,
325 
                                          asection *osection ATTRIBUTE_UNUSED)
326 
{
327 
  return TRUE;
328 
}
329 
 
330 
/* Copy any private info we understand from the input bfd
331 
   to the output bfd.  */
332 
 
333 
bfd_boolean
334 
bfd_mach_o_bfd_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
335 
{
336 
  if (bfd_get_flavour (ibfd) != bfd_target_mach_o_flavour
337 
      || bfd_get_flavour (obfd) != bfd_target_mach_o_flavour)
338 
    return TRUE;
339 
 
340 
  BFD_ASSERT (bfd_mach_o_valid (ibfd));
341 
  BFD_ASSERT (bfd_mach_o_valid (obfd));
342 
 
343 
  /* FIXME: copy commands.  */
344 
 
345 
  return TRUE;
346 
}
347 
 
348 
/* Count the total number of symbols.  */
349 
 
350 
static long
351 
bfd_mach_o_count_symbols (bfd *abfd)
352 
{
353 
  bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
354 
 
355 
  if (mdata->symtab == NULL)
356 
    return 0;
357 
  return mdata->symtab->nsyms;
358 
}
359 
 
360 
long
361 
bfd_mach_o_get_symtab_upper_bound (bfd *abfd)
362 
{
363 
  long nsyms = bfd_mach_o_count_symbols (abfd);
364 
 
365 
  return ((nsyms + 1) * sizeof (asymbol *));
366 
}
367 
 
368 
long
369 
bfd_mach_o_canonicalize_symtab (bfd *abfd, asymbol **alocation)
370 
{
371 
  bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
372 
  long nsyms = bfd_mach_o_count_symbols (abfd);
373 
  bfd_mach_o_symtab_command *sym = mdata->symtab;
374 
  unsigned long j;
375 
 
376 
  if (nsyms < 0)
377 
    return nsyms;
378 
 
379 
  if (bfd_mach_o_read_symtab_symbols (abfd) != 0)
380 
    {
381 
      fprintf (stderr,
382 
               "bfd_mach_o_canonicalize_symtab: unable to load symbols\n");
383 
      return 0;
384 
    }
385 
 
386 
  BFD_ASSERT (sym->symbols != NULL);
387 
 
388 
  for (j = 0; j < sym->nsyms; j++)
389 
    alocation[j] = &sym->symbols[j].symbol;
390 
 
391 
  alocation[j] = NULL;
392 
 
393 
  return nsyms;
394 
}
395 
 
396 
long
397 
bfd_mach_o_get_synthetic_symtab (bfd *abfd,
398 
                                 long symcount ATTRIBUTE_UNUSED,
399 
                                 asymbol **syms ATTRIBUTE_UNUSED,
400 
                                 long dynsymcount ATTRIBUTE_UNUSED,
401 
                                 asymbol **dynsyms ATTRIBUTE_UNUSED,
402 
                                 asymbol **ret)
403 
{
404 
  bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
405 
  bfd_mach_o_dysymtab_command *dysymtab = mdata->dysymtab;
406 
  bfd_mach_o_symtab_command *symtab = mdata->symtab;
407 
  asymbol *s;
408 
  unsigned long count, i, j, n;
409 
  size_t size;
410 
  char *names;
411 
  char *nul_name;
412 
 
413 
  *ret = NULL;
414 
 
415 
  if (dysymtab == NULL || symtab == NULL || symtab->symbols == NULL)
416 
    return 0;
417 
 
418 
  if (dysymtab->nindirectsyms == 0)
419 
    return 0;
420 
 
421 
  count = dysymtab->nindirectsyms;
422 
  size = count * sizeof (asymbol) + 1;
423 
 
424 
  for (j = 0; j < count; j++)
425 
    {
426 
      unsigned int isym = dysymtab->indirect_syms[j];
427 
 
428 
      if (isym < symtab->nsyms && symtab->symbols[isym].symbol.name)
429 
        size += strlen (symtab->symbols[isym].symbol.name) + sizeof ("$stub");
430 
    }
431 
 
432 
  s = *ret = (asymbol *) bfd_malloc (size);
433 
  if (s == NULL)
434 
    return -1;
435 
  names = (char *) (s + count);
436 
  nul_name = names;
437 
  *names++ = 0;
438 
 
439 
  n = 0;
440 
  for (i = 0; i < mdata->nsects; i++)
441 
    {
442 
      bfd_mach_o_section *sec = mdata->sections[i];
443 
      unsigned int first, last;
444 
      bfd_vma addr;
445 
      bfd_vma entry_size;
446 
 
447 
      switch (sec->flags & BFD_MACH_O_SECTION_TYPE_MASK)
448 
        {
449 
        case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS:
450 
        case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS:
451 
        case BFD_MACH_O_S_SYMBOL_STUBS:
452 
          first = sec->reserved1;
453 
          last = first + bfd_mach_o_section_get_nbr_indirect (abfd, sec);
454 
          addr = sec->addr;
455 
          entry_size = bfd_mach_o_section_get_entry_size (abfd, sec);
456 
          for (j = first; j < last; j++)
457 
            {
458 
              unsigned int isym = dysymtab->indirect_syms[j];
459 
 
460 
              s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
461 
              s->section = sec->bfdsection;
462 
              s->value = addr - sec->addr;
463 
              s->udata.p = NULL;
464 
 
465 
              if (isym < symtab->nsyms
466 
                  && symtab->symbols[isym].symbol.name)
467 
                {
468 
                  const char *sym = symtab->symbols[isym].symbol.name;
469 
                  size_t len;
470 
 
471 
                  s->name = names;
472 
                  len = strlen (sym);
473 
                  memcpy (names, sym, len);
474 
                  names += len;
475 
                  memcpy (names, "$stub", sizeof ("$stub"));
476 
                  names += sizeof ("$stub");
477 
                }
478 
              else
479 
                s->name = nul_name;
480 
 
481 
              addr += entry_size;
482 
              s++;
483 
              n++;
484 
            }
485 
          break;
486 
        default:
487 
          break;
488 
        }
489 
    }
490 
 
491 
  return n;
492 
}
493 
 
494 
void
495 
bfd_mach_o_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED,
496 
                            asymbol *symbol,
497 
                            symbol_info *ret)
498 
{
499 
  bfd_symbol_info (symbol, ret);
500 
}
501 
 
502 
void
503 
bfd_mach_o_print_symbol (bfd *abfd,
504 
                         void * afile,
505 
                         asymbol *symbol,
506 
                         bfd_print_symbol_type how)
507 
{
508 
  FILE *file = (FILE *) afile;
509 
  const char *name;
510 
  bfd_mach_o_asymbol *asym = (bfd_mach_o_asymbol *)symbol;
511 
 
512 
  switch (how)
513 
    {
514 
    case bfd_print_symbol_name:
515 
      fprintf (file, "%s", symbol->name);
516 
      break;
517 
    default:
518 
      bfd_print_symbol_vandf (abfd, (void *) file, symbol);
519 
      if (asym->n_type & BFD_MACH_O_N_STAB)
520 
        name = bfd_get_stab_name (asym->n_type);
521 
      else
522 
        switch (asym->n_type & BFD_MACH_O_N_TYPE)
523 
          {
524 
          case BFD_MACH_O_N_UNDF:
525 
            name = "UND";
526 
            break;
527 
          case BFD_MACH_O_N_ABS:
528 
            name = "ABS";
529 
            break;
530 
          case BFD_MACH_O_N_INDR:
531 
            name = "INDR";
532 
            break;
533 
          case BFD_MACH_O_N_PBUD:
534 
            name = "PBUD";
535 
            break;
536 
          case BFD_MACH_O_N_SECT:
537 
            name = "SECT";
538 
            break;
539 
          default:
540 
            name = "???";
541 
            break;
542 
          }
543 
      if (name == NULL)
544 
        name = "";
545 
      fprintf (file, " %02x %-6s %02x %04x",
546 
               asym->n_type, name, asym->n_sect, asym->n_desc);
547 
      if ((asym->n_type & BFD_MACH_O_N_STAB) == 0
548 
          && (asym->n_type & BFD_MACH_O_N_TYPE) == BFD_MACH_O_N_SECT)
549 
        fprintf (file, " %-5s", symbol->section->name);
550 
      fprintf (file, " %s", symbol->name);
551 
    }
552 
}
553 
 
554 
static void
555 
bfd_mach_o_convert_architecture (bfd_mach_o_cpu_type mtype,
556 
                                 bfd_mach_o_cpu_subtype msubtype ATTRIBUTE_UNUSED,
557 
                                 enum bfd_architecture *type,
558 
                                 unsigned long *subtype)
559 
{
560 
  *subtype = bfd_arch_unknown;
561 
 
562 
  switch (mtype)
563 
    {
564 
    case BFD_MACH_O_CPU_TYPE_VAX: *type = bfd_arch_vax; break;
565 
    case BFD_MACH_O_CPU_TYPE_MC680x0: *type = bfd_arch_m68k; break;
566 
    case BFD_MACH_O_CPU_TYPE_I386:
567 
      *type = bfd_arch_i386;
568 
      *subtype = bfd_mach_i386_i386;
569 
      break;
570 
    case BFD_MACH_O_CPU_TYPE_X86_64:
571 
      *type = bfd_arch_i386;
572 
      *subtype = bfd_mach_x86_64;
573 
      break;
574 
    case BFD_MACH_O_CPU_TYPE_MIPS: *type = bfd_arch_mips; break;
575 
    case BFD_MACH_O_CPU_TYPE_MC98000: *type = bfd_arch_m98k; break;
576 
    case BFD_MACH_O_CPU_TYPE_HPPA: *type = bfd_arch_hppa; break;
577 
    case BFD_MACH_O_CPU_TYPE_ARM: *type = bfd_arch_arm; break;
578 
    case BFD_MACH_O_CPU_TYPE_MC88000: *type = bfd_arch_m88k; break;
579 
    case BFD_MACH_O_CPU_TYPE_SPARC:
580 
      *type = bfd_arch_sparc;
581 
      *subtype = bfd_mach_sparc;
582 
      break;
583 
    case BFD_MACH_O_CPU_TYPE_I860: *type = bfd_arch_i860; break;
584 
    case BFD_MACH_O_CPU_TYPE_ALPHA: *type = bfd_arch_alpha; break;
585 
    case BFD_MACH_O_CPU_TYPE_POWERPC:
586 
      *type = bfd_arch_powerpc;
587 
      *subtype = bfd_mach_ppc;
588 
      break;
589 
    case BFD_MACH_O_CPU_TYPE_POWERPC_64:
590 
      *type = bfd_arch_powerpc;
591 
      *subtype = bfd_mach_ppc64;
592 
      break;
593 
    default:
594 
      *type = bfd_arch_unknown;
595 
      break;
596 
    }
597 
}
598 
 
599 
static bfd_boolean
600 
bfd_mach_o_write_header (bfd *abfd, bfd_mach_o_header *header)
601 
{
602 
  unsigned char buf[32];
603 
  unsigned int size;
604 
 
605 
  size = mach_o_wide_p (header) ?
606 
    BFD_MACH_O_HEADER_64_SIZE : BFD_MACH_O_HEADER_SIZE;
607 
 
608 
  bfd_h_put_32 (abfd, header->magic, buf + 0);
609 
  bfd_h_put_32 (abfd, header->cputype, buf + 4);
610 
  bfd_h_put_32 (abfd, header->cpusubtype, buf + 8);
611 
  bfd_h_put_32 (abfd, header->filetype, buf + 12);
612 
  bfd_h_put_32 (abfd, header->ncmds, buf + 16);
613 
  bfd_h_put_32 (abfd, header->sizeofcmds, buf + 20);
614 
  bfd_h_put_32 (abfd, header->flags, buf + 24);
615 
 
616 
  if (mach_o_wide_p (header))
617 
    bfd_h_put_32 (abfd, header->reserved, buf + 28);
618 
 
619 
  if (bfd_seek (abfd, 0, SEEK_SET) != 0
620 
      || bfd_bwrite ((void *) buf, size, abfd) != size)
621 
    return FALSE;
622 
 
623 
  return TRUE;
624 
}
625 
 
626 
static int
627 
bfd_mach_o_write_thread (bfd *abfd, bfd_mach_o_load_command *command)
628 
{
629 
  bfd_mach_o_thread_command *cmd = &command->command.thread;
630 
  unsigned int i;
631 
  unsigned char buf[8];
632 
  unsigned int offset;
633 
 
634 
  BFD_ASSERT ((command->type == BFD_MACH_O_LC_THREAD)
635 
              || (command->type == BFD_MACH_O_LC_UNIXTHREAD));
636 
 
637 
  offset = 8;
638 
  for (i = 0; i < cmd->nflavours; i++)
639 
    {
640 
      BFD_ASSERT ((cmd->flavours[i].size % 4) == 0);
641 
      BFD_ASSERT (cmd->flavours[i].offset == (command->offset + offset + 8));
642 
 
643 
      bfd_h_put_32 (abfd, cmd->flavours[i].flavour, buf);
644 
      bfd_h_put_32 (abfd, (cmd->flavours[i].size / 4), buf + 4);
645 
 
646 
      if (bfd_seek (abfd, command->offset + offset, SEEK_SET) != 0
647 
          || bfd_bwrite ((void *) buf, 8, abfd) != 8)
648 
        return -1;
649 
 
650 
      offset += cmd->flavours[i].size + 8;
651 
    }
652 
 
653 
  return 0;
654 
}
655 
 
656 
long
657 
bfd_mach_o_get_reloc_upper_bound (bfd *abfd ATTRIBUTE_UNUSED,
658 
                                  asection *asect)
659 
{
660 
  return (asect->reloc_count + 1) * sizeof (arelent *);
661 
}
662 
 
663 
static int
664 
bfd_mach_o_canonicalize_one_reloc (bfd *abfd, char *buf,
665 
                                   arelent *res, asymbol **syms)
666 
{
667 
  bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
668 
  bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
669 
  bfd_mach_o_reloc_info reloc;
670 
  bfd_vma addr;
671 
  bfd_vma symnum;
672 
  asymbol **sym;
673 
 
674 
  addr = bfd_get_32 (abfd, buf + 0);
675 
  symnum = bfd_get_32 (abfd, buf + 4);
676 
 
677 
  if (addr & BFD_MACH_O_SR_SCATTERED)
678 
    {
679 
      unsigned int j;
680 
 
681 
      /* Scattered relocation.
682 
         Extract section and offset from r_value.  */
683 
      res->sym_ptr_ptr = NULL;
684 
      res->addend = 0;
685 
      for (j = 0; j < mdata->nsects; j++)
686 
        {
687 
          bfd_mach_o_section *sect = mdata->sections[j];
688 
          if (symnum >= sect->addr && symnum < sect->addr + sect->size)
689 
            {
690 
              res->sym_ptr_ptr = sect->bfdsection->symbol_ptr_ptr;
691 
              res->addend = symnum - sect->addr;
692 
              break;
693 
            }
694 
        }
695 
      res->address = BFD_MACH_O_GET_SR_ADDRESS (addr);
696 
      reloc.r_type = BFD_MACH_O_GET_SR_TYPE (addr);
697 
      reloc.r_length = BFD_MACH_O_GET_SR_LENGTH (addr);
698 
      reloc.r_pcrel = addr & BFD_MACH_O_SR_PCREL;
699 
      reloc.r_scattered = 1;
700 
    }
701 
  else
702 
    {
703 
      unsigned int num = BFD_MACH_O_GET_R_SYMBOLNUM (symnum);
704 
      res->addend = 0;
705 
      res->address = addr;
706 
      if (symnum & BFD_MACH_O_R_EXTERN)
707 
        {
708 
          sym = syms + num;
709 
          reloc.r_extern = 1;
710 
        }
711 
      else
712 
        {
713 
          BFD_ASSERT (num != 0);
714 
          BFD_ASSERT (num <= mdata->nsects);
715 
          sym = mdata->sections[num - 1]->bfdsection->symbol_ptr_ptr;
716 
          /* For a symbol defined in section S, the addend (stored in the
717 
             binary) contains the address of the section.  To comply with
718 
             bfd conventio, substract the section address.
719 
             Use the address from the header, so that the user can modify
720 
             the vma of the section.  */
721 
          res->addend = -mdata->sections[num - 1]->addr;
722 
          reloc.r_extern = 0;
723 
        }
724 
      res->sym_ptr_ptr = sym;
725 
      reloc.r_type = BFD_MACH_O_GET_R_TYPE (symnum);
726 
      reloc.r_length = BFD_MACH_O_GET_R_LENGTH (symnum);
727 
      reloc.r_pcrel = (symnum & BFD_MACH_O_R_PCREL) ? 1 : 0;
728 
      reloc.r_scattered = 0;
729 
    }
730 
 
731 
  if (!(*bed->_bfd_mach_o_swap_reloc_in)(res, &reloc))
732 
    return -1;
733 
  return 0;
734 
}
735 
 
736 
static int
737 
bfd_mach_o_canonicalize_relocs (bfd *abfd, unsigned long filepos,
738 
                                unsigned long count,
739 
                                arelent *res, asymbol **syms)
740 
{
741 
  unsigned long i;
742 
  char *native_relocs;
743 
  bfd_size_type native_size;
744 
 
745 
  /* Allocate and read relocs.  */
746 
  native_size = count * BFD_MACH_O_RELENT_SIZE;
747 
  native_relocs = bfd_malloc (native_size);
748 
  if (native_relocs == NULL)
749 
    return -1;
750 
 
751 
  if (bfd_seek (abfd, filepos, SEEK_SET) != 0
752 
      || bfd_bread (native_relocs, native_size, abfd) != native_size)
753 
    goto err;
754 
 
755 
  for (i = 0; i < count; i++)
756 
    {
757 
      char *buf = native_relocs + BFD_MACH_O_RELENT_SIZE * i;
758 
 
759 
      if (bfd_mach_o_canonicalize_one_reloc (abfd, buf, &res[i], syms) < 0)
760 
        goto err;
761 
    }
762 
  free (native_relocs);
763 
  return i;
764 
 err:
765 
  free (native_relocs);
766 
  return -1;
767 
}
768 
 
769 
long
770 
bfd_mach_o_canonicalize_reloc (bfd *abfd, asection *asect,
771 
                               arelent **rels, asymbol **syms)
772 
{
773 
  bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
774 
  unsigned long i;
775 
  arelent *res;
776 
 
777 
  if (asect->reloc_count == 0)
778 
    return 0;
779 
 
780 
  /* No need to go further if we don't know how to read relocs.  */
781 
  if (bed->_bfd_mach_o_swap_reloc_in == NULL)
782 
    return 0;
783 
 
784 
  res = bfd_malloc (asect->reloc_count * sizeof (arelent));
785 
  if (res == NULL)
786 
    return -1;
787 
 
788 
  if (bfd_mach_o_canonicalize_relocs (abfd, asect->rel_filepos,
789 
                                      asect->reloc_count, res, syms) < 0)
790 
    {
791 
      free (res);
792 
      return -1;
793 
    }
794 
 
795 
  for (i = 0; i < asect->reloc_count; i++)
796 
    rels[i] = &res[i];
797 
  rels[i] = NULL;
798 
  asect->relocation = res;
799 
 
800 
  return i;
801 
}
802 
 
803 
long
804 
bfd_mach_o_get_dynamic_reloc_upper_bound (bfd *abfd)
805 
{
806 
  bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
807 
 
808 
  if (mdata->dysymtab == NULL)
809 
    return 1;
810 
  return (mdata->dysymtab->nextrel + mdata->dysymtab->nlocrel)
811 
    * sizeof (arelent *);
812 
}
813 
 
814 
long
815 
bfd_mach_o_canonicalize_dynamic_reloc (bfd *abfd, arelent **rels,
816 
                                       struct bfd_symbol **syms)
817 
{
818 
  bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
819 
  bfd_mach_o_dysymtab_command *dysymtab = mdata->dysymtab;
820 
  bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
821 
  unsigned long i;
822 
  arelent *res;
823 
 
824 
  if (dysymtab == NULL)
825 
    return 0;
826 
  if (dysymtab->nextrel == 0 && dysymtab->nlocrel == 0)
827 
    return 0;
828 
 
829 
  /* No need to go further if we don't know how to read relocs.  */
830 
  if (bed->_bfd_mach_o_swap_reloc_in == NULL)
831 
    return 0;
832 
 
833 
  res = bfd_malloc ((dysymtab->nextrel + dysymtab->nlocrel) * sizeof (arelent));
834 
  if (res == NULL)
835 
    return -1;
836 
 
837 
  if (bfd_mach_o_canonicalize_relocs (abfd, dysymtab->extreloff,
838 
                                      dysymtab->nextrel, res, syms) < 0)
839 
    {
840 
      free (res);
841 
      return -1;
842 
    }
843 
 
844 
  if (bfd_mach_o_canonicalize_relocs (abfd, dysymtab->locreloff,
845 
                                      dysymtab->nlocrel,
846 
                                      res + dysymtab->nextrel, syms) < 0)
847 
    {
848 
      free (res);
849 
      return -1;
850 
    }
851 
 
852 
  for (i = 0; i < dysymtab->nextrel + dysymtab->nlocrel; i++)
853 
    rels[i] = &res[i];
854 
  rels[i] = NULL;
855 
  return i;
856 
}
857 
 
858 
static bfd_boolean
859 
bfd_mach_o_write_relocs (bfd *abfd, bfd_mach_o_section *section)
860 
{
861 
  bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
862 
  unsigned int i;
863 
  arelent **entries;
864 
  asection *sec;
865 
  bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
866 
 
867 
  sec = section->bfdsection;
868 
  if (sec->reloc_count == 0)
869 
    return TRUE;
870 
 
871 
  if (bed->_bfd_mach_o_swap_reloc_out == NULL)
872 
    return TRUE;
873 
 
874 
  /* Allocate relocation room.  */
875 
  mdata->filelen = FILE_ALIGN(mdata->filelen, 2);
876 
  section->nreloc = sec->reloc_count;
877 
  sec->rel_filepos = mdata->filelen;
878 
  section->reloff = sec->rel_filepos;
879 
  mdata->filelen += sec->reloc_count * BFD_MACH_O_RELENT_SIZE;
880 
 
881 
  if (bfd_seek (abfd, section->reloff, SEEK_SET) != 0)
882 
    return FALSE;
883 
 
884 
  /* Convert and write.  */
885 
  entries = section->bfdsection->orelocation;
886 
  for (i = 0; i < section->nreloc; i++)
887 
    {
888 
      arelent *rel = entries[i];
889 
      char buf[8];
890 
      bfd_mach_o_reloc_info info, *pinfo = &info;
891 
 
892 
      /* Convert relocation to an intermediate representation.  */
893 
      if (!(*bed->_bfd_mach_o_swap_reloc_out) (rel, pinfo))
894 
        return FALSE;
895 
 
896 
      /* Lower the relocation info.  */
897 
      if (pinfo->r_scattered)
898 
        {
899 
          unsigned long v;
900 
 
901 
          v = BFD_MACH_O_SR_SCATTERED
902 
            | (pinfo->r_pcrel ? BFD_MACH_O_SR_PCREL : 0)
903 
            | BFD_MACH_O_SET_SR_LENGTH(pinfo->r_length)
904 
            | BFD_MACH_O_SET_SR_TYPE(pinfo->r_type)
905 
            | BFD_MACH_O_SET_SR_ADDRESS(pinfo->r_address);
906 
          bfd_put_32 (abfd, v, buf);
907 
          bfd_put_32 (abfd, pinfo->r_value, buf + 4);
908 
        }
909 
      else
910 
        {
911 
          unsigned long v;
912 
 
913 
          bfd_put_32 (abfd, pinfo->r_address, buf);
914 
          v = BFD_MACH_O_SET_R_SYMBOLNUM (pinfo->r_value)
915 
            | (pinfo->r_pcrel ? BFD_MACH_O_R_PCREL : 0)
916 
            | BFD_MACH_O_SET_R_LENGTH (pinfo->r_length)
917 
            | (pinfo->r_extern ? BFD_MACH_O_R_EXTERN : 0)
918 
            | BFD_MACH_O_SET_R_TYPE (pinfo->r_type);
919 
          bfd_put_32 (abfd, v, buf + 4);
920 
        }
921 
 
922 
      if (bfd_bwrite ((void *) buf, BFD_MACH_O_RELENT_SIZE, abfd)
923 
          != BFD_MACH_O_RELENT_SIZE)
924 
        return FALSE;
925 
    }
926 
  return TRUE;
927 
}
928 
 
929 
static int
930 
bfd_mach_o_write_section_32 (bfd *abfd, bfd_mach_o_section *section)
931 
{
932 
  unsigned char buf[BFD_MACH_O_SECTION_SIZE];
933 
 
934 
  memcpy (buf, section->sectname, 16);
935 
  memcpy (buf + 16, section->segname, 16);
936 
  bfd_h_put_32 (abfd, section->addr, buf + 32);
937 
  bfd_h_put_32 (abfd, section->size, buf + 36);
938 
  bfd_h_put_32 (abfd, section->offset, buf + 40);
939 
  bfd_h_put_32 (abfd, section->align, buf + 44);
940 
  bfd_h_put_32 (abfd, section->reloff, buf + 48);
941 
  bfd_h_put_32 (abfd, section->nreloc, buf + 52);
942 
  bfd_h_put_32 (abfd, section->flags, buf + 56);
943 
  bfd_h_put_32 (abfd, section->reserved1, buf + 60);
944 
  bfd_h_put_32 (abfd, section->reserved2, buf + 64);
945 
 
946 
  if (bfd_bwrite ((void *) buf, BFD_MACH_O_SECTION_SIZE, abfd)
947 
      != BFD_MACH_O_SECTION_SIZE)
948 
    return -1;
949 
 
950 
  return 0;
951 
}
952 
 
953 
static int
954 
bfd_mach_o_write_section_64 (bfd *abfd, bfd_mach_o_section *section)
955 
{
956 
  unsigned char buf[BFD_MACH_O_SECTION_64_SIZE];
957 
 
958 
  memcpy (buf, section->sectname, 16);
959 
  memcpy (buf + 16, section->segname, 16);
960 
  bfd_h_put_64 (abfd, section->addr, buf + 32);
961 
  bfd_h_put_64 (abfd, section->size, buf + 40);
962 
  bfd_h_put_32 (abfd, section->offset, buf + 48);
963 
  bfd_h_put_32 (abfd, section->align, buf + 52);
964 
  bfd_h_put_32 (abfd, section->reloff, buf + 56);
965 
  bfd_h_put_32 (abfd, section->nreloc, buf + 60);
966 
  bfd_h_put_32 (abfd, section->flags, buf + 64);
967 
  bfd_h_put_32 (abfd, section->reserved1, buf + 68);
968 
  bfd_h_put_32 (abfd, section->reserved2, buf + 72);
969 
  bfd_h_put_32 (abfd, section->reserved3, buf + 76);
970 
 
971 
  if (bfd_bwrite ((void *) buf, BFD_MACH_O_SECTION_64_SIZE, abfd)
972 
      != BFD_MACH_O_SECTION_64_SIZE)
973 
    return -1;
974 
 
975 
  return 0;
976 
}
977 
 
978 
static int
979 
bfd_mach_o_write_segment_32 (bfd *abfd, bfd_mach_o_load_command *command)
980 
{
981 
  unsigned char buf[BFD_MACH_O_LC_SEGMENT_SIZE];
982 
  bfd_mach_o_segment_command *seg = &command->command.segment;
983 
  unsigned long i;
984 
 
985 
  BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT);
986 
 
987 
  for (i = 0; i < seg->nsects; i++)
988 
    if (!bfd_mach_o_write_relocs (abfd, &seg->sections[i]))
989 
      return -1;
990 
 
991 
  memcpy (buf, seg->segname, 16);
992 
  bfd_h_put_32 (abfd, seg->vmaddr, buf + 16);
993 
  bfd_h_put_32 (abfd, seg->vmsize, buf + 20);
994 
  bfd_h_put_32 (abfd, seg->fileoff, buf + 24);
995 
  bfd_h_put_32 (abfd, seg->filesize, buf + 28);
996 
  bfd_h_put_32 (abfd, seg->maxprot, buf + 32);
997 
  bfd_h_put_32 (abfd, seg->initprot, buf + 36);
998 
  bfd_h_put_32 (abfd, seg->nsects, buf + 40);
999 
  bfd_h_put_32 (abfd, seg->flags, buf + 44);
1000 
 
1001 
  if (bfd_seek (abfd, command->offset + 8, SEEK_SET) != 0
1002 
      || (bfd_bwrite ((void *) buf, BFD_MACH_O_LC_SEGMENT_SIZE - 8, abfd)
1003 
          != BFD_MACH_O_LC_SEGMENT_SIZE - 8))
1004 
    return -1;
1005 
 
1006 
  for (i = 0; i < seg->nsects; i++)
1007 
    if (bfd_mach_o_write_section_32 (abfd, &seg->sections[i]))
1008 
      return -1;
1009 
 
1010 
  return 0;
1011 
}
1012 
 
1013 
static int
1014 
bfd_mach_o_write_segment_64 (bfd *abfd, bfd_mach_o_load_command *command)
1015 
{
1016 
  unsigned char buf[BFD_MACH_O_LC_SEGMENT_64_SIZE];
1017 
  bfd_mach_o_segment_command *seg = &command->command.segment;
1018 
  unsigned long i;
1019 
 
1020 
  BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT_64);
1021 
 
1022 
  for (i = 0; i < seg->nsects; i++)
1023 
    if (!bfd_mach_o_write_relocs (abfd, &seg->sections[i]))
1024 
      return -1;
1025 
 
1026 
  memcpy (buf, seg->segname, 16);
1027 
  bfd_h_put_64 (abfd, seg->vmaddr, buf + 16);
1028 
  bfd_h_put_64 (abfd, seg->vmsize, buf + 24);
1029 
  bfd_h_put_64 (abfd, seg->fileoff, buf + 32);
1030 
  bfd_h_put_64 (abfd, seg->filesize, buf + 40);
1031 
  bfd_h_put_32 (abfd, seg->maxprot, buf + 48);
1032 
  bfd_h_put_32 (abfd, seg->initprot, buf + 52);
1033 
  bfd_h_put_32 (abfd, seg->nsects, buf + 56);
1034 
  bfd_h_put_32 (abfd, seg->flags, buf + 60);
1035 
 
1036 
  if (bfd_seek (abfd, command->offset + 8, SEEK_SET) != 0
1037 
      || (bfd_bwrite ((void *) buf, BFD_MACH_O_LC_SEGMENT_64_SIZE - 8, abfd)
1038 
          != BFD_MACH_O_LC_SEGMENT_64_SIZE - 8))
1039 
    return -1;
1040 
 
1041 
  for (i = 0; i < seg->nsects; i++)
1042 
    if (bfd_mach_o_write_section_64 (abfd, &seg->sections[i]))
1043 
      return -1;
1044 
 
1045 
  return 0;
1046 
}
1047 
 
1048 
static bfd_boolean
1049 
bfd_mach_o_write_symtab (bfd *abfd, bfd_mach_o_load_command *command)
1050 
{
1051 
  bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
1052 
  bfd_mach_o_symtab_command *sym = &command->command.symtab;
1053 
  unsigned char buf[16];
1054 
  unsigned long i;
1055 
  unsigned int wide = bfd_mach_o_wide_p (abfd);
1056 
  unsigned int symlen = wide ? BFD_MACH_O_NLIST_64_SIZE : BFD_MACH_O_NLIST_SIZE;
1057 
  struct bfd_strtab_hash *strtab;
1058 
  asymbol **symbols = bfd_get_outsymbols (abfd);
1059 
 
1060 
  BFD_ASSERT (command->type == BFD_MACH_O_LC_SYMTAB);
1061 
 
1062 
  /* Write the symbols first.  */
1063 
  mdata->filelen = FILE_ALIGN(mdata->filelen, wide ? 3 : 2);
1064 
  sym->symoff = mdata->filelen;
1065 
  if (bfd_seek (abfd, sym->symoff, SEEK_SET) != 0)
1066 
    return FALSE;
1067 
 
1068 
  sym->nsyms = bfd_get_symcount (abfd);
1069 
  mdata->filelen += sym->nsyms * symlen;
1070 
 
1071 
  strtab = _bfd_stringtab_init ();
1072 
  if (strtab == NULL)
1073 
    return FALSE;
1074 
 
1075 
  for (i = 0; i < sym->nsyms; i++)
1076 
    {
1077 
      bfd_size_type str_index;
1078 
      bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *)symbols[i];
1079 
 
1080 
      /* Compute name index.  */
1081 
      /* An index of 0 always means the empty string.  */
1082 
      if (s->symbol.name == 0 || s->symbol.name[0] == '\0')
1083 
        str_index = 0;
1084 
      else
1085 
        {
1086 
          str_index = _bfd_stringtab_add (strtab, s->symbol.name, TRUE, FALSE);
1087 
          if (str_index == (bfd_size_type) -1)
1088 
            goto err;
1089 
        }
1090 
      bfd_h_put_32 (abfd, str_index, buf);
1091 
      bfd_h_put_8 (abfd, s->n_type, buf + 4);
1092 
      bfd_h_put_8 (abfd, s->n_sect, buf + 5);
1093 
      bfd_h_put_16 (abfd, s->n_desc, buf + 6);
1094 
      if (wide)
1095 
        bfd_h_put_64 (abfd, s->symbol.section->vma + s->symbol.value, buf + 8);
1096 
      else
1097 
        bfd_h_put_32 (abfd, s->symbol.section->vma + s->symbol.value, buf + 8);
1098 
 
1099 
      if (bfd_bwrite ((void *) buf, symlen, abfd) != symlen)
1100 
        goto err;
1101 
    }
1102 
  sym->strsize = _bfd_stringtab_size (strtab);
1103 
  sym->stroff = mdata->filelen;
1104 
  mdata->filelen += sym->strsize;
1105 
 
1106 
  if (_bfd_stringtab_emit (abfd, strtab) != TRUE)
1107 
    goto err;
1108 
  _bfd_stringtab_free (strtab);
1109 
 
1110 
  /* The command.  */
1111 
  bfd_h_put_32 (abfd, sym->symoff, buf);
1112 
  bfd_h_put_32 (abfd, sym->nsyms, buf + 4);
1113 
  bfd_h_put_32 (abfd, sym->stroff, buf + 8);
1114 
  bfd_h_put_32 (abfd, sym->strsize, buf + 12);
1115 
 
1116 
  if (bfd_seek (abfd, command->offset + 8, SEEK_SET) != 0
1117 
      || bfd_bwrite ((void *) buf, 16, abfd) != 16)
1118 
    return FALSE;
1119 
 
1120 
  return TRUE;
1121 
 
1122 
 err:
1123 
  _bfd_stringtab_free (strtab);
1124 
  return FALSE;
1125 
}
1126 
 
1127 
/* Process the symbols and generate Mach-O specific fields.
1128 
   Number them.  */
1129 
 
1130 
static bfd_boolean
1131 
bfd_mach_o_mangle_symbols (bfd *abfd)
1132 
{
1133 
  unsigned long i;
1134 
  asymbol **symbols = bfd_get_outsymbols (abfd);
1135 
 
1136 
  for (i = 0; i < bfd_get_symcount (abfd); i++)
1137 
    {
1138 
      bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *)symbols[i];
1139 
 
1140 
      if (s->n_type == BFD_MACH_O_N_UNDF && !(s->symbol.flags & BSF_DEBUGGING))
1141 
        {
1142 
          /* As genuine Mach-O symbols type shouldn't be N_UNDF (undefined
1143 
             symbols should be N_UNDEF | N_EXT), we suppose the back-end
1144 
             values haven't been set.  */
1145 
          if (s->symbol.section == bfd_abs_section_ptr)
1146 
            s->n_type = BFD_MACH_O_N_ABS;
1147 
          else if (s->symbol.section == bfd_und_section_ptr)
1148 
            {
1149 
              s->n_type = BFD_MACH_O_N_UNDF;
1150 
              if (s->symbol.flags & BSF_WEAK)
1151 
                s->n_desc |= BFD_MACH_O_N_WEAK_REF;
1152 
            }
1153 
          else if (s->symbol.section == bfd_com_section_ptr)
1154 
            s->n_type = BFD_MACH_O_N_UNDF | BFD_MACH_O_N_EXT;
1155 
          else
1156 
            s->n_type = BFD_MACH_O_N_SECT;
1157 
 
1158 
          if (s->symbol.flags & BSF_GLOBAL)
1159 
            s->n_type |= BFD_MACH_O_N_EXT;
1160 
        }
1161 
 
1162 
      /* Compute section index.  */
1163 
      if (s->symbol.section != bfd_abs_section_ptr
1164 
          && s->symbol.section != bfd_und_section_ptr
1165 
          && s->symbol.section != bfd_com_section_ptr)
1166 
        s->n_sect = s->symbol.section->target_index;
1167 
 
1168 
      /* Number symbols.  */
1169 
      s->symbol.udata.i = i;
1170 
    }
1171 
  return TRUE;
1172 
}
1173 
 
1174 
bfd_boolean
1175 
bfd_mach_o_write_contents (bfd *abfd)
1176 
{
1177 
  unsigned int i;
1178 
  bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
1179 
 
1180 
  if (mdata->header.ncmds == 0)
1181 
    if (!bfd_mach_o_build_commands (abfd))
1182 
      return FALSE;
1183 
 
1184 
  /* Now write header information.  */
1185 
  if (mdata->header.filetype == 0)
1186 
    {
1187 
      if (abfd->flags & EXEC_P)
1188 
        mdata->header.filetype = BFD_MACH_O_MH_EXECUTE;
1189 
      else if (abfd->flags & DYNAMIC)
1190 
        mdata->header.filetype = BFD_MACH_O_MH_DYLIB;
1191 
      else
1192 
        mdata->header.filetype = BFD_MACH_O_MH_OBJECT;
1193 
    }
1194 
  if (!bfd_mach_o_write_header (abfd, &mdata->header))
1195 
    return FALSE;
1196 
 
1197 
  /* Assign a number to each symbols.  */
1198 
  if (!bfd_mach_o_mangle_symbols (abfd))
1199 
    return FALSE;
1200 
 
1201 
  for (i = 0; i < mdata->header.ncmds; i++)
1202 
    {
1203 
      unsigned char buf[8];
1204 
      bfd_mach_o_load_command *cur = &mdata->commands[i];
1205 
      unsigned long typeflag;
1206 
 
1207 
      typeflag = cur->type | (cur->type_required ? BFD_MACH_O_LC_REQ_DYLD : 0);
1208 
 
1209 
      bfd_h_put_32 (abfd, typeflag, buf);
1210 
      bfd_h_put_32 (abfd, cur->len, buf + 4);
1211 
 
1212 
      if (bfd_seek (abfd, cur->offset, SEEK_SET) != 0
1213 
          || bfd_bwrite ((void *) buf, 8, abfd) != 8)
1214 
        return FALSE;
1215 
 
1216 
      switch (cur->type)
1217 
        {
1218 
        case BFD_MACH_O_LC_SEGMENT:
1219 
          if (bfd_mach_o_write_segment_32 (abfd, cur) != 0)
1220 
            return FALSE;
1221 
          break;
1222 
        case BFD_MACH_O_LC_SEGMENT_64:
1223 
          if (bfd_mach_o_write_segment_64 (abfd, cur) != 0)
1224 
            return FALSE;
1225 
          break;
1226 
        case BFD_MACH_O_LC_SYMTAB:
1227 
          if (!bfd_mach_o_write_symtab (abfd, cur))
1228 
            return FALSE;
1229 
          break;
1230 
        case BFD_MACH_O_LC_SYMSEG:
1231 
          break;
1232 
        case BFD_MACH_O_LC_THREAD:
1233 
        case BFD_MACH_O_LC_UNIXTHREAD:
1234 
          if (bfd_mach_o_write_thread (abfd, cur) != 0)
1235 
            return FALSE;
1236 
          break;
1237 
        case BFD_MACH_O_LC_LOADFVMLIB:
1238 
        case BFD_MACH_O_LC_IDFVMLIB:
1239 
        case BFD_MACH_O_LC_IDENT:
1240 
        case BFD_MACH_O_LC_FVMFILE:
1241 
        case BFD_MACH_O_LC_PREPAGE:
1242 
        case BFD_MACH_O_LC_DYSYMTAB:
1243 
        case BFD_MACH_O_LC_LOAD_DYLIB:
1244 
        case BFD_MACH_O_LC_LOAD_WEAK_DYLIB:
1245 
        case BFD_MACH_O_LC_ID_DYLIB:
1246 
        case BFD_MACH_O_LC_REEXPORT_DYLIB:
1247 
        case BFD_MACH_O_LC_LOAD_DYLINKER:
1248 
        case BFD_MACH_O_LC_ID_DYLINKER:
1249 
        case BFD_MACH_O_LC_PREBOUND_DYLIB:
1250 
        case BFD_MACH_O_LC_ROUTINES:
1251 
        case BFD_MACH_O_LC_SUB_FRAMEWORK:
1252 
          break;
1253 
        default:
1254 
          fprintf (stderr,
1255 
                   "unable to write unknown load command 0x%lx\n",
1256 
                   (unsigned long) cur->type);
1257 
          return FALSE;
1258 
        }
1259 
    }
1260 
 
1261 
  return TRUE;
1262 
}
1263 
 
1264 
/* Build Mach-O load commands from the sections.  */
1265 
 
1266 
bfd_boolean
1267 
bfd_mach_o_build_commands (bfd *abfd)
1268 
{
1269 
  bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
1270 
  unsigned int wide = mach_o_wide_p (&mdata->header);
1271 
  bfd_mach_o_segment_command *seg;
1272 
  bfd_mach_o_section *sections;
1273 
  asection *sec;
1274 
  bfd_mach_o_load_command *cmd;
1275 
  bfd_mach_o_load_command *symtab_cmd;
1276 
  int target_index;
1277 
 
1278 
  /* Return now if commands are already built.  */
1279 
  if (mdata->header.ncmds)
1280 
    return FALSE;
1281 
 
1282 
  /* Very simple version: 1 command (segment) containing all sections.  */
1283 
  mdata->header.ncmds = 2;
1284 
  mdata->commands = bfd_alloc (abfd, mdata->header.ncmds
1285 
                               * sizeof (bfd_mach_o_load_command));
1286 
  if (mdata->commands == NULL)
1287 
    return FALSE;
1288 
  cmd = &mdata->commands[0];
1289 
  seg = &cmd->command.segment;
1290 
 
1291 
  seg->nsects = bfd_count_sections (abfd);
1292 
  sections = bfd_alloc (abfd, seg->nsects * sizeof (bfd_mach_o_section));
1293 
  if (sections == NULL)
1294 
    return FALSE;
1295 
  seg->sections = sections;
1296 
 
1297 
  /* Set segment command.  */
1298 
  if (wide)
1299 
    {
1300 
      cmd->type = BFD_MACH_O_LC_SEGMENT_64;
1301 
      cmd->offset = BFD_MACH_O_HEADER_64_SIZE;
1302 
      cmd->len = BFD_MACH_O_LC_SEGMENT_64_SIZE
1303 
        + BFD_MACH_O_SECTION_64_SIZE * seg->nsects;
1304 
    }
1305 
  else
1306 
    {
1307 
      cmd->type = BFD_MACH_O_LC_SEGMENT;
1308 
      cmd->offset = BFD_MACH_O_HEADER_SIZE;
1309 
      cmd->len = BFD_MACH_O_LC_SEGMENT_SIZE
1310 
        + BFD_MACH_O_SECTION_SIZE * seg->nsects;
1311 
    }
1312 
  cmd->type_required = FALSE;
1313 
  mdata->header.sizeofcmds = cmd->len;
1314 
  mdata->filelen = cmd->offset + cmd->len;
1315 
 
1316 
  /* Set symtab command.  */
1317 
  symtab_cmd = &mdata->commands[1];
1318 
 
1319 
  symtab_cmd->type = BFD_MACH_O_LC_SYMTAB;
1320 
  symtab_cmd->offset = cmd->offset + cmd->len;
1321 
  symtab_cmd->len = 6 * 4;
1322 
  symtab_cmd->type_required = FALSE;
1323 
 
1324 
  mdata->header.sizeofcmds += symtab_cmd->len;
1325 
  mdata->filelen += symtab_cmd->len;
1326 
 
1327 
  /* Fill segment command.  */
1328 
  memset (seg->segname, 0, sizeof (seg->segname));
1329 
  seg->vmaddr = 0;
1330 
  seg->fileoff = mdata->filelen;
1331 
  seg->filesize = 0;
1332 
  seg->maxprot = BFD_MACH_O_PROT_READ | BFD_MACH_O_PROT_WRITE
1333 
    | BFD_MACH_O_PROT_EXECUTE;
1334 
  seg->initprot = seg->maxprot;
1335 
  seg->flags = 0;
1336 
 
1337 
  /* Create Mach-O sections.  */
1338 
  target_index = 0;
1339 
  for (sec = abfd->sections; sec; sec = sec->next)
1340 
    {
1341 
      sections->bfdsection = sec;
1342 
      bfd_mach_o_convert_section_name_to_mach_o (abfd, sec, sections);
1343 
      sections->addr = bfd_get_section_vma (abfd, sec);
1344 
      sections->size = bfd_get_section_size (sec);
1345 
      sections->align = bfd_get_section_alignment (abfd, sec);
1346 
 
1347 
      if (sections->size != 0)
1348 
        {
1349 
          mdata->filelen = FILE_ALIGN (mdata->filelen, sections->align);
1350 
          sections->offset = mdata->filelen;
1351 
        }
1352 
      else
1353 
        sections->offset = 0;
1354 
      sections->reloff = 0;
1355 
      sections->nreloc = 0;
1356 
      sections->reserved1 = 0;
1357 
      sections->reserved2 = 0;
1358 
      sections->reserved3 = 0;
1359 
 
1360 
      sec->filepos = sections->offset;
1361 
      sec->target_index = ++target_index;
1362 
 
1363 
      mdata->filelen += sections->size;
1364 
      sections++;
1365 
    }
1366 
  seg->filesize = mdata->filelen - seg->fileoff;
1367 
  seg->vmsize = seg->filesize;
1368 
 
1369 
  return TRUE;
1370 
}
1371 
 
1372 
/* Set the contents of a section.  */
1373 
 
1374 
bfd_boolean
1375 
bfd_mach_o_set_section_contents (bfd *abfd,
1376 
                                 asection *section,
1377 
                                 const void * location,
1378 
                                 file_ptr offset,
1379 
                                 bfd_size_type count)
1380 
{
1381 
  file_ptr pos;
1382 
 
1383 
  /* This must be done first, because bfd_set_section_contents is
1384 
     going to set output_has_begun to TRUE.  */
1385 
  if (! abfd->output_has_begun && ! bfd_mach_o_build_commands (abfd))
1386 
    return FALSE;
1387 
 
1388 
  if (count == 0)
1389 
    return TRUE;
1390 
 
1391 
  pos = section->filepos + offset;
1392 
  if (bfd_seek (abfd, pos, SEEK_SET) != 0
1393 
      || bfd_bwrite (location, count, abfd) != count)
1394 
    return FALSE;
1395 
 
1396 
  return TRUE;
1397 
}
1398 
 
1399 
int
1400 
bfd_mach_o_sizeof_headers (bfd *a ATTRIBUTE_UNUSED,
1401 
                           struct bfd_link_info *info ATTRIBUTE_UNUSED)
1402 
{
1403 
  return 0;
1404 
}
1405 
 
1406 
/* Make an empty symbol.  This is required only because
1407 
   bfd_make_section_anyway wants to create a symbol for the section.  */
1408 
 
1409 
asymbol *
1410 
bfd_mach_o_make_empty_symbol (bfd *abfd)
1411 
{
1412 
  asymbol *new_symbol;
1413 
 
1414 
  new_symbol = bfd_zalloc (abfd, sizeof (bfd_mach_o_asymbol));
1415 
  if (new_symbol == NULL)
1416 
    return new_symbol;
1417 
  new_symbol->the_bfd = abfd;
1418 
  new_symbol->udata.i = 0;
1419 
  return new_symbol;
1420 
}
1421 
 
1422 
static bfd_boolean
1423 
bfd_mach_o_read_header (bfd *abfd, bfd_mach_o_header *header)
1424 
{
1425 
  unsigned char buf[32];
1426 
  unsigned int size;
1427 
  bfd_vma (*get32) (const void *) = NULL;
1428 
 
1429 
  /* Just read the magic number.  */
1430 
  if (bfd_seek (abfd, 0, SEEK_SET) != 0
1431 
      || bfd_bread ((void *) buf, 4, abfd) != 4)
1432 
    return FALSE;
1433 
 
1434 
  if (bfd_getb32 (buf) == BFD_MACH_O_MH_MAGIC)
1435 
    {
1436 
      header->byteorder = BFD_ENDIAN_BIG;
1437 
      header->magic = BFD_MACH_O_MH_MAGIC;
1438 
      header->version = 1;
1439 
      get32 = bfd_getb32;
1440 
    }
1441 
  else if (bfd_getl32 (buf) == BFD_MACH_O_MH_MAGIC)
1442 
    {
1443 
      header->byteorder = BFD_ENDIAN_LITTLE;
1444 
      header->magic = BFD_MACH_O_MH_MAGIC;
1445 
      header->version = 1;
1446 
      get32 = bfd_getl32;
1447 
    }
1448 
  else if (bfd_getb32 (buf) == BFD_MACH_O_MH_MAGIC_64)
1449 
    {
1450 
      header->byteorder = BFD_ENDIAN_BIG;
1451 
      header->magic = BFD_MACH_O_MH_MAGIC_64;
1452 
      header->version = 2;
1453 
      get32 = bfd_getb32;
1454 
    }
1455 
  else if (bfd_getl32 (buf) == BFD_MACH_O_MH_MAGIC_64)
1456 
    {
1457 
      header->byteorder = BFD_ENDIAN_LITTLE;
1458 
      header->magic = BFD_MACH_O_MH_MAGIC_64;
1459 
      header->version = 2;
1460 
      get32 = bfd_getl32;
1461 
    }
1462 
  else
1463 
    {
1464 
      header->byteorder = BFD_ENDIAN_UNKNOWN;
1465 
      return FALSE;
1466 
    }
1467 
 
1468 
  /* Once the size of the header is known, read the full header.  */
1469 
  size = mach_o_wide_p (header) ?
1470 
    BFD_MACH_O_HEADER_64_SIZE : BFD_MACH_O_HEADER_SIZE;
1471 
 
1472 
  if (bfd_seek (abfd, 0, SEEK_SET) != 0
1473 
      || bfd_bread ((void *) buf, size, abfd) != size)
1474 
    return FALSE;
1475 
 
1476 
  header->cputype = (*get32) (buf + 4);
1477 
  header->cpusubtype = (*get32) (buf + 8);
1478 
  header->filetype = (*get32) (buf + 12);
1479 
  header->ncmds = (*get32) (buf + 16);
1480 
  header->sizeofcmds = (*get32) (buf + 20);
1481 
  header->flags = (*get32) (buf + 24);
1482 
 
1483 
  if (mach_o_wide_p (header))
1484 
    header->reserved = (*get32) (buf + 28);
1485 
 
1486 
  return TRUE;
1487 
}
1488 
 
1489 
static asection *
1490 
bfd_mach_o_make_bfd_section (bfd *abfd, bfd_mach_o_section *section,
1491 
                             unsigned long prot)
1492 
{
1493 
  asection *bfdsec;
1494 
  char *sname;
1495 
  flagword flags;
1496 
 
1497 
  bfd_mach_o_convert_section_name_to_bfd (abfd, section, &sname, &flags);
1498 
  if (sname == NULL)
1499 
    return NULL;
1500 
 
1501 
  if (flags == SEC_NO_FLAGS)
1502 
    {
1503 
      /* Try to guess flags.  */
1504 
      if (section->flags & BFD_MACH_O_S_ATTR_DEBUG)
1505 
        flags = SEC_DEBUGGING;
1506 
      else
1507 
        {
1508 
          flags = SEC_ALLOC;
1509 
          if ((section->flags & BFD_MACH_O_SECTION_TYPE_MASK)
1510 
              != BFD_MACH_O_S_ZEROFILL)
1511 
            {
1512 
              flags |= SEC_LOAD;
1513 
              if (prot & BFD_MACH_O_PROT_EXECUTE)
1514 
                flags |= SEC_CODE;
1515 
              if (prot & BFD_MACH_O_PROT_WRITE)
1516 
                flags |= SEC_DATA;
1517 
              else if (prot & BFD_MACH_O_PROT_READ)
1518 
                flags |= SEC_READONLY;
1519 
            }
1520 
        }
1521 
    }
1522 
  else
1523 
    {
1524 
      if ((flags & SEC_DEBUGGING) == 0)
1525 
        flags |= SEC_ALLOC;
1526 
    }
1527 
 
1528 
  if (section->offset != 0)
1529 
    flags |= SEC_HAS_CONTENTS;
1530 
  if (section->nreloc != 0)
1531 
    flags |= SEC_RELOC;
1532 
 
1533 
  bfdsec = bfd_make_section_anyway_with_flags (abfd, sname, flags);
1534 
  if (bfdsec == NULL)
1535 
    return NULL;
1536 
 
1537 
  bfdsec->vma = section->addr;
1538 
  bfdsec->lma = section->addr;
1539 
  bfdsec->size = section->size;
1540 
  bfdsec->filepos = section->offset;
1541 
  bfdsec->alignment_power = section->align;
1542 
  bfdsec->segment_mark = 0;
1543 
  bfdsec->reloc_count = section->nreloc;
1544 
  bfdsec->rel_filepos = section->reloff;
1545 
 
1546 
  return bfdsec;
1547 
}
1548 
 
1549 
static int
1550 
bfd_mach_o_read_section_32 (bfd *abfd,
1551 
                            bfd_mach_o_section *section,
1552 
                            unsigned int offset,
1553 
                            unsigned long prot)
1554 
{
1555 
  unsigned char buf[BFD_MACH_O_SECTION_SIZE];
1556 
 
1557 
  if (bfd_seek (abfd, offset, SEEK_SET) != 0
1558 
      || (bfd_bread ((void *) buf, BFD_MACH_O_SECTION_SIZE, abfd)
1559 
          != BFD_MACH_O_SECTION_SIZE))
1560 
    return -1;
1561 
 
1562 
  memcpy (section->sectname, buf, 16);
1563 
  section->sectname[16] = '\0';
1564 
  memcpy (section->segname, buf + 16, 16);
1565 
  section->segname[16] = '\0';
1566 
  section->addr = bfd_h_get_32 (abfd, buf + 32);
1567 
  section->size = bfd_h_get_32 (abfd, buf + 36);
1568 
  section->offset = bfd_h_get_32 (abfd, buf + 40);
1569 
  section->align = bfd_h_get_32 (abfd, buf + 44);
1570 
  section->reloff = bfd_h_get_32 (abfd, buf + 48);
1571 
  section->nreloc = bfd_h_get_32 (abfd, buf + 52);
1572 
  section->flags = bfd_h_get_32 (abfd, buf + 56);
1573 
  section->reserved1 = bfd_h_get_32 (abfd, buf + 60);
1574 
  section->reserved2 = bfd_h_get_32 (abfd, buf + 64);
1575 
  section->reserved3 = 0;
1576 
  section->bfdsection = bfd_mach_o_make_bfd_section (abfd, section, prot);
1577 
 
1578 
  if (section->bfdsection == NULL)
1579 
    return -1;
1580 
 
1581 
  return 0;
1582 
}
1583 
 
1584 
static int
1585 
bfd_mach_o_read_section_64 (bfd *abfd,
1586 
                            bfd_mach_o_section *section,
1587 
                            unsigned int offset,
1588 
                            unsigned long prot)
1589 
{
1590 
  unsigned char buf[BFD_MACH_O_SECTION_64_SIZE];
1591 
 
1592 
  if (bfd_seek (abfd, offset, SEEK_SET) != 0
1593 
      || (bfd_bread ((void *) buf, BFD_MACH_O_SECTION_64_SIZE, abfd)
1594 
          != BFD_MACH_O_SECTION_64_SIZE))
1595 
    return -1;
1596 
 
1597 
  memcpy (section->sectname, buf, 16);
1598 
  section->sectname[16] = '\0';
1599 
  memcpy (section->segname, buf + 16, 16);
1600 
  section->segname[16] = '\0';
1601 
  section->addr = bfd_h_get_64 (abfd, buf + 32);
1602 
  section->size = bfd_h_get_64 (abfd, buf + 40);
1603 
  section->offset = bfd_h_get_32 (abfd, buf + 48);
1604 
  section->align = bfd_h_get_32 (abfd, buf + 52);
1605 
  section->reloff = bfd_h_get_32 (abfd, buf + 56);
1606 
  section->nreloc = bfd_h_get_32 (abfd, buf + 60);
1607 
  section->flags = bfd_h_get_32 (abfd, buf + 64);
1608 
  section->reserved1 = bfd_h_get_32 (abfd, buf + 68);
1609 
  section->reserved2 = bfd_h_get_32 (abfd, buf + 72);
1610 
  section->reserved3 = bfd_h_get_32 (abfd, buf + 76);
1611 
  section->bfdsection = bfd_mach_o_make_bfd_section (abfd, section, prot);
1612 
 
1613 
  if (section->bfdsection == NULL)
1614 
    return -1;
1615 
 
1616 
  return 0;
1617 
}
1618 
 
1619 
static int
1620 
bfd_mach_o_read_section (bfd *abfd,
1621 
                         bfd_mach_o_section *section,
1622 
                         unsigned int offset,
1623 
                         unsigned long prot,
1624 
                         unsigned int wide)
1625 
{
1626 
  if (wide)
1627 
    return bfd_mach_o_read_section_64 (abfd, section, offset, prot);
1628 
  else
1629 
    return bfd_mach_o_read_section_32 (abfd, section, offset, prot);
1630 
}
1631 
 
1632 
static int
1633 
bfd_mach_o_read_symtab_symbol (bfd *abfd,
1634 
                               bfd_mach_o_symtab_command *sym,
1635 
                               bfd_mach_o_asymbol *s,
1636 
                               unsigned long i)
1637 
{
1638 
  bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
1639 
  unsigned int wide = mach_o_wide_p (&mdata->header);
1640 
  unsigned int symwidth =
1641 
    wide ? BFD_MACH_O_NLIST_64_SIZE : BFD_MACH_O_NLIST_SIZE;
1642 
  unsigned int symoff = sym->symoff + (i * symwidth);
1643 
  unsigned char buf[16];
1644 
  unsigned char type = -1;
1645 
  unsigned char section = -1;
1646 
  short desc = -1;
1647 
  symvalue value = -1;
1648 
  unsigned long stroff = -1;
1649 
  unsigned int symtype = -1;
1650 
 
1651 
  BFD_ASSERT (sym->strtab != NULL);
1652 
 
1653 
  if (bfd_seek (abfd, symoff, SEEK_SET) != 0
1654 
      || bfd_bread ((void *) buf, symwidth, abfd) != symwidth)
1655 
    {
1656 
      fprintf (stderr, "bfd_mach_o_read_symtab_symbol: unable to read %d bytes at %lu\n",
1657 
               symwidth, (unsigned long) symoff);
1658 
      return -1;
1659 
    }
1660 
 
1661 
  stroff = bfd_h_get_32 (abfd, buf);
1662 
  type = bfd_h_get_8 (abfd, buf + 4);
1663 
  symtype = type & BFD_MACH_O_N_TYPE;
1664 
  section = bfd_h_get_8 (abfd, buf + 5);
1665 
  desc = bfd_h_get_16 (abfd, buf + 6);
1666 
  if (wide)
1667 
    value = bfd_h_get_64 (abfd, buf + 8);
1668 
  else
1669 
    value = bfd_h_get_32 (abfd, buf + 8);
1670 
 
1671 
  if (stroff >= sym->strsize)
1672 
    {
1673 
      fprintf (stderr, "bfd_mach_o_read_symtab_symbol: symbol name out of range (%lu >= %lu)\n",
1674 
               (unsigned long) stroff, (unsigned long) sym->strsize);
1675 
      return -1;
1676 
    }
1677 
 
1678 
  s->symbol.the_bfd = abfd;
1679 
  s->symbol.name = sym->strtab + stroff;
1680 
  s->symbol.value = value;
1681 
  s->symbol.flags = 0x0;
1682 
  s->symbol.udata.i = 0;
1683 
  s->n_type = type;
1684 
  s->n_sect = section;
1685 
  s->n_desc = desc;
1686 
 
1687 
  if (type & BFD_MACH_O_N_STAB)
1688 
    {
1689 
      s->symbol.flags |= BSF_DEBUGGING;
1690 
      s->symbol.section = bfd_und_section_ptr;
1691 
      switch (type)
1692 
        {
1693 
        case N_FUN:
1694 
        case N_STSYM:
1695 
        case N_LCSYM:
1696 
        case N_BNSYM:
1697 
        case N_SLINE:
1698 
        case N_ENSYM:
1699 
        case N_ECOMM:
1700 
        case N_ECOML:
1701 
        case N_GSYM:
1702 
          if ((section > 0) && (section <= mdata->nsects))
1703 
            {
1704 
              s->symbol.section = mdata->sections[section - 1]->bfdsection;
1705 
              s->symbol.value =
1706 
                s->symbol.value - mdata->sections[section - 1]->addr;
1707 
            }
1708 
          break;
1709 
        }
1710 
    }
1711 
  else
1712 
    {
1713 
      if (type & BFD_MACH_O_N_PEXT)
1714 
        s->symbol.flags |= BSF_GLOBAL;
1715 
 
1716 
      if (type & BFD_MACH_O_N_EXT)
1717 
        s->symbol.flags |= BSF_GLOBAL;
1718 
 
1719 
      if (!(type & (BFD_MACH_O_N_PEXT | BFD_MACH_O_N_EXT)))
1720 
        s->symbol.flags |= BSF_LOCAL;
1721 
 
1722 
      switch (symtype)
1723 
        {
1724 
        case BFD_MACH_O_N_UNDF:
1725 
          if (type == (BFD_MACH_O_N_UNDF | BFD_MACH_O_N_EXT)
1726 
              && s->symbol.value != 0)
1727 
            {
1728 
              /* A common symbol.  */
1729 
              s->symbol.section = bfd_com_section_ptr;
1730 
              s->symbol.flags = BSF_NO_FLAGS;
1731 
            }
1732 
          else
1733 
            {
1734 
              s->symbol.section = bfd_und_section_ptr;
1735 
              if (s->n_desc & BFD_MACH_O_N_WEAK_REF)
1736 
                s->symbol.flags |= BSF_WEAK;
1737 
            }
1738 
          break;
1739 
        case BFD_MACH_O_N_PBUD:
1740 
          s->symbol.section = bfd_und_section_ptr;
1741 
          break;
1742 
        case BFD_MACH_O_N_ABS:
1743 
          s->symbol.section = bfd_abs_section_ptr;
1744 
          break;
1745 
        case BFD_MACH_O_N_SECT:
1746 
          if ((section > 0) && (section <= mdata->nsects))
1747 
            {
1748 
              s->symbol.section = mdata->sections[section - 1]->bfdsection;
1749 
              s->symbol.value =
1750 
                s->symbol.value - mdata->sections[section - 1]->addr;
1751 
            }
1752 
          else
1753 
            {
1754 
              /* Mach-O uses 0 to mean "no section"; not an error.  */
1755 
              if (section != 0)
1756 
                {
1757 
                  fprintf (stderr, "bfd_mach_o_read_symtab_symbol: "
1758 
                           "symbol \"%s\" specified invalid section %d (max %lu): setting to undefined\n",
1759 
                           s->symbol.name, section, mdata->nsects);
1760 
                }
1761 
              s->symbol.section = bfd_und_section_ptr;
1762 
            }
1763 
          break;
1764 
        case BFD_MACH_O_N_INDR:
1765 
          fprintf (stderr, "bfd_mach_o_read_symtab_symbol: "
1766 
                   "symbol \"%s\" is unsupported 'indirect' reference: setting to undefined\n",
1767 
                   s->symbol.name);
1768 
          s->symbol.section = bfd_und_section_ptr;
1769 
          break;
1770 
        default:
1771 
          fprintf (stderr, "bfd_mach_o_read_symtab_symbol: "
1772 
                   "symbol \"%s\" specified invalid type field 0x%x: setting to undefined\n",
1773 
                   s->symbol.name, symtype);
1774 
          s->symbol.section = bfd_und_section_ptr;
1775 
          break;
1776 
        }
1777 
    }
1778 
 
1779 
  return 0;
1780 
}
1781 
 
1782 
static int
1783 
bfd_mach_o_read_symtab_strtab (bfd *abfd)
1784 
{
1785 
  bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
1786 
  bfd_mach_o_symtab_command *sym = mdata->symtab;
1787 
 
1788 
  /* Fail if there is no symtab.  */
1789 
  if (sym == NULL)
1790 
    return -1;
1791 
 
1792 
  /* Success if already loaded.  */
1793 
  if (sym->strtab)
1794 
    return 0;
1795 
 
1796 
  if (abfd->flags & BFD_IN_MEMORY)
1797 
    {
1798 
      struct bfd_in_memory *b;
1799 
 
1800 
      b = (struct bfd_in_memory *) abfd->iostream;
1801 
 
1802 
      if ((sym->stroff + sym->strsize) > b->size)
1803 
        {
1804 
          bfd_set_error (bfd_error_file_truncated);
1805 
          return -1;
1806 
        }
1807 
      sym->strtab = (char *) b->buffer + sym->stroff;
1808 
    }
1809 
  else
1810 
    {
1811 
      sym->strtab = bfd_alloc (abfd, sym->strsize);
1812 
      if (sym->strtab == NULL)
1813 
        return -1;
1814 
 
1815 
      if (bfd_seek (abfd, sym->stroff, SEEK_SET) != 0
1816 
          || bfd_bread ((void *) sym->strtab, sym->strsize, abfd) != sym->strsize)
1817 
        {
1818 
          bfd_set_error (bfd_error_file_truncated);
1819 
          return -1;
1820 
        }
1821 
    }
1822 
 
1823 
  return 0;
1824 
}
1825 
 
1826 
static int
1827 
bfd_mach_o_read_symtab_symbols (bfd *abfd)
1828 
{
1829 
  bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
1830 
  bfd_mach_o_symtab_command *sym = mdata->symtab;
1831 
  unsigned long i;
1832 
  int ret;
1833 
 
1834 
  if (sym->symbols)
1835 
    return 0;
1836 
 
1837 
  sym->symbols = bfd_alloc (abfd, sym->nsyms * sizeof (bfd_mach_o_asymbol));
1838 
 
1839 
  if (sym->symbols == NULL)
1840 
    {
1841 
      fprintf (stderr, "bfd_mach_o_read_symtab_symbols: unable to allocate memory for symbols\n");
1842 
      return -1;
1843 
    }
1844 
 
1845 
  ret = bfd_mach_o_read_symtab_strtab (abfd);
1846 
  if (ret != 0)
1847 
    return ret;
1848 
 
1849 
  for (i = 0; i < sym->nsyms; i++)
1850 
    {
1851 
      ret = bfd_mach_o_read_symtab_symbol (abfd, sym, &sym->symbols[i], i);
1852 
      if (ret != 0)
1853 
        return ret;
1854 
    }
1855 
 
1856 
  return 0;
1857 
}
1858 
 
1859 
int
1860 
bfd_mach_o_read_dysymtab_symbol (bfd *abfd,
1861 
                                 bfd_mach_o_dysymtab_command *dysym,
1862 
                                 bfd_mach_o_symtab_command *sym,
1863 
                                 bfd_mach_o_asymbol *s,
1864 
                                 unsigned long i)
1865 
{
1866 
  unsigned long isymoff = dysym->indirectsymoff + (i * 4);
1867 
  unsigned long sym_index;
1868 
  unsigned char buf[4];
1869 
 
1870 
  BFD_ASSERT (i < dysym->nindirectsyms);
1871 
 
1872 
  if (bfd_seek (abfd, isymoff, SEEK_SET) != 0
1873 
      || bfd_bread ((void *) buf, 4, abfd) != 4)
1874 
    {
1875 
      fprintf (stderr, "bfd_mach_o_read_dysymtab_symbol: unable to read %lu bytes at %lu\n",
1876 
               (unsigned long) 4, isymoff);
1877 
      return -1;
1878 
    }
1879 
  sym_index = bfd_h_get_32 (abfd, buf);
1880 
 
1881 
  return bfd_mach_o_read_symtab_symbol (abfd, sym, s, sym_index);
1882 
}
1883 
 
1884 
static const char *
1885 
bfd_mach_o_i386_flavour_string (unsigned int flavour)
1886 
{
1887 
  switch ((int) flavour)
1888 
    {
1889 
    case BFD_MACH_O_x86_THREAD_STATE32:    return "x86_THREAD_STATE32";
1890 
    case BFD_MACH_O_x86_FLOAT_STATE32:     return "x86_FLOAT_STATE32";
1891 
    case BFD_MACH_O_x86_EXCEPTION_STATE32: return "x86_EXCEPTION_STATE32";
1892 
    case BFD_MACH_O_x86_THREAD_STATE64:    return "x86_THREAD_STATE64";
1893 
    case BFD_MACH_O_x86_FLOAT_STATE64:     return "x86_FLOAT_STATE64";
1894 
    case BFD_MACH_O_x86_EXCEPTION_STATE64: return "x86_EXCEPTION_STATE64";
1895 
    case BFD_MACH_O_x86_THREAD_STATE:      return "x86_THREAD_STATE";
1896 
    case BFD_MACH_O_x86_FLOAT_STATE:       return "x86_FLOAT_STATE";
1897 
    case BFD_MACH_O_x86_EXCEPTION_STATE:   return "x86_EXCEPTION_STATE";
1898 
    case BFD_MACH_O_x86_DEBUG_STATE32:     return "x86_DEBUG_STATE32";
1899 
    case BFD_MACH_O_x86_DEBUG_STATE64:     return "x86_DEBUG_STATE64";
1900 
    case BFD_MACH_O_x86_DEBUG_STATE:       return "x86_DEBUG_STATE";
1901 
    case BFD_MACH_O_x86_THREAD_STATE_NONE: return "x86_THREAD_STATE_NONE";
1902 
    default: return "UNKNOWN";
1903 
    }
1904 
}
1905 
 
1906 
static const char *
1907 
bfd_mach_o_ppc_flavour_string (unsigned int flavour)
1908 
{
1909 
  switch ((int) flavour)
1910 
    {
1911 
    case BFD_MACH_O_PPC_THREAD_STATE:      return "PPC_THREAD_STATE";
1912 
    case BFD_MACH_O_PPC_FLOAT_STATE:       return "PPC_FLOAT_STATE";
1913 
    case BFD_MACH_O_PPC_EXCEPTION_STATE:   return "PPC_EXCEPTION_STATE";
1914 
    case BFD_MACH_O_PPC_VECTOR_STATE:      return "PPC_VECTOR_STATE";
1915 
    case BFD_MACH_O_PPC_THREAD_STATE64:    return "PPC_THREAD_STATE64";
1916 
    case BFD_MACH_O_PPC_EXCEPTION_STATE64: return "PPC_EXCEPTION_STATE64";
1917 
    default: return "UNKNOWN";
1918 
    }
1919 
}
1920 
 
1921 
static int
1922 
bfd_mach_o_read_dylinker (bfd *abfd, bfd_mach_o_load_command *command)
1923 
{
1924 
  bfd_mach_o_dylinker_command *cmd = &command->command.dylinker;
1925 
  unsigned char buf[4];
1926 
  unsigned int nameoff;
1927 
 
1928 
  BFD_ASSERT ((command->type == BFD_MACH_O_LC_ID_DYLINKER)
1929 
              || (command->type == BFD_MACH_O_LC_LOAD_DYLINKER));
1930 
 
1931 
  if (bfd_seek (abfd, command->offset + 8, SEEK_SET) != 0
1932 
      || bfd_bread ((void *) buf, 4, abfd) != 4)
1933 
    return -1;
1934 
 
1935 
  nameoff = bfd_h_get_32 (abfd, buf + 0);
1936 
 
1937 
  cmd->name_offset = command->offset + nameoff;
1938 
  cmd->name_len = command->len - nameoff;
1939 
  cmd->name_str = bfd_alloc (abfd, cmd->name_len);
1940 
  if (cmd->name_str == NULL)
1941 
    return -1;
1942 
  if (bfd_seek (abfd, cmd->name_offset, SEEK_SET) != 0
1943 
      || bfd_bread (cmd->name_str, cmd->name_len, abfd) != cmd->name_len)
1944 
    return -1;
1945 
  return 0;
1946 
}
1947 
 
1948 
static int
1949 
bfd_mach_o_read_dylib (bfd *abfd, bfd_mach_o_load_command *command)
1950 
{
1951 
  bfd_mach_o_dylib_command *cmd = &command->command.dylib;
1952 
  unsigned char buf[16];
1953 
  unsigned int nameoff;
1954 
 
1955 
  switch (command->type)
1956 
    {
1957 
    case BFD_MACH_O_LC_LOAD_DYLIB:
1958 
    case BFD_MACH_O_LC_LOAD_WEAK_DYLIB:
1959 
    case BFD_MACH_O_LC_ID_DYLIB:
1960 
    case BFD_MACH_O_LC_REEXPORT_DYLIB:
1961 
      break;
1962 
    default:
1963 
      BFD_FAIL ();
1964 
      return -1;
1965 
    }
1966 
 
1967 
  if (bfd_seek (abfd, command->offset + 8, SEEK_SET) != 0
1968 
      || bfd_bread ((void *) buf, 16, abfd) != 16)
1969 
    return -1;
1970 
 
1971 
  nameoff = bfd_h_get_32 (abfd, buf + 0);
1972 
  cmd->timestamp = bfd_h_get_32 (abfd, buf + 4);
1973 
  cmd->current_version = bfd_h_get_32 (abfd, buf + 8);
1974 
  cmd->compatibility_version = bfd_h_get_32 (abfd, buf + 12);
1975 
 
1976 
  cmd->name_offset = command->offset + nameoff;
1977 
  cmd->name_len = command->len - nameoff;
1978 
  cmd->name_str = bfd_alloc (abfd, cmd->name_len);
1979 
  if (cmd->name_str == NULL)
1980 
    return -1;
1981 
  if (bfd_seek (abfd, cmd->name_offset, SEEK_SET) != 0
1982 
      || bfd_bread (cmd->name_str, cmd->name_len, abfd) != cmd->name_len)
1983 
    return -1;
1984 
  return 0;
1985 
}
1986 
 
1987 
static int
1988 
bfd_mach_o_read_prebound_dylib (bfd *abfd ATTRIBUTE_UNUSED,
1989 
                                bfd_mach_o_load_command *command ATTRIBUTE_UNUSED)
1990 
{
1991 
  /* bfd_mach_o_prebound_dylib_command *cmd = &command->command.prebound_dylib; */
1992 
 
1993 
  BFD_ASSERT (command->type == BFD_MACH_O_LC_PREBOUND_DYLIB);
1994 
  return 0;
1995 
}
1996 
 
1997 
static int
1998 
bfd_mach_o_read_thread (bfd *abfd, bfd_mach_o_load_command *command)
1999 
{
2000 
  bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
2001 
  bfd_mach_o_thread_command *cmd = &command->command.thread;
2002 
  unsigned char buf[8];
2003 
  unsigned int offset;
2004 
  unsigned int nflavours;
2005 
  unsigned int i;
2006 
 
2007 
  BFD_ASSERT ((command->type == BFD_MACH_O_LC_THREAD)
2008 
              || (command->type == BFD_MACH_O_LC_UNIXTHREAD));
2009 
 
2010 
  /* Count the number of threads.  */
2011 
  offset = 8;
2012 
  nflavours = 0;
2013 
  while (offset != command->len)
2014 
    {
2015 
      if (offset >= command->len)
2016 
        return -1;
2017 
 
2018 
      if (bfd_seek (abfd, command->offset + offset, SEEK_SET) != 0
2019 
          || bfd_bread ((void *) buf, 8, abfd) != 8)
2020 
        return -1;
2021 
 
2022 
      offset += 8 + bfd_h_get_32 (abfd, buf + 4) * 4;
2023 
      nflavours++;
2024 
    }
2025 
 
2026 
  /* Allocate threads.  */
2027 
  cmd->flavours = bfd_alloc
2028 
    (abfd, nflavours * sizeof (bfd_mach_o_thread_flavour));
2029 
  if (cmd->flavours == NULL)
2030 
    return -1;
2031 
  cmd->nflavours = nflavours;
2032 
 
2033 
  offset = 8;
2034 
  nflavours = 0;
2035 
  while (offset != command->len)
2036 
    {
2037 
      if (offset >= command->len)
2038 
        return -1;
2039 
 
2040 
      if (nflavours >= cmd->nflavours)
2041 
        return -1;
2042 
 
2043 
      if (bfd_seek (abfd, command->offset + offset, SEEK_SET) != 0
2044 
          || bfd_bread ((void *) buf, 8, abfd) != 8)
2045 
        return -1;
2046 
 
2047 
      cmd->flavours[nflavours].flavour = bfd_h_get_32 (abfd, buf);
2048 
      cmd->flavours[nflavours].offset = command->offset + offset + 8;
2049 
      cmd->flavours[nflavours].size = bfd_h_get_32 (abfd, buf + 4) * 4;
2050 
      offset += cmd->flavours[nflavours].size + 8;
2051 
      nflavours++;
2052 
    }
2053 
 
2054 
  for (i = 0; i < nflavours; i++)
2055 
    {
2056 
      asection *bfdsec;
2057 
      unsigned int snamelen;
2058 
      char *sname;
2059 
      const char *flavourstr;
2060 
      const char *prefix = "LC_THREAD";
2061 
      unsigned int j = 0;
2062 
 
2063 
      switch (mdata->header.cputype)
2064 
        {
2065 
        case BFD_MACH_O_CPU_TYPE_POWERPC:
2066 
        case BFD_MACH_O_CPU_TYPE_POWERPC_64:
2067 
          flavourstr = bfd_mach_o_ppc_flavour_string (cmd->flavours[i].flavour);
2068 
          break;
2069 
        case BFD_MACH_O_CPU_TYPE_I386:
2070 
        case BFD_MACH_O_CPU_TYPE_X86_64:
2071 
          flavourstr = bfd_mach_o_i386_flavour_string (cmd->flavours[i].flavour);
2072 
          break;
2073 
        default:
2074 
          flavourstr = "UNKNOWN_ARCHITECTURE";
2075 
          break;
2076 
        }
2077 
 
2078 
      snamelen = strlen (prefix) + 1 + 20 + 1 + strlen (flavourstr) + 1;
2079 
      sname = bfd_alloc (abfd, snamelen);
2080 
      if (sname == NULL)
2081 
        return -1;
2082 
 
2083 
      for (;;)
2084 
        {
2085 
          sprintf (sname, "%s.%s.%u", prefix, flavourstr, j);
2086 
          if (bfd_get_section_by_name (abfd, sname) == NULL)
2087 
            break;
2088 
          j++;
2089 
        }
2090 
 
2091 
      bfdsec = bfd_make_section_with_flags (abfd, sname, SEC_HAS_CONTENTS);
2092 
 
2093 
      bfdsec->vma = 0;
2094 
      bfdsec->lma = 0;
2095 
      bfdsec->size = cmd->flavours[i].size;
2096 
      bfdsec->filepos = cmd->flavours[i].offset;
2097 
      bfdsec->alignment_power = 0x0;
2098 
 
2099 
      cmd->section = bfdsec;
2100 
    }
2101 
 
2102 
  return 0;
2103 
}
2104 
 
2105 
static int
2106 
bfd_mach_o_read_dysymtab (bfd *abfd, bfd_mach_o_load_command *command)
2107 
{
2108 
  bfd_mach_o_dysymtab_command *cmd = &command->command.dysymtab;
2109 
  bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
2110 
  unsigned char buf[72];
2111 
 
2112 
  BFD_ASSERT (command->type == BFD_MACH_O_LC_DYSYMTAB);
2113 
 
2114 
  if (bfd_seek (abfd, command->offset + 8, SEEK_SET) != 0
2115 
      || bfd_bread ((void *) buf, 72, abfd) != 72)
2116 
    return -1;
2117 
 
2118 
  cmd->ilocalsym = bfd_h_get_32 (abfd, buf + 0);
2119 
  cmd->nlocalsym = bfd_h_get_32 (abfd, buf + 4);
2120 
  cmd->iextdefsym = bfd_h_get_32 (abfd, buf + 8);
2121 
  cmd->nextdefsym = bfd_h_get_32 (abfd, buf + 12);
2122 
  cmd->iundefsym = bfd_h_get_32 (abfd, buf + 16);
2123 
  cmd->nundefsym = bfd_h_get_32 (abfd, buf + 20);
2124 
  cmd->tocoff = bfd_h_get_32 (abfd, buf + 24);
2125 
  cmd->ntoc = bfd_h_get_32 (abfd, buf + 28);
2126 
  cmd->modtaboff = bfd_h_get_32 (abfd, buf + 32);
2127 
  cmd->nmodtab = bfd_h_get_32 (abfd, buf + 36);
2128 
  cmd->extrefsymoff = bfd_h_get_32 (abfd, buf + 40);
2129 
  cmd->nextrefsyms = bfd_h_get_32 (abfd, buf + 44);
2130 
  cmd->indirectsymoff = bfd_h_get_32 (abfd, buf + 48);
2131 
  cmd->nindirectsyms = bfd_h_get_32 (abfd, buf + 52);
2132 
  cmd->extreloff = bfd_h_get_32 (abfd, buf + 56);
2133 
  cmd->nextrel = bfd_h_get_32 (abfd, buf + 60);
2134 
  cmd->locreloff = bfd_h_get_32 (abfd, buf + 64);
2135 
  cmd->nlocrel = bfd_h_get_32 (abfd, buf + 68);
2136 
 
2137 
  if (cmd->nmodtab != 0)
2138 
    {
2139 
      unsigned int i;
2140 
      int wide = bfd_mach_o_wide_p (abfd);
2141 
      unsigned int module_len = wide ? 56 : 52;
2142 
 
2143 
      cmd->dylib_module =
2144 
        bfd_alloc (abfd, cmd->nmodtab * sizeof (bfd_mach_o_dylib_module));
2145 
      if (cmd->dylib_module == NULL)
2146 
        return -1;
2147 
 
2148 
      if (bfd_seek (abfd, cmd->modtaboff, SEEK_SET) != 0)
2149 
        return -1;
2150 
 
2151 
      for (i = 0; i < cmd->nmodtab; i++)
2152 
        {
2153 
          bfd_mach_o_dylib_module *module = &cmd->dylib_module[i];
2154 
          unsigned long v;
2155 
 
2156 
          if (bfd_bread ((void *) buf, module_len, abfd) != module_len)
2157 
            return -1;
2158 
 
2159 
          module->module_name_idx = bfd_h_get_32 (abfd, buf + 0);
2160 
          module->iextdefsym = bfd_h_get_32 (abfd, buf + 4);
2161 
          module->nextdefsym = bfd_h_get_32 (abfd, buf + 8);
2162 
          module->irefsym = bfd_h_get_32 (abfd, buf + 12);
2163 
          module->nrefsym = bfd_h_get_32 (abfd, buf + 16);
2164 
          module->ilocalsym = bfd_h_get_32 (abfd, buf + 20);
2165 
          module->nlocalsym = bfd_h_get_32 (abfd, buf + 24);
2166 
          module->iextrel = bfd_h_get_32 (abfd, buf + 28);
2167 
          module->nextrel = bfd_h_get_32 (abfd, buf + 32);
2168 
          v = bfd_h_get_32 (abfd, buf +36);
2169 
          module->iinit = v & 0xffff;
2170 
          module->iterm = (v >> 16) & 0xffff;
2171 
          v = bfd_h_get_32 (abfd, buf + 40);
2172 
          module->ninit = v & 0xffff;
2173 
          module->nterm = (v >> 16) & 0xffff;
2174 
          if (wide)
2175 
            {
2176 
              module->objc_module_info_size = bfd_h_get_32 (abfd, buf + 44);
2177 
              module->objc_module_info_addr = bfd_h_get_64 (abfd, buf + 48);
2178 
            }
2179 
          else
2180 
            {
2181 
              module->objc_module_info_addr = bfd_h_get_32 (abfd, buf + 44);
2182 
              module->objc_module_info_size = bfd_h_get_32 (abfd, buf + 48);
2183 
            }
2184 
        }
2185 
    }
2186 
 
2187 
  if (cmd->ntoc != 0)
2188 
    {
2189 
      unsigned int i;
2190 
 
2191 
      cmd->dylib_toc = bfd_alloc
2192 
        (abfd, cmd->ntoc * sizeof (bfd_mach_o_dylib_table_of_content));
2193 
      if (cmd->dylib_toc == NULL)
2194 
        return -1;
2195 
 
2196 
      if (bfd_seek (abfd, cmd->tocoff, SEEK_SET) != 0)
2197 
        return -1;
2198 
 
2199 
      for (i = 0; i < cmd->ntoc; i++)
2200 
        {
2201 
          bfd_mach_o_dylib_table_of_content *toc = &cmd->dylib_toc[i];
2202 
 
2203 
          if (bfd_bread ((void *) buf, 8, abfd) != 8)
2204 
            return -1;
2205 
 
2206 
          toc->symbol_index = bfd_h_get_32 (abfd, buf + 0);
2207 
          toc->module_index = bfd_h_get_32 (abfd, buf + 4);
2208 
        }
2209 
    }
2210 
 
2211 
  if (cmd->nindirectsyms != 0)
2212 
    {
2213 
      unsigned int i;
2214 
 
2215 
      cmd->indirect_syms = bfd_alloc
2216 
        (abfd, cmd->nindirectsyms * sizeof (unsigned int));
2217 
      if (cmd->indirect_syms == NULL)
2218 
        return -1;
2219 
 
2220 
      if (bfd_seek (abfd, cmd->indirectsymoff, SEEK_SET) != 0)
2221 
        return -1;
2222 
 
2223 
      for (i = 0; i < cmd->nindirectsyms; i++)
2224 
        {
2225 
          unsigned int *is = &cmd->indirect_syms[i];
2226 
 
2227 
          if (bfd_bread ((void *) buf, 4, abfd) != 4)
2228 
            return -1;
2229 
 
2230 
          *is = bfd_h_get_32 (abfd, buf + 0);
2231 
        }
2232 
    }
2233 
 
2234 
  if (cmd->nextrefsyms != 0)
2235 
    {
2236 
      unsigned long v;
2237 
      unsigned int i;
2238 
 
2239 
      cmd->ext_refs = bfd_alloc
2240 
        (abfd, cmd->nextrefsyms * sizeof (bfd_mach_o_dylib_reference));
2241 
      if (cmd->ext_refs == NULL)
2242 
        return -1;
2243 
 
2244 
      if (bfd_seek (abfd, cmd->extrefsymoff, SEEK_SET) != 0)
2245 
        return -1;
2246 
 
2247 
      for (i = 0; i < cmd->nextrefsyms; i++)
2248 
        {
2249 
          bfd_mach_o_dylib_reference *ref = &cmd->ext_refs[i];
2250 
 
2251 
          if (bfd_bread ((void *) buf, 4, abfd) != 4)
2252 
            return -1;
2253 
 
2254 
          /* Fields isym and flags are written as bit-fields, thus we need
2255 
             a specific processing for endianness.  */
2256 
          v = bfd_h_get_32 (abfd, buf + 0);
2257 
          if (bfd_big_endian (abfd))
2258 
            {
2259 
              ref->isym = (v >> 8) & 0xffffff;
2260 
              ref->flags = v & 0xff;
2261 
            }
2262 
          else
2263 
            {
2264 
              ref->isym = v & 0xffffff;
2265 
              ref->flags = (v >> 24) & 0xff;
2266 
            }
2267 
        }
2268 
    }
2269 
 
2270 
  if (mdata->dysymtab)
2271 
    return -1;
2272 
  mdata->dysymtab = cmd;
2273 
 
2274 
  return 0;
2275 
}
2276 
 
2277 
static int
2278 
bfd_mach_o_read_symtab (bfd *abfd, bfd_mach_o_load_command *command)
2279 
{
2280 
  bfd_mach_o_symtab_command *symtab = &command->command.symtab;
2281 
  bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
2282 
  unsigned char buf[16];
2283 
 
2284 
  BFD_ASSERT (command->type == BFD_MACH_O_LC_SYMTAB);
2285 
 
2286 
  if (bfd_seek (abfd, command->offset + 8, SEEK_SET) != 0
2287 
      || bfd_bread ((void *) buf, 16, abfd) != 16)
2288 
    return -1;
2289 
 
2290 
  symtab->symoff = bfd_h_get_32 (abfd, buf);
2291 
  symtab->nsyms = bfd_h_get_32 (abfd, buf + 4);
2292 
  symtab->stroff = bfd_h_get_32 (abfd, buf + 8);
2293 
  symtab->strsize = bfd_h_get_32 (abfd, buf + 12);
2294 
  symtab->symbols = NULL;
2295 
  symtab->strtab = NULL;
2296 
 
2297 
  if (symtab->nsyms != 0)
2298 
    abfd->flags |= HAS_SYMS;
2299 
 
2300 
  if (mdata->symtab)
2301 
    return -1;
2302 
  mdata->symtab = symtab;
2303 
  return 0;
2304 
}
2305 
 
2306 
static int
2307 
bfd_mach_o_read_uuid (bfd *abfd, bfd_mach_o_load_command *command)
2308 
{
2309 
  bfd_mach_o_uuid_command *cmd = &command->command.uuid;
2310 
 
2311 
  BFD_ASSERT (command->type == BFD_MACH_O_LC_UUID);
2312 
 
2313 
  if (bfd_seek (abfd, command->offset + 8, SEEK_SET) != 0
2314 
      || bfd_bread ((void *) cmd->uuid, 16, abfd) != 16)
2315 
    return -1;
2316 
 
2317 
  return 0;
2318 
}
2319 
 
2320 
static int
2321 
bfd_mach_o_read_linkedit (bfd *abfd, bfd_mach_o_load_command *command)
2322 
{
2323 
  bfd_mach_o_linkedit_command *cmd = &command->command.linkedit;
2324 
  char buf[8];
2325 
 
2326 
  if (bfd_seek (abfd, command->offset + 8, SEEK_SET) != 0
2327 
      || bfd_bread ((void *) buf, 8, abfd) != 8)
2328 
    return -1;
2329 
 
2330 
  cmd->dataoff = bfd_get_32 (abfd, buf + 0);
2331 
  cmd->datasize = bfd_get_32 (abfd, buf + 4);
2332 
  return 0;
2333 
}
2334 
 
2335 
static int
2336 
bfd_mach_o_read_str (bfd *abfd, bfd_mach_o_load_command *command)
2337 
{
2338 
  bfd_mach_o_str_command *cmd = &command->command.str;
2339 
  char buf[4];
2340 
  unsigned long off;
2341 
 
2342 
  if (bfd_seek (abfd, command->offset + 8, SEEK_SET) != 0
2343 
      || bfd_bread ((void *) buf, 4, abfd) != 4)
2344 
    return -1;
2345 
 
2346 
  off = bfd_get_32 (abfd, buf + 0);
2347 
  cmd->stroff = command->offset + off;
2348 
  cmd->str_len = command->len - off;
2349 
  cmd->str = bfd_alloc (abfd, cmd->str_len);
2350 
  if (cmd->str == NULL)
2351 
    return -1;
2352 
  if (bfd_seek (abfd, cmd->stroff, SEEK_SET) != 0
2353 
      || bfd_bread ((void *) cmd->str, cmd->str_len, abfd) != cmd->str_len)
2354 
    return -1;
2355 
  return 0;
2356 
}
2357 
 
2358 
static int
2359 
bfd_mach_o_read_dyld_info (bfd *abfd, bfd_mach_o_load_command *command)
2360 
{
2361 
  bfd_mach_o_dyld_info_command *cmd = &command->command.dyld_info;
2362 
  char buf[40];
2363 
 
2364 
  if (bfd_seek (abfd, command->offset + 8, SEEK_SET) != 0
2365 
      || bfd_bread ((void *) buf, sizeof (buf), abfd) != sizeof (buf))
2366 
    return -1;
2367 
 
2368 
  cmd->rebase_off = bfd_get_32 (abfd, buf + 0);
2369 
  cmd->rebase_size = bfd_get_32 (abfd, buf + 4);
2370 
  cmd->bind_off = bfd_get_32 (abfd, buf + 8);
2371 
  cmd->bind_size = bfd_get_32 (abfd, buf + 12);
2372 
  cmd->weak_bind_off = bfd_get_32 (abfd, buf + 16);
2373 
  cmd->weak_bind_size = bfd_get_32 (abfd, buf + 20);
2374 
  cmd->lazy_bind_off = bfd_get_32 (abfd, buf + 24);
2375 
  cmd->lazy_bind_size = bfd_get_32 (abfd, buf + 28);
2376 
  cmd->export_off = bfd_get_32 (abfd, buf + 32);
2377 
  cmd->export_size = bfd_get_32 (abfd, buf + 36);
2378 
  return 0;
2379 
}
2380 
 
2381 
static int
2382 
bfd_mach_o_read_segment (bfd *abfd,
2383 
                         bfd_mach_o_load_command *command,
2384 
                         unsigned int wide)
2385 
{
2386 
  unsigned char buf[64];
2387 
  bfd_mach_o_segment_command *seg = &command->command.segment;
2388 
  unsigned long i;
2389 
 
2390 
  if (wide)
2391 
    {
2392 
      BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT_64);
2393 
 
2394 
      if (bfd_seek (abfd, command->offset + 8, SEEK_SET) != 0
2395 
          || bfd_bread ((void *) buf, 64, abfd) != 64)
2396 
        return -1;
2397 
 
2398 
      memcpy (seg->segname, buf, 16);
2399 
      seg->segname[16] = '\0';
2400 
 
2401 
      seg->vmaddr = bfd_h_get_64 (abfd, buf + 16);
2402 
      seg->vmsize = bfd_h_get_64 (abfd, buf + 24);
2403 
      seg->fileoff = bfd_h_get_64 (abfd, buf + 32);
2404 
      seg->filesize = bfd_h_get_64 (abfd, buf + 40);
2405 
      seg->maxprot = bfd_h_get_32 (abfd, buf + 48);
2406 
      seg->initprot = bfd_h_get_32 (abfd, buf + 52);
2407 
      seg->nsects = bfd_h_get_32 (abfd, buf + 56);
2408 
      seg->flags = bfd_h_get_32 (abfd, buf + 60);
2409 
    }
2410 
  else
2411 
    {
2412 
      BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT);
2413 
 
2414 
      if (bfd_seek (abfd, command->offset + 8, SEEK_SET) != 0
2415 
          || bfd_bread ((void *) buf, 48, abfd) != 48)
2416 
        return -1;
2417 
 
2418 
      memcpy (seg->segname, buf, 16);
2419 
      seg->segname[16] = '\0';
2420 
 
2421 
      seg->vmaddr = bfd_h_get_32 (abfd, buf + 16);
2422 
      seg->vmsize = bfd_h_get_32 (abfd, buf + 20);
2423 
      seg->fileoff = bfd_h_get_32 (abfd, buf + 24);
2424 
      seg->filesize = bfd_h_get_32 (abfd, buf +  28);
2425 
      seg->maxprot = bfd_h_get_32 (abfd, buf + 32);
2426 
      seg->initprot = bfd_h_get_32 (abfd, buf + 36);
2427 
      seg->nsects = bfd_h_get_32 (abfd, buf + 40);
2428 
      seg->flags = bfd_h_get_32 (abfd, buf + 44);
2429 
    }
2430 
 
2431 
  if (seg->nsects != 0)
2432 
    {
2433 
      seg->sections = bfd_alloc (abfd, seg->nsects
2434 
                                 * sizeof (bfd_mach_o_section));
2435 
      if (seg->sections == NULL)
2436 
        return -1;
2437 
 
2438 
      for (i = 0; i < seg->nsects; i++)
2439 
        {
2440 
          bfd_vma segoff;
2441 
          if (wide)
2442 
            segoff = command->offset + BFD_MACH_O_LC_SEGMENT_64_SIZE
2443 
              + (i * BFD_MACH_O_SECTION_64_SIZE);
2444 
          else
2445 
            segoff = command->offset + BFD_MACH_O_LC_SEGMENT_SIZE
2446 
              + (i * BFD_MACH_O_SECTION_SIZE);
2447 
 
2448 
          if (bfd_mach_o_read_section
2449 
              (abfd, &seg->sections[i], segoff, seg->initprot, wide) != 0)
2450 
            return -1;
2451 
        }
2452 
    }
2453 
 
2454 
  return 0;
2455 
}
2456 
 
2457 
static int
2458 
bfd_mach_o_read_segment_32 (bfd *abfd, bfd_mach_o_load_command *command)
2459 
{
2460 
  return bfd_mach_o_read_segment (abfd, command, 0);
2461 
}
2462 
 
2463 
static int
2464 
bfd_mach_o_read_segment_64 (bfd *abfd, bfd_mach_o_load_command *command)
2465 
{
2466 
  return bfd_mach_o_read_segment (abfd, command, 1);
2467 
}
2468 
 
2469 
static int
2470 
bfd_mach_o_read_command (bfd *abfd, bfd_mach_o_load_command *command)
2471 
{
2472 
  unsigned char buf[8];
2473 
 
2474 
  /* Read command type and length.  */
2475 
  if (bfd_seek (abfd, command->offset, SEEK_SET) != 0
2476 
      || bfd_bread ((void *) buf, 8, abfd) != 8)
2477 
    return -1;
2478 
 
2479 
  command->type = bfd_h_get_32 (abfd, buf) & ~BFD_MACH_O_LC_REQ_DYLD;
2480 
  command->type_required = (bfd_h_get_32 (abfd, buf) & BFD_MACH_O_LC_REQ_DYLD
2481 
                            ? TRUE : FALSE);
2482 
  command->len = bfd_h_get_32 (abfd, buf + 4);
2483 
 
2484 
  switch (command->type)
2485 
    {
2486 
    case BFD_MACH_O_LC_SEGMENT:
2487 
      if (bfd_mach_o_read_segment_32 (abfd, command) != 0)
2488 
        return -1;
2489 
      break;
2490 
    case BFD_MACH_O_LC_SEGMENT_64:
2491 
      if (bfd_mach_o_read_segment_64 (abfd, command) != 0)
2492 
        return -1;
2493 
      break;
2494 
    case BFD_MACH_O_LC_SYMTAB:
2495 
      if (bfd_mach_o_read_symtab (abfd, command) != 0)
2496 
        return -1;
2497 
      break;
2498 
    case BFD_MACH_O_LC_SYMSEG:
2499 
      break;
2500 
    case BFD_MACH_O_LC_THREAD:
2501 
    case BFD_MACH_O_LC_UNIXTHREAD:
2502 
      if (bfd_mach_o_read_thread (abfd, command) != 0)
2503 
        return -1;
2504 
      break;
2505 
    case BFD_MACH_O_LC_LOAD_DYLINKER:
2506 
    case BFD_MACH_O_LC_ID_DYLINKER:
2507 
      if (bfd_mach_o_read_dylinker (abfd, command) != 0)
2508 
        return -1;
2509 
      break;
2510 
    case BFD_MACH_O_LC_LOAD_DYLIB:
2511 
    case BFD_MACH_O_LC_ID_DYLIB:
2512 
    case BFD_MACH_O_LC_LOAD_WEAK_DYLIB:
2513 
    case BFD_MACH_O_LC_REEXPORT_DYLIB:
2514 
      if (bfd_mach_o_read_dylib (abfd, command) != 0)
2515 
        return -1;
2516 
      break;
2517 
    case BFD_MACH_O_LC_PREBOUND_DYLIB:
2518 
      if (bfd_mach_o_read_prebound_dylib (abfd, command) != 0)
2519 
        return -1;
2520 
      break;
2521 
    case BFD_MACH_O_LC_LOADFVMLIB:
2522 
    case BFD_MACH_O_LC_IDFVMLIB:
2523 
    case BFD_MACH_O_LC_IDENT:
2524 
    case BFD_MACH_O_LC_FVMFILE:
2525 
    case BFD_MACH_O_LC_PREPAGE:
2526 
    case BFD_MACH_O_LC_ROUTINES:
2527 
      break;
2528 
    case BFD_MACH_O_LC_SUB_FRAMEWORK:
2529 
    case BFD_MACH_O_LC_SUB_UMBRELLA:
2530 
    case BFD_MACH_O_LC_SUB_LIBRARY:
2531 
    case BFD_MACH_O_LC_SUB_CLIENT:
2532 
    case BFD_MACH_O_LC_RPATH:
2533 
      if (bfd_mach_o_read_str (abfd, command) != 0)
2534 
        return -1;
2535 
      break;
2536 
    case BFD_MACH_O_LC_DYSYMTAB:
2537 
      if (bfd_mach_o_read_dysymtab (abfd, command) != 0)
2538 
        return -1;
2539 
      break;
2540 
    case BFD_MACH_O_LC_TWOLEVEL_HINTS:
2541 
    case BFD_MACH_O_LC_PREBIND_CKSUM:
2542 
      break;
2543 
    case BFD_MACH_O_LC_UUID:
2544 
      if (bfd_mach_o_read_uuid (abfd, command) != 0)
2545 
        return -1;
2546 
      break;
2547 
    case BFD_MACH_O_LC_CODE_SIGNATURE:
2548 
    case BFD_MACH_O_LC_SEGMENT_SPLIT_INFO:
2549 
      if (bfd_mach_o_read_linkedit (abfd, command) != 0)
2550 
        return -1;
2551 
      break;
2552 
    case BFD_MACH_O_LC_DYLD_INFO:
2553 
      if (bfd_mach_o_read_dyld_info (abfd, command) != 0)
2554 
        return -1;
2555 
      break;
2556 
    default:
2557 
      fprintf (stderr, "unable to read unknown load command 0x%lx\n",
2558 
               (unsigned long) command->type);
2559 
      break;
2560 
    }
2561 
 
2562 
  return 0;
2563 
}
2564 
 
2565 
static void
2566 
bfd_mach_o_flatten_sections (bfd *abfd)
2567 
{
2568 
  bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
2569 
  long csect = 0;
2570 
  unsigned long i, j;
2571 
 
2572 
  /* Count total number of sections.  */
2573 
  mdata->nsects = 0;
2574 
 
2575 
  for (i = 0; i < mdata->header.ncmds; i++)
2576 
    {
2577 
      if (mdata->commands[i].type == BFD_MACH_O_LC_SEGMENT
2578 
          || mdata->commands[i].type == BFD_MACH_O_LC_SEGMENT_64)
2579 
        {
2580 
          bfd_mach_o_segment_command *seg;
2581 
 
2582 
          seg = &mdata->commands[i].command.segment;
2583 
          mdata->nsects += seg->nsects;
2584 
        }
2585 
    }
2586 
 
2587 
  /* Allocate sections array.  */
2588 
  mdata->sections = bfd_alloc (abfd,
2589 
                               mdata->nsects * sizeof (bfd_mach_o_section *));
2590 
 
2591 
  /* Fill the array.  */
2592 
  csect = 0;
2593 
 
2594 
  for (i = 0; i < mdata->header.ncmds; i++)
2595 
    {
2596 
      if (mdata->commands[i].type == BFD_MACH_O_LC_SEGMENT
2597 
          || mdata->commands[i].type == BFD_MACH_O_LC_SEGMENT_64)
2598 
        {
2599 
          bfd_mach_o_segment_command *seg;
2600 
 
2601 
          seg = &mdata->commands[i].command.segment;
2602 
          BFD_ASSERT (csect + seg->nsects <= mdata->nsects);
2603 
 
2604 
          for (j = 0; j < seg->nsects; j++)
2605 
            mdata->sections[csect++] = &seg->sections[j];
2606 
        }
2607 
    }
2608 
}
2609 
 
2610 
int
2611 
bfd_mach_o_scan_start_address (bfd *abfd)
2612 
{
2613 
  bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
2614 
  bfd_mach_o_thread_command *cmd = NULL;
2615 
  unsigned long i;
2616 
 
2617 
  for (i = 0; i < mdata->header.ncmds; i++)
2618 
    {
2619 
      if ((mdata->commands[i].type == BFD_MACH_O_LC_THREAD) ||
2620 
          (mdata->commands[i].type == BFD_MACH_O_LC_UNIXTHREAD))
2621 
        {
2622 
          if (cmd == NULL)
2623 
            cmd = &mdata->commands[i].command.thread;
2624 
          else
2625 
            return 0;
2626 
        }
2627 
    }
2628 
 
2629 
  if (cmd == NULL)
2630 
    return 0;
2631 
 
2632 
  for (i = 0; i < cmd->nflavours; i++)
2633 
    {
2634 
      if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_I386)
2635 
          && (cmd->flavours[i].flavour
2636 
              == (unsigned long) BFD_MACH_O_x86_THREAD_STATE32))
2637 
        {
2638 
          unsigned char buf[4];
2639 
 
2640 
          if (bfd_seek (abfd, cmd->flavours[i].offset + 40, SEEK_SET) != 0
2641 
              || bfd_bread (buf, 4, abfd) != 4)
2642 
            return -1;
2643 
 
2644 
          abfd->start_address = bfd_h_get_32 (abfd, buf);
2645 
        }
2646 
      else if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_POWERPC)
2647 
               && (cmd->flavours[i].flavour == BFD_MACH_O_PPC_THREAD_STATE))
2648 
        {
2649 
          unsigned char buf[4];
2650 
 
2651 
          if (bfd_seek (abfd, cmd->flavours[i].offset + 0, SEEK_SET) != 0
2652 
              || bfd_bread (buf, 4, abfd) != 4)
2653 
            return -1;
2654 
 
2655 
          abfd->start_address = bfd_h_get_32 (abfd, buf);
2656 
        }
2657 
      else if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_POWERPC_64)
2658 
               && (cmd->flavours[i].flavour == BFD_MACH_O_PPC_THREAD_STATE64))
2659 
        {
2660 
          unsigned char buf[8];
2661 
 
2662 
          if (bfd_seek (abfd, cmd->flavours[i].offset + 0, SEEK_SET) != 0
2663 
              || bfd_bread (buf, 8, abfd) != 8)
2664 
            return -1;
2665 
 
2666 
          abfd->start_address = bfd_h_get_64 (abfd, buf);
2667 
        }
2668 
      else if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_X86_64)
2669 
               && (cmd->flavours[i].flavour == BFD_MACH_O_x86_THREAD_STATE64))
2670 
        {
2671 
          unsigned char buf[8];
2672 
 
2673 
          if (bfd_seek (abfd, cmd->flavours[i].offset + (16 * 8), SEEK_SET) != 0
2674 
              || bfd_bread (buf, 8, abfd) != 8)
2675 
            return -1;
2676 
 
2677 
          abfd->start_address = bfd_h_get_64 (abfd, buf);
2678 
        }
2679 
    }
2680 
 
2681 
  return 0;
2682 
}
2683 
 
2684 
bfd_boolean
2685 
bfd_mach_o_set_arch_mach (bfd *abfd,
2686 
                          enum bfd_architecture arch,
2687 
                          unsigned long machine)
2688 
{
2689 
  bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
2690 
 
2691 
  /* If this isn't the right architecture for this backend, and this
2692 
     isn't the generic backend, fail.  */
2693 
  if (arch != bed->arch
2694 
      && arch != bfd_arch_unknown
2695 
      && bed->arch != bfd_arch_unknown)
2696 
    return FALSE;
2697 
 
2698 
  return bfd_default_set_arch_mach (abfd, arch, machine);
2699 
}
2700 
 
2701 
int
2702 
bfd_mach_o_scan (bfd *abfd,
2703 
                 bfd_mach_o_header *header,
2704 
                 bfd_mach_o_data_struct *mdata)
2705 
{
2706 
  unsigned int i;
2707 
  enum bfd_architecture cputype;
2708 
  unsigned long cpusubtype;
2709 
  unsigned int hdrsize;
2710 
 
2711 
  hdrsize = mach_o_wide_p (header) ?
2712 
    BFD_MACH_O_HEADER_64_SIZE : BFD_MACH_O_HEADER_SIZE;
2713 
 
2714 
  mdata->header = *header;
2715 
 
2716 
  abfd->flags = abfd->flags & BFD_IN_MEMORY;
2717 
  switch (header->filetype)
2718 
    {
2719 
    case BFD_MACH_O_MH_OBJECT:
2720 
      abfd->flags |= HAS_RELOC;
2721 
      break;
2722 
    case BFD_MACH_O_MH_EXECUTE:
2723 
      abfd->flags |= EXEC_P;
2724 
      break;
2725 
    case BFD_MACH_O_MH_DYLIB:
2726 
    case BFD_MACH_O_MH_BUNDLE:
2727 
      abfd->flags |= DYNAMIC;
2728 
      break;
2729 
    }
2730 
 
2731 
  abfd->tdata.mach_o_data = mdata;
2732 
 
2733 
  bfd_mach_o_convert_architecture (header->cputype, header->cpusubtype,
2734 
                                   &cputype, &cpusubtype);
2735 
  if (cputype == bfd_arch_unknown)
2736 
    {
2737 
      fprintf (stderr, "bfd_mach_o_scan: unknown architecture 0x%lx/0x%lx\n",
2738 
               header->cputype, header->cpusubtype);
2739 
      return -1;
2740 
    }
2741 
 
2742 
  bfd_set_arch_mach (abfd, cputype, cpusubtype);
2743 
 
2744 
  if (header->ncmds != 0)
2745 
    {
2746 
      mdata->commands = bfd_alloc
2747 
        (abfd, header->ncmds * sizeof (bfd_mach_o_load_command));
2748 
      if (mdata->commands == NULL)
2749 
        return -1;
2750 
 
2751 
      for (i = 0; i < header->ncmds; i++)
2752 
        {
2753 
          bfd_mach_o_load_command *cur = &mdata->commands[i];
2754 
 
2755 
          if (i == 0)
2756 
            cur->offset = hdrsize;
2757 
          else
2758 
            {
2759 
              bfd_mach_o_load_command *prev = &mdata->commands[i - 1];
2760 
              cur->offset = prev->offset + prev->len;
2761 
            }
2762 
 
2763 
          if (bfd_mach_o_read_command (abfd, cur) < 0)
2764 
            return -1;
2765 
        }
2766 
    }
2767 
 
2768 
  if (bfd_mach_o_scan_start_address (abfd) < 0)
2769 
    return -1;
2770 
 
2771 
  bfd_mach_o_flatten_sections (abfd);
2772 
  return 0;
2773 
}
2774 
 
2775 
bfd_boolean
2776 
bfd_mach_o_mkobject_init (bfd *abfd)
2777 
{
2778 
  bfd_mach_o_data_struct *mdata = NULL;
2779 
 
2780 
  mdata = bfd_alloc (abfd, sizeof (bfd_mach_o_data_struct));
2781 
  if (mdata == NULL)
2782 
    return FALSE;
2783 
  abfd->tdata.mach_o_data = mdata;
2784 
 
2785 
  mdata->header.magic = 0;
2786 
  mdata->header.cputype = 0;
2787 
  mdata->header.cpusubtype = 0;
2788 
  mdata->header.filetype = 0;
2789 
  mdata->header.ncmds = 0;
2790 
  mdata->header.sizeofcmds = 0;
2791 
  mdata->header.flags = 0;
2792 
  mdata->header.byteorder = BFD_ENDIAN_UNKNOWN;
2793 
  mdata->commands = NULL;
2794 
  mdata->nsects = 0;
2795 
  mdata->sections = NULL;
2796 
 
2797 
  return TRUE;
2798 
}
2799 
 
2800 
static bfd_boolean
2801 
bfd_mach_o_gen_mkobject (bfd *abfd)
2802 
{
2803 
  bfd_mach_o_data_struct *mdata;
2804 
 
2805 
  if (!bfd_mach_o_mkobject_init (abfd))
2806 
    return FALSE;
2807 
 
2808 
  mdata = bfd_mach_o_get_data (abfd);
2809 
  mdata->header.magic = BFD_MACH_O_MH_MAGIC;
2810 
  mdata->header.cputype = 0;
2811 
  mdata->header.cpusubtype = 0;
2812 
  mdata->header.byteorder = abfd->xvec->byteorder;
2813 
  mdata->header.version = 1;
2814 
 
2815 
  return TRUE;
2816 
}
2817 
 
2818 
const bfd_target *
2819 
bfd_mach_o_header_p (bfd *abfd,
2820 
                     bfd_mach_o_filetype filetype,
2821 
                     bfd_mach_o_cpu_type cputype)
2822 
{
2823 
  struct bfd_preserve preserve;
2824 
  bfd_mach_o_header header;
2825 
 
2826 
  preserve.marker = NULL;
2827 
  if (!bfd_mach_o_read_header (abfd, &header))
2828 
    goto wrong;
2829 
 
2830 
  if (! (header.byteorder == BFD_ENDIAN_BIG
2831 
         || header.byteorder == BFD_ENDIAN_LITTLE))
2832 
    {
2833 
      fprintf (stderr, "unknown header byte-order value 0x%lx\n",
2834 
               (unsigned long) header.byteorder);
2835 
      goto wrong;
2836 
    }
2837 
 
2838 
  if (! ((header.byteorder == BFD_ENDIAN_BIG
2839 
          && abfd->xvec->byteorder == BFD_ENDIAN_BIG
2840 
          && abfd->xvec->header_byteorder == BFD_ENDIAN_BIG)
2841 
         || (header.byteorder == BFD_ENDIAN_LITTLE
2842 
             && abfd->xvec->byteorder == BFD_ENDIAN_LITTLE
2843 
             && abfd->xvec->header_byteorder == BFD_ENDIAN_LITTLE)))
2844 
    goto wrong;
2845 
 
2846 
  /* Check cputype and filetype.
2847 
     In case of wildcard, do not accept magics that are handled by existing
2848 
     targets.  */
2849 
  if (cputype)
2850 
    {
2851 
      if (header.cputype != cputype)
2852 
        goto wrong;
2853 
    }
2854 
  else
2855 
    {
2856 
      switch (header.cputype)
2857 
        {
2858 
        case BFD_MACH_O_CPU_TYPE_I386:
2859 
          /* Handled by mach-o-i386 */
2860 
          goto wrong;
2861 
        default:
2862 
          break;
2863 
        }
2864 
    }
2865 
  if (filetype)
2866 
    {
2867 
      if (header.filetype != filetype)
2868 
        goto wrong;
2869 
    }
2870 
  else
2871 
    {
2872 
      switch (header.filetype)
2873 
        {
2874 
        case BFD_MACH_O_MH_CORE:
2875 
          /* Handled by core_p */
2876 
          goto wrong;
2877 
        default:
2878 
          break;
2879 
        }
2880 
    }
2881 
 
2882 
  preserve.marker = bfd_zalloc (abfd, sizeof (bfd_mach_o_data_struct));
2883 
  if (preserve.marker == NULL
2884 
      || !bfd_preserve_save (abfd, &preserve))
2885 
    goto fail;
2886 
 
2887 
  if (bfd_mach_o_scan (abfd, &header,
2888 
                       (bfd_mach_o_data_struct *) preserve.marker) != 0)
2889 
    goto wrong;
2890 
 
2891 
  bfd_preserve_finish (abfd, &preserve);
2892 
  return abfd->xvec;
2893 
 
2894 
 wrong:
2895 
  bfd_set_error (bfd_error_wrong_format);
2896 
 
2897 
 fail:
2898 
  if (preserve.marker != NULL)
2899 
    bfd_preserve_restore (abfd, &preserve);
2900 
  return NULL;
2901 
}
2902 
 
2903 
static const bfd_target *
2904 
bfd_mach_o_gen_object_p (bfd *abfd)
2905 
{
2906 
  return bfd_mach_o_header_p (abfd, 0, 0);
2907 
}
2908 
 
2909 
static const bfd_target *
2910 
bfd_mach_o_gen_core_p (bfd *abfd)
2911 
{
2912 
  return bfd_mach_o_header_p (abfd, BFD_MACH_O_MH_CORE, 0);
2913 
}
2914 
 
2915 
typedef struct mach_o_fat_archentry
2916 
{
2917 
  unsigned long cputype;
2918 
  unsigned long cpusubtype;
2919 
  unsigned long offset;
2920 
  unsigned long size;
2921 
  unsigned long align;
2922 
} mach_o_fat_archentry;
2923 
 
2924 
typedef struct mach_o_fat_data_struct
2925 
{
2926 
  unsigned long magic;
2927 
  unsigned long nfat_arch;
2928 
  mach_o_fat_archentry *archentries;
2929 
} mach_o_fat_data_struct;
2930 
 
2931 
const bfd_target *
2932 
bfd_mach_o_archive_p (bfd *abfd)
2933 
{
2934 
  mach_o_fat_data_struct *adata = NULL;
2935 
  unsigned char buf[20];
2936 
  unsigned long i;
2937 
 
2938 
  if (bfd_seek (abfd, 0, SEEK_SET) != 0
2939 
      || bfd_bread ((void *) buf, 8, abfd) != 8)
2940 
    goto error;
2941 
 
2942 
  adata = bfd_alloc (abfd, sizeof (mach_o_fat_data_struct));
2943 
  if (adata == NULL)
2944 
    goto error;
2945 
 
2946 
  adata->magic = bfd_getb32 (buf);
2947 
  adata->nfat_arch = bfd_getb32 (buf + 4);
2948 
  if (adata->magic != 0xcafebabe)
2949 
    goto error;
2950 
  /* Avoid matching Java bytecode files, which have the same magic number.
2951 
     In the Java bytecode file format this field contains the JVM version,
2952 
     which starts at 43.0.  */
2953 
  if (adata->nfat_arch > 30)
2954 
    goto error;
2955 
 
2956 
  adata->archentries =
2957 
    bfd_alloc (abfd, adata->nfat_arch * sizeof (mach_o_fat_archentry));
2958 
  if (adata->archentries == NULL)
2959 
    goto error;
2960 
 
2961 
  for (i = 0; i < adata->nfat_arch; i++)
2962 
    {
2963 
      if (bfd_seek (abfd, 8 + 20 * i, SEEK_SET) != 0
2964 
          || bfd_bread ((void *) buf, 20, abfd) != 20)
2965 
        goto error;
2966 
      adata->archentries[i].cputype = bfd_getb32 (buf);
2967 
      adata->archentries[i].cpusubtype = bfd_getb32 (buf + 4);
2968 
      adata->archentries[i].offset = bfd_getb32 (buf + 8);
2969 
      adata->archentries[i].size = bfd_getb32 (buf + 12);
2970 
      adata->archentries[i].align = bfd_getb32 (buf + 16);
2971 
    }
2972 
 
2973 
  abfd->tdata.mach_o_fat_data = adata;
2974 
  return abfd->xvec;
2975 
 
2976 
 error:
2977 
  if (adata != NULL)
2978 
    bfd_release (abfd, adata);
2979 
  bfd_set_error (bfd_error_wrong_format);
2980 
  return NULL;
2981 
}
2982 
 
2983 
bfd *
2984 
bfd_mach_o_openr_next_archived_file (bfd *archive, bfd *prev)
2985 
{
2986 
  mach_o_fat_data_struct *adata;
2987 
  mach_o_fat_archentry *entry = NULL;
2988 
  unsigned long i;
2989 
  bfd *nbfd;
2990 
  enum bfd_architecture arch_type;
2991 
  unsigned long arch_subtype;
2992 
 
2993 
  adata = (mach_o_fat_data_struct *) archive->tdata.mach_o_fat_data;
2994 
  BFD_ASSERT (adata != NULL);
2995 
 
2996 
  /* Find index of previous entry.  */
2997 
  if (prev == NULL)
2998 
    i = 0;       /* Start at first one.  */
2999 
  else
3000 
    {
3001 
      for (i = 0; i < adata->nfat_arch; i++)
3002 
        {
3003 
          if (adata->archentries[i].offset == prev->origin)
3004 
            break;
3005 
        }
3006 
 
3007 
      if (i == adata->nfat_arch)
3008 
        {
3009 
          /* Not found.  */
3010 
          bfd_set_error (bfd_error_bad_value);
3011 
          return NULL;
3012 
        }
3013 
    i++;        /* Get next entry.  */
3014 
  }
3015 
 
3016 
  if (i >= adata->nfat_arch)
3017 
    {
3018 
      bfd_set_error (bfd_error_no_more_archived_files);
3019 
      return NULL;
3020 
    }
3021 
 
3022 
  entry = &adata->archentries[i];
3023 
  nbfd = _bfd_new_bfd_contained_in (archive);
3024 
  if (nbfd == NULL)
3025 
    return NULL;
3026 
 
3027 
  nbfd->origin = entry->offset;
3028 
 
3029 
  bfd_mach_o_convert_architecture (entry->cputype, entry->cpusubtype,
3030 
                                   &arch_type, &arch_subtype);
3031 
  /* Create the member filename.
3032 
     Use FILENAME:ARCH_NAME.  */
3033 
  {
3034 
    char *s = NULL;
3035 
    const char *arch_name;
3036 
    size_t arch_file_len = strlen (bfd_get_filename (archive));
3037 
 
3038 
    arch_name = bfd_printable_arch_mach (arch_type, arch_subtype);
3039 
    s = bfd_malloc (arch_file_len + 1 + strlen (arch_name) + 1);
3040 
    if (s == NULL)
3041 
      return NULL;
3042 
    memcpy (s, bfd_get_filename (archive), arch_file_len);
3043 
    s[arch_file_len] = ':';
3044 
    strcpy (s + arch_file_len + 1, arch_name);
3045 
    nbfd->filename = s;
3046 
  }
3047 
  nbfd->iostream = NULL;
3048 
  bfd_set_arch_mach (nbfd, arch_type, arch_subtype);
3049 
 
3050 
  return nbfd;
3051 
}
3052 
 
3053 
/* If ABFD format is FORMAT and architecture is ARCH, return it.
3054 
   If ABFD is a fat image containing a member that corresponds to FORMAT
3055 
   and ARCH, returns it.
3056 
   In other case, returns NULL.
3057 
   This function allows transparent uses of fat images.  */
3058 
bfd *
3059 
bfd_mach_o_fat_extract (bfd *abfd,
3060 
                        bfd_format format,
3061 
                        const bfd_arch_info_type *arch)
3062 
{
3063 
  bfd *res;
3064 
  mach_o_fat_data_struct *adata;
3065 
  unsigned int i;
3066 
 
3067 
  if (bfd_check_format (abfd, format))
3068 
    {
3069 
      if (bfd_get_arch_info (abfd) == arch)
3070 
        return abfd;
3071 
      return NULL;
3072 
    }
3073 
  if (!bfd_check_format (abfd, bfd_archive)
3074 
      || abfd->xvec != &mach_o_fat_vec)
3075 
    return NULL;
3076 
 
3077 
  /* This is a Mach-O fat image.  */
3078 
  adata = (mach_o_fat_data_struct *) abfd->tdata.mach_o_fat_data;
3079 
  BFD_ASSERT (adata != NULL);
3080 
 
3081 
  for (i = 0; i < adata->nfat_arch; i++)
3082 
    {
3083 
      struct mach_o_fat_archentry *e = &adata->archentries[i];
3084 
      enum bfd_architecture cpu_type;
3085 
      unsigned long cpu_subtype;
3086 
 
3087 
      bfd_mach_o_convert_architecture (e->cputype, e->cpusubtype,
3088 
                                       &cpu_type, &cpu_subtype);
3089 
      if (cpu_type != arch->arch || cpu_subtype != arch->mach)
3090 
        continue;
3091 
 
3092 
      /* The architecture is found.  */
3093 
      res = _bfd_new_bfd_contained_in (abfd);
3094 
      if (res == NULL)
3095 
        return NULL;
3096 
 
3097 
      res->origin = e->offset;
3098 
 
3099 
      res->filename = strdup (abfd->filename);
3100 
      res->iostream = NULL;
3101 
 
3102 
      if (bfd_check_format (res, format))
3103 
        {
3104 
          BFD_ASSERT (bfd_get_arch_info (res) == arch);
3105 
          return res;
3106 
        }
3107 
      bfd_close (res);
3108 
      return NULL;
3109 
    }
3110 
 
3111 
  return NULL;
3112 
}
3113 
 
3114 
int
3115 
bfd_mach_o_lookup_section (bfd *abfd,
3116 
                           asection *section,
3117 
                           bfd_mach_o_load_command **mcommand,
3118 
                           bfd_mach_o_section **msection)
3119 
{
3120 
  struct mach_o_data_struct *md = bfd_mach_o_get_data (abfd);
3121 
  unsigned int i, j, num;
3122 
 
3123 
  bfd_mach_o_load_command *ncmd = NULL;
3124 
  bfd_mach_o_section *nsect = NULL;
3125 
 
3126 
  BFD_ASSERT (mcommand != NULL);
3127 
  BFD_ASSERT (msection != NULL);
3128 
 
3129 
  num = 0;
3130 
  for (i = 0; i < md->header.ncmds; i++)
3131 
    {
3132 
      struct bfd_mach_o_load_command *cmd = &md->commands[i];
3133 
      struct bfd_mach_o_segment_command *seg = NULL;
3134 
 
3135 
      if (cmd->type != BFD_MACH_O_LC_SEGMENT
3136 
          || cmd->type != BFD_MACH_O_LC_SEGMENT_64)
3137 
        continue;
3138 
      seg = &cmd->command.segment;
3139 
 
3140 
      for (j = 0; j < seg->nsects; j++)
3141 
        {
3142 
          struct bfd_mach_o_section *sect = &seg->sections[j];
3143 
 
3144 
          if (sect->bfdsection == section)
3145 
            {
3146 
              if (num == 0)
3147 
                {
3148 
                  nsect = sect;
3149 
                  ncmd = cmd;
3150 
                }
3151 
              num++;
3152 
            }
3153 
        }
3154 
    }
3155 
 
3156 
  *mcommand = ncmd;
3157 
  *msection = nsect;
3158 
  return num;
3159 
}
3160 
 
3161 
int
3162 
bfd_mach_o_lookup_command (bfd *abfd,
3163 
                           bfd_mach_o_load_command_type type,
3164 
                           bfd_mach_o_load_command **mcommand)
3165 
{
3166 
  struct mach_o_data_struct *md = bfd_mach_o_get_data (abfd);
3167 
  bfd_mach_o_load_command *ncmd = NULL;
3168 
  unsigned int i, num;
3169 
 
3170 
  BFD_ASSERT (md != NULL);
3171 
  BFD_ASSERT (mcommand != NULL);
3172 
 
3173 
  num = 0;
3174 
  for (i = 0; i < md->header.ncmds; i++)
3175 
    {
3176 
      struct bfd_mach_o_load_command *cmd = &md->commands[i];
3177 
 
3178 
      if (cmd->type != type)
3179 
        continue;
3180 
 
3181 
      if (num == 0)
3182 
        ncmd = cmd;
3183 
      num++;
3184 
    }
3185 
 
3186 
  *mcommand = ncmd;
3187 
  return num;
3188 
}
3189 
 
3190 
unsigned long
3191 
bfd_mach_o_stack_addr (enum bfd_mach_o_cpu_type type)
3192 
{
3193 
  switch (type)
3194 
    {
3195 
    case BFD_MACH_O_CPU_TYPE_MC680x0:
3196 
      return 0x04000000;
3197 
    case BFD_MACH_O_CPU_TYPE_MC88000:
3198 
      return 0xffffe000;
3199 
    case BFD_MACH_O_CPU_TYPE_POWERPC:
3200 
      return 0xc0000000;
3201 
    case BFD_MACH_O_CPU_TYPE_I386:
3202 
      return 0xc0000000;
3203 
    case BFD_MACH_O_CPU_TYPE_SPARC:
3204 
      return 0xf0000000;
3205 
    case BFD_MACH_O_CPU_TYPE_I860:
3206 
      return 0;
3207 
    case BFD_MACH_O_CPU_TYPE_HPPA:
3208 
      return 0xc0000000 - 0x04000000;
3209 
    default:
3210 
      return 0;
3211 
    }
3212 
}
3213 
 
3214 
typedef struct bfd_mach_o_xlat_name
3215 
{
3216 
  const char *name;
3217 
  unsigned long val;
3218 
}
3219 
bfd_mach_o_xlat_name;
3220 
 
3221 
static void
3222 
bfd_mach_o_print_flags (const bfd_mach_o_xlat_name *table,
3223 
                        unsigned long val,
3224 
                        FILE *file)
3225 
{
3226 
  int first = 1;
3227 
 
3228 
  for (; table->name; table++)
3229 
    {
3230 
      if (table->val & val)
3231 
        {
3232 
          if (!first)
3233 
            fprintf (file, "+");
3234 
          fprintf (file, "%s", table->name);
3235 
          val &= ~table->val;
3236 
          first = 0;
3237 
        }
3238 
    }
3239 
  if (val)
3240 
    {
3241 
      if (!first)
3242 
        fprintf (file, "+");
3243 
      fprintf (file, "0x%lx", val);
3244 
      return;
3245 
    }
3246 
  if (first)
3247 
    fprintf (file, "-");
3248 
}
3249 
 
3250 
static const char *
3251 
bfd_mach_o_get_name (const bfd_mach_o_xlat_name *table, unsigned long val)
3252 
{
3253 
  for (; table->name; table++)
3254 
    if (table->val == val)
3255 
      return table->name;
3256 
  return "*UNKNOWN*";
3257 
}
3258 
 
3259 
static bfd_mach_o_xlat_name bfd_mach_o_cpu_name[] =
3260 
{
3261 
  { "vax", BFD_MACH_O_CPU_TYPE_VAX },
3262 
  { "mc680x0", BFD_MACH_O_CPU_TYPE_MC680x0 },
3263 
  { "i386", BFD_MACH_O_CPU_TYPE_I386 },
3264 
  { "mips", BFD_MACH_O_CPU_TYPE_MIPS },
3265 
  { "mc98000", BFD_MACH_O_CPU_TYPE_MC98000 },
3266 
  { "hppa", BFD_MACH_O_CPU_TYPE_HPPA },
3267 
  { "arm", BFD_MACH_O_CPU_TYPE_ARM },
3268 
  { "mc88000", BFD_MACH_O_CPU_TYPE_MC88000 },
3269 
  { "sparc", BFD_MACH_O_CPU_TYPE_SPARC },
3270 
  { "i860", BFD_MACH_O_CPU_TYPE_I860 },
3271 
  { "alpha", BFD_MACH_O_CPU_TYPE_ALPHA },
3272 
  { "powerpc", BFD_MACH_O_CPU_TYPE_POWERPC },
3273 
  { "powerpc_64", BFD_MACH_O_CPU_TYPE_POWERPC_64 },
3274 
  { "x86_64", BFD_MACH_O_CPU_TYPE_X86_64 },
3275 
  { NULL, 0}
3276 
};
3277 
 
3278 
static bfd_mach_o_xlat_name bfd_mach_o_filetype_name[] =
3279 
{
3280 
  { "object", BFD_MACH_O_MH_OBJECT },
3281 
  { "execute", BFD_MACH_O_MH_EXECUTE },
3282 
  { "fvmlib", BFD_MACH_O_MH_FVMLIB },
3283 
  { "core", BFD_MACH_O_MH_CORE },
3284 
  { "preload", BFD_MACH_O_MH_PRELOAD },
3285 
  { "dylib", BFD_MACH_O_MH_DYLIB },
3286 
  { "dylinker", BFD_MACH_O_MH_DYLINKER },
3287 
  { "bundle", BFD_MACH_O_MH_BUNDLE },
3288 
  { "dylib_stub", BFD_MACH_O_MH_DYLIB_STUB },
3289 
  { "dym", BFD_MACH_O_MH_DSYM },
3290 
  { "kext_bundle", BFD_MACH_O_MH_KEXT_BUNDLE },
3291 
  { NULL, 0}
3292 
};
3293 
 
3294 
static bfd_mach_o_xlat_name bfd_mach_o_header_flags_name[] =
3295 
{
3296 
  { "noundefs", BFD_MACH_O_MH_NOUNDEFS },
3297 
  { "incrlink", BFD_MACH_O_MH_INCRLINK },
3298 
  { "dyldlink", BFD_MACH_O_MH_DYLDLINK },
3299 
  { "bindatload", BFD_MACH_O_MH_BINDATLOAD },
3300 
  { "prebound", BFD_MACH_O_MH_PREBOUND },
3301 
  { "split_segs", BFD_MACH_O_MH_SPLIT_SEGS },
3302 
  { "lazy_init", BFD_MACH_O_MH_LAZY_INIT },
3303 
  { "twolevel", BFD_MACH_O_MH_TWOLEVEL },
3304 
  { "force_flat", BFD_MACH_O_MH_FORCE_FLAT },
3305 
  { "nomultidefs", BFD_MACH_O_MH_NOMULTIDEFS },
3306 
  { "nofixprebinding", BFD_MACH_O_MH_NOFIXPREBINDING },
3307 
  { "prebindable", BFD_MACH_O_MH_PREBINDABLE },
3308 
  { "allmodsbound", BFD_MACH_O_MH_ALLMODSBOUND },
3309 
  { "subsections_via_symbols", BFD_MACH_O_MH_SUBSECTIONS_VIA_SYMBOLS },
3310 
  { "canonical", BFD_MACH_O_MH_CANONICAL },
3311 
  { "weak_defines", BFD_MACH_O_MH_WEAK_DEFINES },
3312 
  { "binds_to_weak", BFD_MACH_O_MH_BINDS_TO_WEAK },
3313 
  { "allow_stack_execution", BFD_MACH_O_MH_ALLOW_STACK_EXECUTION },
3314 
  { "root_safe", BFD_MACH_O_MH_ROOT_SAFE },
3315 
  { "setuid_safe", BFD_MACH_O_MH_SETUID_SAFE },
3316 
  { "no_reexported_dylibs", BFD_MACH_O_MH_NO_REEXPORTED_DYLIBS },
3317 
  { "pie", BFD_MACH_O_MH_PIE },
3318 
  { NULL, 0}
3319 
};
3320 
 
3321 
static bfd_mach_o_xlat_name bfd_mach_o_section_type_name[] =
3322 
{
3323 
  { "regular", BFD_MACH_O_S_REGULAR},
3324 
  { "zerofill", BFD_MACH_O_S_ZEROFILL},
3325 
  { "cstring_literals", BFD_MACH_O_S_CSTRING_LITERALS},
3326 
  { "4byte_literals", BFD_MACH_O_S_4BYTE_LITERALS},
3327 
  { "8byte_literals", BFD_MACH_O_S_8BYTE_LITERALS},
3328 
  { "literal_pointers", BFD_MACH_O_S_LITERAL_POINTERS},
3329 
  { "non_lazy_symbol_pointers", BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS},
3330 
  { "lazy_symbol_pointers", BFD_MACH_O_S_LAZY_SYMBOL_POINTERS},
3331 
  { "symbol_stubs", BFD_MACH_O_S_SYMBOL_STUBS},
3332 
  { "mod_init_func_pointers", BFD_MACH_O_S_MOD_INIT_FUNC_POINTERS},
3333 
  { "mod_fini_func_pointers", BFD_MACH_O_S_MOD_FINI_FUNC_POINTERS},
3334 
  { "coalesced", BFD_MACH_O_S_COALESCED},
3335 
  { "gb_zerofill", BFD_MACH_O_S_GB_ZEROFILL},
3336 
  { "interposing", BFD_MACH_O_S_INTERPOSING},
3337 
  { "16byte_literals", BFD_MACH_O_S_16BYTE_LITERALS},
3338 
  { "dtrace_dof", BFD_MACH_O_S_DTRACE_DOF},
3339 
  { "lazy_dylib_symbol_pointers", BFD_MACH_O_S_LAZY_DYLIB_SYMBOL_POINTERS},
3340 
  { NULL, 0}
3341 
};
3342 
 
3343 
static bfd_mach_o_xlat_name bfd_mach_o_section_attribute_name[] =
3344 
{
3345 
  { "loc_reloc", BFD_MACH_O_S_ATTR_LOC_RELOC },
3346 
  { "ext_reloc", BFD_MACH_O_S_ATTR_EXT_RELOC },
3347 
  { "some_instructions", BFD_MACH_O_S_ATTR_SOME_INSTRUCTIONS },
3348 
  { "debug", BFD_MACH_O_S_ATTR_DEBUG },
3349 
  { "modifying_code", BFD_MACH_O_S_SELF_MODIFYING_CODE },
3350 
  { "live_support", BFD_MACH_O_S_ATTR_LIVE_SUPPORT },
3351 
  { "no_dead_strip", BFD_MACH_O_S_ATTR_NO_DEAD_STRIP },
3352 
  { "strip_static_syms", BFD_MACH_O_S_ATTR_STRIP_STATIC_SYMS },
3353 
  { "no_toc", BFD_MACH_O_S_ATTR_NO_TOC },
3354 
  { "pure_instructions", BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS },
3355 
  { NULL, 0}
3356 
};
3357 
 
3358 
static bfd_mach_o_xlat_name bfd_mach_o_load_command_name[] =
3359 
{
3360 
  { "segment", BFD_MACH_O_LC_SEGMENT},
3361 
  { "symtab", BFD_MACH_O_LC_SYMTAB},
3362 
  { "symseg", BFD_MACH_O_LC_SYMSEG},
3363 
  { "thread", BFD_MACH_O_LC_THREAD},
3364 
  { "unixthread", BFD_MACH_O_LC_UNIXTHREAD},
3365 
  { "loadfvmlib", BFD_MACH_O_LC_LOADFVMLIB},
3366 
  { "idfvmlib", BFD_MACH_O_LC_IDFVMLIB},
3367 
  { "ident", BFD_MACH_O_LC_IDENT},
3368 
  { "fvmfile", BFD_MACH_O_LC_FVMFILE},
3369 
  { "prepage", BFD_MACH_O_LC_PREPAGE},
3370 
  { "dysymtab", BFD_MACH_O_LC_DYSYMTAB},
3371 
  { "load_dylib", BFD_MACH_O_LC_LOAD_DYLIB},
3372 
  { "id_dylib", BFD_MACH_O_LC_ID_DYLIB},
3373 
  { "load_dylinker", BFD_MACH_O_LC_LOAD_DYLINKER},
3374 
  { "id_dylinker", BFD_MACH_O_LC_ID_DYLINKER},
3375 
  { "prebound_dylib", BFD_MACH_O_LC_PREBOUND_DYLIB},
3376 
  { "routines", BFD_MACH_O_LC_ROUTINES},
3377 
  { "sub_framework", BFD_MACH_O_LC_SUB_FRAMEWORK},
3378 
  { "sub_umbrella", BFD_MACH_O_LC_SUB_UMBRELLA},
3379 
  { "sub_client", BFD_MACH_O_LC_SUB_CLIENT},
3380 
  { "sub_library", BFD_MACH_O_LC_SUB_LIBRARY},
3381 
  { "twolevel_hints", BFD_MACH_O_LC_TWOLEVEL_HINTS},
3382 
  { "prebind_cksum", BFD_MACH_O_LC_PREBIND_CKSUM},
3383 
  { "load_weak_dylib", BFD_MACH_O_LC_LOAD_WEAK_DYLIB},
3384 
  { "segment_64", BFD_MACH_O_LC_SEGMENT_64},
3385 
  { "routines_64", BFD_MACH_O_LC_ROUTINES_64},
3386 
  { "uuid", BFD_MACH_O_LC_UUID},
3387 
  { "rpath", BFD_MACH_O_LC_RPATH},
3388 
  { "code_signature", BFD_MACH_O_LC_CODE_SIGNATURE},
3389 
  { "segment_split_info", BFD_MACH_O_LC_SEGMENT_SPLIT_INFO},
3390 
  { "reexport_dylib", BFD_MACH_O_LC_REEXPORT_DYLIB},
3391 
  { "lazy_load_dylib", BFD_MACH_O_LC_LAZY_LOAD_DYLIB},
3392 
  { "encryption_info", BFD_MACH_O_LC_ENCRYPTION_INFO},
3393 
  { "dyld_info", BFD_MACH_O_LC_DYLD_INFO},
3394 
  { NULL, 0}
3395 
};
3396 
 
3397 
static void
3398 
bfd_mach_o_print_private_header (bfd *abfd, FILE *file)
3399 
{
3400 
  bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3401 
  bfd_mach_o_header *h = &mdata->header;
3402 
 
3403 
  fputs (_("Mach-O header:\n"), file);
3404 
  fprintf (file, _(" magic     : %08lx\n"), h->magic);
3405 
  fprintf (file, _(" cputype   : %08lx (%s)\n"), h->cputype,
3406 
           bfd_mach_o_get_name (bfd_mach_o_cpu_name, h->cputype));
3407 
  fprintf (file, _(" cpusubtype: %08lx\n"), h->cpusubtype);
3408 
  fprintf (file, _(" filetype  : %08lx (%s)\n"),
3409 
           h->filetype,
3410 
           bfd_mach_o_get_name (bfd_mach_o_filetype_name, h->filetype));
3411 
  fprintf (file, _(" ncmds     : %08lx (%lu)\n"), h->ncmds, h->ncmds);
3412 
  fprintf (file, _(" sizeofcmds: %08lx\n"), h->sizeofcmds);
3413 
  fprintf (file, _(" flags     : %08lx ("), h->flags);
3414 
  bfd_mach_o_print_flags (bfd_mach_o_header_flags_name, h->flags, file);
3415 
  fputs (_(")\n"), file);
3416 
  fprintf (file, _(" reserved  : %08x\n"), h->reserved);
3417 
}
3418 
 
3419 
static void
3420 
bfd_mach_o_print_section_map (bfd *abfd, FILE *file)
3421 
{
3422 
  bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3423 
  unsigned int i, j;
3424 
  unsigned int sec_nbr = 0;
3425 
 
3426 
  fputs (_("Segments and Sections:\n"), file);
3427 
  fputs (_(" #: Segment name     Section name     Address\n"), file);
3428 
 
3429 
  for (i = 0; i < mdata->header.ncmds; i++)
3430 
    {
3431 
      bfd_mach_o_segment_command *seg;
3432 
 
3433 
      if (mdata->commands[i].type != BFD_MACH_O_LC_SEGMENT
3434 
          && mdata->commands[i].type != BFD_MACH_O_LC_SEGMENT_64)
3435 
        continue;
3436 
 
3437 
      seg = &mdata->commands[i].command.segment;
3438 
 
3439 
      fprintf (file, "[Segment %-16s ", seg->segname);
3440 
      fprintf_vma (file, seg->vmaddr);
3441 
      fprintf (file, "-");
3442 
      fprintf_vma  (file, seg->vmaddr + seg->vmsize - 1);
3443 
      fputc (' ', file);
3444 
      fputc (seg->initprot & BFD_MACH_O_PROT_READ ? 'r' : '-', file);
3445 
      fputc (seg->initprot & BFD_MACH_O_PROT_WRITE ? 'w' : '-', file);
3446 
      fputc (seg->initprot & BFD_MACH_O_PROT_EXECUTE ? 'x' : '-', file);
3447 
      fprintf (file, "]\n");
3448 
      for (j = 0; j < seg->nsects; j++)
3449 
        {
3450 
          bfd_mach_o_section *sec = &seg->sections[j];
3451 
          fprintf (file, "%02u: %-16s %-16s ", ++sec_nbr,
3452 
                   sec->segname, sec->sectname);
3453 
          fprintf_vma (file, sec->addr);
3454 
          fprintf (file, " ");
3455 
          fprintf_vma  (file, sec->size);
3456 
          fprintf (file, " %08lx\n", sec->flags);
3457 
        }
3458 
    }
3459 
}
3460 
 
3461 
static void
3462 
bfd_mach_o_print_section (bfd *abfd ATTRIBUTE_UNUSED,
3463 
                          bfd_mach_o_section *sec, FILE *file)
3464 
{
3465 
  fprintf (file, " Section: %-16s %-16s (bfdname: %s)\n",
3466 
           sec->sectname, sec->segname, sec->bfdsection->name);
3467 
  fprintf (file, "  addr: ");
3468 
  fprintf_vma (file, sec->addr);
3469 
  fprintf (file, " size: ");
3470 
  fprintf_vma  (file, sec->size);
3471 
  fprintf (file, " offset: ");
3472 
  fprintf_vma (file, sec->offset);
3473 
  fprintf (file, "\n");
3474 
  fprintf (file, "  align: %ld", sec->align);
3475 
  fprintf (file, "  nreloc: %lu  reloff: ", sec->nreloc);
3476 
  fprintf_vma (file, sec->reloff);
3477 
  fprintf (file, "\n");
3478 
  fprintf (file, "  flags: %08lx (type: %s", sec->flags,
3479 
           bfd_mach_o_get_name (bfd_mach_o_section_type_name,
3480 
                                sec->flags & BFD_MACH_O_SECTION_TYPE_MASK));
3481 
  fprintf (file, " attr: ");
3482 
  bfd_mach_o_print_flags (bfd_mach_o_section_attribute_name,
3483 
                          sec->flags & BFD_MACH_O_SECTION_ATTRIBUTES_MASK,
3484 
                          file);
3485 
  fprintf (file, ")\n");
3486 
  switch (sec->flags & BFD_MACH_O_SECTION_TYPE_MASK)
3487 
    {
3488 
    case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS:
3489 
    case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS:
3490 
    case BFD_MACH_O_S_SYMBOL_STUBS:
3491 
      fprintf (file, "  first indirect sym: %lu", sec->reserved1);
3492 
      fprintf (file, " (%u entries)",
3493 
               bfd_mach_o_section_get_nbr_indirect (abfd, sec));
3494 
      break;
3495 
    default:
3496 
      fprintf (file, "  reserved1: 0x%lx", sec->reserved1);
3497 
      break;
3498 
    }
3499 
  switch (sec->flags & BFD_MACH_O_SECTION_TYPE_MASK)
3500 
    {
3501 
    case BFD_MACH_O_S_SYMBOL_STUBS:
3502 
      fprintf (file, "  stub size: %lu", sec->reserved2);
3503 
      break;
3504 
    default:
3505 
      fprintf (file, "  reserved2: 0x%lx", sec->reserved2);
3506 
      break;
3507 
    }
3508 
  fprintf (file, "  reserved3: 0x%lx\n", sec->reserved3);
3509 
}
3510 
 
3511 
static void
3512 
bfd_mach_o_print_segment (bfd *abfd ATTRIBUTE_UNUSED,
3513 
                          bfd_mach_o_load_command *cmd, FILE *file)
3514 
{
3515 
  bfd_mach_o_segment_command *seg = &cmd->command.segment;
3516 
  unsigned int i;
3517 
 
3518 
  fprintf (file, " name: %s\n", *seg->segname ? seg->segname : "*none*");
3519 
  fprintf (file, "    vmaddr: ");
3520 
  fprintf_vma (file, seg->vmaddr);
3521 
  fprintf (file, "   vmsize: ");
3522 
  fprintf_vma  (file, seg->vmsize);
3523 
  fprintf (file, "\n");
3524 
  fprintf (file, "   fileoff: ");
3525 
  fprintf_vma (file, seg->fileoff);
3526 
  fprintf (file, " filesize: ");
3527 
  fprintf_vma (file, (bfd_vma)seg->filesize);
3528 
  fprintf (file, " endoff: ");
3529 
  fprintf_vma (file, (bfd_vma)(seg->fileoff + seg->filesize));
3530 
  fprintf (file, "\n");
3531 
  fprintf (file, "   nsects: %lu  ", seg->nsects);
3532 
  fprintf (file, " flags: %lx\n", seg->flags);
3533 
  for (i = 0; i < seg->nsects; i++)
3534 
    bfd_mach_o_print_section (abfd, &seg->sections[i], file);
3535 
}
3536 
 
3537 
static void
3538 
bfd_mach_o_print_dysymtab (bfd *abfd ATTRIBUTE_UNUSED,
3539 
                           bfd_mach_o_load_command *cmd, FILE *file)
3540 
{
3541 
  bfd_mach_o_dysymtab_command *dysymtab = &cmd->command.dysymtab;
3542 
  bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3543 
  unsigned int i;
3544 
 
3545 
  fprintf (file, "              local symbols: idx: %10lu  num: %-8lu",
3546 
           dysymtab->ilocalsym, dysymtab->nlocalsym);
3547 
  fprintf (file, " (nxtidx: %lu)\n",
3548 
           dysymtab->ilocalsym + dysymtab->nlocalsym);
3549 
  fprintf (file, "           external symbols: idx: %10lu  num: %-8lu",
3550 
           dysymtab->iextdefsym, dysymtab->nextdefsym);
3551 
  fprintf (file, " (nxtidx: %lu)\n",
3552 
           dysymtab->iextdefsym + dysymtab->nextdefsym);
3553 
  fprintf (file, "          undefined symbols: idx: %10lu  num: %-8lu",
3554 
           dysymtab->iundefsym, dysymtab->nundefsym);
3555 
  fprintf (file, " (nxtidx: %lu)\n",
3556 
           dysymtab->iundefsym + dysymtab->nundefsym);
3557 
  fprintf (file, "           table of content: off: 0x%08lx  num: %-8lu",
3558 
           dysymtab->tocoff, dysymtab->ntoc);
3559 
  fprintf (file, " (endoff: 0x%08lx)\n",
3560 
           dysymtab->tocoff
3561 
           + dysymtab->ntoc * BFD_MACH_O_TABLE_OF_CONTENT_SIZE);
3562 
  fprintf (file, "               module table: off: 0x%08lx  num: %-8lu",
3563 
           dysymtab->modtaboff, dysymtab->nmodtab);
3564 
  fprintf (file, " (endoff: 0x%08lx)\n",
3565 
           dysymtab->modtaboff + dysymtab->nmodtab
3566 
           * (mach_o_wide_p (&mdata->header) ?
3567 
              BFD_MACH_O_DYLIB_MODULE_64_SIZE : BFD_MACH_O_DYLIB_MODULE_SIZE));
3568 
  fprintf (file, "   external reference table: off: 0x%08lx  num: %-8lu",
3569 
           dysymtab->extrefsymoff, dysymtab->nextrefsyms);
3570 
  fprintf (file, " (endoff: 0x%08lx)\n",
3571 
           dysymtab->extrefsymoff
3572 
           + dysymtab->nextrefsyms * BFD_MACH_O_REFERENCE_SIZE);
3573 
  fprintf (file, "      indirect symbol table: off: 0x%08lx  num: %-8lu",
3574 
           dysymtab->indirectsymoff, dysymtab->nindirectsyms);
3575 
  fprintf (file, " (endoff: 0x%08lx)\n",
3576 
           dysymtab->indirectsymoff
3577 
           + dysymtab->nindirectsyms * BFD_MACH_O_INDIRECT_SYMBOL_SIZE);
3578 
  fprintf (file, "  external relocation table: off: 0x%08lx  num: %-8lu",
3579 
           dysymtab->extreloff, dysymtab->nextrel);
3580 
  fprintf (file, " (endoff: 0x%08lx)\n",
3581 
           dysymtab->extreloff + dysymtab->nextrel * BFD_MACH_O_RELENT_SIZE);
3582 
  fprintf (file, "     local relocation table: off: 0x%08lx  num: %-8lu",
3583 
           dysymtab->locreloff, dysymtab->nlocrel);
3584 
  fprintf (file, " (endoff: 0x%08lx)\n",
3585 
           dysymtab->locreloff + dysymtab->nlocrel * BFD_MACH_O_RELENT_SIZE);
3586 
 
3587 
  if (dysymtab->ntoc > 0
3588 
      || dysymtab->nindirectsyms > 0
3589 
      || dysymtab->nextrefsyms > 0)
3590 
    {
3591 
      /* Try to read the symbols to display the toc or indirect symbols.  */
3592 
      bfd_mach_o_read_symtab_symbols (abfd);
3593 
    }
3594 
  else if (dysymtab->nmodtab > 0)
3595 
    {
3596 
      /* Try to read the strtab to display modules name.  */
3597 
      bfd_mach_o_read_symtab_strtab (abfd);
3598 
    }
3599 
 
3600 
  for (i = 0; i < dysymtab->nmodtab; i++)
3601 
    {
3602 
      bfd_mach_o_dylib_module *module = &dysymtab->dylib_module[i];
3603 
      fprintf (file, "  module %u:\n", i);
3604 
      fprintf (file, "   name: %lu", module->module_name_idx);
3605 
      if (mdata->symtab && mdata->symtab->strtab)
3606 
        fprintf (file, ": %s",
3607 
                 mdata->symtab->strtab + module->module_name_idx);
3608 
      fprintf (file, "\n");
3609 
      fprintf (file, "   extdefsym: idx: %8lu  num: %lu\n",
3610 
               module->iextdefsym, module->nextdefsym);
3611 
      fprintf (file, "      refsym: idx: %8lu  num: %lu\n",
3612 
               module->irefsym, module->nrefsym);
3613 
      fprintf (file, "    localsym: idx: %8lu  num: %lu\n",
3614 
               module->ilocalsym, module->nlocalsym);
3615 
      fprintf (file, "      extrel: idx: %8lu  num: %lu\n",
3616 
               module->iextrel, module->nextrel);
3617 
      fprintf (file, "        init: idx: %8u  num: %u\n",
3618 
               module->iinit, module->ninit);
3619 
      fprintf (file, "        term: idx: %8u  num: %u\n",
3620 
               module->iterm, module->nterm);
3621 
      fprintf (file, "   objc_module_info: addr: ");
3622 
      fprintf_vma (file, module->objc_module_info_addr);
3623 
      fprintf (file, "  size: %lu\n", module->objc_module_info_size);
3624 
    }
3625 
 
3626 
  if (dysymtab->ntoc > 0)
3627 
    {
3628 
      bfd_mach_o_symtab_command *symtab = mdata->symtab;
3629 
 
3630 
      fprintf (file, "  table of content: (symbol/module)\n");
3631 
      for (i = 0; i < dysymtab->ntoc; i++)
3632 
        {
3633 
          bfd_mach_o_dylib_table_of_content *toc = &dysymtab->dylib_toc[i];
3634 
 
3635 
          fprintf (file, "   %4u: ", i);
3636 
          if (symtab && symtab->symbols && toc->symbol_index < symtab->nsyms)
3637 
            {
3638 
              const char *name = symtab->symbols[toc->symbol_index].symbol.name;
3639 
              fprintf (file, "%s (%lu)", name ? name : "*invalid*",
3640 
                       toc->symbol_index);
3641 
            }
3642 
          else
3643 
            fprintf (file, "%lu", toc->symbol_index);
3644 
 
3645 
          fprintf (file, " / ");
3646 
          if (symtab && symtab->strtab
3647 
              && toc->module_index < dysymtab->nmodtab)
3648 
            {
3649 
              bfd_mach_o_dylib_module *mod;
3650 
              mod = &dysymtab->dylib_module[toc->module_index];
3651 
              fprintf (file, "%s (%lu)",
3652 
                       symtab->strtab + mod->module_name_idx,
3653 
                       toc->module_index);
3654 
            }
3655 
          else
3656 
            fprintf (file, "%lu", toc->module_index);
3657 
 
3658 
          fprintf (file, "\n");
3659 
        }
3660 
    }
3661 
 
3662 
  if (dysymtab->nindirectsyms != 0)
3663 
    {
3664 
      fprintf (file, "  indirect symbols:\n");
3665 
 
3666 
      for (i = 0; i < mdata->nsects; i++)
3667 
        {
3668 
          bfd_mach_o_section *sec = mdata->sections[i];
3669 
          unsigned int j, first, last;
3670 
          bfd_mach_o_symtab_command *symtab = mdata->symtab;
3671 
          bfd_vma addr;
3672 
          bfd_vma entry_size;
3673 
 
3674 
          switch (sec->flags & BFD_MACH_O_SECTION_TYPE_MASK)
3675 
            {
3676 
            case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS:
3677 
            case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS:
3678 
            case BFD_MACH_O_S_SYMBOL_STUBS:
3679 
              first = sec->reserved1;
3680 
              last = first + bfd_mach_o_section_get_nbr_indirect (abfd, sec);
3681 
              addr = sec->addr;
3682 
              entry_size = bfd_mach_o_section_get_entry_size (abfd, sec);
3683 
              fprintf (file, "  for section %s.%s:\n",
3684 
                       sec->segname, sec->sectname);
3685 
              for (j = first; j < last; j++)
3686 
                {
3687 
                  unsigned int isym = dysymtab->indirect_syms[j];
3688 
 
3689 
                  fprintf (file, "   ");
3690 
                  fprintf_vma (file, addr);
3691 
                  fprintf (file, " %5u: 0x%08x", j, isym);
3692 
                  if (isym & BFD_MACH_O_INDIRECT_SYMBOL_LOCAL)
3693 
                    fprintf (file, " LOCAL");
3694 
                  if (isym & BFD_MACH_O_INDIRECT_SYMBOL_ABS)
3695 
                    fprintf (file, " ABSOLUTE");
3696 
                  if (symtab && symtab->symbols
3697 
                      && isym < symtab->nsyms
3698 
                      && symtab->symbols[isym].symbol.name)
3699 
                    fprintf (file, " %s", symtab->symbols[isym].symbol.name);
3700 
                  fprintf (file, "\n");
3701 
                  addr += entry_size;
3702 
                }
3703 
              break;
3704 
            default:
3705 
              break;
3706 
            }
3707 
        }
3708 
    }
3709 
  if (dysymtab->nextrefsyms > 0)
3710 
    {
3711 
      bfd_mach_o_symtab_command *symtab = mdata->symtab;
3712 
 
3713 
      fprintf (file, "  external reference table: (symbol flags)\n");
3714 
      for (i = 0; i < dysymtab->nextrefsyms; i++)
3715 
        {
3716 
          bfd_mach_o_dylib_reference *ref = &dysymtab->ext_refs[i];
3717 
 
3718 
          fprintf (file, "   %4u: %5lu 0x%02lx", i, ref->isym, ref->flags);
3719 
          if (symtab && symtab->symbols
3720 
              && ref->isym < symtab->nsyms
3721 
              && symtab->symbols[ref->isym].symbol.name)
3722 
            fprintf (file, " %s", symtab->symbols[ref->isym].symbol.name);
3723 
          fprintf (file, "\n");
3724 
        }
3725 
    }
3726 
 
3727 
}
3728 
 
3729 
static void
3730 
bfd_mach_o_print_dyld_info (bfd *abfd ATTRIBUTE_UNUSED,
3731 
                            bfd_mach_o_load_command *cmd, FILE *file)
3732 
{
3733 
  bfd_mach_o_dyld_info_command *info = &cmd->command.dyld_info;
3734 
 
3735 
  fprintf (file, "       rebase: off: 0x%08x  size: %-8u\n",
3736 
           info->rebase_off, info->rebase_size);
3737 
  fprintf (file, "         bind: off: 0x%08x  size: %-8u\n",
3738 
           info->bind_off, info->bind_size);
3739 
  fprintf (file, "    weak bind: off: 0x%08x  size: %-8u\n",
3740 
           info->weak_bind_off, info->weak_bind_size);
3741 
  fprintf (file, "    lazy bind: off: 0x%08x  size: %-8u\n",
3742 
           info->lazy_bind_off, info->lazy_bind_size);
3743 
  fprintf (file, "       export: off: 0x%08x  size: %-8u\n",
3744 
           info->export_off, info->export_size);
3745 
}
3746 
 
3747 
bfd_boolean
3748 
bfd_mach_o_bfd_print_private_bfd_data (bfd *abfd, void * ptr)
3749 
{
3750 
  bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3751 
  FILE *file = (FILE *) ptr;
3752 
  unsigned int i;
3753 
 
3754 
  bfd_mach_o_print_private_header (abfd, file);
3755 
  fputc ('\n', file);
3756 
 
3757 
  for (i = 0; i < mdata->header.ncmds; i++)
3758 
    {
3759 
      bfd_mach_o_load_command *cmd = &mdata->commands[i];
3760 
 
3761 
      fprintf (file, "Load command %s:",
3762 
               bfd_mach_o_get_name (bfd_mach_o_load_command_name, cmd->type));
3763 
      switch (cmd->type)
3764 
        {
3765 
        case BFD_MACH_O_LC_SEGMENT:
3766 
        case BFD_MACH_O_LC_SEGMENT_64:
3767 
          bfd_mach_o_print_segment (abfd, cmd, file);
3768 
          break;
3769 
        case BFD_MACH_O_LC_UUID:
3770 
          {
3771 
            bfd_mach_o_uuid_command *uuid = &cmd->command.uuid;
3772 
            unsigned int j;
3773 
 
3774 
            for (j = 0; j < sizeof (uuid->uuid); j ++)
3775 
              fprintf (file, " %02x", uuid->uuid[j]);
3776 
            fputc ('\n', file);
3777 
          }
3778 
          break;
3779 
        case BFD_MACH_O_LC_LOAD_DYLIB:
3780 
        case BFD_MACH_O_LC_LOAD_WEAK_DYLIB:
3781 
        case BFD_MACH_O_LC_REEXPORT_DYLIB:
3782 
        case BFD_MACH_O_LC_ID_DYLIB:
3783 
          {
3784 
            bfd_mach_o_dylib_command *dylib = &cmd->command.dylib;
3785 
            fprintf (file, " %s\n", dylib->name_str);
3786 
            fprintf (file, "            time stamp: 0x%08lx\n",
3787 
                     dylib->timestamp);
3788 
            fprintf (file, "       current version: 0x%08lx\n",
3789 
                     dylib->current_version);
3790 
            fprintf (file, "  comptibility version: 0x%08lx\n",
3791 
                     dylib->compatibility_version);
3792 
            break;
3793 
          }
3794 
        case BFD_MACH_O_LC_LOAD_DYLINKER:
3795 
        case BFD_MACH_O_LC_ID_DYLINKER:
3796 
          fprintf (file, " %s\n", cmd->command.dylinker.name_str);
3797 
          break;
3798 
        case BFD_MACH_O_LC_SYMTAB:
3799 
          {
3800 
            bfd_mach_o_symtab_command *symtab = &cmd->command.symtab;
3801 
            fprintf (file,
3802 
                     "\n"
3803 
                     "   symoff: 0x%08x    nsyms: %8u  (endoff: 0x%08x)\n",
3804 
                     symtab->symoff, symtab->nsyms,
3805 
                     symtab->symoff + symtab->nsyms
3806 
                     * (mach_o_wide_p (&mdata->header)
3807 
                        ? BFD_MACH_O_NLIST_64_SIZE : BFD_MACH_O_NLIST_SIZE));
3808 
            fprintf (file,
3809 
                     "   stroff: 0x%08x  strsize: %8u  (endoff: 0x%08x)\n",
3810 
                     symtab->stroff, symtab->strsize,
3811 
                     symtab->stroff + symtab->strsize);
3812 
            break;
3813 
          }
3814 
        case BFD_MACH_O_LC_DYSYMTAB:
3815 
          fprintf (file, "\n");
3816 
          bfd_mach_o_print_dysymtab (abfd, cmd, file);
3817 
          break;
3818 
        case BFD_MACH_O_LC_CODE_SIGNATURE:
3819 
        case BFD_MACH_O_LC_SEGMENT_SPLIT_INFO:
3820 
          {
3821 
            bfd_mach_o_linkedit_command *linkedit = &cmd->command.linkedit;
3822 
            fprintf
3823 
              (file, "\n"
3824 
               "  dataoff: 0x%08lx  datasize: 0x%08lx  (endoff: 0x%08lx)\n",
3825 
               linkedit->dataoff, linkedit->datasize,
3826 
               linkedit->dataoff + linkedit->datasize);
3827 
            break;
3828 
          }
3829 
        case BFD_MACH_O_LC_SUB_FRAMEWORK:
3830 
        case BFD_MACH_O_LC_SUB_UMBRELLA:
3831 
        case BFD_MACH_O_LC_SUB_LIBRARY:
3832 
        case BFD_MACH_O_LC_SUB_CLIENT:
3833 
        case BFD_MACH_O_LC_RPATH:
3834 
          {
3835 
            bfd_mach_o_str_command *str = &cmd->command.str;
3836 
            fprintf (file, " %s\n", str->str);
3837 
            break;
3838 
          }
3839 
        case BFD_MACH_O_LC_THREAD:
3840 
        case BFD_MACH_O_LC_UNIXTHREAD:
3841 
          {
3842 
            bfd_mach_o_thread_command *thread = &cmd->command.thread;
3843 
            unsigned int j;
3844 
            bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
3845 
 
3846 
            fprintf (file, " nflavours: %lu\n", thread->nflavours);
3847 
            for (j = 0; j < thread->nflavours; j++)
3848 
              {
3849 
                bfd_mach_o_thread_flavour *flavour = &thread->flavours[j];
3850 
 
3851 
                fprintf (file, "  %2u: flavour: 0x%08lx  offset: 0x%08lx"
3852 
                         "  size: 0x%08lx\n",
3853 
                         j, flavour->flavour, flavour->offset,
3854 
                         flavour->size);
3855 
                if (bed->_bfd_mach_o_print_thread)
3856 
                  {
3857 
                    char *buf = bfd_malloc (flavour->size);
3858 
 
3859 
                    if (buf
3860 
                        && bfd_seek (abfd, flavour->offset, SEEK_SET) == 0
3861 
                        && (bfd_bread (buf, flavour->size, abfd)
3862 
                            == flavour->size))
3863 
                      (*bed->_bfd_mach_o_print_thread)(abfd, flavour,
3864 
                                                       file, buf);
3865 
                    free (buf);
3866 
                  }
3867 
              }
3868 
            break;
3869 
          }
3870 
        case BFD_MACH_O_LC_DYLD_INFO:
3871 
          fprintf (file, "\n");
3872 
          bfd_mach_o_print_dyld_info (abfd, cmd, file);
3873 
          break;
3874 
        default:
3875 
          fprintf (file, "\n");
3876 
          break;
3877 
        }
3878 
      fputc ('\n', file);
3879 
    }
3880 
 
3881 
  bfd_mach_o_print_section_map (abfd, file);
3882 
 
3883 
  return TRUE;
3884 
}
3885 
 
3886 
int
3887 
bfd_mach_o_core_fetch_environment (bfd *abfd,
3888 
                                   unsigned char **rbuf,
3889 
                                   unsigned int *rlen)
3890 
{
3891 
  bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3892 
  unsigned long stackaddr = bfd_mach_o_stack_addr (mdata->header.cputype);
3893 
  unsigned int i = 0;
3894 
 
3895 
  for (i = 0; i < mdata->header.ncmds; i++)
3896 
    {
3897 
      bfd_mach_o_load_command *cur = &mdata->commands[i];
3898 
      bfd_mach_o_segment_command *seg = NULL;
3899 
 
3900 
      if (cur->type != BFD_MACH_O_LC_SEGMENT)
3901 
        continue;
3902 
 
3903 
      seg = &cur->command.segment;
3904 
 
3905 
      if ((seg->vmaddr + seg->vmsize) == stackaddr)
3906 
        {
3907 
          unsigned long start = seg->fileoff;
3908 
          unsigned long end = seg->fileoff + seg->filesize;
3909 
          unsigned char *buf = bfd_malloc (1024);
3910 
          unsigned long size = 1024;
3911 
 
3912 
          for (;;)
3913 
            {
3914 
              bfd_size_type nread = 0;
3915 
              unsigned long offset;
3916 
              int found_nonnull = 0;
3917 
 
3918 
              if (size > (end - start))
3919 
                size = (end - start);
3920 
 
3921 
              buf = bfd_realloc_or_free (buf, size);
3922 
              if (buf == NULL)
3923 
                return -1;
3924 
 
3925 
              if (bfd_seek (abfd, end - size, SEEK_SET) != 0)
3926 
                {
3927 
                  free (buf);
3928 
                  return -1;
3929 
                }
3930 
 
3931 
              nread = bfd_bread (buf, size, abfd);
3932 
 
3933 
              if (nread != size)
3934 
                {
3935 
                  free (buf);
3936 
                  return -1;
3937 
                }
3938 
 
3939 
              for (offset = 4; offset <= size; offset += 4)
3940 
                {
3941 
                  unsigned long val;
3942 
 
3943 
                  val = *((unsigned long *) (buf + size - offset));
3944 
                  if (! found_nonnull)
3945 
                    {
3946 
                      if (val != 0)
3947 
                        found_nonnull = 1;
3948 
                    }
3949 
                  else if (val == 0x0)
3950 
                    {
3951 
                      unsigned long bottom;
3952 
                      unsigned long top;
3953 
 
3954 
                      bottom = seg->fileoff + seg->filesize - offset;
3955 
                      top = seg->fileoff + seg->filesize - 4;
3956 
                      *rbuf = bfd_malloc (top - bottom);
3957 
                      *rlen = top - bottom;
3958 
 
3959 
                      memcpy (*rbuf, buf + size - *rlen, *rlen);
3960 
                      free (buf);
3961 
                      return 0;
3962 
                    }
3963 
                }
3964 
 
3965 
              if (size == (end - start))
3966 
                break;
3967 
 
3968 
              size *= 2;
3969 
            }
3970 
 
3971 
          free (buf);
3972 
        }
3973 
    }
3974 
 
3975 
  return -1;
3976 
}
3977 
 
3978 
char *
3979 
bfd_mach_o_core_file_failing_command (bfd *abfd)
3980 
{
3981 
  unsigned char *buf = NULL;
3982 
  unsigned int len = 0;
3983 
  int ret = -1;
3984 
 
3985 
  ret = bfd_mach_o_core_fetch_environment (abfd, &buf, &len);
3986 
  if (ret < 0)
3987 
    return NULL;
3988 
 
3989 
  return (char *) buf;
3990 
}
3991 
 
3992 
int
3993 
bfd_mach_o_core_file_failing_signal (bfd *abfd ATTRIBUTE_UNUSED)
3994 
{
3995 
  return 0;
3996 
}
3997 
 
3998 
#define bfd_mach_o_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
3999 
#define bfd_mach_o_bfd_reloc_name_lookup _bfd_norelocs_bfd_reloc_name_lookup
4000 
 
4001 
#define bfd_mach_o_swap_reloc_in NULL
4002 
#define bfd_mach_o_swap_reloc_out NULL
4003 
#define bfd_mach_o_print_thread NULL
4004 
 
4005 
#define TARGET_NAME             mach_o_be_vec
4006 
#define TARGET_STRING           "mach-o-be"
4007 
#define TARGET_ARCHITECTURE     bfd_arch_unknown
4008 
#define TARGET_BIG_ENDIAN       1
4009 
#define TARGET_ARCHIVE          0
4010 
#include "mach-o-target.c"
4011 
 
4012 
#undef TARGET_NAME
4013 
#undef TARGET_STRING
4014 
#undef TARGET_ARCHITECTURE
4015 
#undef TARGET_BIG_ENDIAN
4016 
#undef TARGET_ARCHIVE
4017 
 
4018 
#define TARGET_NAME             mach_o_le_vec
4019 
#define TARGET_STRING           "mach-o-le"
4020 
#define TARGET_ARCHITECTURE     bfd_arch_unknown
4021 
#define TARGET_BIG_ENDIAN       0
4022 
#define TARGET_ARCHIVE          0
4023 
 
4024 
#include "mach-o-target.c"
4025 
 
4026 
#undef TARGET_NAME
4027 
#undef TARGET_STRING
4028 
#undef TARGET_ARCHITECTURE
4029 
#undef TARGET_BIG_ENDIAN
4030 
#undef TARGET_ARCHIVE
4031 
 
4032 
/* Not yet handled: creating an archive.  */
4033 
#define bfd_mach_o_mkarchive                      _bfd_noarchive_mkarchive
4034 
 
4035 
/* Not used.  */
4036 
#define bfd_mach_o_read_ar_hdr                    _bfd_noarchive_read_ar_hdr
4037 
#define bfd_mach_o_write_ar_hdr                   _bfd_noarchive_write_ar_hdr
4038 
#define bfd_mach_o_slurp_armap                    _bfd_noarchive_slurp_armap
4039 
#define bfd_mach_o_slurp_extended_name_table      _bfd_noarchive_slurp_extended_name_table
4040 
#define bfd_mach_o_construct_extended_name_table  _bfd_noarchive_construct_extended_name_table
4041 
#define bfd_mach_o_truncate_arname                _bfd_noarchive_truncate_arname
4042 
#define bfd_mach_o_write_armap                    _bfd_noarchive_write_armap
4043 
#define bfd_mach_o_get_elt_at_index               _bfd_noarchive_get_elt_at_index
4044 
#define bfd_mach_o_generic_stat_arch_elt          _bfd_noarchive_generic_stat_arch_elt
4045 
#define bfd_mach_o_update_armap_timestamp         _bfd_noarchive_update_armap_timestamp
4046 
 
4047 
#define TARGET_NAME             mach_o_fat_vec
4048 
#define TARGET_STRING           "mach-o-fat"
4049 
#define TARGET_ARCHITECTURE     bfd_arch_unknown
4050 
#define TARGET_BIG_ENDIAN       1
4051 
#define TARGET_ARCHIVE          1
4052 
 
4053 
#include "mach-o-target.c"
4054 
 
4055 
#undef TARGET_NAME
4056 
#undef TARGET_STRING
4057 
#undef TARGET_ARCHITECTURE
4058 
#undef TARGET_BIG_ENDIAN
4059 
#undef TARGET_ARCHIVE

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.