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

Subversion Repositories open8_urisc

[/] [open8_urisc/] [trunk/] [gnu/] [binutils/] [bfd/] [mach-o.c] - Blame information for rev 139

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

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

powered by: WebSVN 2.1.0

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