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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-7.1/] [bfd/] [mach-o.c] - Blame information for rev 824

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

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

powered by: WebSVN 2.1.0

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