Coverage Report

Created: 2024-05-21 06:29

/src/binutils-gdb/bfd/mach-o.c
Line
Count
Source (jump to first uncovered line)
1
/* Mach-O support for BFD.
2
   Copyright (C) 1999-2024 Free Software Foundation, Inc.
3
4
   This file is part of BFD, the Binary File Descriptor library.
5
6
   This program is free software; you can redistribute it and/or modify
7
   it under the terms of the GNU General Public License as published by
8
   the Free Software Foundation; either version 3 of the License, or
9
   (at your option) any later version.
10
11
   This program is distributed in the hope that it will be useful,
12
   but WITHOUT ANY WARRANTY; without even the implied warranty of
13
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14
   GNU General Public License for more details.
15
16
   You should have received a copy of the GNU General Public License
17
   along with this program; if not, write to the Free Software
18
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
19
   MA 02110-1301, USA.  */
20
21
#include "sysdep.h"
22
#include <limits.h>
23
#include "bfd.h"
24
#include "libbfd.h"
25
#include "libiberty.h"
26
#include "mach-o.h"
27
#include "aout/stab_gnu.h"
28
#include "mach-o/reloc.h"
29
#include "mach-o/external.h"
30
#include <ctype.h>
31
#include <stdlib.h>
32
#include <string.h>
33
34
#define bfd_mach_o_object_p bfd_mach_o_gen_object_p
35
#define bfd_mach_o_core_p bfd_mach_o_gen_core_p
36
#define bfd_mach_o_mkobject bfd_mach_o_gen_mkobject
37
38
#define FILE_ALIGN(off, algn) \
39
82
  (((off) + ((ufile_ptr) 1 << (algn)) - 1) & ((ufile_ptr) -1 << (algn)))
40
41
static bool
42
bfd_mach_o_read_dyld_content (bfd *abfd, bfd_mach_o_dyld_info_command *cmd);
43
44
unsigned int
45
bfd_mach_o_version (bfd *abfd)
46
0
{
47
0
  bfd_mach_o_data_struct *mdata = NULL;
48
49
0
  BFD_ASSERT (bfd_mach_o_valid (abfd));
50
0
  mdata = bfd_mach_o_get_data (abfd);
51
52
0
  return mdata->header.version;
53
0
}
54
55
bool
56
bfd_mach_o_valid (bfd *abfd)
57
4
{
58
4
  if (abfd == NULL || abfd->xvec == NULL)
59
0
    return false;
60
61
4
  if (abfd->xvec->flavour != bfd_target_mach_o_flavour)
62
0
    return false;
63
64
4
  if (bfd_mach_o_get_data (abfd) == NULL)
65
0
    return false;
66
4
  return true;
67
4
}
68
69
static inline bool
70
mach_o_wide_p (bfd_mach_o_header *header)
71
1.24M
{
72
1.24M
  switch (header->version)
73
1.24M
    {
74
388k
    case 1:
75
388k
      return false;
76
855k
    case 2:
77
855k
      return true;
78
0
    default:
79
0
      BFD_FAIL ();
80
0
      return false;
81
1.24M
    }
82
1.24M
}
83
84
static inline bool
85
bfd_mach_o_wide_p (bfd *abfd)
86
8.41k
{
87
8.41k
  return mach_o_wide_p (&bfd_mach_o_get_data (abfd)->header);
88
8.41k
}
89
90
/* Tables to translate well known Mach-O segment/section names to bfd
91
   names.  Use of canonical names (such as .text or .debug_frame) is required
92
   by gdb.  */
93
94
/* __TEXT Segment.  */
95
static const mach_o_section_name_xlat text_section_names_xlat[] =
96
  {
97
    { ".text",        "__text",
98
  SEC_CODE | SEC_LOAD,      BFD_MACH_O_S_REGULAR,
99
  BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS,  0},
100
    { ".const",       "__const",
101
  SEC_READONLY | SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
102
  BFD_MACH_O_S_ATTR_NONE,     0},
103
    { ".static_const",      "__static_const",
104
  SEC_READONLY | SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
105
  BFD_MACH_O_S_ATTR_NONE,     0},
106
    { ".cstring",       "__cstring",
107
  SEC_READONLY | SEC_DATA | SEC_LOAD | SEC_MERGE | SEC_STRINGS,
108
            BFD_MACH_O_S_CSTRING_LITERALS,
109
  BFD_MACH_O_S_ATTR_NONE,     0},
110
    { ".literal4",        "__literal4",
111
  SEC_READONLY | SEC_DATA | SEC_LOAD, BFD_MACH_O_S_4BYTE_LITERALS,
112
  BFD_MACH_O_S_ATTR_NONE,     2},
113
    { ".literal8",        "__literal8",
114
  SEC_READONLY | SEC_DATA | SEC_LOAD, BFD_MACH_O_S_8BYTE_LITERALS,
115
  BFD_MACH_O_S_ATTR_NONE,     3},
116
    { ".literal16",       "__literal16",
117
  SEC_READONLY | SEC_DATA | SEC_LOAD, BFD_MACH_O_S_16BYTE_LITERALS,
118
  BFD_MACH_O_S_ATTR_NONE,     4},
119
    { ".constructor",       "__constructor",
120
  SEC_CODE | SEC_LOAD,      BFD_MACH_O_S_REGULAR,
121
  BFD_MACH_O_S_ATTR_NONE,     0},
122
    { ".destructor",        "__destructor",
123
  SEC_CODE | SEC_LOAD,      BFD_MACH_O_S_REGULAR,
124
  BFD_MACH_O_S_ATTR_NONE,     0},
125
    { ".eh_frame",        "__eh_frame",
126
  SEC_READONLY | SEC_DATA | SEC_LOAD, BFD_MACH_O_S_COALESCED,
127
  BFD_MACH_O_S_ATTR_LIVE_SUPPORT
128
  | BFD_MACH_O_S_ATTR_STRIP_STATIC_SYMS
129
  | BFD_MACH_O_S_ATTR_NO_TOC,   2},
130
    { NULL, NULL, 0, 0, 0, 0}
131
  };
132
133
/* __DATA Segment.  */
134
static const mach_o_section_name_xlat data_section_names_xlat[] =
135
  {
136
    { ".data",      "__data",
137
  SEC_DATA | SEC_LOAD,    BFD_MACH_O_S_REGULAR,
138
  BFD_MACH_O_S_ATTR_NONE,   0},
139
    { ".bss",       "__bss",
140
  SEC_NO_FLAGS,     BFD_MACH_O_S_ZEROFILL,
141
  BFD_MACH_O_S_ATTR_NONE,   0},
142
    { ".const_data",      "__const",
143
  SEC_DATA | SEC_LOAD,    BFD_MACH_O_S_REGULAR,
144
  BFD_MACH_O_S_ATTR_NONE,   0},
145
    { ".static_data",     "__static_data",
146
  SEC_DATA | SEC_LOAD,    BFD_MACH_O_S_REGULAR,
147
  BFD_MACH_O_S_ATTR_NONE,   0},
148
    { ".mod_init_func",   "__mod_init_func",
149
  SEC_DATA | SEC_LOAD,    BFD_MACH_O_S_MOD_INIT_FUNC_POINTERS,
150
  BFD_MACH_O_S_ATTR_NONE,   2},
151
    { ".mod_term_func",   "__mod_term_func",
152
  SEC_DATA | SEC_LOAD,    BFD_MACH_O_S_MOD_FINI_FUNC_POINTERS,
153
  BFD_MACH_O_S_ATTR_NONE,   2},
154
    { ".dyld",      "__dyld",
155
  SEC_DATA | SEC_LOAD,    BFD_MACH_O_S_REGULAR,
156
  BFD_MACH_O_S_ATTR_NONE,   0},
157
    { ".cfstring",      "__cfstring",
158
  SEC_DATA | SEC_LOAD,    BFD_MACH_O_S_REGULAR,
159
  BFD_MACH_O_S_ATTR_NONE,   2},
160
    { NULL, NULL, 0, 0, 0, 0}
161
  };
162
163
/* __DWARF Segment.  */
164
static const mach_o_section_name_xlat dwarf_section_names_xlat[] =
165
  {
166
    { ".debug_frame",     "__debug_frame",
167
  SEC_DEBUGGING,      BFD_MACH_O_S_REGULAR,
168
  BFD_MACH_O_S_ATTR_DEBUG,  0},
169
    { ".debug_info",      "__debug_info",
170
  SEC_DEBUGGING,      BFD_MACH_O_S_REGULAR,
171
  BFD_MACH_O_S_ATTR_DEBUG,  0},
172
    { ".debug_abbrev",    "__debug_abbrev",
173
  SEC_DEBUGGING,      BFD_MACH_O_S_REGULAR,
174
  BFD_MACH_O_S_ATTR_DEBUG,  0},
175
    { ".debug_aranges",   "__debug_aranges",
176
  SEC_DEBUGGING,      BFD_MACH_O_S_REGULAR,
177
  BFD_MACH_O_S_ATTR_DEBUG,  0},
178
    { ".debug_macinfo",   "__debug_macinfo",
179
  SEC_DEBUGGING,      BFD_MACH_O_S_REGULAR,
180
  BFD_MACH_O_S_ATTR_DEBUG,  0},
181
    { ".debug_line",      "__debug_line",
182
  SEC_DEBUGGING,      BFD_MACH_O_S_REGULAR,
183
  BFD_MACH_O_S_ATTR_DEBUG,  0},
184
    { ".debug_loc",     "__debug_loc",
185
  SEC_DEBUGGING,      BFD_MACH_O_S_REGULAR,
186
  BFD_MACH_O_S_ATTR_DEBUG,  0},
187
    { ".debug_pubnames",    "__debug_pubnames",
188
  SEC_DEBUGGING,      BFD_MACH_O_S_REGULAR,
189
  BFD_MACH_O_S_ATTR_DEBUG,  0},
190
    { ".debug_pubtypes",    "__debug_pubtypes",
191
  SEC_DEBUGGING,      BFD_MACH_O_S_REGULAR,
192
  BFD_MACH_O_S_ATTR_DEBUG,  0},
193
    { ".debug_str",     "__debug_str",
194
  SEC_DEBUGGING,      BFD_MACH_O_S_REGULAR,
195
  BFD_MACH_O_S_ATTR_DEBUG,  0},
196
    { ".debug_ranges",    "__debug_ranges",
197
  SEC_DEBUGGING,      BFD_MACH_O_S_REGULAR,
198
  BFD_MACH_O_S_ATTR_DEBUG,  0},
199
    { ".debug_macro",     "__debug_macro",
200
  SEC_DEBUGGING,      BFD_MACH_O_S_REGULAR,
201
  BFD_MACH_O_S_ATTR_DEBUG,  0},
202
    { ".debug_gdb_scripts",   "__debug_gdb_scri",
203
  SEC_DEBUGGING,      BFD_MACH_O_S_REGULAR,
204
  BFD_MACH_O_S_ATTR_DEBUG,  0},
205
    { NULL, NULL, 0, 0, 0, 0}
206
  };
207
208
/* __OBJC Segment.  */
209
static const mach_o_section_name_xlat objc_section_names_xlat[] =
210
  {
211
    { ".objc_class",      "__class",
212
  SEC_DATA | SEC_LOAD,    BFD_MACH_O_S_REGULAR,
213
  BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
214
    { ".objc_meta_class",   "__meta_class",
215
  SEC_DATA | SEC_LOAD,    BFD_MACH_O_S_REGULAR,
216
  BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
217
    { ".objc_cat_cls_meth",   "__cat_cls_meth",
218
  SEC_DATA | SEC_LOAD,    BFD_MACH_O_S_REGULAR,
219
  BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
220
    { ".objc_cat_inst_meth",    "__cat_inst_meth",
221
  SEC_DATA | SEC_LOAD,    BFD_MACH_O_S_REGULAR,
222
  BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
223
    { ".objc_protocol",   "__protocol",
224
  SEC_DATA | SEC_LOAD,    BFD_MACH_O_S_REGULAR,
225
  BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
226
    { ".objc_string_object",    "__string_object",
227
  SEC_DATA | SEC_LOAD,    BFD_MACH_O_S_REGULAR,
228
  BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
229
    { ".objc_cls_meth",   "__cls_meth",
230
  SEC_DATA | SEC_LOAD,    BFD_MACH_O_S_REGULAR,
231
  BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
232
    { ".objc_inst_meth",    "__inst_meth",
233
  SEC_DATA | SEC_LOAD,    BFD_MACH_O_S_REGULAR,
234
  BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
235
    { ".objc_cls_refs",   "__cls_refs",
236
  SEC_DATA | SEC_LOAD,    BFD_MACH_O_S_LITERAL_POINTERS,
237
  BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
238
    { ".objc_message_refs",   "__message_refs",
239
  SEC_DATA | SEC_LOAD,    BFD_MACH_O_S_LITERAL_POINTERS,
240
  BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
241
    { ".objc_symbols",    "__symbols",
242
  SEC_DATA | SEC_LOAD,    BFD_MACH_O_S_REGULAR,
243
  BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
244
    { ".objc_category",   "__category",
245
  SEC_DATA | SEC_LOAD,    BFD_MACH_O_S_REGULAR,
246
  BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
247
    { ".objc_class_vars",   "__class_vars",
248
  SEC_DATA | SEC_LOAD,    BFD_MACH_O_S_REGULAR,
249
  BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
250
    { ".objc_instance_vars",    "__instance_vars",
251
  SEC_DATA | SEC_LOAD,    BFD_MACH_O_S_REGULAR,
252
  BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
253
    { ".objc_module_info",    "__module_info",
254
  SEC_DATA | SEC_LOAD,    BFD_MACH_O_S_REGULAR,
255
  BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
256
    { ".objc_selector_strs",    "__selector_strs",
257
  SEC_DATA | SEC_LOAD,    BFD_MACH_O_S_CSTRING_LITERALS,
258
  BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
259
    { ".objc_image_info",   "__image_info",
260
  SEC_DATA | SEC_LOAD,    BFD_MACH_O_S_REGULAR,
261
  BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
262
    { ".objc_selector_fixup",   "__sel_fixup",
263
  SEC_DATA | SEC_LOAD,    BFD_MACH_O_S_REGULAR,
264
  BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
265
    /* Objc V1 */
266
    { ".objc1_class_ext",   "__class_ext",
267
  SEC_DATA | SEC_LOAD,    BFD_MACH_O_S_REGULAR,
268
  BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
269
    { ".objc1_property_list",   "__property",
270
  SEC_DATA | SEC_LOAD,    BFD_MACH_O_S_REGULAR,
271
  BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
272
    { ".objc1_protocol_ext",    "__protocol_ext",
273
  SEC_DATA | SEC_LOAD,    BFD_MACH_O_S_REGULAR,
274
  BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
275
    { NULL, NULL, 0, 0, 0, 0}
276
  };
277
278
static const mach_o_segment_name_xlat segsec_names_xlat[] =
279
  {
280
    { "__TEXT", text_section_names_xlat },
281
    { "__DATA", data_section_names_xlat },
282
    { "__DWARF", dwarf_section_names_xlat },
283
    { "__OBJC", objc_section_names_xlat },
284
    { NULL, NULL }
285
  };
286
287
static const char dsym_subdir[] = ".dSYM/Contents/Resources/DWARF";
288
289
/* For both cases bfd-name => mach-o name and vice versa, the specific target
290
   is checked before the generic.  This allows a target (e.g. ppc for cstring)
291
   to override the generic definition with a more specific one.  */
292
293
/* Fetch the translation from a Mach-O section designation (segment, section)
294
   as a bfd short name, if one exists.  Otherwise return NULL.
295
296
   Allow the segment and section names to be unterminated 16 byte arrays.  */
297
298
const mach_o_section_name_xlat *
299
bfd_mach_o_section_data_for_mach_sect (bfd *abfd, const char *segname,
300
               const char *sectname)
301
4.57M
{
302
4.57M
  const struct mach_o_segment_name_xlat *seg;
303
4.57M
  const mach_o_section_name_xlat *sec;
304
4.57M
  bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
305
306
  /* First try any target-specific translations defined...  */
307
4.57M
  if (bed->segsec_names_xlat)
308
4.83M
    for (seg = bed->segsec_names_xlat; seg->segname; seg++)
309
3.03M
      if (strncmp (seg->segname, segname, BFD_MACH_O_SEGNAME_SIZE) == 0)
310
19.2k
  for (sec = seg->sections; sec->mach_o_name; sec++)
311
13.7k
    if (strncmp (sec->mach_o_name, sectname,
312
13.7k
           BFD_MACH_O_SECTNAME_SIZE) == 0)
313
876
      return sec;
314
315
  /* ... and then the Mach-O generic ones.  */
316
22.8M
  for (seg = segsec_names_xlat; seg->segname; seg++)
317
18.2M
    if (strncmp (seg->segname, segname, BFD_MACH_O_SEGNAME_SIZE) == 0)
318
183k
      for (sec = seg->sections; sec->mach_o_name; sec++)
319
167k
  if (strncmp (sec->mach_o_name, sectname,
320
167k
         BFD_MACH_O_SECTNAME_SIZE) == 0)
321
4.34k
    return sec;
322
323
4.57M
  return NULL;
324
4.57M
}
325
326
/* If the bfd_name for this section is a 'canonical' form for which we
327
   know the Mach-O data, return the segment name and the data for the
328
   Mach-O equivalent.  Otherwise return NULL.  */
329
330
const mach_o_section_name_xlat *
331
bfd_mach_o_section_data_for_bfd_name (bfd *abfd, const char *bfd_name,
332
              const char **segname)
333
4.67M
{
334
4.67M
  const struct mach_o_segment_name_xlat *seg;
335
4.67M
  const mach_o_section_name_xlat *sec;
336
4.67M
  bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
337
4.67M
  *segname = NULL;
338
339
4.67M
  if (bfd_name[0] != '.')
340
4.67M
    return NULL;
341
342
  /* First try any target-specific translations defined...  */
343
5.24k
  if (bed->segsec_names_xlat)
344
7.06k
    for (seg = bed->segsec_names_xlat; seg->segname; seg++)
345
16.1k
      for (sec = seg->sections; sec->bfd_name; sec++)
346
11.7k
  if (strcmp (bfd_name, sec->bfd_name) == 0)
347
876
    {
348
876
      *segname = seg->segname;
349
876
      return sec;
350
876
    }
351
352
  /* ... and then the Mach-O generic ones.  */
353
7.26k
  for (seg = segsec_names_xlat; seg->segname; seg++)
354
42.8k
    for (sec = seg->sections; sec->bfd_name; sec++)
355
39.9k
      if (strcmp (bfd_name, sec->bfd_name) == 0)
356
4.36k
  {
357
4.36k
    *segname = seg->segname;
358
4.36k
    return sec;
359
4.36k
  }
360
361
0
  return NULL;
362
4.36k
}
363
364
/* Convert Mach-O section name to BFD.
365
366
   Try to use standard/canonical names, for which we have tables including
367
   default flag settings - which are returned.  Otherwise forge a new name
368
   in the form "<segmentname>.<sectionname>" this will be prefixed with
369
   LC_SEGMENT. if the segment name does not begin with an underscore.
370
371
   SEGNAME and SECTNAME are 16 byte arrays (they do not need to be NUL-
372
   terminated if the name length is exactly 16 bytes - but must be if the name
373
   length is less than 16 characters).  */
374
375
void
376
bfd_mach_o_convert_section_name_to_bfd (bfd *abfd, const char *segname,
377
          const char *secname, const char **name,
378
          flagword *flags)
379
4.57M
{
380
4.57M
  const mach_o_section_name_xlat *xlat;
381
4.57M
  char *res;
382
4.57M
  size_t len;
383
4.57M
  const char *pfx = "";
384
385
4.57M
  *name = NULL;
386
4.57M
  *flags = SEC_NO_FLAGS;
387
388
  /* First search for a canonical name...
389
     xlat will be non-null if there is an entry for segname, secname.  */
390
4.57M
  xlat = bfd_mach_o_section_data_for_mach_sect (abfd, segname, secname);
391
4.57M
  if (xlat)
392
5.22k
    {
393
5.22k
      len = strlen (xlat->bfd_name);
394
5.22k
      res = bfd_alloc (abfd, len + 1);
395
5.22k
      if (res == NULL)
396
0
  return;
397
5.22k
      memcpy (res, xlat->bfd_name, len + 1);
398
5.22k
      *name = res;
399
5.22k
      *flags = xlat->bfd_flags;
400
5.22k
      return;
401
5.22k
    }
402
403
  /* ... else we make up a bfd name from the segment concatenated with the
404
     section.  */
405
406
4.57M
  len = 16 + 1 + 16 + 1;
407
408
  /* Put "LC_SEGMENT." prefix if the segment name is weird (ie doesn't start
409
     with an underscore.  */
410
4.57M
  if (segname[0] != '_')
411
4.53M
    {
412
4.53M
      static const char seg_pfx[] = "LC_SEGMENT.";
413
414
4.53M
      pfx = seg_pfx;
415
4.53M
      len += sizeof (seg_pfx) - 1;
416
4.53M
    }
417
418
4.57M
  res = bfd_alloc (abfd, len);
419
4.57M
  if (res == NULL)
420
0
    return;
421
4.57M
  snprintf (res, len, "%s%.16s.%.16s", pfx, segname, secname);
422
4.57M
  *name = res;
423
4.57M
}
424
425
/* Convert a bfd section name to a Mach-O segment + section name.
426
427
   If the name is a canonical one for which we have a Darwin match
428
   return the translation table - which contains defaults for flags,
429
   type, attribute and default alignment data.
430
431
   Otherwise, expand the bfd_name (assumed to be in the form
432
   "[LC_SEGMENT.]<segmentname>.<sectionname>") and return NULL.  */
433
434
static const mach_o_section_name_xlat *
435
bfd_mach_o_convert_section_name_to_mach_o (bfd *abfd ATTRIBUTE_UNUSED,
436
             asection *sect,
437
             bfd_mach_o_section *section)
438
4.67M
{
439
4.67M
  const mach_o_section_name_xlat *xlat;
440
4.67M
  const char *name = bfd_section_name (sect);
441
4.67M
  const char *segname;
442
4.67M
  const char *dot;
443
4.67M
  size_t len;
444
4.67M
  size_t seglen;
445
4.67M
  size_t seclen;
446
447
4.67M
  memset (section->segname, 0, BFD_MACH_O_SEGNAME_SIZE + 1);
448
4.67M
  memset (section->sectname, 0, BFD_MACH_O_SECTNAME_SIZE + 1);
449
450
  /* See if is a canonical name ... */
451
4.67M
  xlat = bfd_mach_o_section_data_for_bfd_name (abfd, name, &segname);
452
4.67M
  if (xlat)
453
5.24k
    {
454
5.24k
      strcpy (section->segname, segname);
455
5.24k
      strcpy (section->sectname, xlat->mach_o_name);
456
5.24k
      return xlat;
457
5.24k
    }
458
459
  /* .. else we convert our constructed one back to Mach-O.
460
     Strip LC_SEGMENT. prefix, if present.  */
461
4.67M
  if (strncmp (name, "LC_SEGMENT.", 11) == 0)
462
4.53M
    name += 11;
463
464
  /* Find a dot.  */
465
4.67M
  dot = strchr (name, '.');
466
4.67M
  len = strlen (name);
467
468
  /* Try to split name into segment and section names.  */
469
4.67M
  if (dot && dot != name)
470
2.13M
    {
471
2.13M
      seglen = dot - name;
472
2.13M
      seclen = len - (dot + 1 - name);
473
474
2.13M
      if (seglen <= BFD_MACH_O_SEGNAME_SIZE
475
2.13M
    && seclen <= BFD_MACH_O_SECTNAME_SIZE)
476
2.08M
  {
477
2.08M
    memcpy (section->segname, name, seglen);
478
2.08M
    section->segname[seglen] = 0;
479
2.08M
    memcpy (section->sectname, dot + 1, seclen);
480
2.08M
    section->sectname[seclen] = 0;
481
2.08M
    return NULL;
482
2.08M
  }
483
2.13M
    }
484
485
  /* The segment and section names are both missing - don't make them
486
     into dots.  */
487
2.58M
  if (dot && dot == name)
488
2.53M
    return NULL;
489
490
  /* Just duplicate the name into both segment and section.  */
491
48.6k
  if (len > 16)
492
48.6k
    len = 16;
493
48.6k
  memcpy (section->segname, name, len);
494
48.6k
  section->segname[len] = 0;
495
48.6k
  memcpy (section->sectname, name, len);
496
48.6k
  section->sectname[len] = 0;
497
48.6k
  return NULL;
498
2.58M
}
499
500
/* Return the size of an entry for section SEC.
501
   Must be called only for symbol pointer section and symbol stubs
502
   sections.  */
503
504
unsigned int
505
bfd_mach_o_section_get_entry_size (bfd *abfd, bfd_mach_o_section *sec)
506
537
{
507
537
  switch (sec->flags & BFD_MACH_O_SECTION_TYPE_MASK)
508
537
    {
509
211
    case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS:
510
350
    case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS:
511
350
      return bfd_mach_o_wide_p (abfd) ? 8 : 4;
512
187
    case BFD_MACH_O_S_SYMBOL_STUBS:
513
187
      return sec->reserved2;
514
0
    default:
515
0
      BFD_FAIL ();
516
0
      return 0;
517
537
    }
518
537
}
519
520
/* Return the number of indirect symbols for a section.
521
   Must be called only for symbol pointer section and symbol stubs
522
   sections.  */
523
524
unsigned int
525
bfd_mach_o_section_get_nbr_indirect (bfd *abfd, bfd_mach_o_section *sec)
526
543
{
527
543
  unsigned int elsz;
528
529
  /* FIXME: This array is set by the assembler but does not seem to be
530
     set anywhere for objcopy.  Since bfd_mach_o_build_dysymtab will
531
     not fill in output bfd_mach_o_dysymtab_command indirect_syms when
532
     this array is NULL we may as well return zero for the size.
533
     This is enough to stop objcopy allocating huge amounts of memory
534
     for indirect symbols in fuzzed object files.  */
535
543
  if (sec->indirect_syms == NULL)
536
543
    return 0;
537
538
0
  elsz = bfd_mach_o_section_get_entry_size (abfd, sec);
539
0
  if (elsz == 0)
540
0
    return 0;
541
0
  else
542
0
    return sec->size / elsz;
543
0
}
544
545
/* Append command CMD to ABFD.  Note that header.ncmds is not updated.  */
546
547
static void
548
bfd_mach_o_append_command (bfd *abfd, bfd_mach_o_load_command *cmd)
549
205k
{
550
205k
  bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
551
552
205k
  if (mdata->last_command != NULL)
553
82.9k
    mdata->last_command->next = cmd;
554
122k
  else
555
122k
    mdata->first_command = cmd;
556
205k
  mdata->last_command = cmd;
557
205k
  cmd->next = NULL;
558
205k
}
559
560
/* Copy any private info we understand from the input symbol
561
   to the output symbol.  */
562
563
bool
564
bfd_mach_o_bfd_copy_private_symbol_data (bfd *ibfd ATTRIBUTE_UNUSED,
565
           asymbol *isymbol,
566
           bfd *obfd ATTRIBUTE_UNUSED,
567
           asymbol *osymbol)
568
3.02k
{
569
3.02k
  bfd_mach_o_asymbol *os, *is;
570
571
3.02k
  os = (bfd_mach_o_asymbol *)osymbol;
572
3.02k
  is = (bfd_mach_o_asymbol *)isymbol;
573
3.02k
  os->n_type = is->n_type;
574
3.02k
  os->n_sect = is->n_sect;
575
3.02k
  os->n_desc = is->n_desc;
576
3.02k
  os->symbol.udata.i = is->symbol.udata.i;
577
578
3.02k
  return true;
579
3.02k
}
580
581
/* Copy any private info we understand from the input section
582
   to the output section.  */
583
584
bool
585
bfd_mach_o_bfd_copy_private_section_data (bfd *ibfd, asection *isection,
586
            bfd *obfd, asection *osection)
587
28
{
588
28
  bfd_mach_o_section *os = bfd_mach_o_get_mach_o_section (osection);
589
28
  bfd_mach_o_section *is = bfd_mach_o_get_mach_o_section (isection);
590
591
28
  if (ibfd->xvec->flavour != bfd_target_mach_o_flavour
592
28
      || obfd->xvec->flavour != bfd_target_mach_o_flavour)
593
0
    return true;
594
595
28
  BFD_ASSERT (is != NULL && os != NULL);
596
597
28
  os->flags = is->flags;
598
28
  os->reserved1 = is->reserved1;
599
28
  os->reserved2 = is->reserved2;
600
28
  os->reserved3 = is->reserved3;
601
602
28
  return true;
603
28
}
604
605
static const char *
606
cputype (unsigned long value)
607
434
{
608
434
  switch (value)
609
434
    {
610
6
    case BFD_MACH_O_CPU_TYPE_VAX: return "VAX";
611
5
    case BFD_MACH_O_CPU_TYPE_MC680x0: return "MC68k";
612
56
    case BFD_MACH_O_CPU_TYPE_I386: return "I386";
613
3
    case BFD_MACH_O_CPU_TYPE_MIPS: return "MIPS";
614
2
    case BFD_MACH_O_CPU_TYPE_MC98000: return "MC98k";
615
10
    case BFD_MACH_O_CPU_TYPE_HPPA: return "HPPA";
616
111
    case BFD_MACH_O_CPU_TYPE_ARM: return "ARM";
617
0
    case BFD_MACH_O_CPU_TYPE_MC88000: return "MC88K";
618
1
    case BFD_MACH_O_CPU_TYPE_SPARC: return "SPARC";
619
0
    case BFD_MACH_O_CPU_TYPE_I860: return "I860";
620
1
    case BFD_MACH_O_CPU_TYPE_ALPHA: return "ALPHA";
621
21
    case BFD_MACH_O_CPU_TYPE_POWERPC: return "PPC";
622
21
    case BFD_MACH_O_CPU_TYPE_POWERPC_64: return "PPC64";
623
153
    case BFD_MACH_O_CPU_TYPE_X86_64: return "X86_64";
624
44
    case BFD_MACH_O_CPU_TYPE_ARM64: return "ARM64";
625
0
    default: return _("<unknown>");
626
434
    }
627
434
}
628
629
static const char *
630
cpusubtype (unsigned long cpu_type, unsigned long cpu_subtype, char *buffer)
631
434
{
632
434
  buffer[0] = 0;
633
434
  switch (cpu_subtype & BFD_MACH_O_CPU_SUBTYPE_MASK)
634
434
    {
635
243
    case 0:
636
243
      break;
637
82
    case BFD_MACH_O_CPU_SUBTYPE_LIB64:
638
82
      sprintf (buffer, " (LIB64)"); break;
639
109
    default:
640
109
      sprintf (buffer, _("<unknown mask flags>")); break;
641
434
    }
642
643
434
  cpu_subtype &= ~ BFD_MACH_O_CPU_SUBTYPE_MASK;
644
645
434
  switch (cpu_type)
646
434
    {
647
153
    case BFD_MACH_O_CPU_TYPE_X86_64:
648
209
    case BFD_MACH_O_CPU_TYPE_I386:
649
209
      switch (cpu_subtype)
650
209
  {
651
65
  case BFD_MACH_O_CPU_SUBTYPE_X86_ALL:
652
65
    return strcat (buffer, " (X86_ALL)");
653
144
  default:
654
144
    break;
655
209
  }
656
144
      break;
657
658
144
    case BFD_MACH_O_CPU_TYPE_ARM:
659
111
      switch (cpu_subtype)
660
111
  {
661
22
  case BFD_MACH_O_CPU_SUBTYPE_ARM_ALL:
662
22
    return strcat (buffer, " (ARM_ALL)");
663
0
  case BFD_MACH_O_CPU_SUBTYPE_ARM_V4T:
664
0
    return strcat (buffer, " (ARM_V4T)");
665
0
  case BFD_MACH_O_CPU_SUBTYPE_ARM_V6:
666
0
    return strcat (buffer, " (ARM_V6)");
667
0
  case BFD_MACH_O_CPU_SUBTYPE_ARM_V5TEJ:
668
0
    return strcat (buffer, " (ARM_V5TEJ)");
669
2
  case BFD_MACH_O_CPU_SUBTYPE_ARM_XSCALE:
670
2
    return strcat (buffer, " (ARM_XSCALE)");
671
3
  case BFD_MACH_O_CPU_SUBTYPE_ARM_V7:
672
3
    return strcat (buffer, " (ARM_V7)");
673
84
  default:
674
84
    break;
675
111
  }
676
84
      break;
677
678
84
    case BFD_MACH_O_CPU_TYPE_ARM64:
679
44
      switch (cpu_subtype)
680
44
  {
681
12
  case BFD_MACH_O_CPU_SUBTYPE_ARM64_ALL:
682
12
    return strcat (buffer, " (ARM64_ALL)");
683
0
  case BFD_MACH_O_CPU_SUBTYPE_ARM64_V8:
684
0
    return strcat (buffer, " (ARM64_V8)");
685
32
  default:
686
32
    break;
687
44
  }
688
32
      break;
689
690
70
    default:
691
70
      break;
692
434
    }
693
694
330
  if (cpu_subtype != 0)
695
309
    return strcat (buffer, _(" (<unknown>)"));
696
697
21
  return buffer;
698
330
}
699
700
bool
701
bfd_mach_o_bfd_print_private_bfd_data (bfd *abfd, void *ptr)
702
434
{
703
434
  FILE * file = (FILE *) ptr;
704
434
  bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
705
434
  char buff[128];
706
707
434
  fprintf (file, _(" MACH-O header:\n"));
708
434
  fprintf (file, _("   magic:      %#lx\n"), (long) mdata->header.magic);
709
434
  fprintf (file, _("   cputype:    %#lx (%s)\n"), (long) mdata->header.cputype,
710
434
     cputype (mdata->header.cputype));
711
434
  fprintf (file, _("   cpusubtype: %#lx%s\n"), (long) mdata->header.cpusubtype,
712
434
     cpusubtype (mdata->header.cputype, mdata->header.cpusubtype, buff));
713
434
  fprintf (file, _("   filetype:   %#lx\n"), (long) mdata->header.filetype);
714
434
  fprintf (file, _("   ncmds:      %#lx\n"), (long) mdata->header.ncmds);
715
434
  fprintf (file, _("   sizeocmds:  %#lx\n"), (long) mdata->header.sizeofcmds);
716
434
  fprintf (file, _("   flags:      %#lx\n"), (long) mdata->header.flags);
717
434
  fprintf (file, _("   version:    %x\n"), mdata->header.version);
718
719
434
  return true;
720
434
}
721
722
/* Copy any private info we understand from the input bfd
723
   to the output bfd.  */
724
725
bool
726
bfd_mach_o_bfd_copy_private_header_data (bfd *ibfd, bfd *obfd)
727
2
{
728
2
  bfd_mach_o_data_struct *imdata;
729
2
  bfd_mach_o_data_struct *omdata;
730
2
  bfd_mach_o_load_command *icmd;
731
732
2
  if (bfd_get_flavour (ibfd) != bfd_target_mach_o_flavour
733
2
      || bfd_get_flavour (obfd) != bfd_target_mach_o_flavour)
734
0
    return true;
735
736
2
  BFD_ASSERT (bfd_mach_o_valid (ibfd));
737
2
  BFD_ASSERT (bfd_mach_o_valid (obfd));
738
739
2
  imdata = bfd_mach_o_get_data (ibfd);
740
2
  omdata = bfd_mach_o_get_data (obfd);
741
742
  /* Copy header flags.  */
743
2
  omdata->header.flags = imdata->header.flags;
744
745
  /* PR 23299.  Copy the cputype.  */
746
2
  if (imdata->header.cputype != omdata->header.cputype)
747
2
    {
748
2
      if (omdata->header.cputype == 0)
749
2
  omdata->header.cputype = imdata->header.cputype;
750
0
      else if (imdata->header.cputype != 0)
751
  /* Urg - what has happened ?  */
752
0
  _bfd_error_handler (_("incompatible cputypes in mach-o files: %ld vs %ld"),
753
0
          (long) imdata->header.cputype,
754
0
          (long) omdata->header.cputype);
755
2
    }
756
757
  /* Copy the cpusubtype.  */
758
2
  omdata->header.cpusubtype = imdata->header.cpusubtype;
759
760
  /* Copy commands.  */
761
28
  for (icmd = imdata->first_command; icmd != NULL; icmd = icmd->next)
762
26
    {
763
26
      bfd_mach_o_load_command *ocmd;
764
765
26
      switch (icmd->type)
766
26
  {
767
8
  case BFD_MACH_O_LC_LOAD_DYLIB:
768
10
  case BFD_MACH_O_LC_LOAD_DYLINKER:
769
10
  case BFD_MACH_O_LC_DYLD_INFO:
770
    /* Command is copied.  */
771
10
    ocmd = bfd_alloc (obfd, sizeof (bfd_mach_o_load_command));
772
10
    if (ocmd == NULL)
773
0
      return false;
774
775
    /* Copy common fields.  */
776
10
    ocmd->type = icmd->type;
777
10
    ocmd->type_required = icmd->type_required;
778
10
    ocmd->offset = 0;
779
10
    ocmd->len = icmd->len;
780
10
    break;
781
782
16
  default:
783
    /* Command is not copied.  */
784
16
    continue;
785
16
    break;
786
26
  }
787
788
10
      switch (icmd->type)
789
10
  {
790
8
  case BFD_MACH_O_LC_LOAD_DYLIB:
791
8
    {
792
8
      bfd_mach_o_dylib_command *idy = &icmd->command.dylib;
793
8
      bfd_mach_o_dylib_command *ody = &ocmd->command.dylib;
794
795
8
      ody->name_offset = idy->name_offset;
796
8
      ody->timestamp = idy->timestamp;
797
8
      ody->current_version = idy->current_version;
798
8
      ody->compatibility_version = idy->compatibility_version;
799
8
      ody->name_str = idy->name_str;
800
8
    }
801
8
    break;
802
803
2
  case BFD_MACH_O_LC_LOAD_DYLINKER:
804
2
    {
805
2
      bfd_mach_o_dylinker_command *idy = &icmd->command.dylinker;
806
2
      bfd_mach_o_dylinker_command *ody = &ocmd->command.dylinker;
807
808
2
      ody->name_offset = idy->name_offset;
809
2
      ody->name_str = idy->name_str;
810
2
    }
811
2
    break;
812
813
0
  case BFD_MACH_O_LC_DYLD_INFO:
814
0
    {
815
0
      bfd_mach_o_dyld_info_command *idy = &icmd->command.dyld_info;
816
0
      bfd_mach_o_dyld_info_command *ody = &ocmd->command.dyld_info;
817
818
0
      if (bfd_mach_o_read_dyld_content (ibfd, idy))
819
0
        {
820
0
    ody->rebase_size = idy->rebase_size;
821
0
    ody->rebase_content = idy->rebase_content;
822
823
0
    ody->bind_size = idy->bind_size;
824
0
    ody->bind_content = idy->bind_content;
825
826
0
    ody->weak_bind_size = idy->weak_bind_size;
827
0
    ody->weak_bind_content = idy->weak_bind_content;
828
829
0
    ody->lazy_bind_size = idy->lazy_bind_size;
830
0
    ody->lazy_bind_content = idy->lazy_bind_content;
831
832
0
    ody->export_size = idy->export_size;
833
0
    ody->export_content = idy->export_content;
834
0
        }
835
      /* PR 17512L: file: 730e492d.  */
836
0
      else
837
0
        {
838
0
    ody->rebase_size =
839
0
      ody->bind_size =
840
0
      ody->weak_bind_size =
841
0
      ody->lazy_bind_size =
842
0
      ody->export_size = 0;
843
0
    ody->rebase_content =
844
0
      ody->bind_content =
845
0
      ody->weak_bind_content =
846
0
      ody->lazy_bind_content =
847
0
      ody->export_content = NULL;
848
0
        }
849
0
    }
850
0
    break;
851
852
0
  default:
853
    /* That command should be handled.  */
854
0
    abort ();
855
10
  }
856
857
      /* Insert command.  */
858
10
      bfd_mach_o_append_command (obfd, ocmd);
859
10
    }
860
861
2
  return true;
862
2
}
863
864
/* This allows us to set up to 32 bits of flags (unless we invent some
865
   fiendish scheme to subdivide).  For now, we'll just set the file flags
866
   without error checking - just overwrite.  */
867
868
bool
869
bfd_mach_o_bfd_set_private_flags (bfd *abfd, flagword flags)
870
0
{
871
0
  bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
872
873
0
  if (!mdata)
874
0
    return false;
875
876
0
  mdata->header.flags = flags;
877
0
  return true;
878
0
}
879
880
/* Count the total number of symbols.  */
881
882
static long
883
bfd_mach_o_count_symbols (bfd *abfd)
884
8.00M
{
885
8.00M
  bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
886
887
8.00M
  if (mdata->symtab == NULL)
888
289
    return 0;
889
8.00M
  return mdata->symtab->nsyms;
890
8.00M
}
891
892
long
893
bfd_mach_o_get_symtab_upper_bound (bfd *abfd)
894
2.34k
{
895
2.34k
  long nsyms = bfd_mach_o_count_symbols (abfd);
896
897
2.34k
  return ((nsyms + 1) * sizeof (asymbol *));
898
2.34k
}
899
900
long
901
bfd_mach_o_canonicalize_symtab (bfd *abfd, asymbol **alocation)
902
1.91k
{
903
1.91k
  bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
904
1.91k
  long nsyms = bfd_mach_o_count_symbols (abfd);
905
1.91k
  bfd_mach_o_symtab_command *sym = mdata->symtab;
906
1.91k
  unsigned long j;
907
908
1.91k
  if (nsyms < 0)
909
0
    return nsyms;
910
911
1.91k
  if (nsyms == 0)
912
202
    {
913
      /* Do not try to read symbols if there are none.  */
914
202
      alocation[0] = NULL;
915
202
      return 0;
916
202
    }
917
918
1.71k
  if (!bfd_mach_o_read_symtab_symbols (abfd))
919
225
    {
920
225
      _bfd_error_handler
921
225
  (_("bfd_mach_o_canonicalize_symtab: unable to load symbols"));
922
225
      return -1;
923
225
    }
924
925
1.49k
  BFD_ASSERT (sym->symbols != NULL);
926
927
51.4k
  for (j = 0; j < sym->nsyms; j++)
928
49.9k
    alocation[j] = &sym->symbols[j].symbol;
929
930
1.49k
  alocation[j] = NULL;
931
932
1.49k
  return nsyms;
933
1.71k
}
934
935
/* Create synthetic symbols for indirect symbols.  */
936
937
long
938
bfd_mach_o_get_synthetic_symtab (bfd *abfd,
939
         long symcount ATTRIBUTE_UNUSED,
940
         asymbol **syms ATTRIBUTE_UNUSED,
941
         long dynsymcount ATTRIBUTE_UNUSED,
942
         asymbol **dynsyms ATTRIBUTE_UNUSED,
943
         asymbol **ret)
944
429
{
945
429
  bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
946
429
  bfd_mach_o_dysymtab_command *dysymtab = mdata->dysymtab;
947
429
  bfd_mach_o_symtab_command *symtab = mdata->symtab;
948
429
  asymbol *s;
949
429
  char * s_start;
950
429
  unsigned long count, i, j, n;
951
429
  size_t size;
952
429
  char *names;
953
429
  const char stub [] = "$stub";
954
955
429
  *ret = NULL;
956
957
  /* Stop now if no symbols or no indirect symbols.  */
958
429
  if (dysymtab == NULL || dysymtab->nindirectsyms == 0
959
429
      || symtab == NULL || symtab->symbols == NULL)
960
266
    return 0;
961
962
  /* We need to allocate a bfd symbol for every indirect symbol and to
963
     allocate the memory for its name.  */
964
163
  count = dysymtab->nindirectsyms;
965
163
  size = 0;
966
5.88k
  for (j = 0; j < count; j++)
967
5.72k
    {
968
5.72k
      unsigned int isym = dysymtab->indirect_syms[j];
969
5.72k
      const char *str;
970
971
      /* Some indirect symbols are anonymous.  */
972
5.72k
      if (isym < symtab->nsyms
973
5.72k
    && (str = symtab->symbols[isym].symbol.name) != NULL)
974
5.05k
  {
975
    /* PR 17512: file: f5b8eeba.  */
976
5.05k
    size += strnlen (str, symtab->strsize - (str - symtab->strtab));
977
5.05k
    size += sizeof (stub);
978
5.05k
  }
979
5.72k
    }
980
981
163
  s_start = bfd_malloc (size + count * sizeof (asymbol));
982
163
  s = *ret = (asymbol *) s_start;
983
163
  if (s == NULL)
984
0
    return -1;
985
163
  names = (char *) (s + count);
986
987
163
  n = 0;
988
30.4k
  for (i = 0; i < mdata->nsects; i++)
989
30.3k
    {
990
30.3k
      bfd_mach_o_section *sec = mdata->sections[i];
991
30.3k
      unsigned int first, last;
992
30.3k
      bfd_vma addr;
993
30.3k
      unsigned int entry_size;
994
995
30.3k
      switch (sec->flags & BFD_MACH_O_SECTION_TYPE_MASK)
996
30.3k
  {
997
211
  case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS:
998
350
  case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS:
999
537
  case BFD_MACH_O_S_SYMBOL_STUBS:
1000
    /* Only these sections have indirect symbols.  */
1001
537
    first = sec->reserved1;
1002
537
    last = first + bfd_mach_o_section_get_nbr_indirect (abfd, sec);
1003
537
    addr = sec->addr;
1004
537
    entry_size = bfd_mach_o_section_get_entry_size (abfd, sec);
1005
1006
    /* PR 17512: file: 08e15eec.  */
1007
537
    if (first >= count || last > count || first > last)
1008
95
      goto fail;
1009
1010
442
    for (j = first; j < last; j++)
1011
0
      {
1012
0
        unsigned int isym = dysymtab->indirect_syms[j];
1013
0
        const char *str;
1014
0
        size_t len;
1015
1016
0
        if (isym < symtab->nsyms
1017
0
      && (str = symtab->symbols[isym].symbol.name) != NULL)
1018
0
    {
1019
      /* PR 17512: file: 04d64d9b.  */
1020
0
      if (n >= count)
1021
0
        goto fail;
1022
0
      len = strnlen (str, symtab->strsize - (str - symtab->strtab));
1023
      /* PR 17512: file: 47dfd4d2, 18f340a4.  */
1024
0
      if (size < len + sizeof (stub))
1025
0
        goto fail;
1026
0
      memcpy (names, str, len);
1027
0
      memcpy (names + len, stub, sizeof (stub));
1028
0
      s->name = names;
1029
0
      names += len + sizeof (stub);
1030
0
      size -= len + sizeof (stub);
1031
0
      s->the_bfd = symtab->symbols[isym].symbol.the_bfd;
1032
0
      s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
1033
0
      s->section = sec->bfdsection;
1034
0
      s->value = addr - sec->addr;
1035
0
      s->udata.p = NULL;
1036
0
      s++;
1037
0
      n++;
1038
0
    }
1039
0
        addr += entry_size;
1040
0
      }
1041
442
    break;
1042
29.8k
  default:
1043
29.8k
    break;
1044
30.3k
  }
1045
30.3k
    }
1046
1047
68
  return n;
1048
1049
95
 fail:
1050
95
  free (s_start);
1051
95
  * ret = NULL;
1052
95
  return -1;
1053
163
}
1054
1055
void
1056
bfd_mach_o_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED,
1057
          asymbol *symbol,
1058
          symbol_info *ret)
1059
7.27k
{
1060
7.27k
  bfd_symbol_info (symbol, ret);
1061
7.27k
}
1062
1063
void
1064
bfd_mach_o_print_symbol (bfd *abfd,
1065
       void * afile,
1066
       asymbol *symbol,
1067
       bfd_print_symbol_type how)
1068
0
{
1069
0
  FILE *file = (FILE *) afile;
1070
0
  const char *name;
1071
0
  bfd_mach_o_asymbol *asym = (bfd_mach_o_asymbol *)symbol;
1072
1073
0
  switch (how)
1074
0
    {
1075
0
    case bfd_print_symbol_name:
1076
0
      fprintf (file, "%s", symbol->name);
1077
0
      break;
1078
0
    default:
1079
0
      bfd_print_symbol_vandf (abfd, (void *) file, symbol);
1080
0
      if (asym->n_type & BFD_MACH_O_N_STAB)
1081
0
  name = bfd_get_stab_name (asym->n_type);
1082
0
      else
1083
0
  switch (asym->n_type & BFD_MACH_O_N_TYPE)
1084
0
    {
1085
0
    case BFD_MACH_O_N_UNDF:
1086
0
      if (symbol->value == 0)
1087
0
        name = "UND";
1088
0
      else
1089
0
        name = "COM";
1090
0
      break;
1091
0
    case BFD_MACH_O_N_ABS:
1092
0
      name = "ABS";
1093
0
      break;
1094
0
    case BFD_MACH_O_N_INDR:
1095
0
      name = "INDR";
1096
0
      break;
1097
0
    case BFD_MACH_O_N_PBUD:
1098
0
      name = "PBUD";
1099
0
      break;
1100
0
    case BFD_MACH_O_N_SECT:
1101
0
      name = "SECT";
1102
0
      break;
1103
0
    default:
1104
0
      name = "???";
1105
0
      break;
1106
0
    }
1107
0
      if (name == NULL)
1108
0
  name = "";
1109
0
      fprintf (file, " %02x %-6s %02x %04x",
1110
0
         asym->n_type, name, asym->n_sect, asym->n_desc);
1111
0
      if ((asym->n_type & BFD_MACH_O_N_STAB) == 0
1112
0
    && (asym->n_type & BFD_MACH_O_N_TYPE) == BFD_MACH_O_N_SECT)
1113
0
  fprintf (file, " [%s]", symbol->section->name);
1114
0
      fprintf (file, " %s", symbol->name);
1115
0
    }
1116
0
}
1117
1118
static void
1119
bfd_mach_o_convert_architecture (bfd_mach_o_cpu_type mtype,
1120
         bfd_mach_o_cpu_subtype msubtype,
1121
         enum bfd_architecture *type,
1122
         unsigned long *subtype)
1123
135k
{
1124
135k
  *subtype = bfd_arch_unknown;
1125
1126
135k
  switch (mtype)
1127
135k
    {
1128
5.73k
    case BFD_MACH_O_CPU_TYPE_VAX:
1129
5.73k
      *type = bfd_arch_vax;
1130
5.73k
      break;
1131
15.0k
    case BFD_MACH_O_CPU_TYPE_MC680x0:
1132
15.0k
      *type = bfd_arch_m68k;
1133
15.0k
      break;
1134
44.1k
    case BFD_MACH_O_CPU_TYPE_I386:
1135
44.1k
      *type = bfd_arch_i386;
1136
44.1k
      *subtype = bfd_mach_i386_i386;
1137
44.1k
      break;
1138
31.4k
    case BFD_MACH_O_CPU_TYPE_X86_64:
1139
31.4k
      *type = bfd_arch_i386;
1140
31.4k
      *subtype = bfd_mach_x86_64;
1141
31.4k
      break;
1142
4.69k
    case BFD_MACH_O_CPU_TYPE_MIPS:
1143
4.69k
      *type = bfd_arch_mips;
1144
4.69k
      break;
1145
2.08k
    case BFD_MACH_O_CPU_TYPE_MC98000:
1146
2.08k
      *type = bfd_arch_m98k;
1147
2.08k
      break;
1148
1.36k
    case BFD_MACH_O_CPU_TYPE_HPPA:
1149
1.36k
      *type = bfd_arch_hppa;
1150
1.36k
      break;
1151
15.2k
    case BFD_MACH_O_CPU_TYPE_ARM:
1152
15.2k
      *type = bfd_arch_arm;
1153
15.2k
      switch (msubtype)
1154
15.2k
  {
1155
16
  case BFD_MACH_O_CPU_SUBTYPE_ARM_V4T:
1156
16
    *subtype = bfd_mach_arm_4T;
1157
16
    break;
1158
11
  case BFD_MACH_O_CPU_SUBTYPE_ARM_V6:
1159
11
    *subtype = bfd_mach_arm_4T; /* Best fit ?  */
1160
11
    break;
1161
22
  case BFD_MACH_O_CPU_SUBTYPE_ARM_V5TEJ:
1162
22
    *subtype = bfd_mach_arm_5TE;
1163
22
    break;
1164
1.84k
  case BFD_MACH_O_CPU_SUBTYPE_ARM_XSCALE:
1165
1.84k
    *subtype = bfd_mach_arm_XScale;
1166
1.84k
    break;
1167
501
  case BFD_MACH_O_CPU_SUBTYPE_ARM_V7:
1168
501
    *subtype = bfd_mach_arm_5TE; /* Best fit ?  */
1169
501
    break;
1170
472
  case BFD_MACH_O_CPU_SUBTYPE_ARM_ALL:
1171
12.8k
  default:
1172
12.8k
    break;
1173
15.2k
  }
1174
15.2k
      break;
1175
15.2k
    case BFD_MACH_O_CPU_TYPE_SPARC:
1176
6.69k
      *type = bfd_arch_sparc;
1177
6.69k
      *subtype = bfd_mach_sparc;
1178
6.69k
      break;
1179
3.18k
    case BFD_MACH_O_CPU_TYPE_ALPHA:
1180
3.18k
      *type = bfd_arch_alpha;
1181
3.18k
      break;
1182
1.40k
    case BFD_MACH_O_CPU_TYPE_POWERPC:
1183
1.40k
      *type = bfd_arch_powerpc;
1184
1.40k
      *subtype = bfd_mach_ppc;
1185
1.40k
      break;
1186
1.43k
    case BFD_MACH_O_CPU_TYPE_POWERPC_64:
1187
1.43k
      *type = bfd_arch_powerpc;
1188
1.43k
      *subtype = bfd_mach_ppc64;
1189
1.43k
      break;
1190
1.46k
    case BFD_MACH_O_CPU_TYPE_ARM64:
1191
1.46k
      *type = bfd_arch_aarch64;
1192
1.46k
      *subtype = bfd_mach_aarch64;
1193
1.46k
      break;
1194
1.23k
    default:
1195
1.23k
      *type = bfd_arch_unknown;
1196
1.23k
      break;
1197
135k
    }
1198
135k
}
1199
1200
/* Write n NUL bytes to ABFD so that LEN + n is a multiple of 4.  Return the
1201
   number of bytes written or -1 in case of error.  */
1202
1203
static int
1204
bfd_mach_o_pad4 (bfd *abfd, size_t len)
1205
2
{
1206
2
  if (len % 4 != 0)
1207
2
    {
1208
2
      char pad[4] = {0,0,0,0};
1209
2
      unsigned int padlen = 4 - (len % 4);
1210
1211
2
      if (bfd_write (pad, padlen, abfd) != padlen)
1212
0
  return -1;
1213
1214
2
      return padlen;
1215
2
    }
1216
0
  else
1217
0
    return 0;
1218
2
}
1219
1220
/* Likewise, but for a command.  */
1221
1222
static int
1223
bfd_mach_o_pad_command (bfd *abfd, size_t len)
1224
10
{
1225
10
  size_t align = bfd_mach_o_wide_p (abfd) ? 8 : 4;
1226
1227
10
  if (len % align != 0)
1228
8
    {
1229
8
      char pad[8] = {0};
1230
8
      size_t padlen = align - (len % align);
1231
1232
8
      if (bfd_write (pad, padlen, abfd) != padlen)
1233
0
  return -1;
1234
1235
8
      return padlen;
1236
8
    }
1237
2
  else
1238
2
    return 0;
1239
10
}
1240
1241
static bool
1242
bfd_mach_o_write_header (bfd *abfd, bfd_mach_o_header *header)
1243
4
{
1244
4
  struct mach_o_header_external raw;
1245
4
  size_t size;
1246
1247
4
  size = mach_o_wide_p (header) ?
1248
4
    BFD_MACH_O_HEADER_64_SIZE : BFD_MACH_O_HEADER_SIZE;
1249
1250
4
  bfd_h_put_32 (abfd, header->magic, raw.magic);
1251
4
  bfd_h_put_32 (abfd, header->cputype, raw.cputype);
1252
4
  bfd_h_put_32 (abfd, header->cpusubtype, raw.cpusubtype);
1253
4
  bfd_h_put_32 (abfd, header->filetype, raw.filetype);
1254
4
  bfd_h_put_32 (abfd, header->ncmds, raw.ncmds);
1255
4
  bfd_h_put_32 (abfd, header->sizeofcmds, raw.sizeofcmds);
1256
4
  bfd_h_put_32 (abfd, header->flags, raw.flags);
1257
1258
4
  if (mach_o_wide_p (header))
1259
4
    bfd_h_put_32 (abfd, header->reserved, raw.reserved);
1260
1261
4
  if (bfd_seek (abfd, 0, SEEK_SET) != 0
1262
4
      || bfd_write (&raw, size, abfd) != size)
1263
0
    return false;
1264
1265
4
  return true;
1266
4
}
1267
1268
static bool
1269
bfd_mach_o_write_thread (bfd *abfd, bfd_mach_o_load_command *command)
1270
0
{
1271
0
  bfd_mach_o_thread_command *cmd = &command->command.thread;
1272
0
  unsigned int i;
1273
0
  struct mach_o_thread_command_external raw;
1274
0
  size_t offset;
1275
1276
0
  BFD_ASSERT ((command->type == BFD_MACH_O_LC_THREAD)
1277
0
        || (command->type == BFD_MACH_O_LC_UNIXTHREAD));
1278
1279
0
  offset = BFD_MACH_O_LC_SIZE;
1280
0
  for (i = 0; i < cmd->nflavours; i++)
1281
0
    {
1282
0
      BFD_ASSERT ((cmd->flavours[i].size % 4) == 0);
1283
0
      BFD_ASSERT (cmd->flavours[i].offset
1284
0
      == command->offset + offset + BFD_MACH_O_LC_SIZE);
1285
1286
0
      bfd_h_put_32 (abfd, cmd->flavours[i].flavour, raw.flavour);
1287
0
      bfd_h_put_32 (abfd, (cmd->flavours[i].size / 4), raw.count);
1288
1289
0
      if (bfd_seek (abfd, command->offset + offset, SEEK_SET) != 0
1290
0
    || bfd_write (&raw, sizeof (raw), abfd) != sizeof (raw))
1291
0
  return false;
1292
1293
0
      offset += cmd->flavours[i].size + sizeof (raw);
1294
0
    }
1295
1296
0
  return true;
1297
0
}
1298
1299
static bool
1300
bfd_mach_o_write_dylinker (bfd *abfd, bfd_mach_o_load_command *command)
1301
2
{
1302
2
  bfd_mach_o_dylinker_command *cmd = &command->command.dylinker;
1303
2
  struct mach_o_str_command_external raw;
1304
2
  size_t namelen;
1305
1306
2
  bfd_h_put_32 (abfd, cmd->name_offset, raw.str);
1307
1308
2
  if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
1309
2
      || bfd_write (&raw, sizeof (raw), abfd) != sizeof (raw))
1310
0
    return false;
1311
1312
2
  namelen = strlen (cmd->name_str) + 1;
1313
2
  if (bfd_write (cmd->name_str, namelen, abfd) != namelen)
1314
0
    return false;
1315
1316
2
  if (bfd_mach_o_pad_command (abfd, namelen) < 0)
1317
0
    return false;
1318
1319
2
  return true;
1320
2
}
1321
1322
static bool
1323
bfd_mach_o_write_dylib (bfd *abfd, bfd_mach_o_load_command *command)
1324
8
{
1325
8
  bfd_mach_o_dylib_command *cmd = &command->command.dylib;
1326
8
  struct mach_o_dylib_command_external raw;
1327
8
  size_t namelen;
1328
1329
8
  bfd_h_put_32 (abfd, cmd->name_offset, raw.name);
1330
8
  bfd_h_put_32 (abfd, cmd->timestamp, raw.timestamp);
1331
8
  bfd_h_put_32 (abfd, cmd->current_version, raw.current_version);
1332
8
  bfd_h_put_32 (abfd, cmd->compatibility_version, raw.compatibility_version);
1333
1334
8
  if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
1335
8
      || bfd_write (&raw, sizeof (raw), abfd) != sizeof (raw))
1336
0
    return false;
1337
1338
8
  namelen = strlen (cmd->name_str) + 1;
1339
8
  if (bfd_write (cmd->name_str, namelen, abfd) != namelen)
1340
0
    return false;
1341
1342
8
  if (bfd_mach_o_pad_command (abfd, namelen) < 0)
1343
0
    return false;
1344
1345
8
  return true;
1346
8
}
1347
1348
static bool
1349
bfd_mach_o_write_main (bfd *abfd, bfd_mach_o_load_command *command)
1350
2
{
1351
2
  bfd_mach_o_main_command *cmd = &command->command.main;
1352
2
  struct mach_o_entry_point_command_external raw;
1353
1354
2
  bfd_h_put_64 (abfd, cmd->entryoff, raw.entryoff);
1355
2
  bfd_h_put_64 (abfd, cmd->stacksize, raw.stacksize);
1356
1357
2
  if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
1358
2
      || bfd_write (&raw, sizeof (raw), abfd) != sizeof (raw))
1359
0
    return false;
1360
1361
2
  return true;
1362
2
}
1363
1364
static bool
1365
bfd_mach_o_write_dyld_info (bfd *abfd, bfd_mach_o_load_command *command)
1366
0
{
1367
0
  bfd_mach_o_dyld_info_command *cmd = &command->command.dyld_info;
1368
0
  struct mach_o_dyld_info_command_external raw;
1369
1370
0
  bfd_h_put_32 (abfd, cmd->rebase_off, raw.rebase_off);
1371
0
  bfd_h_put_32 (abfd, cmd->rebase_size, raw.rebase_size);
1372
0
  bfd_h_put_32 (abfd, cmd->bind_off, raw.bind_off);
1373
0
  bfd_h_put_32 (abfd, cmd->bind_size, raw.bind_size);
1374
0
  bfd_h_put_32 (abfd, cmd->weak_bind_off, raw.weak_bind_off);
1375
0
  bfd_h_put_32 (abfd, cmd->weak_bind_size, raw.weak_bind_size);
1376
0
  bfd_h_put_32 (abfd, cmd->lazy_bind_off, raw.lazy_bind_off);
1377
0
  bfd_h_put_32 (abfd, cmd->lazy_bind_size, raw.lazy_bind_size);
1378
0
  bfd_h_put_32 (abfd, cmd->export_off, raw.export_off);
1379
0
  bfd_h_put_32 (abfd, cmd->export_size, raw.export_size);
1380
1381
0
  if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
1382
0
      || bfd_write (&raw, sizeof (raw), abfd) != sizeof (raw))
1383
0
    return false;
1384
1385
0
  if (cmd->rebase_size != 0)
1386
0
    if (bfd_seek (abfd, cmd->rebase_off, SEEK_SET) != 0
1387
0
  || (bfd_write (cmd->rebase_content, cmd->rebase_size, abfd) !=
1388
0
      cmd->rebase_size))
1389
0
      return false;
1390
1391
0
  if (cmd->bind_size != 0)
1392
0
    if (bfd_seek (abfd, cmd->bind_off, SEEK_SET) != 0
1393
0
  || (bfd_write (cmd->bind_content, cmd->bind_size, abfd) !=
1394
0
      cmd->bind_size))
1395
0
      return false;
1396
1397
0
  if (cmd->weak_bind_size != 0)
1398
0
    if (bfd_seek (abfd, cmd->weak_bind_off, SEEK_SET) != 0
1399
0
  || (bfd_write (cmd->weak_bind_content, cmd->weak_bind_size, abfd) !=
1400
0
      cmd->weak_bind_size))
1401
0
      return false;
1402
1403
0
  if (cmd->lazy_bind_size != 0)
1404
0
    if (bfd_seek (abfd, cmd->lazy_bind_off, SEEK_SET) != 0
1405
0
  || (bfd_write (cmd->lazy_bind_content, cmd->lazy_bind_size, abfd) !=
1406
0
      cmd->lazy_bind_size))
1407
0
      return false;
1408
1409
0
  if (cmd->export_size != 0)
1410
0
    if (bfd_seek (abfd, cmd->export_off, SEEK_SET) != 0
1411
0
  || (bfd_write (cmd->export_content, cmd->export_size, abfd) !=
1412
0
      cmd->export_size))
1413
0
      return false;
1414
1415
0
  return true;
1416
0
}
1417
1418
long
1419
bfd_mach_o_get_reloc_upper_bound (bfd *abfd, asection *asect)
1420
1.07M
{
1421
1.07M
  size_t count, raw;
1422
1423
1.07M
  count = asect->reloc_count;
1424
1.07M
  if (count >= LONG_MAX / sizeof (arelent *)
1425
1.07M
      || _bfd_mul_overflow (count, BFD_MACH_O_RELENT_SIZE, &raw))
1426
0
    {
1427
0
      bfd_set_error (bfd_error_file_too_big);
1428
0
      return -1;
1429
0
    }
1430
1.07M
  if (!bfd_write_p (abfd))
1431
1.07M
    {
1432
1.07M
      ufile_ptr filesize = bfd_get_file_size (abfd);
1433
1.07M
      if (filesize != 0 && raw > filesize)
1434
834k
  {
1435
834k
    bfd_set_error (bfd_error_file_truncated);
1436
834k
    return -1;
1437
834k
  }
1438
1.07M
    }
1439
240k
  return (count + 1) * sizeof (arelent *);
1440
1.07M
}
1441
1442
/* In addition to the need to byte-swap the symbol number, the bit positions
1443
   of the fields in the relocation information vary per target endian-ness.  */
1444
1445
void
1446
bfd_mach_o_swap_in_non_scattered_reloc (bfd *abfd, bfd_mach_o_reloc_info *rel,
1447
          unsigned char *fields)
1448
16.8M
{
1449
16.8M
  unsigned char info = fields[3];
1450
1451
16.8M
  if (bfd_big_endian (abfd))
1452
0
    {
1453
0
      rel->r_value = (fields[0] << 16) | (fields[1] << 8) | fields[2];
1454
0
      rel->r_type = (info >> BFD_MACH_O_BE_TYPE_SHIFT) & BFD_MACH_O_TYPE_MASK;
1455
0
      rel->r_pcrel = (info & BFD_MACH_O_BE_PCREL) ? 1 : 0;
1456
0
      rel->r_length = (info >> BFD_MACH_O_BE_LENGTH_SHIFT)
1457
0
          & BFD_MACH_O_LENGTH_MASK;
1458
0
      rel->r_extern = (info & BFD_MACH_O_BE_EXTERN) ? 1 : 0;
1459
0
    }
1460
16.8M
  else
1461
16.8M
    {
1462
16.8M
      rel->r_value = (fields[2] << 16) | (fields[1] << 8) | fields[0];
1463
16.8M
      rel->r_type = (info >> BFD_MACH_O_LE_TYPE_SHIFT) & BFD_MACH_O_TYPE_MASK;
1464
16.8M
      rel->r_pcrel = (info & BFD_MACH_O_LE_PCREL) ? 1 : 0;
1465
16.8M
      rel->r_length = (info >> BFD_MACH_O_LE_LENGTH_SHIFT)
1466
16.8M
          & BFD_MACH_O_LENGTH_MASK;
1467
16.8M
      rel->r_extern = (info & BFD_MACH_O_LE_EXTERN) ? 1 : 0;
1468
16.8M
    }
1469
16.8M
}
1470
1471
/* Set syms_ptr_ptr and addend of RES.  */
1472
1473
bool
1474
bfd_mach_o_canonicalize_non_scattered_reloc (bfd *abfd,
1475
               bfd_mach_o_reloc_info *reloc,
1476
               arelent *res, asymbol **syms)
1477
16.8M
{
1478
16.8M
  bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
1479
16.8M
  unsigned int num;
1480
16.8M
  asymbol **sym;
1481
1482
  /* Non-scattered relocation.  */
1483
16.8M
  reloc->r_scattered = 0;
1484
16.8M
  res->addend = 0;
1485
1486
16.8M
  num = reloc->r_value;
1487
1488
16.8M
  if (reloc->r_extern)
1489
7.99M
    {
1490
      /* PR 17512: file: 8396-1185-0.004.  */
1491
7.99M
      if (num >= (unsigned) bfd_mach_o_count_symbols (abfd))
1492
7.98M
  sym = bfd_und_section_ptr->symbol_ptr_ptr;
1493
11.0k
      else if (syms == NULL)
1494
0
  sym = bfd_und_section_ptr->symbol_ptr_ptr;
1495
11.0k
      else
1496
  /* An external symbol number.  */
1497
11.0k
  sym = syms + num;
1498
7.99M
    }
1499
8.87M
  else if (num == 0x00ffffff || num == 0)
1500
8.71M
    {
1501
      /* The 'symnum' in a non-scattered PAIR is 0x00ffffff.  But as this
1502
   is generic code, we don't know wether this is really a PAIR.
1503
   This value is almost certainly not a valid section number, hence
1504
   this specific case to avoid an assertion failure.
1505
   Target specific swap_reloc_in routine should adjust that.  */
1506
8.71M
      sym = bfd_abs_section_ptr->symbol_ptr_ptr;
1507
8.71M
    }
1508
165k
  else
1509
165k
    {
1510
      /* PR 17512: file: 006-2964-0.004.  */
1511
165k
      if (num > mdata->nsects)
1512
63.3k
  {
1513
63.3k
    _bfd_error_handler (_("\
1514
63.3k
malformed mach-o reloc: section index is greater than the number of sections"));
1515
63.3k
    return false;
1516
63.3k
  }
1517
1518
      /* A section number.  */
1519
102k
      sym = mdata->sections[num - 1]->bfdsection->symbol_ptr_ptr;
1520
      /* For a symbol defined in section S, the addend (stored in the
1521
   binary) contains the address of the section.  To comply with
1522
   bfd convention, subtract the section address.
1523
   Use the address from the header, so that the user can modify
1524
       the vma of the section.  */
1525
102k
      res->addend = -mdata->sections[num - 1]->addr;
1526
102k
    }
1527
1528
  /* Note: Pairs for PPC LO/HI/HA are not scattered, but contain the offset
1529
     in the lower 16bits of the address value.  So we have to find the
1530
     'symbol' from the preceding reloc.  We do this even though the
1531
     section symbol is probably not needed here, because NULL symbol
1532
     values cause an assert in generic BFD code.  This must be done in
1533
     the PPC swap_reloc_in routine.  */
1534
16.8M
  res->sym_ptr_ptr = sym;
1535
1536
16.8M
  return true;
1537
16.8M
}
1538
1539
/* Do most of the work for canonicalize_relocs on RAW: create internal
1540
   representation RELOC and set most fields of RES using symbol table SYMS.
1541
   Each target still has to set the howto of RES and possibly adjust other
1542
   fields.
1543
   Previously the Mach-O hook point was simply swap_in, but some targets
1544
   (like arm64) don't follow the generic rules (symnum is a value for the
1545
   non-scattered relocation ADDEND).  */
1546
1547
bool
1548
bfd_mach_o_pre_canonicalize_one_reloc (bfd *abfd,
1549
               struct mach_o_reloc_info_external *raw,
1550
               bfd_mach_o_reloc_info *reloc,
1551
               arelent *res, asymbol **syms)
1552
13.2M
{
1553
13.2M
  bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
1554
13.2M
  bfd_vma addr;
1555
1556
13.2M
  addr = bfd_get_32 (abfd, raw->r_address);
1557
13.2M
  res->sym_ptr_ptr = bfd_und_section_ptr->symbol_ptr_ptr;
1558
13.2M
  res->addend = 0;
1559
1560
13.2M
  if (addr & BFD_MACH_O_SR_SCATTERED)
1561
69.4k
    {
1562
69.4k
      unsigned int j;
1563
69.4k
      bfd_vma symnum = bfd_get_32 (abfd, raw->r_symbolnum);
1564
1565
      /* Scattered relocation, can't be extern. */
1566
69.4k
      reloc->r_scattered = 1;
1567
69.4k
      reloc->r_extern = 0;
1568
1569
      /*   Extract section and offset from r_value (symnum).  */
1570
69.4k
      reloc->r_value = symnum;
1571
      /* FIXME: This breaks when a symbol in a reloc exactly follows the
1572
   end of the data for the section (e.g. in a calculation of section
1573
   data length).  At present, the symbol will end up associated with
1574
   the following section or, if it falls within alignment padding, as
1575
   the undefined section symbol.  */
1576
376k
      for (j = 0; j < mdata->nsects; j++)
1577
376k
  {
1578
376k
    bfd_mach_o_section *sect = mdata->sections[j];
1579
376k
    if (symnum >= sect->addr && symnum < sect->addr + sect->size)
1580
69.3k
      {
1581
69.3k
        res->sym_ptr_ptr = sect->bfdsection->symbol_ptr_ptr;
1582
69.3k
        res->addend = symnum - sect->addr;
1583
69.3k
        break;
1584
69.3k
      }
1585
376k
  }
1586
1587
      /* Extract the info and address fields from r_address.  */
1588
69.4k
      reloc->r_type = BFD_MACH_O_GET_SR_TYPE (addr);
1589
69.4k
      reloc->r_length = BFD_MACH_O_GET_SR_LENGTH (addr);
1590
69.4k
      reloc->r_pcrel = addr & BFD_MACH_O_SR_PCREL;
1591
69.4k
      reloc->r_address = BFD_MACH_O_GET_SR_TYPE (addr);
1592
69.4k
      res->address = BFD_MACH_O_GET_SR_ADDRESS (addr);
1593
69.4k
    }
1594
13.1M
  else
1595
13.1M
    {
1596
      /* Non-scattered relocation.  */
1597
13.1M
      reloc->r_scattered = 0;
1598
13.1M
      reloc->r_address = addr;
1599
13.1M
      res->address = addr;
1600
1601
      /* The value and info fields have to be extracted dependent on target
1602
   endian-ness.  */
1603
13.1M
      bfd_mach_o_swap_in_non_scattered_reloc (abfd, reloc, raw->r_symbolnum);
1604
1605
13.1M
      if (!bfd_mach_o_canonicalize_non_scattered_reloc (abfd, reloc,
1606
13.1M
              res, syms))
1607
42.7k
  return false;
1608
13.1M
    }
1609
1610
  /* We have set up a reloc with all the information present, so the swapper
1611
     can modify address, value and addend fields, if necessary, to convey
1612
     information in the generic BFD reloc that is mach-o specific.  */
1613
1614
13.2M
  return true;
1615
13.2M
}
1616
1617
static int
1618
bfd_mach_o_canonicalize_relocs (bfd *abfd, unsigned long filepos,
1619
        unsigned long count,
1620
        arelent *res, asymbol **syms)
1621
239k
{
1622
239k
  bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
1623
239k
  unsigned long i;
1624
239k
  struct mach_o_reloc_info_external *native_relocs = NULL;
1625
239k
  size_t native_size;
1626
1627
  /* Allocate and read relocs.  */
1628
239k
  if (_bfd_mul_overflow (count, BFD_MACH_O_RELENT_SIZE, &native_size))
1629
    /* PR 17512: file: 09477b57.  */
1630
0
    goto err;
1631
1632
239k
  if (bfd_seek (abfd, filepos, SEEK_SET) != 0)
1633
0
    return -1;
1634
239k
  native_relocs = (struct mach_o_reloc_info_external *)
1635
239k
    _bfd_malloc_and_read (abfd, native_size, native_size);
1636
239k
  if (native_relocs == NULL)
1637
46.3k
    return -1;
1638
1639
16.9M
  for (i = 0; i < count; i++)
1640
16.9M
    {
1641
16.9M
      if (!(*bed->_bfd_mach_o_canonicalize_one_reloc)(abfd, &native_relocs[i],
1642
16.9M
                  &res[i], syms, res))
1643
191k
  goto err;
1644
16.9M
    }
1645
1.96k
  free (native_relocs);
1646
1.96k
  return i;
1647
1648
191k
 err:
1649
191k
  free (native_relocs);
1650
191k
  if (bfd_get_error () == bfd_error_no_error)
1651
0
    bfd_set_error (bfd_error_invalid_operation);
1652
191k
  return -1;
1653
193k
}
1654
1655
long
1656
bfd_mach_o_canonicalize_reloc (bfd *abfd, asection *asect,
1657
             arelent **rels, asymbol **syms)
1658
240k
{
1659
240k
  bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
1660
240k
  unsigned long i;
1661
240k
  arelent *res;
1662
1663
240k
  if (asect->reloc_count == 0)
1664
34
    return 0;
1665
1666
  /* No need to go further if we don't know how to read relocs.  */
1667
240k
  if (bed->_bfd_mach_o_canonicalize_one_reloc == NULL)
1668
660
    return 0;
1669
1670
239k
  if (asect->relocation == NULL)
1671
239k
    {
1672
239k
      size_t amt;
1673
1674
239k
      if (_bfd_mul_overflow (asect->reloc_count, sizeof (arelent), &amt))
1675
0
  {
1676
0
    bfd_set_error (bfd_error_file_too_big);
1677
0
    return -1;
1678
0
  }
1679
239k
      res = bfd_malloc (amt);
1680
239k
      if (res == NULL)
1681
0
  return -1;
1682
1683
239k
      if (bfd_mach_o_canonicalize_relocs (abfd, asect->rel_filepos,
1684
239k
            asect->reloc_count, res, syms) < 0)
1685
237k
  {
1686
237k
    free (res);
1687
237k
    return -1;
1688
237k
  }
1689
1.96k
      asect->relocation = res;
1690
1.96k
    }
1691
1692
1.96k
  res = asect->relocation;
1693
140k
  for (i = 0; i < asect->reloc_count; i++)
1694
138k
    rels[i] = &res[i];
1695
1.96k
  rels[i] = NULL;
1696
1697
1.96k
  return i;
1698
239k
}
1699
1700
long
1701
bfd_mach_o_get_dynamic_reloc_upper_bound (bfd *abfd)
1702
427
{
1703
427
  bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
1704
427
  bfd_mach_o_dysymtab_command *dysymtab = mdata->dysymtab;
1705
1706
427
  if (dysymtab == NULL)
1707
165
    return 1;
1708
1709
262
  ufile_ptr filesize = bfd_get_file_size (abfd);
1710
262
  size_t amt;
1711
1712
262
  if (filesize != 0)
1713
262
    {
1714
262
      if (dysymtab->extreloff > filesize
1715
262
    || dysymtab->nextrel > ((filesize - dysymtab->extreloff)
1716
251
          / BFD_MACH_O_RELENT_SIZE)
1717
262
    || dysymtab->locreloff > filesize
1718
262
    || dysymtab->nlocrel > ((filesize - dysymtab->locreloff)
1719
248
          / BFD_MACH_O_RELENT_SIZE))
1720
15
  {
1721
15
    bfd_set_error (bfd_error_file_truncated);
1722
15
    return -1;
1723
15
  }
1724
262
    }
1725
247
  if (dysymtab->nextrel + dysymtab->nlocrel < dysymtab->nextrel
1726
247
      || _bfd_mul_overflow (dysymtab->nextrel + dysymtab->nlocrel,
1727
247
          sizeof (arelent), &amt))
1728
0
    {
1729
0
      bfd_set_error (bfd_error_file_too_big);
1730
0
      return -1;
1731
0
    }
1732
1733
247
  return (dysymtab->nextrel + dysymtab->nlocrel + 1) * sizeof (arelent *);
1734
247
}
1735
1736
long
1737
bfd_mach_o_canonicalize_dynamic_reloc (bfd *abfd, arelent **rels,
1738
               struct bfd_symbol **syms)
1739
412
{
1740
412
  bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
1741
412
  bfd_mach_o_dysymtab_command *dysymtab = mdata->dysymtab;
1742
412
  bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
1743
412
  unsigned long i;
1744
412
  arelent *res;
1745
1746
412
  if (dysymtab == NULL)
1747
165
    return 0;
1748
247
  if (dysymtab->nextrel == 0 && dysymtab->nlocrel == 0)
1749
240
    return 0;
1750
1751
  /* No need to go further if we don't know how to read relocs.  */
1752
7
  if (bed->_bfd_mach_o_canonicalize_one_reloc == NULL)
1753
6
    return 0;
1754
1755
1
  if (mdata->dyn_reloc_cache == NULL)
1756
1
    {
1757
1
      size_t amt = (dysymtab->nextrel + dysymtab->nlocrel) * sizeof (arelent);
1758
1
      res = bfd_malloc (amt);
1759
1
      if (res == NULL)
1760
0
  return -1;
1761
1762
1
      if (bfd_mach_o_canonicalize_relocs (abfd, dysymtab->extreloff,
1763
1
            dysymtab->nextrel, res, syms) < 0)
1764
0
  {
1765
0
    free (res);
1766
0
    return -1;
1767
0
  }
1768
1769
1
      if (bfd_mach_o_canonicalize_relocs (abfd, dysymtab->locreloff,
1770
1
            dysymtab->nlocrel,
1771
1
            res + dysymtab->nextrel, syms) < 0)
1772
1
  {
1773
1
    free (res);
1774
1
    return -1;
1775
1
  }
1776
1777
0
      mdata->dyn_reloc_cache = res;
1778
0
    }
1779
1780
0
  res = mdata->dyn_reloc_cache;
1781
0
  for (i = 0; i < dysymtab->nextrel + dysymtab->nlocrel; i++)
1782
0
    rels[i] = &res[i];
1783
0
  rels[i] = NULL;
1784
0
  return i;
1785
1
}
1786
1787
/* In addition to the need to byte-swap the symbol number, the bit positions
1788
   of the fields in the relocation information vary per target endian-ness.  */
1789
1790
static void
1791
bfd_mach_o_swap_out_non_scattered_reloc (bfd *abfd, unsigned char *fields,
1792
           bfd_mach_o_reloc_info *rel)
1793
0
{
1794
0
  unsigned char info = 0;
1795
1796
0
  BFD_ASSERT (rel->r_type <= 15);
1797
0
  BFD_ASSERT (rel->r_length <= 3);
1798
1799
0
  if (bfd_big_endian (abfd))
1800
0
    {
1801
0
      fields[0] = (rel->r_value >> 16) & 0xff;
1802
0
      fields[1] = (rel->r_value >> 8) & 0xff;
1803
0
      fields[2] = rel->r_value & 0xff;
1804
0
      info |= rel->r_type << BFD_MACH_O_BE_TYPE_SHIFT;
1805
0
      info |= rel->r_pcrel ? BFD_MACH_O_BE_PCREL : 0;
1806
0
      info |= rel->r_length << BFD_MACH_O_BE_LENGTH_SHIFT;
1807
0
      info |= rel->r_extern ? BFD_MACH_O_BE_EXTERN : 0;
1808
0
    }
1809
0
  else
1810
0
    {
1811
0
      fields[2] = (rel->r_value >> 16) & 0xff;
1812
0
      fields[1] = (rel->r_value >> 8) & 0xff;
1813
0
      fields[0] = rel->r_value & 0xff;
1814
0
      info |= rel->r_type << BFD_MACH_O_LE_TYPE_SHIFT;
1815
0
      info |= rel->r_pcrel ? BFD_MACH_O_LE_PCREL : 0;
1816
0
      info |= rel->r_length << BFD_MACH_O_LE_LENGTH_SHIFT;
1817
0
      info |= rel->r_extern ? BFD_MACH_O_LE_EXTERN : 0;
1818
0
    }
1819
0
  fields[3] = info;
1820
0
}
1821
1822
static bool
1823
bfd_mach_o_write_relocs (bfd *abfd, bfd_mach_o_section *section)
1824
28
{
1825
28
  unsigned int i;
1826
28
  arelent **entries;
1827
28
  asection *sec;
1828
28
  bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
1829
1830
28
  sec = section->bfdsection;
1831
28
  if (sec->reloc_count == 0)
1832
28
    return true;
1833
1834
0
  if (bed->_bfd_mach_o_swap_reloc_out == NULL)
1835
0
    return true;
1836
1837
0
  if (bfd_seek (abfd, section->reloff, SEEK_SET) != 0)
1838
0
    return false;
1839
1840
  /* Convert and write.  */
1841
0
  entries = section->bfdsection->orelocation;
1842
0
  for (i = 0; i < section->nreloc; i++)
1843
0
    {
1844
0
      arelent *rel = entries[i];
1845
0
      struct mach_o_reloc_info_external raw;
1846
0
      bfd_mach_o_reloc_info info, *pinfo = &info;
1847
1848
      /* Convert relocation to an intermediate representation.  */
1849
0
      if (!(*bed->_bfd_mach_o_swap_reloc_out) (rel, pinfo))
1850
0
  return false;
1851
1852
      /* Lower the relocation info.  */
1853
0
      if (pinfo->r_scattered)
1854
0
  {
1855
0
    unsigned long v;
1856
1857
0
    v = BFD_MACH_O_SR_SCATTERED
1858
0
      | (pinfo->r_pcrel ? BFD_MACH_O_SR_PCREL : 0)
1859
0
      | BFD_MACH_O_SET_SR_LENGTH (pinfo->r_length)
1860
0
      | BFD_MACH_O_SET_SR_TYPE (pinfo->r_type)
1861
0
      | BFD_MACH_O_SET_SR_ADDRESS (pinfo->r_address);
1862
    /* Note: scattered relocs have field in reverse order...  */
1863
0
    bfd_put_32 (abfd, v, raw.r_address);
1864
0
    bfd_put_32 (abfd, pinfo->r_value, raw.r_symbolnum);
1865
0
  }
1866
0
      else
1867
0
  {
1868
0
    bfd_put_32 (abfd, pinfo->r_address, raw.r_address);
1869
0
    bfd_mach_o_swap_out_non_scattered_reloc (abfd, raw.r_symbolnum,
1870
0
               pinfo);
1871
0
  }
1872
1873
0
      if (bfd_write (&raw, BFD_MACH_O_RELENT_SIZE, abfd)
1874
0
    != BFD_MACH_O_RELENT_SIZE)
1875
0
  return false;
1876
0
    }
1877
0
  return true;
1878
0
}
1879
1880
static bool
1881
bfd_mach_o_write_section_32 (bfd *abfd, bfd_mach_o_section *section)
1882
28
{
1883
28
  struct mach_o_section_32_external raw;
1884
1885
28
  memcpy (raw.sectname, section->sectname, 16);
1886
28
  memcpy (raw.segname, section->segname, 16);
1887
28
  bfd_h_put_32 (abfd, section->addr, raw.addr);
1888
28
  bfd_h_put_32 (abfd, section->size, raw.size);
1889
28
  bfd_h_put_32 (abfd, section->offset, raw.offset);
1890
28
  bfd_h_put_32 (abfd, section->align, raw.align);
1891
28
  bfd_h_put_32 (abfd, section->reloff, raw.reloff);
1892
28
  bfd_h_put_32 (abfd, section->nreloc, raw.nreloc);
1893
28
  bfd_h_put_32 (abfd, section->flags, raw.flags);
1894
28
  bfd_h_put_32 (abfd, section->reserved1, raw.reserved1);
1895
28
  bfd_h_put_32 (abfd, section->reserved2, raw.reserved2);
1896
1897
28
  if (bfd_write (&raw, BFD_MACH_O_SECTION_SIZE, abfd)
1898
28
      != BFD_MACH_O_SECTION_SIZE)
1899
0
    return false;
1900
1901
28
  return true;
1902
28
}
1903
1904
static bool
1905
bfd_mach_o_write_section_64 (bfd *abfd, bfd_mach_o_section *section)
1906
0
{
1907
0
  struct mach_o_section_64_external raw;
1908
1909
0
  memcpy (raw.sectname, section->sectname, 16);
1910
0
  memcpy (raw.segname, section->segname, 16);
1911
0
  bfd_h_put_64 (abfd, section->addr, raw.addr);
1912
0
  bfd_h_put_64 (abfd, section->size, raw.size);
1913
0
  bfd_h_put_32 (abfd, section->offset, raw.offset);
1914
0
  bfd_h_put_32 (abfd, section->align, raw.align);
1915
0
  bfd_h_put_32 (abfd, section->reloff, raw.reloff);
1916
0
  bfd_h_put_32 (abfd, section->nreloc, raw.nreloc);
1917
0
  bfd_h_put_32 (abfd, section->flags, raw.flags);
1918
0
  bfd_h_put_32 (abfd, section->reserved1, raw.reserved1);
1919
0
  bfd_h_put_32 (abfd, section->reserved2, raw.reserved2);
1920
0
  bfd_h_put_32 (abfd, section->reserved3, raw.reserved3);
1921
1922
0
  if (bfd_write (&raw, BFD_MACH_O_SECTION_64_SIZE, abfd)
1923
0
      != BFD_MACH_O_SECTION_64_SIZE)
1924
0
    return false;
1925
1926
0
  return true;
1927
0
}
1928
1929
static bool
1930
bfd_mach_o_write_segment_32 (bfd *abfd, bfd_mach_o_load_command *command)
1931
14
{
1932
14
  struct mach_o_segment_command_32_external raw;
1933
14
  bfd_mach_o_segment_command *seg = &command->command.segment;
1934
14
  bfd_mach_o_section *sec;
1935
1936
14
  BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT);
1937
1938
42
  for (sec = seg->sect_head; sec != NULL; sec = sec->next)
1939
28
    if (!bfd_mach_o_write_relocs (abfd, sec))
1940
0
      return false;
1941
1942
14
  memcpy (raw.segname, seg->segname, 16);
1943
14
  bfd_h_put_32 (abfd, seg->vmaddr, raw.vmaddr);
1944
14
  bfd_h_put_32 (abfd, seg->vmsize, raw.vmsize);
1945
14
  bfd_h_put_32 (abfd, seg->fileoff, raw.fileoff);
1946
14
  bfd_h_put_32 (abfd, seg->filesize, raw.filesize);
1947
14
  bfd_h_put_32 (abfd, seg->maxprot, raw.maxprot);
1948
14
  bfd_h_put_32 (abfd, seg->initprot, raw.initprot);
1949
14
  bfd_h_put_32 (abfd, seg->nsects, raw.nsects);
1950
14
  bfd_h_put_32 (abfd, seg->flags, raw.flags);
1951
1952
14
  if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
1953
14
      || bfd_write (&raw, sizeof (raw), abfd) != sizeof (raw))
1954
0
    return false;
1955
1956
42
  for (sec = seg->sect_head; sec != NULL; sec = sec->next)
1957
28
    if (!bfd_mach_o_write_section_32 (abfd, sec))
1958
0
      return false;
1959
1960
14
  return true;
1961
14
}
1962
1963
static bool
1964
bfd_mach_o_write_segment_64 (bfd *abfd, bfd_mach_o_load_command *command)
1965
0
{
1966
0
  struct mach_o_segment_command_64_external raw;
1967
0
  bfd_mach_o_segment_command *seg = &command->command.segment;
1968
0
  bfd_mach_o_section *sec;
1969
1970
0
  BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT_64);
1971
1972
0
  for (sec = seg->sect_head; sec != NULL; sec = sec->next)
1973
0
    if (!bfd_mach_o_write_relocs (abfd, sec))
1974
0
      return false;
1975
1976
0
  memcpy (raw.segname, seg->segname, 16);
1977
0
  bfd_h_put_64 (abfd, seg->vmaddr, raw.vmaddr);
1978
0
  bfd_h_put_64 (abfd, seg->vmsize, raw.vmsize);
1979
0
  bfd_h_put_64 (abfd, seg->fileoff, raw.fileoff);
1980
0
  bfd_h_put_64 (abfd, seg->filesize, raw.filesize);
1981
0
  bfd_h_put_32 (abfd, seg->maxprot, raw.maxprot);
1982
0
  bfd_h_put_32 (abfd, seg->initprot, raw.initprot);
1983
0
  bfd_h_put_32 (abfd, seg->nsects, raw.nsects);
1984
0
  bfd_h_put_32 (abfd, seg->flags, raw.flags);
1985
1986
0
  if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
1987
0
      || bfd_write (&raw, sizeof (raw), abfd) != sizeof (raw))
1988
0
    return false;
1989
1990
0
  for (sec = seg->sect_head; sec != NULL; sec = sec->next)
1991
0
    if (!bfd_mach_o_write_section_64 (abfd, sec))
1992
0
      return false;
1993
1994
0
  return true;
1995
0
}
1996
1997
static bool
1998
bfd_mach_o_write_symtab_content (bfd *abfd, bfd_mach_o_symtab_command *sym)
1999
2
{
2000
2
  bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
2001
2
  unsigned long i;
2002
2
  unsigned int wide = bfd_mach_o_wide_p (abfd);
2003
2
  struct bfd_strtab_hash *strtab;
2004
2
  asymbol **symbols = bfd_get_outsymbols (abfd);
2005
2
  int padlen;
2006
2007
  /* Write the symbols first.  */
2008
2
  if (bfd_seek (abfd, sym->symoff, SEEK_SET) != 0)
2009
0
    return false;
2010
2011
2
  strtab = _bfd_stringtab_init ();
2012
2
  if (strtab == NULL)
2013
0
    return false;
2014
2015
2
  if (sym->nsyms > 0)
2016
    /* Although we don't strictly need to do this, for compatibility with
2017
       Darwin system tools, actually output an empty string for the index
2018
       0 entry.  */
2019
2
    _bfd_stringtab_add (strtab, "", true, false);
2020
2021
3.02k
  for (i = 0; i < sym->nsyms; i++)
2022
3.02k
    {
2023
3.02k
      bfd_size_type str_index;
2024
3.02k
      bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *)symbols[i];
2025
2026
3.02k
      if (s->symbol.name == 0 || s->symbol.name[0] == '\0')
2027
  /* An index of 0 always means the empty string.  */
2028
177
  str_index = 0;
2029
2.84k
      else
2030
2.84k
  {
2031
2.84k
    str_index = _bfd_stringtab_add (strtab, s->symbol.name, true, false);
2032
2033
2.84k
    if (str_index == (bfd_size_type) -1)
2034
0
      goto err;
2035
2.84k
  }
2036
2037
3.02k
      if (wide)
2038
0
  {
2039
0
    struct mach_o_nlist_64_external raw;
2040
2041
0
    bfd_h_put_32 (abfd, str_index, raw.n_strx);
2042
0
    bfd_h_put_8 (abfd, s->n_type, raw.n_type);
2043
0
    bfd_h_put_8 (abfd, s->n_sect, raw.n_sect);
2044
0
    bfd_h_put_16 (abfd, s->n_desc, raw.n_desc);
2045
0
    bfd_h_put_64 (abfd, s->symbol.section->vma + s->symbol.value,
2046
0
      raw.n_value);
2047
2048
0
    if (bfd_write (&raw, sizeof (raw), abfd) != sizeof (raw))
2049
0
      goto err;
2050
0
  }
2051
3.02k
      else
2052
3.02k
  {
2053
3.02k
    struct mach_o_nlist_external raw;
2054
2055
3.02k
    bfd_h_put_32 (abfd, str_index, raw.n_strx);
2056
3.02k
    bfd_h_put_8 (abfd, s->n_type, raw.n_type);
2057
3.02k
    bfd_h_put_8 (abfd, s->n_sect, raw.n_sect);
2058
3.02k
    bfd_h_put_16 (abfd, s->n_desc, raw.n_desc);
2059
3.02k
    bfd_h_put_32 (abfd, s->symbol.section->vma + s->symbol.value,
2060
3.02k
      raw.n_value);
2061
2062
3.02k
    if (bfd_write (&raw, sizeof (raw), abfd) != sizeof (raw))
2063
0
      goto err;
2064
3.02k
  }
2065
3.02k
    }
2066
2
  sym->strsize = _bfd_stringtab_size (strtab);
2067
2
  sym->stroff = mdata->filelen;
2068
2
  mdata->filelen += sym->strsize;
2069
2070
2
  if (bfd_seek (abfd, sym->stroff, SEEK_SET) != 0)
2071
0
    goto err;
2072
2073
2
  if (!_bfd_stringtab_emit (abfd, strtab))
2074
0
    goto err;
2075
2076
2
  _bfd_stringtab_free (strtab);
2077
2078
  /* Pad string table.  */
2079
2
  padlen = bfd_mach_o_pad4 (abfd, sym->strsize);
2080
2
  if (padlen < 0)
2081
0
    return false;
2082
2
  mdata->filelen += padlen;
2083
2
  sym->strsize += padlen;
2084
2085
2
  return true;
2086
2087
0
 err:
2088
0
  _bfd_stringtab_free (strtab);
2089
0
  sym->strsize = 0;
2090
0
  return false;
2091
2
}
2092
2093
static bool
2094
bfd_mach_o_write_symtab (bfd *abfd, bfd_mach_o_load_command *command)
2095
2
{
2096
2
  bfd_mach_o_symtab_command *sym = &command->command.symtab;
2097
2
  struct mach_o_symtab_command_external raw;
2098
2099
2
  BFD_ASSERT (command->type == BFD_MACH_O_LC_SYMTAB);
2100
2101
  /* The command.  */
2102
2
  bfd_h_put_32 (abfd, sym->symoff, raw.symoff);
2103
2
  bfd_h_put_32 (abfd, sym->nsyms, raw.nsyms);
2104
2
  bfd_h_put_32 (abfd, sym->stroff, raw.stroff);
2105
2
  bfd_h_put_32 (abfd, sym->strsize, raw.strsize);
2106
2107
2
  if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
2108
2
      || bfd_write (&raw, sizeof (raw), abfd) != sizeof (raw))
2109
0
    return false;
2110
2111
2
  return true;
2112
2
}
2113
2114
/* Count the number of indirect symbols in the image.
2115
   Requires that the sections are in their final order.  */
2116
2117
static unsigned int
2118
bfd_mach_o_count_indirect_symbols (bfd *abfd, bfd_mach_o_data_struct *mdata)
2119
2
{
2120
2
  unsigned int i;
2121
2
  unsigned int nisyms = 0;
2122
2123
30
  for (i = 0; i < mdata->nsects; ++i)
2124
28
    {
2125
28
      bfd_mach_o_section *sec = mdata->sections[i];
2126
2127
28
      switch (sec->flags & BFD_MACH_O_SECTION_TYPE_MASK)
2128
28
  {
2129
2
    case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS:
2130
4
    case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS:
2131
6
    case BFD_MACH_O_S_SYMBOL_STUBS:
2132
6
      nisyms += bfd_mach_o_section_get_nbr_indirect (abfd, sec);
2133
6
      break;
2134
22
    default:
2135
22
      break;
2136
28
  }
2137
28
    }
2138
2
  return nisyms;
2139
2
}
2140
2141
/* Create the dysymtab.  */
2142
2143
static bool
2144
bfd_mach_o_build_dysymtab (bfd *abfd, bfd_mach_o_dysymtab_command *cmd)
2145
2
{
2146
2
  bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
2147
2148
  /* TODO:
2149
     We are not going to try and fill these in yet and, moreover, we are
2150
     going to bail if they are already set.  */
2151
2
  if (cmd->nmodtab != 0
2152
2
      || cmd->ntoc != 0
2153
2
      || cmd->nextrefsyms != 0)
2154
0
    {
2155
0
      _bfd_error_handler (_("sorry: modtab, toc and extrefsyms are not yet"
2156
0
          " implemented for dysymtab commands."));
2157
0
      return false;
2158
0
    }
2159
2160
2
  cmd->ilocalsym = 0;
2161
2162
2
  if (bfd_get_symcount (abfd) > 0)
2163
2
    {
2164
2
      asymbol **symbols = bfd_get_outsymbols (abfd);
2165
2
      unsigned long i;
2166
2167
       /* Count the number of each kind of symbol.  */
2168
1.40k
      for (i = 0; i < bfd_get_symcount (abfd); ++i)
2169
1.40k
  {
2170
1.40k
    bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *)symbols[i];
2171
1.40k
    if (s->n_type & (BFD_MACH_O_N_EXT | BFD_MACH_O_N_PEXT))
2172
2
      break;
2173
1.40k
  }
2174
2
      cmd->nlocalsym = i;
2175
2
      cmd->iextdefsym = i;
2176
172
      for (; i < bfd_get_symcount (abfd); ++i)
2177
172
  {
2178
172
    bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *)symbols[i];
2179
172
    if ((s->n_type & BFD_MACH_O_N_TYPE) == BFD_MACH_O_N_UNDF)
2180
2
      break;
2181
172
  }
2182
2
      cmd->nextdefsym = i - cmd->nlocalsym;
2183
2
      cmd->iundefsym = cmd->nextdefsym + cmd->iextdefsym;
2184
2
      cmd->nundefsym = bfd_get_symcount (abfd)
2185
2
      - cmd->nlocalsym
2186
2
      - cmd->nextdefsym;
2187
2
    }
2188
0
  else
2189
0
    {
2190
0
      cmd->nlocalsym = 0;
2191
0
      cmd->iextdefsym = 0;
2192
0
      cmd->nextdefsym = 0;
2193
0
      cmd->iundefsym = 0;
2194
0
      cmd->nundefsym = 0;
2195
0
    }
2196
2197
2
  cmd->nindirectsyms = bfd_mach_o_count_indirect_symbols (abfd, mdata);
2198
2
  if (cmd->nindirectsyms > 0)
2199
0
    {
2200
0
      unsigned i;
2201
0
      unsigned n;
2202
0
      size_t amt;
2203
2204
0
      mdata->filelen = FILE_ALIGN (mdata->filelen, 2);
2205
0
      cmd->indirectsymoff = mdata->filelen;
2206
0
      if (_bfd_mul_overflow (cmd->nindirectsyms, 4, &amt))
2207
0
  return false;
2208
0
      mdata->filelen += amt;
2209
2210
0
      cmd->indirect_syms = bfd_zalloc (abfd, amt);
2211
0
      if (cmd->indirect_syms == NULL)
2212
0
  return false;
2213
2214
0
      n = 0;
2215
0
      for (i = 0; i < mdata->nsects; ++i)
2216
0
  {
2217
0
    bfd_mach_o_section *sec = mdata->sections[i];
2218
2219
0
    switch (sec->flags & BFD_MACH_O_SECTION_TYPE_MASK)
2220
0
      {
2221
0
        case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS:
2222
0
        case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS:
2223
0
        case BFD_MACH_O_S_SYMBOL_STUBS:
2224
0
    {
2225
0
      unsigned j, num;
2226
0
      bfd_mach_o_asymbol **isyms = sec->indirect_syms;
2227
2228
0
      num = bfd_mach_o_section_get_nbr_indirect (abfd, sec);
2229
0
      if (isyms == NULL || num == 0)
2230
0
        break;
2231
      /* Record the starting index in the reserved1 field.  */
2232
0
      sec->reserved1 = n;
2233
0
      for (j = 0; j < num; j++, n++)
2234
0
        {
2235
0
          if (isyms[j] == NULL)
2236
0
      cmd->indirect_syms[n] = BFD_MACH_O_INDIRECT_SYM_LOCAL;
2237
0
          else if (isyms[j]->symbol.section == bfd_abs_section_ptr
2238
0
             && ! (isyms[j]->n_type & BFD_MACH_O_N_EXT))
2239
0
      cmd->indirect_syms[n] = BFD_MACH_O_INDIRECT_SYM_LOCAL
2240
0
             | BFD_MACH_O_INDIRECT_SYM_ABS;
2241
0
          else
2242
0
      cmd->indirect_syms[n] = isyms[j]->symbol.udata.i;
2243
0
        }
2244
0
    }
2245
0
    break;
2246
0
        default:
2247
0
    break;
2248
0
      }
2249
0
  }
2250
0
    }
2251
2252
2
  return true;
2253
2
}
2254
2255
/* Write a dysymtab command.
2256
   TODO: Possibly coalesce writes of smaller objects.  */
2257
2258
static bool
2259
bfd_mach_o_write_dysymtab (bfd *abfd, bfd_mach_o_load_command *command)
2260
2
{
2261
2
  bfd_mach_o_dysymtab_command *cmd = &command->command.dysymtab;
2262
2263
2
  BFD_ASSERT (command->type == BFD_MACH_O_LC_DYSYMTAB);
2264
2265
2
  if (cmd->nmodtab != 0)
2266
0
    {
2267
0
      unsigned int i;
2268
2269
0
      if (bfd_seek (abfd, cmd->modtaboff, SEEK_SET) != 0)
2270
0
  return false;
2271
2272
0
      for (i = 0; i < cmd->nmodtab; i++)
2273
0
  {
2274
0
    bfd_mach_o_dylib_module *module = &cmd->dylib_module[i];
2275
0
    unsigned int iinit;
2276
0
    unsigned int ninit;
2277
2278
0
    iinit = module->iinit & 0xffff;
2279
0
    iinit |= ((module->iterm & 0xffff) << 16);
2280
2281
0
    ninit = module->ninit & 0xffff;
2282
0
    ninit |= ((module->nterm & 0xffff) << 16);
2283
2284
0
    if (bfd_mach_o_wide_p (abfd))
2285
0
      {
2286
0
        struct mach_o_dylib_module_64_external w;
2287
2288
0
        bfd_h_put_32 (abfd, module->module_name_idx, &w.module_name);
2289
0
        bfd_h_put_32 (abfd, module->iextdefsym, &w.iextdefsym);
2290
0
        bfd_h_put_32 (abfd, module->nextdefsym, &w.nextdefsym);
2291
0
        bfd_h_put_32 (abfd, module->irefsym, &w.irefsym);
2292
0
        bfd_h_put_32 (abfd, module->nrefsym, &w.nrefsym);
2293
0
        bfd_h_put_32 (abfd, module->ilocalsym, &w.ilocalsym);
2294
0
        bfd_h_put_32 (abfd, module->nlocalsym, &w.nlocalsym);
2295
0
        bfd_h_put_32 (abfd, module->iextrel, &w.iextrel);
2296
0
        bfd_h_put_32 (abfd, module->nextrel, &w.nextrel);
2297
0
        bfd_h_put_32 (abfd, iinit, &w.iinit_iterm);
2298
0
        bfd_h_put_32 (abfd, ninit, &w.ninit_nterm);
2299
0
        bfd_h_put_64 (abfd, module->objc_module_info_addr,
2300
0
          &w.objc_module_info_addr);
2301
0
        bfd_h_put_32 (abfd, module->objc_module_info_size,
2302
0
          &w.objc_module_info_size);
2303
2304
0
        if (bfd_write (&w, sizeof (w), abfd) != sizeof (w))
2305
0
    return false;
2306
0
      }
2307
0
    else
2308
0
      {
2309
0
        struct mach_o_dylib_module_external n;
2310
2311
0
        bfd_h_put_32 (abfd, module->module_name_idx, &n.module_name);
2312
0
        bfd_h_put_32 (abfd, module->iextdefsym, &n.iextdefsym);
2313
0
        bfd_h_put_32 (abfd, module->nextdefsym, &n.nextdefsym);
2314
0
        bfd_h_put_32 (abfd, module->irefsym, &n.irefsym);
2315
0
        bfd_h_put_32 (abfd, module->nrefsym, &n.nrefsym);
2316
0
        bfd_h_put_32 (abfd, module->ilocalsym, &n.ilocalsym);
2317
0
        bfd_h_put_32 (abfd, module->nlocalsym, &n.nlocalsym);
2318
0
        bfd_h_put_32 (abfd, module->iextrel, &n.iextrel);
2319
0
        bfd_h_put_32 (abfd, module->nextrel, &n.nextrel);
2320
0
        bfd_h_put_32 (abfd, iinit, &n.iinit_iterm);
2321
0
        bfd_h_put_32 (abfd, ninit, &n.ninit_nterm);
2322
0
        bfd_h_put_32 (abfd, module->objc_module_info_addr,
2323
0
          &n.objc_module_info_addr);
2324
0
        bfd_h_put_32 (abfd, module->objc_module_info_size,
2325
0
          &n.objc_module_info_size);
2326
2327
0
        if (bfd_write (&n, sizeof (n), abfd) != sizeof (n))
2328
0
    return false;
2329
0
      }
2330
0
  }
2331
0
    }
2332
2333
2
  if (cmd->ntoc != 0)
2334
0
    {
2335
0
      unsigned int i;
2336
2337
0
      if (bfd_seek (abfd, cmd->tocoff, SEEK_SET) != 0)
2338
0
  return false;
2339
2340
0
      for (i = 0; i < cmd->ntoc; i++)
2341
0
  {
2342
0
    struct mach_o_dylib_table_of_contents_external raw;
2343
0
    bfd_mach_o_dylib_table_of_content *toc = &cmd->dylib_toc[i];
2344
2345
0
    bfd_h_put_32 (abfd, toc->symbol_index, &raw.symbol_index);
2346
0
    bfd_h_put_32 (abfd, toc->module_index, &raw.module_index);
2347
2348
0
    if (bfd_write (&raw, sizeof (raw), abfd) != sizeof (raw))
2349
0
      return false;
2350
0
  }
2351
0
    }
2352
2353
2
  if (cmd->nindirectsyms > 0)
2354
0
    {
2355
0
      unsigned int i;
2356
2357
0
      if (bfd_seek (abfd, cmd->indirectsymoff, SEEK_SET) != 0)
2358
0
  return false;
2359
2360
0
      for (i = 0; i < cmd->nindirectsyms; ++i)
2361
0
  {
2362
0
    unsigned char raw[4];
2363
2364
0
    bfd_h_put_32 (abfd, cmd->indirect_syms[i], &raw);
2365
0
    if (bfd_write (raw, sizeof (raw), abfd) != sizeof (raw))
2366
0
      return false;
2367
0
  }
2368
0
    }
2369
2370
2
  if (cmd->nextrefsyms != 0)
2371
0
    {
2372
0
      unsigned int i;
2373
2374
0
      if (bfd_seek (abfd, cmd->extrefsymoff, SEEK_SET) != 0)
2375
0
  return false;
2376
2377
0
      for (i = 0; i < cmd->nextrefsyms; i++)
2378
0
  {
2379
0
    unsigned long v;
2380
0
    unsigned char raw[4];
2381
0
    bfd_mach_o_dylib_reference *ref = &cmd->ext_refs[i];
2382
2383
    /* Fields isym and flags are written as bit-fields, thus we need
2384
       a specific processing for endianness.  */
2385
2386
0
    if (bfd_big_endian (abfd))
2387
0
      {
2388
0
        v = ((ref->isym & 0xffffff) << 8);
2389
0
        v |= ref->flags & 0xff;
2390
0
      }
2391
0
    else
2392
0
      {
2393
0
        v = ref->isym  & 0xffffff;
2394
0
        v |= ((ref->flags & 0xff) << 24);
2395
0
      }
2396
2397
0
    bfd_h_put_32 (abfd, v, raw);
2398
0
    if (bfd_write (raw, sizeof (raw), abfd) != sizeof (raw))
2399
0
      return false;
2400
0
  }
2401
0
    }
2402
2403
  /* The command.  */
2404
2
  if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0)
2405
0
    return false;
2406
2
  else
2407
2
    {
2408
2
      struct mach_o_dysymtab_command_external raw;
2409
2410
2
      bfd_h_put_32 (abfd, cmd->ilocalsym, &raw.ilocalsym);
2411
2
      bfd_h_put_32 (abfd, cmd->nlocalsym, &raw.nlocalsym);
2412
2
      bfd_h_put_32 (abfd, cmd->iextdefsym, &raw.iextdefsym);
2413
2
      bfd_h_put_32 (abfd, cmd->nextdefsym, &raw.nextdefsym);
2414
2
      bfd_h_put_32 (abfd, cmd->iundefsym, &raw.iundefsym);
2415
2
      bfd_h_put_32 (abfd, cmd->nundefsym, &raw.nundefsym);
2416
2
      bfd_h_put_32 (abfd, cmd->tocoff, &raw.tocoff);
2417
2
      bfd_h_put_32 (abfd, cmd->ntoc, &raw.ntoc);
2418
2
      bfd_h_put_32 (abfd, cmd->modtaboff, &raw.modtaboff);
2419
2
      bfd_h_put_32 (abfd, cmd->nmodtab, &raw.nmodtab);
2420
2
      bfd_h_put_32 (abfd, cmd->extrefsymoff, &raw.extrefsymoff);
2421
2
      bfd_h_put_32 (abfd, cmd->nextrefsyms, &raw.nextrefsyms);
2422
2
      bfd_h_put_32 (abfd, cmd->indirectsymoff, &raw.indirectsymoff);
2423
2
      bfd_h_put_32 (abfd, cmd->nindirectsyms, &raw.nindirectsyms);
2424
2
      bfd_h_put_32 (abfd, cmd->extreloff, &raw.extreloff);
2425
2
      bfd_h_put_32 (abfd, cmd->nextrel, &raw.nextrel);
2426
2
      bfd_h_put_32 (abfd, cmd->locreloff, &raw.locreloff);
2427
2
      bfd_h_put_32 (abfd, cmd->nlocrel, &raw.nlocrel);
2428
2429
2
      if (bfd_write (&raw, sizeof (raw), abfd) != sizeof (raw))
2430
0
  return false;
2431
2
    }
2432
2433
2
  return true;
2434
2
}
2435
2436
static unsigned
2437
bfd_mach_o_primary_symbol_sort_key (bfd_mach_o_asymbol *s)
2438
33.6k
{
2439
33.6k
  unsigned mtyp = s->n_type & BFD_MACH_O_N_TYPE;
2440
2441
  /* Just leave debug symbols where they are (pretend they are local, and
2442
     then they will just be sorted on position).  */
2443
33.6k
  if (s->n_type & BFD_MACH_O_N_STAB)
2444
3.59k
    return 0;
2445
2446
  /* Local (we should never see an undefined local AFAICT).  */
2447
30.0k
  if (! (s->n_type & (BFD_MACH_O_N_EXT | BFD_MACH_O_N_PEXT)))
2448
15.6k
    return 0;
2449
2450
  /* Common symbols look like undefined externs.  */
2451
14.4k
  if (mtyp == BFD_MACH_O_N_UNDF)
2452
10.8k
    return 2;
2453
2454
  /* A defined non-local, non-debug symbol.  */
2455
3.55k
  return 1;
2456
14.4k
}
2457
2458
static int
2459
bfd_mach_o_cf_symbols (const void *a, const void *b)
2460
16.8k
{
2461
16.8k
  bfd_mach_o_asymbol *sa = *(bfd_mach_o_asymbol **) a;
2462
16.8k
  bfd_mach_o_asymbol *sb = *(bfd_mach_o_asymbol **) b;
2463
16.8k
  unsigned int soa, sob;
2464
2465
16.8k
  soa = bfd_mach_o_primary_symbol_sort_key (sa);
2466
16.8k
  sob = bfd_mach_o_primary_symbol_sort_key (sb);
2467
16.8k
  if (soa < sob)
2468
905
    return -1;
2469
2470
15.9k
  if (soa > sob)
2471
1.23k
    return 1;
2472
2473
  /* If it's local or stab, just preserve the input order.  */
2474
14.7k
  if (soa == 0)
2475
8.69k
    {
2476
8.69k
      if (sa->symbol.udata.i < sb->symbol.udata.i)
2477
8.69k
  return -1;
2478
0
      if (sa->symbol.udata.i > sb->symbol.udata.i)
2479
0
  return  1;
2480
2481
      /* This is probably an error.  */
2482
0
      return 0;
2483
0
    }
2484
2485
  /* The second sort key is name.  */
2486
6.00k
  return strcmp (sa->symbol.name, sb->symbol.name);
2487
14.7k
}
2488
2489
/* Process the symbols.
2490
2491
   This should be OK for single-module files - but it is not likely to work
2492
   for multi-module shared libraries.
2493
2494
   (a) If the application has not filled in the relevant mach-o fields, make
2495
       an estimate.
2496
2497
   (b) Order them, like this:
2498
  (  i) local.
2499
    (unsorted)
2500
  ( ii) external defined
2501
    (by name)
2502
  (iii) external undefined/common
2503
    (by name)
2504
  ( iv) common
2505
    (by name)
2506
*/
2507
2508
static bool
2509
bfd_mach_o_mangle_symbols (bfd *abfd)
2510
4
{
2511
4
  unsigned long i;
2512
4
  asymbol **symbols = bfd_get_outsymbols (abfd);
2513
2514
4
  if (symbols == NULL || bfd_get_symcount (abfd) == 0)
2515
2
    return true;
2516
2517
3.02k
  for (i = 0; i < bfd_get_symcount (abfd); i++)
2518
3.02k
    {
2519
3.02k
      bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *)symbols[i];
2520
2521
      /* We use this value, which is out-of-range as a symbol index, to signal
2522
   that the mach-o-specific data are not filled in and need to be created
2523
   from the bfd values.  It is much preferable for the application to do
2524
   this, since more meaningful diagnostics can be made that way.  */
2525
2526
3.02k
      if (s->symbol.udata.i == SYM_MACHO_FIELDS_UNSET)
2527
0
  {
2528
    /* No symbol information has been set - therefore determine
2529
       it from the bfd symbol flags/info.  */
2530
0
    if (s->symbol.section == bfd_abs_section_ptr)
2531
0
      s->n_type = BFD_MACH_O_N_ABS;
2532
0
    else if (s->symbol.section == bfd_und_section_ptr)
2533
0
      {
2534
0
        s->n_type = BFD_MACH_O_N_UNDF;
2535
0
        if (s->symbol.flags & BSF_WEAK)
2536
0
    s->n_desc |= BFD_MACH_O_N_WEAK_REF;
2537
        /* mach-o automatically makes undefined symbols extern.  */
2538
0
        s->n_type |= BFD_MACH_O_N_EXT;
2539
0
        s->symbol.flags |= BSF_GLOBAL;
2540
0
      }
2541
0
    else if (s->symbol.section == bfd_com_section_ptr)
2542
0
      {
2543
0
        s->n_type = BFD_MACH_O_N_UNDF | BFD_MACH_O_N_EXT;
2544
0
        s->symbol.flags |= BSF_GLOBAL;
2545
0
      }
2546
0
    else
2547
0
      s->n_type = BFD_MACH_O_N_SECT;
2548
0
  }
2549
2550
      /* Update external symbol bit in case objcopy changed it.  */
2551
3.02k
      if (s->symbol.flags & BSF_GLOBAL)
2552
1.28k
  s->n_type |= BFD_MACH_O_N_EXT;
2553
1.74k
      else
2554
1.74k
  s->n_type &= ~BFD_MACH_O_N_EXT;
2555
2556
      /* Put the section index in, where required.  */
2557
3.02k
      if ((s->symbol.section != bfd_abs_section_ptr
2558
3.02k
    && s->symbol.section != bfd_und_section_ptr
2559
3.02k
    && s->symbol.section != bfd_com_section_ptr)
2560
3.02k
    || ((s->n_type & BFD_MACH_O_N_STAB) != 0
2561
2.58k
         && s->symbol.name == NULL))
2562
436
  s->n_sect = s->symbol.section->output_section->target_index;
2563
2564
      /* Number to preserve order for local and debug syms.  */
2565
3.02k
      s->symbol.udata.i = i;
2566
3.02k
    }
2567
2568
  /* Sort the symbols.  */
2569
2
  qsort ((void *) symbols, (size_t) bfd_get_symcount (abfd),
2570
2
   sizeof (asymbol *), bfd_mach_o_cf_symbols);
2571
2572
3.02k
  for (i = 0; i < bfd_get_symcount (abfd); ++i)
2573
3.02k
    {
2574
3.02k
      bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *)symbols[i];
2575
3.02k
      s->symbol.udata.i = i;  /* renumber.  */
2576
3.02k
    }
2577
2578
2
  return true;
2579
4
}
2580
2581
/* We build a flat table of sections, which can be re-ordered if necessary.
2582
   Fill in the section number and other mach-o-specific data.  */
2583
2584
static bool
2585
bfd_mach_o_mangle_sections (bfd *abfd, bfd_mach_o_data_struct *mdata)
2586
4
{
2587
4
  asection *sec;
2588
4
  unsigned target_index;
2589
4
  unsigned nsect;
2590
4
  size_t amt;
2591
2592
4
  nsect = bfd_count_sections (abfd);
2593
2594
  /* Don't do it if it's already set - assume the application knows what it's
2595
     doing.  */
2596
4
  if (mdata->nsects == nsect
2597
4
      && (mdata->nsects == 0 || mdata->sections != NULL))
2598
2
    return true;
2599
2600
  /* We need to check that this can be done...  */
2601
2
  if (nsect > 255)
2602
0
    {
2603
0
      _bfd_error_handler (_("mach-o: there are too many sections (%u)"
2604
0
          " maximum is 255,\n"), nsect);
2605
0
      return false;
2606
0
    }
2607
2608
2
  mdata->nsects = nsect;
2609
2
  amt = mdata->nsects * sizeof (bfd_mach_o_section *);
2610
2
  mdata->sections = bfd_alloc (abfd, amt);
2611
2
  if (mdata->sections == NULL)
2612
0
    return false;
2613
2614
  /* Create Mach-O sections.
2615
     Section type, attribute and align should have been set when the
2616
     section was created - either read in or specified.  */
2617
2
  target_index = 0;
2618
30
  for (sec = abfd->sections; sec; sec = sec->next)
2619
28
    {
2620
28
      unsigned bfd_align = bfd_section_alignment (sec);
2621
28
      bfd_mach_o_section *msect = bfd_mach_o_get_mach_o_section (sec);
2622
2623
28
      mdata->sections[target_index] = msect;
2624
2625
28
      msect->addr = bfd_section_vma (sec);
2626
28
      msect->size = bfd_section_size (sec);
2627
2628
      /* Use the largest alignment set, in case it was bumped after the
2629
   section was created.  */
2630
28
      msect->align = msect->align > bfd_align ? msect->align : bfd_align;
2631
2632
28
      msect->offset = 0;
2633
28
      sec->target_index = ++target_index;
2634
28
    }
2635
2636
2
  return true;
2637
2
}
2638
2639
bool
2640
bfd_mach_o_write_contents (bfd *abfd)
2641
4
{
2642
4
  bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
2643
4
  bfd_mach_o_load_command *cmd;
2644
4
  bfd_mach_o_symtab_command *symtab = NULL;
2645
4
  bfd_mach_o_dysymtab_command *dysymtab = NULL;
2646
4
  bfd_mach_o_segment_command *linkedit = NULL;
2647
2648
  /* Make the commands, if not already present.  */
2649
4
  if (!abfd->output_has_begun && !bfd_mach_o_build_commands (abfd))
2650
0
    return false;
2651
4
  abfd->output_has_begun = true;
2652
2653
  /* Write the header.  */
2654
4
  if (!bfd_mach_o_write_header (abfd, &mdata->header))
2655
0
    return false;
2656
2657
  /* First pass: allocate the linkedit segment.  */
2658
34
  for (cmd = mdata->first_command; cmd != NULL; cmd = cmd->next)
2659
30
    switch (cmd->type)
2660
30
      {
2661
0
      case BFD_MACH_O_LC_SEGMENT_64:
2662
14
      case BFD_MACH_O_LC_SEGMENT:
2663
14
  if (strcmp (cmd->command.segment.segname, "__LINKEDIT") == 0)
2664
4
    linkedit = &cmd->command.segment;
2665
14
  break;
2666
2
      case BFD_MACH_O_LC_SYMTAB:
2667
2
  symtab = &cmd->command.symtab;
2668
2
  break;
2669
2
      case BFD_MACH_O_LC_DYSYMTAB:
2670
2
  dysymtab = &cmd->command.dysymtab;
2671
2
  break;
2672
0
      case BFD_MACH_O_LC_DYLD_INFO:
2673
0
  {
2674
0
    bfd_mach_o_dyld_info_command *di = &cmd->command.dyld_info;
2675
2676
0
    di->rebase_off = di->rebase_size != 0 ? mdata->filelen : 0;
2677
0
    mdata->filelen += di->rebase_size;
2678
0
    di->bind_off = di->bind_size != 0 ? mdata->filelen : 0;
2679
0
    mdata->filelen += di->bind_size;
2680
0
    di->weak_bind_off = di->weak_bind_size != 0 ? mdata->filelen : 0;
2681
0
    mdata->filelen += di->weak_bind_size;
2682
0
    di->lazy_bind_off = di->lazy_bind_size != 0 ? mdata->filelen : 0;
2683
0
    mdata->filelen += di->lazy_bind_size;
2684
0
    di->export_off = di->export_size != 0 ? mdata->filelen : 0;
2685
0
    mdata->filelen += di->export_size;
2686
0
  }
2687
0
  break;
2688
8
      case BFD_MACH_O_LC_LOAD_DYLIB:
2689
10
      case BFD_MACH_O_LC_LOAD_DYLINKER:
2690
12
      case BFD_MACH_O_LC_MAIN:
2691
  /* Nothing to do.  */
2692
12
  break;
2693
0
      default:
2694
0
  _bfd_error_handler
2695
0
    (_("unable to allocate data for load command %#x"),
2696
0
     cmd->type);
2697
0
  break;
2698
30
      }
2699
2700
  /* Specially handle symtab and dysymtab.  */
2701
2702
  /* Pre-allocate the symbol table (but not the string table).  The reason
2703
     is that the dysymtab is after the symbol table but before the string
2704
     table (required by the native strip tool).  */
2705
4
  if (symtab != NULL)
2706
2
    {
2707
2
      unsigned int symlen;
2708
2
      unsigned int wide = bfd_mach_o_wide_p (abfd);
2709
2710
2
      symlen = wide ? BFD_MACH_O_NLIST_64_SIZE : BFD_MACH_O_NLIST_SIZE;
2711
2712
      /* Align for symbols.  */
2713
2
      mdata->filelen = FILE_ALIGN (mdata->filelen, wide ? 3 : 2);
2714
2
      symtab->symoff = mdata->filelen;
2715
2716
2
      symtab->nsyms = bfd_get_symcount (abfd);
2717
2
      mdata->filelen += symtab->nsyms * symlen;
2718
2
    }
2719
2720
  /* Build the dysymtab.  */
2721
4
  if (dysymtab != NULL)
2722
2
    if (!bfd_mach_o_build_dysymtab (abfd, dysymtab))
2723
0
      return false;
2724
2725
  /* Write symtab and strtab.  */
2726
4
  if (symtab != NULL)
2727
2
    if (!bfd_mach_o_write_symtab_content (abfd, symtab))
2728
0
      return false;
2729
2730
  /* Adjust linkedit size.  */
2731
4
  if (linkedit != NULL)
2732
4
    {
2733
      /* bfd_vma pagemask = bfd_mach_o_get_backend_data (abfd)->page_size - 1; */
2734
2735
4
      linkedit->vmsize = mdata->filelen - linkedit->fileoff;
2736
      /* linkedit->vmsize = (linkedit->vmsize + pagemask) & ~pagemask; */
2737
4
      linkedit->filesize = mdata->filelen - linkedit->fileoff;
2738
2739
4
      linkedit->initprot = BFD_MACH_O_PROT_READ;
2740
4
      linkedit->maxprot = BFD_MACH_O_PROT_READ | BFD_MACH_O_PROT_WRITE
2741
4
  | BFD_MACH_O_PROT_EXECUTE;
2742
4
    }
2743
2744
  /* Second pass: write commands.  */
2745
34
  for (cmd = mdata->first_command; cmd != NULL; cmd = cmd->next)
2746
30
    {
2747
30
      struct mach_o_load_command_external raw;
2748
30
      unsigned long typeflag;
2749
2750
30
      typeflag = cmd->type | (cmd->type_required ? BFD_MACH_O_LC_REQ_DYLD : 0);
2751
2752
30
      bfd_h_put_32 (abfd, typeflag, raw.cmd);
2753
30
      bfd_h_put_32 (abfd, cmd->len, raw.cmdsize);
2754
2755
30
      if (bfd_seek (abfd, cmd->offset, SEEK_SET) != 0
2756
30
    || bfd_write (&raw, BFD_MACH_O_LC_SIZE, abfd) != 8)
2757
0
  return false;
2758
2759
30
      switch (cmd->type)
2760
30
  {
2761
14
  case BFD_MACH_O_LC_SEGMENT:
2762
14
    if (!bfd_mach_o_write_segment_32 (abfd, cmd))
2763
0
      return false;
2764
14
    break;
2765
14
  case BFD_MACH_O_LC_SEGMENT_64:
2766
0
    if (!bfd_mach_o_write_segment_64 (abfd, cmd))
2767
0
      return false;
2768
0
    break;
2769
2
  case BFD_MACH_O_LC_SYMTAB:
2770
2
    if (!bfd_mach_o_write_symtab (abfd, cmd))
2771
0
      return false;
2772
2
    break;
2773
2
  case BFD_MACH_O_LC_DYSYMTAB:
2774
2
    if (!bfd_mach_o_write_dysymtab (abfd, cmd))
2775
0
      return false;
2776
2
    break;
2777
2
  case BFD_MACH_O_LC_THREAD:
2778
0
  case BFD_MACH_O_LC_UNIXTHREAD:
2779
0
    if (!bfd_mach_o_write_thread (abfd, cmd))
2780
0
      return false;
2781
0
    break;
2782
8
  case BFD_MACH_O_LC_LOAD_DYLIB:
2783
8
    if (!bfd_mach_o_write_dylib (abfd, cmd))
2784
0
      return false;
2785
8
    break;
2786
8
  case BFD_MACH_O_LC_LOAD_DYLINKER:
2787
2
    if (!bfd_mach_o_write_dylinker (abfd, cmd))
2788
0
      return false;
2789
2
    break;
2790
2
  case BFD_MACH_O_LC_MAIN:
2791
2
    if (!bfd_mach_o_write_main (abfd, cmd))
2792
0
      return false;
2793
2
    break;
2794
2
  case BFD_MACH_O_LC_DYLD_INFO:
2795
0
    if (!bfd_mach_o_write_dyld_info (abfd, cmd))
2796
0
      return false;
2797
0
    break;
2798
0
  default:
2799
0
    _bfd_error_handler
2800
0
      (_("unable to write unknown load command %#x"),
2801
0
       cmd->type);
2802
0
    return false;
2803
30
  }
2804
30
    }
2805
2806
4
  return true;
2807
4
}
2808
2809
static void
2810
bfd_mach_o_append_section_to_segment (bfd_mach_o_segment_command *seg,
2811
              bfd_mach_o_section *s)
2812
4.57M
{
2813
4.57M
  if (seg->sect_head == NULL)
2814
19.5k
    seg->sect_head = s;
2815
4.55M
  else
2816
4.55M
    seg->sect_tail->next = s;
2817
4.57M
  seg->sect_tail = s;
2818
4.57M
}
2819
2820
/* Create section Mach-O flags from BFD flags.  */
2821
2822
static void
2823
bfd_mach_o_set_section_flags_from_bfd (bfd *abfd ATTRIBUTE_UNUSED,
2824
               asection *sec)
2825
4.67M
{
2826
4.67M
  flagword bfd_flags;
2827
4.67M
  bfd_mach_o_section *s = bfd_mach_o_get_mach_o_section (sec);
2828
2829
  /* Create default flags.  */
2830
4.67M
  bfd_flags = bfd_section_flags (sec);
2831
4.67M
  if ((bfd_flags & SEC_CODE) == SEC_CODE)
2832
2
    s->flags = BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS
2833
2
      | BFD_MACH_O_S_ATTR_SOME_INSTRUCTIONS
2834
2
      | BFD_MACH_O_S_REGULAR;
2835
4.67M
  else if ((bfd_flags & (SEC_ALLOC | SEC_LOAD)) == SEC_ALLOC)
2836
2
    s->flags = BFD_MACH_O_S_ZEROFILL;
2837
4.67M
  else if (bfd_flags & SEC_DEBUGGING)
2838
0
    s->flags = BFD_MACH_O_S_REGULAR |  BFD_MACH_O_S_ATTR_DEBUG;
2839
4.67M
  else
2840
4.67M
    s->flags = BFD_MACH_O_S_REGULAR;
2841
4.67M
}
2842
2843
static bool
2844
bfd_mach_o_build_obj_seg_command (bfd *abfd, bfd_mach_o_segment_command *seg)
2845
0
{
2846
0
  bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
2847
0
  unsigned int i, j;
2848
2849
0
  seg->vmaddr = 0;
2850
0
  seg->fileoff = mdata->filelen;
2851
0
  seg->initprot = BFD_MACH_O_PROT_READ | BFD_MACH_O_PROT_WRITE
2852
0
    | BFD_MACH_O_PROT_EXECUTE;
2853
0
  seg->maxprot = seg->initprot;
2854
2855
  /*  Append sections to the segment.
2856
2857
      This is a little tedious, we have to honor the need to account zerofill
2858
      sections after all the rest.  This forces us to do the calculation of
2859
      total vmsize in three passes so that any alignment increments are
2860
      properly accounted.  */
2861
0
  for (i = 0; i < mdata->nsects; ++i)
2862
0
    {
2863
0
      bfd_mach_o_section *s = mdata->sections[i];
2864
0
      asection *sec = s->bfdsection;
2865
2866
      /* Although we account for zerofill section sizes in vm order, they are
2867
   placed in the file in source sequence.  */
2868
0
      bfd_mach_o_append_section_to_segment (seg, s);
2869
0
      s->offset = 0;
2870
2871
      /* Zerofill sections have zero file size & offset, the only content
2872
   written to the file is the symbols.  */
2873
0
      if ((s->flags & BFD_MACH_O_SECTION_TYPE_MASK) == BFD_MACH_O_S_ZEROFILL
2874
0
    || ((s->flags & BFD_MACH_O_SECTION_TYPE_MASK)
2875
0
        == BFD_MACH_O_S_GB_ZEROFILL))
2876
0
  continue;
2877
2878
      /* The Darwin system tools (in MH_OBJECT files, at least) always account
2879
   sections, even those with zero size.  */
2880
0
      if (s->size > 0)
2881
0
  {
2882
0
    seg->vmsize = FILE_ALIGN (seg->vmsize, s->align);
2883
0
    seg->vmsize += s->size;
2884
2885
    /* MH_OBJECT files have unaligned content.  */
2886
0
    if (1)
2887
0
      {
2888
0
        seg->filesize = FILE_ALIGN (seg->filesize, s->align);
2889
0
        mdata->filelen = FILE_ALIGN (mdata->filelen, s->align);
2890
0
      }
2891
0
    seg->filesize += s->size;
2892
2893
    /* The system tools write even zero-sized sections with an offset
2894
       field set to the current file position.  */
2895
0
    s->offset = mdata->filelen;
2896
0
  }
2897
2898
0
      sec->filepos = s->offset;
2899
0
      mdata->filelen += s->size;
2900
0
    }
2901
2902
  /* Now pass through again, for zerofill, only now we just update the
2903
     vmsize, and then for zerofill_GB.  */
2904
0
  for (j = 0; j < 2; j++)
2905
0
    {
2906
0
      unsigned int stype;
2907
2908
0
      if (j == 0)
2909
0
  stype = BFD_MACH_O_S_ZEROFILL;
2910
0
      else
2911
0
  stype = BFD_MACH_O_S_GB_ZEROFILL;
2912
2913
0
      for (i = 0; i < mdata->nsects; ++i)
2914
0
  {
2915
0
    bfd_mach_o_section *s = mdata->sections[i];
2916
2917
0
    if ((s->flags & BFD_MACH_O_SECTION_TYPE_MASK) != stype)
2918
0
      continue;
2919
2920
0
    if (s->size > 0)
2921
0
      {
2922
0
        seg->vmsize = FILE_ALIGN (seg->vmsize, s->align);
2923
0
        seg->vmsize += s->size;
2924
0
      }
2925
0
  }
2926
0
    }
2927
2928
  /* Allocate space for the relocations.  */
2929
0
  mdata->filelen = FILE_ALIGN (mdata->filelen, 2);
2930
2931
0
  for (i = 0; i < mdata->nsects; ++i)
2932
0
    {
2933
0
      bfd_mach_o_section *ms = mdata->sections[i];
2934
0
      asection *sec = ms->bfdsection;
2935
2936
0
      ms->nreloc = sec->reloc_count;
2937
0
      if (ms->nreloc == 0)
2938
0
  {
2939
    /* Clear nreloc and reloff if there is no relocs.  */
2940
0
    ms->reloff = 0;
2941
0
    continue;
2942
0
  }
2943
0
      sec->rel_filepos = mdata->filelen;
2944
0
      ms->reloff = sec->rel_filepos;
2945
0
      mdata->filelen += sec->reloc_count * BFD_MACH_O_RELENT_SIZE;
2946
0
    }
2947
2948
0
  return true;
2949
0
}
2950
2951
static bool
2952
bfd_mach_o_build_exec_seg_command (bfd *abfd, bfd_mach_o_segment_command *seg)
2953
6
{
2954
6
  bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
2955
6
  unsigned int i;
2956
6
  bfd_vma pagemask = bfd_mach_o_get_backend_data (abfd)->page_size - 1;
2957
6
  bfd_vma vma;
2958
6
  bfd_mach_o_section *s;
2959
2960
6
  seg->vmsize = 0;
2961
2962
6
  seg->fileoff = mdata->filelen;
2963
6
  seg->maxprot = 0;
2964
6
  seg->initprot = 0;
2965
6
  seg->flags = 0;
2966
2967
  /*  Append sections to the segment.  We assume they are properly ordered
2968
      by vma (but we check that).  */
2969
6
  vma = 0;
2970
90
  for (i = 0; i < mdata->nsects; ++i)
2971
84
    {
2972
84
      s = mdata->sections[i];
2973
2974
      /* Consider only sections for this segment.  */
2975
84
      if (strcmp (seg->segname, s->segname) != 0)
2976
56
  continue;
2977
2978
28
      bfd_mach_o_append_section_to_segment (seg, s);
2979
2980
28
      if (s->addr < vma)
2981
0
  {
2982
0
    _bfd_error_handler
2983
      /* xgettext:c-format */
2984
0
      (_("section address (%#" PRIx64 ") "
2985
0
         "below start of segment (%#" PRIx64 ")"),
2986
0
         (uint64_t) s->addr, (uint64_t) vma);
2987
0
    return false;
2988
0
  }
2989
2990
28
      vma = s->addr + s->size;
2991
28
    }
2992
2993
  /* Set segment file offset: make it page aligned.  */
2994
6
  vma = seg->sect_head->addr;
2995
6
  seg->vmaddr = vma & ~pagemask;
2996
6
  if ((mdata->filelen & pagemask) > (vma & pagemask))
2997
0
    mdata->filelen += pagemask + 1;
2998
6
  seg->fileoff = mdata->filelen & ~pagemask;
2999
6
  mdata->filelen = seg->fileoff + (vma & pagemask);
3000
3001
  /* Set section file offset.  */
3002
34
  for (s = seg->sect_head; s != NULL; s = s->next)
3003
28
    {
3004
28
      asection *sec = s->bfdsection;
3005
28
      flagword flags = bfd_section_flags (sec);
3006
3007
      /* Adjust segment size.  */
3008
28
      seg->vmsize = FILE_ALIGN (seg->vmsize, s->align);
3009
28
      seg->vmsize += s->size;
3010
3011
      /* File offset and length.  */
3012
28
      seg->filesize = FILE_ALIGN (seg->filesize, s->align);
3013
3014
28
      if ((s->flags & BFD_MACH_O_SECTION_TYPE_MASK) != BFD_MACH_O_S_ZEROFILL
3015
28
    && ((s->flags & BFD_MACH_O_SECTION_TYPE_MASK)
3016
24
        != BFD_MACH_O_S_GB_ZEROFILL))
3017
24
  {
3018
24
    mdata->filelen = FILE_ALIGN (mdata->filelen, s->align);
3019
3020
24
    s->offset = mdata->filelen;
3021
24
    s->bfdsection->filepos = s->offset;
3022
3023
24
    seg->filesize += s->size;
3024
24
    mdata->filelen += s->size;
3025
24
  }
3026
4
      else
3027
4
  {
3028
4
    s->offset = 0;
3029
4
    s->bfdsection->filepos = 0;
3030
4
  }
3031
3032
      /* Set protection.  */
3033
28
      if (flags & SEC_LOAD)
3034
22
  {
3035
22
    if (flags & SEC_CODE)
3036
4
      seg->initprot |= BFD_MACH_O_PROT_READ | BFD_MACH_O_PROT_EXECUTE;
3037
22
    if ((flags & (SEC_DATA | SEC_READONLY)) == SEC_DATA)
3038
10
      seg->initprot |= BFD_MACH_O_PROT_WRITE | BFD_MACH_O_PROT_READ;
3039
22
  }
3040
3041
      /* Relocs shouldn't appear in non-object files.  */
3042
28
      if (s->bfdsection->reloc_count != 0)
3043
0
  return false;
3044
28
    }
3045
3046
  /* Set maxprot.  */
3047
6
  if (seg->initprot != 0)
3048
4
    seg->maxprot = BFD_MACH_O_PROT_READ | BFD_MACH_O_PROT_WRITE
3049
4
     | BFD_MACH_O_PROT_EXECUTE;
3050
2
  else
3051
2
    seg->maxprot = 0;
3052
3053
  /* Round segment size (and file size).  */
3054
6
  seg->vmsize = (seg->vmsize + pagemask) & ~pagemask;
3055
6
  seg->filesize = (seg->filesize + pagemask) & ~pagemask;
3056
6
  mdata->filelen = (mdata->filelen + pagemask) & ~pagemask;
3057
3058
6
  return true;
3059
6
}
3060
3061
/* Layout the commands: set commands size and offset, set ncmds and sizeofcmds
3062
   fields in header.  */
3063
3064
static bool
3065
bfd_mach_o_layout_commands (bfd_mach_o_data_struct *mdata)
3066
4
{
3067
4
  unsigned wide = mach_o_wide_p (&mdata->header);
3068
4
  unsigned int hdrlen;
3069
4
  ufile_ptr offset;
3070
4
  bfd_mach_o_load_command *cmd;
3071
4
  unsigned int align;
3072
4
  bool ret = true;
3073
3074
4
  hdrlen = wide ? BFD_MACH_O_HEADER_64_SIZE : BFD_MACH_O_HEADER_SIZE;
3075
4
  align = wide ? 8 - 1 : 4 - 1;
3076
4
  offset = hdrlen;
3077
4
  mdata->header.ncmds = 0;
3078
3079
34
  for (cmd = mdata->first_command; cmd; cmd = cmd->next)
3080
30
    {
3081
30
      mdata->header.ncmds++;
3082
30
      cmd->offset = offset;
3083
3084
30
      switch (cmd->type)
3085
30
  {
3086
0
  case BFD_MACH_O_LC_SEGMENT_64:
3087
0
    cmd->len = BFD_MACH_O_LC_SEGMENT_64_SIZE
3088
0
      + BFD_MACH_O_SECTION_64_SIZE * cmd->command.segment.nsects;
3089
0
    break;
3090
14
  case BFD_MACH_O_LC_SEGMENT:
3091
14
    cmd->len = BFD_MACH_O_LC_SEGMENT_SIZE
3092
14
      + BFD_MACH_O_SECTION_SIZE * cmd->command.segment.nsects;
3093
14
    break;
3094
2
  case BFD_MACH_O_LC_SYMTAB:
3095
2
    cmd->len = sizeof (struct mach_o_symtab_command_external)
3096
2
      + BFD_MACH_O_LC_SIZE;
3097
2
    break;
3098
2
  case BFD_MACH_O_LC_DYSYMTAB:
3099
2
    cmd->len = sizeof (struct mach_o_dysymtab_command_external)
3100
2
     + BFD_MACH_O_LC_SIZE;
3101
2
    break;
3102
8
  case BFD_MACH_O_LC_LOAD_DYLIB:
3103
8
    cmd->len = sizeof (struct mach_o_dylib_command_external)
3104
8
     + BFD_MACH_O_LC_SIZE;
3105
8
    cmd->command.dylib.name_offset = cmd->len;
3106
8
    cmd->len += strlen (cmd->command.dylib.name_str);
3107
8
    cmd->len = (cmd->len + align) & ~align;
3108
8
    break;
3109
2
  case BFD_MACH_O_LC_LOAD_DYLINKER:
3110
2
    cmd->len = sizeof (struct mach_o_str_command_external)
3111
2
     + BFD_MACH_O_LC_SIZE;
3112
2
    cmd->command.dylinker.name_offset = cmd->len;
3113
2
    cmd->len += strlen (cmd->command.dylinker.name_str);
3114
2
    cmd->len = (cmd->len + align) & ~align;
3115
2
    break;
3116
2
  case BFD_MACH_O_LC_MAIN:
3117
2
    cmd->len = sizeof (struct mach_o_entry_point_command_external)
3118
2
     + BFD_MACH_O_LC_SIZE;
3119
2
    break;
3120
0
  case BFD_MACH_O_LC_DYLD_INFO:
3121
0
    cmd->len = sizeof (struct mach_o_dyld_info_command_external)
3122
0
     + BFD_MACH_O_LC_SIZE;
3123
0
    break;
3124
0
  default:
3125
0
    _bfd_error_handler
3126
0
      (_("unable to layout unknown load command %#x"),
3127
0
       cmd->type);
3128
0
    ret = false;
3129
0
    break;
3130
30
  }
3131
3132
30
      BFD_ASSERT (cmd->len % (align + 1) == 0);
3133
30
      offset += cmd->len;
3134
30
    }
3135
4
  mdata->header.sizeofcmds = offset - hdrlen;
3136
4
  mdata->filelen = offset;
3137
3138
4
  return ret;
3139
4
}
3140
3141
/* Subroutine of bfd_mach_o_build_commands: set type, name and nsects of a
3142
   segment.  */
3143
3144
static void
3145
bfd_mach_o_init_segment (bfd_mach_o_data_struct *mdata,
3146
       bfd_mach_o_load_command *cmd,
3147
       const char *segname, unsigned int nbr_sect)
3148
14
{
3149
14
  bfd_mach_o_segment_command *seg = &cmd->command.segment;
3150
14
  unsigned wide = mach_o_wide_p (&mdata->header);
3151
3152
  /* Init segment command.  */
3153
14
  cmd->type = wide ? BFD_MACH_O_LC_SEGMENT_64 : BFD_MACH_O_LC_SEGMENT;
3154
14
  cmd->type_required = false;
3155
3156
14
  strcpy (seg->segname, segname);
3157
14
  seg->nsects = nbr_sect;
3158
3159
14
  seg->vmaddr = 0;
3160
14
  seg->vmsize = 0;
3161
3162
14
  seg->fileoff = 0;
3163
14
  seg->filesize = 0;
3164
14
  seg->maxprot = 0;
3165
14
  seg->initprot = 0;
3166
14
  seg->flags = 0;
3167
14
  seg->sect_head = NULL;
3168
14
  seg->sect_tail = NULL;
3169
14
}
3170
3171
/* Build Mach-O load commands (currently assuming an MH_OBJECT file).
3172
   TODO: Other file formats, rebuilding symtab/dysymtab commands for strip
3173
   and copy functionality.  */
3174
3175
bool
3176
bfd_mach_o_build_commands (bfd *abfd)
3177
4
{
3178
4
  bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3179
4
  unsigned wide = mach_o_wide_p (&mdata->header);
3180
4
  unsigned int nbr_segcmd = 0;
3181
4
  bfd_mach_o_load_command *commands;
3182
4
  unsigned int nbr_commands;
3183
4
  int symtab_idx = -1;
3184
4
  int dysymtab_idx = -1;
3185
4
  int main_idx = -1;
3186
4
  unsigned int i;
3187
3188
  /* Return now if already built.  */
3189
4
  if (mdata->header.ncmds != 0)
3190
0
    return true;
3191
3192
  /* Fill in the file type, if not already set.  */
3193
4
  if (mdata->header.filetype == 0)
3194
4
    {
3195
4
      if (abfd->flags & EXEC_P)
3196
4
  mdata->header.filetype = BFD_MACH_O_MH_EXECUTE;
3197
0
      else if (abfd->flags & DYNAMIC)
3198
0
  mdata->header.filetype = BFD_MACH_O_MH_DYLIB;
3199
0
      else
3200
0
  mdata->header.filetype = BFD_MACH_O_MH_OBJECT;
3201
4
    }
3202
3203
  /* If hasn't already been done, flatten sections list, and sort
3204
     if/when required.  Must be done before the symbol table is adjusted,
3205
     since that depends on properly numbered sections.  */
3206
4
  if (mdata->nsects == 0 || mdata->sections == NULL)
3207
4
    if (! bfd_mach_o_mangle_sections (abfd, mdata))
3208
0
      return false;
3209
3210
  /* Order the symbol table, fill-in/check mach-o specific fields and
3211
     partition out any indirect symbols.  */
3212
4
  if (!bfd_mach_o_mangle_symbols (abfd))
3213
0
    return false;
3214
3215
  /* Segment commands.  */
3216
4
  if (mdata->header.filetype == BFD_MACH_O_MH_OBJECT)
3217
0
    {
3218
      /* Only one segment for all the sections.  But the segment is
3219
   optional if there is no sections.  */
3220
0
      nbr_segcmd = (mdata->nsects > 0) ? 1 : 0;
3221
0
    }
3222
4
  else
3223
4
    {
3224
4
      bfd_mach_o_section *prev_sect = NULL;
3225
3226
      /* One pagezero segment and one linkedit segment.  */
3227
4
      nbr_segcmd = 2;
3228
3229
      /* Create one segment for associated segment name in sections.
3230
   Assume that sections with the same segment name are consecutive.  */
3231
32
      for (i = 0; i < mdata->nsects; i++)
3232
28
  {
3233
28
    bfd_mach_o_section *this_sect = mdata->sections[i];
3234
3235
28
    if (prev_sect == NULL
3236
28
        || strcmp (prev_sect->segname, this_sect->segname) != 0)
3237
6
      {
3238
6
        nbr_segcmd++;
3239
6
        prev_sect = this_sect;
3240
6
      }
3241
28
  }
3242
4
    }
3243
3244
4
  nbr_commands = nbr_segcmd;
3245
3246
  /* One command for the symbol table (only if there are symbols.  */
3247
4
  if (bfd_get_symcount (abfd) > 0)
3248
2
    symtab_idx = nbr_commands++;
3249
3250
  /* FIXME:
3251
     This is a rather crude test for whether we should build a dysymtab.  */
3252
4
  if (bfd_mach_o_should_emit_dysymtab ()
3253
4
      && bfd_get_symcount (abfd))
3254
2
    {
3255
      /* If there should be a case where a dysymtab could be emitted without
3256
   a symtab (seems improbable), this would need amending.  */
3257
2
      dysymtab_idx = nbr_commands++;
3258
2
    }
3259
3260
  /* Add an entry point command.  */
3261
4
  if (mdata->header.filetype == BFD_MACH_O_MH_EXECUTE
3262
4
      && bfd_get_start_address (abfd) != 0)
3263
2
    main_idx = nbr_commands++;
3264
3265
  /* Well, we must have a header, at least.  */
3266
4
  mdata->filelen = wide ? BFD_MACH_O_HEADER_64_SIZE : BFD_MACH_O_HEADER_SIZE;
3267
3268
  /* A bit unusual, but no content is valid;
3269
     as -n empty.s -o empty.o  */
3270
4
  if (nbr_commands == 0)
3271
0
    {
3272
      /* Layout commands (well none...) and set headers command fields.  */
3273
0
      return bfd_mach_o_layout_commands (mdata);
3274
0
    }
3275
3276
  /* Create commands for segments (and symtabs), prepend them.  */
3277
4
  commands = bfd_zalloc (abfd, nbr_commands * sizeof (bfd_mach_o_load_command));
3278
4
  if (commands == NULL)
3279
0
    return false;
3280
20
  for (i = 0; i < nbr_commands - 1; i++)
3281
16
    commands[i].next = &commands[i + 1];
3282
4
  commands[nbr_commands - 1].next = mdata->first_command;
3283
4
  if (mdata->first_command == NULL)
3284
2
    mdata->last_command = &commands[nbr_commands - 1];
3285
4
  mdata->first_command = &commands[0];
3286
3287
4
  if (mdata->header.filetype == BFD_MACH_O_MH_OBJECT && nbr_segcmd != 0)
3288
0
    {
3289
      /* For object file, there is only one segment.  */
3290
0
      bfd_mach_o_init_segment (mdata, &commands[0], "", mdata->nsects);
3291
0
    }
3292
4
  else if (nbr_segcmd != 0)
3293
4
    {
3294
4
      bfd_mach_o_load_command *cmd;
3295
3296
4
      BFD_ASSERT (nbr_segcmd >= 2);
3297
3298
      /* The pagezero.  */
3299
4
      cmd = &commands[0];
3300
4
      bfd_mach_o_init_segment (mdata, cmd, "__PAGEZERO", 0);
3301
3302
      /* Segments from sections.  */
3303
4
      cmd++;
3304
10
      for (i = 0; i < mdata->nsects;)
3305
6
  {
3306
6
    const char *segname = mdata->sections[i]->segname;
3307
6
    unsigned int nbr_sect = 1;
3308
3309
    /* Count number of sections for this segment.  */
3310
28
    for (i++; i < mdata->nsects; i++)
3311
26
      if (strcmp (mdata->sections[i]->segname, segname) == 0)
3312
22
        nbr_sect++;
3313
4
      else
3314
4
        break;
3315
3316
6
    bfd_mach_o_init_segment (mdata, cmd, segname, nbr_sect);
3317
6
    cmd++;
3318
6
  }
3319
3320
      /* The linkedit.  */
3321
4
      bfd_mach_o_init_segment (mdata, cmd, "__LINKEDIT", 0);
3322
4
    }
3323
3324
4
  if (symtab_idx >= 0)
3325
2
    {
3326
      /* Init symtab command.  */
3327
2
      bfd_mach_o_load_command *cmd = &commands[symtab_idx];
3328
3329
2
      cmd->type = BFD_MACH_O_LC_SYMTAB;
3330
2
      cmd->type_required = false;
3331
2
    }
3332
3333
  /* If required, setup symtab command, see comment above about the quality
3334
     of this test.  */
3335
4
  if (dysymtab_idx >= 0)
3336
2
    {
3337
2
      bfd_mach_o_load_command *cmd = &commands[dysymtab_idx];
3338
3339
2
      cmd->type = BFD_MACH_O_LC_DYSYMTAB;
3340
2
      cmd->type_required = false;
3341
2
    }
3342
3343
  /* Create the main command.  */
3344
4
  if (main_idx >= 0)
3345
2
    {
3346
2
      bfd_mach_o_load_command *cmd = &commands[main_idx];
3347
3348
2
      cmd->type = BFD_MACH_O_LC_MAIN;
3349
2
      cmd->type_required = true;
3350
3351
2
      cmd->command.main.entryoff = 0;
3352
2
      cmd->command.main.stacksize = 0;
3353
2
    }
3354
3355
  /* Layout commands.  */
3356
4
  if (! bfd_mach_o_layout_commands (mdata))
3357
0
    return false;
3358
3359
  /* So, now we have sized the commands and the filelen set to that.
3360
     Now we can build the segment command and set the section file offsets.  */
3361
4
  if (mdata->header.filetype == BFD_MACH_O_MH_OBJECT)
3362
0
    {
3363
0
      for (i = 0; i < nbr_segcmd; i++)
3364
0
  if (!bfd_mach_o_build_obj_seg_command
3365
0
      (abfd, &commands[i].command.segment))
3366
0
    return false;
3367
0
    }
3368
4
  else
3369
4
    {
3370
4
      bfd_vma maxvma = 0;
3371
3372
      /* Skip pagezero and linkedit segments.  */
3373
10
      for (i = 1; i < nbr_segcmd - 1; i++)
3374
6
  {
3375
6
    bfd_mach_o_segment_command *seg = &commands[i].command.segment;
3376
3377
6
    if (!bfd_mach_o_build_exec_seg_command (abfd, seg))
3378
0
      return false;
3379
3380
6
    if (seg->vmaddr + seg->vmsize > maxvma)
3381
4
      maxvma = seg->vmaddr + seg->vmsize;
3382
6
  }
3383
3384
      /* Set the size of __PAGEZERO.  */
3385
4
      commands[0].command.segment.vmsize =
3386
4
  commands[1].command.segment.vmaddr;
3387
3388
      /* Set the vma and fileoff of __LINKEDIT.  */
3389
4
      commands[nbr_segcmd - 1].command.segment.vmaddr = maxvma;
3390
4
      commands[nbr_segcmd - 1].command.segment.fileoff = mdata->filelen;
3391
3392
      /* Set entry point (once segments have been laid out).  */
3393
4
      if (main_idx >= 0)
3394
2
  commands[main_idx].command.main.entryoff =
3395
2
    bfd_get_start_address (abfd) - commands[1].command.segment.vmaddr;
3396
4
    }
3397
3398
4
  return true;
3399
4
}
3400
3401
/* Set the contents of a section.  */
3402
3403
bool
3404
bfd_mach_o_set_section_contents (bfd *abfd,
3405
         asection *section,
3406
         const void * location,
3407
         file_ptr offset,
3408
         bfd_size_type count)
3409
24
{
3410
24
  file_ptr pos;
3411
3412
  /* Trying to write the first section contents will trigger the creation of
3413
     the load commands if they are not already present.  */
3414
24
  if (!abfd->output_has_begun && !bfd_mach_o_build_commands (abfd))
3415
0
    return false;
3416
3417
24
  if (count == 0)
3418
0
    return true;
3419
3420
24
  pos = section->filepos + offset;
3421
24
  if (bfd_seek (abfd, pos, SEEK_SET) != 0
3422
24
      || bfd_write (location, count, abfd) != count)
3423
0
    return false;
3424
3425
24
  return true;
3426
24
}
3427
3428
int
3429
bfd_mach_o_sizeof_headers (bfd *a ATTRIBUTE_UNUSED,
3430
         struct bfd_link_info *info ATTRIBUTE_UNUSED)
3431
0
{
3432
0
  return 0;
3433
0
}
3434
3435
/* Make an empty symbol.  This is required only because
3436
   bfd_make_section_anyway wants to create a symbol for the section.  */
3437
3438
asymbol *
3439
bfd_mach_o_make_empty_symbol (bfd *abfd)
3440
4.67M
{
3441
4.67M
  asymbol *new_symbol;
3442
3443
4.67M
  new_symbol = bfd_zalloc (abfd, sizeof (bfd_mach_o_asymbol));
3444
4.67M
  if (new_symbol == NULL)
3445
0
    return new_symbol;
3446
4.67M
  new_symbol->the_bfd = abfd;
3447
4.67M
  new_symbol->udata.i = SYM_MACHO_FIELDS_UNSET;
3448
4.67M
  return new_symbol;
3449
4.67M
}
3450
3451
static bool
3452
bfd_mach_o_read_header (bfd *abfd, file_ptr hdr_off, bfd_mach_o_header *header)
3453
10.2M
{
3454
10.2M
  struct mach_o_header_external raw;
3455
10.2M
  unsigned int size;
3456
10.2M
  bfd_vma (*get32) (const void *) = NULL;
3457
3458
  /* Just read the magic number.  */
3459
10.2M
  if (bfd_seek (abfd, hdr_off, SEEK_SET) != 0
3460
10.2M
      || bfd_read (raw.magic, sizeof (raw.magic), abfd) != 4)
3461
17.2k
    return false;
3462
3463
10.2M
  if (bfd_getb32 (raw.magic) == BFD_MACH_O_MH_MAGIC)
3464
4.05k
    {
3465
4.05k
      header->byteorder = BFD_ENDIAN_BIG;
3466
4.05k
      header->magic = BFD_MACH_O_MH_MAGIC;
3467
4.05k
      header->version = 1;
3468
4.05k
      get32 = bfd_getb32;
3469
4.05k
    }
3470
10.2M
  else if (bfd_getl32 (raw.magic) == BFD_MACH_O_MH_MAGIC)
3471
148k
    {
3472
148k
      header->byteorder = BFD_ENDIAN_LITTLE;
3473
148k
      header->magic = BFD_MACH_O_MH_MAGIC;
3474
148k
      header->version = 1;
3475
148k
      get32 = bfd_getl32;
3476
148k
    }
3477
10.0M
  else if (bfd_getb32 (raw.magic) == BFD_MACH_O_MH_MAGIC_64)
3478
1.31k
    {
3479
1.31k
      header->byteorder = BFD_ENDIAN_BIG;
3480
1.31k
      header->magic = BFD_MACH_O_MH_MAGIC_64;
3481
1.31k
      header->version = 2;
3482
1.31k
      get32 = bfd_getb32;
3483
1.31k
    }
3484
10.0M
  else if (bfd_getl32 (raw.magic) == BFD_MACH_O_MH_MAGIC_64)
3485
370k
    {
3486
370k
      header->byteorder = BFD_ENDIAN_LITTLE;
3487
370k
      header->magic = BFD_MACH_O_MH_MAGIC_64;
3488
370k
      header->version = 2;
3489
370k
      get32 = bfd_getl32;
3490
370k
    }
3491
9.72M
  else
3492
9.72M
    {
3493
9.72M
      header->byteorder = BFD_ENDIAN_UNKNOWN;
3494
9.72M
      return false;
3495
9.72M
    }
3496
3497
  /* Once the size of the header is known, read the full header.  */
3498
524k
  size = mach_o_wide_p (header) ?
3499
372k
    BFD_MACH_O_HEADER_64_SIZE : BFD_MACH_O_HEADER_SIZE;
3500
3501
524k
  if (bfd_seek (abfd, hdr_off, SEEK_SET) != 0
3502
524k
      || bfd_read (&raw, size, abfd) != size)
3503
3.43k
    return false;
3504
3505
521k
  header->cputype = (*get32) (raw.cputype);
3506
521k
  header->cpusubtype = (*get32) (raw.cpusubtype);
3507
521k
  header->filetype = (*get32) (raw.filetype);
3508
521k
  header->ncmds = (*get32) (raw.ncmds);
3509
521k
  header->sizeofcmds = (*get32) (raw.sizeofcmds);
3510
521k
  header->flags = (*get32) (raw.flags);
3511
3512
521k
  if (mach_o_wide_p (header))
3513
369k
    header->reserved = (*get32) (raw.reserved);
3514
151k
  else
3515
151k
    header->reserved = 0;
3516
3517
521k
  return true;
3518
524k
}
3519
3520
bool
3521
bfd_mach_o_new_section_hook (bfd *abfd, asection *sec)
3522
4.67M
{
3523
4.67M
  bfd_mach_o_section *s;
3524
4.67M
  unsigned bfdalign = bfd_section_alignment (sec);
3525
3526
4.67M
  s = bfd_mach_o_get_mach_o_section (sec);
3527
4.67M
  if (s == NULL)
3528
4.67M
    {
3529
4.67M
      flagword bfd_flags;
3530
4.67M
      static const mach_o_section_name_xlat * xlat;
3531
3532
4.67M
      s = (bfd_mach_o_section *) bfd_zalloc (abfd, sizeof (*s));
3533
4.67M
      if (s == NULL)
3534
0
  return false;
3535
4.67M
      sec->used_by_bfd = s;
3536
4.67M
      s->bfdsection = sec;
3537
3538
      /* Create the Darwin seg/sect name pair from the bfd name.
3539
   If this is a canonical name for which a specific paiting exists
3540
   there will also be defined flags, type, attribute and alignment
3541
   values.  */
3542
4.67M
      xlat = bfd_mach_o_convert_section_name_to_mach_o (abfd, sec, s);
3543
4.67M
      if (xlat != NULL)
3544
5.24k
  {
3545
5.24k
    s->flags = xlat->macho_sectype | xlat->macho_secattr;
3546
5.24k
    s->align = xlat->sectalign > bfdalign ? xlat->sectalign
3547
5.24k
            : bfdalign;
3548
5.24k
    bfd_set_section_alignment (sec, s->align);
3549
5.24k
    bfd_flags = bfd_section_flags (sec);
3550
5.24k
    if (bfd_flags == SEC_NO_FLAGS)
3551
375
      bfd_set_section_flags (sec, xlat->bfd_flags);
3552
5.24k
  }
3553
4.67M
      else
3554
  /* Create default flags.  */
3555
4.67M
  bfd_mach_o_set_section_flags_from_bfd (abfd, sec);
3556
4.67M
    }
3557
3558
4.67M
  return _bfd_generic_new_section_hook (abfd, sec);
3559
4.67M
}
3560
3561
static void
3562
bfd_mach_o_init_section_from_mach_o (asection *sec, unsigned long prot)
3563
4.57M
{
3564
4.57M
  flagword flags;
3565
4.57M
  bfd_mach_o_section *section;
3566
3567
4.57M
  flags = bfd_section_flags (sec);
3568
4.57M
  section = bfd_mach_o_get_mach_o_section (sec);
3569
3570
  /* TODO: see if we should use the xlat system for doing this by
3571
     preference and fall back to this for unknown sections.  */
3572
3573
4.57M
  if (flags == SEC_NO_FLAGS)
3574
4.57M
    {
3575
      /* Try to guess flags.  */
3576
4.57M
      if (section->flags & BFD_MACH_O_S_ATTR_DEBUG)
3577
811k
  flags = SEC_DEBUGGING;
3578
3.75M
      else
3579
3.75M
  {
3580
3.75M
    flags = SEC_ALLOC;
3581
3.75M
    if ((section->flags & BFD_MACH_O_SECTION_TYPE_MASK)
3582
3.75M
        != BFD_MACH_O_S_ZEROFILL)
3583
3.66M
      {
3584
3.66M
        flags |= SEC_LOAD;
3585
3.66M
        if (prot & BFD_MACH_O_PROT_EXECUTE)
3586
2.18M
    flags |= SEC_CODE;
3587
3.66M
        if (prot & BFD_MACH_O_PROT_WRITE)
3588
287k
    flags |= SEC_DATA;
3589
3.37M
        else if (prot & BFD_MACH_O_PROT_READ)
3590
2.19M
    flags |= SEC_READONLY;
3591
3.66M
      }
3592
3.75M
  }
3593
4.57M
    }
3594
4.84k
  else
3595
4.84k
    {
3596
4.84k
      if ((flags & SEC_DEBUGGING) == 0)
3597
4.81k
  flags |= SEC_ALLOC;
3598
4.84k
    }
3599
3600
4.57M
  if (section->offset != 0)
3601
3.10M
    flags |= SEC_HAS_CONTENTS;
3602
4.57M
  if (section->nreloc != 0)
3603
3.08M
    flags |= SEC_RELOC;
3604
3605
4.57M
  bfd_set_section_flags (sec, flags);
3606
3607
4.57M
  sec->vma = section->addr;
3608
4.57M
  sec->lma = section->addr;
3609
4.57M
  sec->size = section->size;
3610
4.57M
  sec->filepos = section->offset;
3611
4.57M
  sec->alignment_power = section->align;
3612
4.57M
  sec->segment_mark = 0;
3613
4.57M
  sec->reloc_count = section->nreloc;
3614
4.57M
  sec->rel_filepos = section->reloff;
3615
4.57M
}
3616
3617
static asection *
3618
bfd_mach_o_make_bfd_section (bfd *abfd,
3619
           const unsigned char *segname,
3620
           const unsigned char *sectname)
3621
4.57M
{
3622
4.57M
  const char *sname;
3623
4.57M
  flagword flags;
3624
3625
4.57M
  bfd_mach_o_convert_section_name_to_bfd
3626
4.57M
    (abfd, (const char *)segname, (const char *)sectname, &sname, &flags);
3627
4.57M
  if (sname == NULL)
3628
0
    return NULL;
3629
3630
4.57M
  return bfd_make_section_anyway_with_flags (abfd, sname, flags);
3631
4.57M
}
3632
3633
static asection *
3634
bfd_mach_o_read_section_32 (bfd *abfd, unsigned long prot)
3635
1.37M
{
3636
1.37M
  struct mach_o_section_32_external raw;
3637
1.37M
  asection *sec;
3638
1.37M
  bfd_mach_o_section *section;
3639
3640
1.37M
  if (bfd_read (&raw, BFD_MACH_O_SECTION_SIZE, abfd)
3641
1.37M
      != BFD_MACH_O_SECTION_SIZE)
3642
4.81k
    return NULL;
3643
3644
1.37M
  sec = bfd_mach_o_make_bfd_section (abfd, raw.segname, raw.sectname);
3645
1.37M
  if (sec == NULL)
3646
0
    return NULL;
3647
3648
1.37M
  section = bfd_mach_o_get_mach_o_section (sec);
3649
1.37M
  memcpy (section->segname, raw.segname, sizeof (raw.segname));
3650
1.37M
  section->segname[BFD_MACH_O_SEGNAME_SIZE] = 0;
3651
1.37M
  memcpy (section->sectname, raw.sectname, sizeof (raw.sectname));
3652
1.37M
  section->sectname[BFD_MACH_O_SECTNAME_SIZE] = 0;
3653
1.37M
  section->addr = bfd_h_get_32 (abfd, raw.addr);
3654
1.37M
  section->size = bfd_h_get_32 (abfd, raw.size);
3655
1.37M
  section->offset = bfd_h_get_32 (abfd, raw.offset);
3656
1.37M
  section->align = bfd_h_get_32 (abfd, raw.align);
3657
  /* PR 17512: file: 0017eb76.  */
3658
1.37M
  if (section->align >= 31)
3659
914k
    {
3660
914k
      _bfd_error_handler
3661
914k
  (_("bfd_mach_o_read_section_32: overlarge alignment value: %#lx"),
3662
914k
   section->align);
3663
914k
      section->align = 30;
3664
914k
    }
3665
1.37M
  section->reloff = bfd_h_get_32 (abfd, raw.reloff);
3666
1.37M
  section->nreloc = bfd_h_get_32 (abfd, raw.nreloc);
3667
1.37M
  section->flags = bfd_h_get_32 (abfd, raw.flags);
3668
1.37M
  section->reserved1 = bfd_h_get_32 (abfd, raw.reserved1);
3669
1.37M
  section->reserved2 = bfd_h_get_32 (abfd, raw.reserved2);
3670
1.37M
  section->reserved3 = 0;
3671
3672
1.37M
  bfd_mach_o_init_section_from_mach_o (sec, prot);
3673
3674
1.37M
  return sec;
3675
1.37M
}
3676
3677
static asection *
3678
bfd_mach_o_read_section_64 (bfd *abfd, unsigned long prot)
3679
3.20M
{
3680
3.20M
  struct mach_o_section_64_external raw;
3681
3.20M
  asection *sec;
3682
3.20M
  bfd_mach_o_section *section;
3683
3684
3.20M
  if (bfd_read (&raw, BFD_MACH_O_SECTION_64_SIZE, abfd)
3685
3.20M
      != BFD_MACH_O_SECTION_64_SIZE)
3686
6.23k
    return NULL;
3687
3688
3.20M
  sec = bfd_mach_o_make_bfd_section (abfd, raw.segname, raw.sectname);
3689
3.20M
  if (sec == NULL)
3690
0
    return NULL;
3691
3692
3.20M
  section = bfd_mach_o_get_mach_o_section (sec);
3693
3.20M
  memcpy (section->segname, raw.segname, sizeof (raw.segname));
3694
3.20M
  section->segname[BFD_MACH_O_SEGNAME_SIZE] = 0;
3695
3.20M
  memcpy (section->sectname, raw.sectname, sizeof (raw.sectname));
3696
3.20M
  section->sectname[BFD_MACH_O_SECTNAME_SIZE] = 0;
3697
3.20M
  section->addr = bfd_h_get_64 (abfd, raw.addr);
3698
3.20M
  section->size = bfd_h_get_64 (abfd, raw.size);
3699
3.20M
  section->offset = bfd_h_get_32 (abfd, raw.offset);
3700
3.20M
  section->align = bfd_h_get_32 (abfd, raw.align);
3701
3.20M
  if (section->align >= 63)
3702
2.05M
    {
3703
2.05M
      _bfd_error_handler
3704
2.05M
  (_("bfd_mach_o_read_section_64: overlarge alignment value: %#lx"),
3705
2.05M
   section->align);
3706
2.05M
      section->align = 62;
3707
2.05M
    }
3708
3.20M
  section->reloff = bfd_h_get_32 (abfd, raw.reloff);
3709
3.20M
  section->nreloc = bfd_h_get_32 (abfd, raw.nreloc);
3710
3.20M
  section->flags = bfd_h_get_32 (abfd, raw.flags);
3711
3.20M
  section->reserved1 = bfd_h_get_32 (abfd, raw.reserved1);
3712
3.20M
  section->reserved2 = bfd_h_get_32 (abfd, raw.reserved2);
3713
3.20M
  section->reserved3 = bfd_h_get_32 (abfd, raw.reserved3);
3714
3715
3.20M
  bfd_mach_o_init_section_from_mach_o (sec, prot);
3716
3717
3.20M
  return sec;
3718
3.20M
}
3719
3720
static asection *
3721
bfd_mach_o_read_section (bfd *abfd, unsigned long prot, unsigned int wide)
3722
4.58M
{
3723
4.58M
  if (wide)
3724
3.20M
    return bfd_mach_o_read_section_64 (abfd, prot);
3725
1.37M
  else
3726
1.37M
    return bfd_mach_o_read_section_32 (abfd, prot);
3727
4.58M
}
3728
3729
static bool
3730
bfd_mach_o_read_symtab_symbol (bfd *abfd,
3731
             bfd_mach_o_symtab_command *sym,
3732
             bfd_mach_o_asymbol *s,
3733
             unsigned long i)
3734
52.8k
{
3735
52.8k
  bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3736
52.8k
  unsigned int wide = mach_o_wide_p (&mdata->header);
3737
52.8k
  unsigned int symwidth =
3738
52.8k
    wide ? BFD_MACH_O_NLIST_64_SIZE : BFD_MACH_O_NLIST_SIZE;
3739
52.8k
  unsigned int symoff = sym->symoff + (i * symwidth);
3740
52.8k
  struct mach_o_nlist_64_external raw;
3741
52.8k
  unsigned char type = -1;
3742
52.8k
  unsigned char section = -1;
3743
52.8k
  short desc = -1;
3744
52.8k
  symvalue value = -1;
3745
52.8k
  unsigned long stroff = -1;
3746
52.8k
  unsigned int symtype = -1;
3747
3748
52.8k
  BFD_ASSERT (sym->strtab != NULL);
3749
3750
52.8k
  if (bfd_seek (abfd, symoff, SEEK_SET) != 0
3751
52.8k
      || bfd_read (&raw, symwidth, abfd) != symwidth)
3752
0
    {
3753
0
      _bfd_error_handler
3754
  /* xgettext:c-format */
3755
0
  (_("bfd_mach_o_read_symtab_symbol: unable to read %d bytes at %u"),
3756
0
   symwidth, symoff);
3757
0
      return false;
3758
0
    }
3759
3760
52.8k
  stroff = bfd_h_get_32 (abfd, raw.n_strx);
3761
52.8k
  type = bfd_h_get_8 (abfd, raw.n_type);
3762
52.8k
  symtype = type & BFD_MACH_O_N_TYPE;
3763
52.8k
  section = bfd_h_get_8 (abfd, raw.n_sect);
3764
52.8k
  desc = bfd_h_get_16 (abfd, raw.n_desc);
3765
52.8k
  if (wide)
3766
6.41k
    value = bfd_h_get_64 (abfd, raw.n_value);
3767
46.4k
  else
3768
46.4k
    value = bfd_h_get_32 (abfd, raw.n_value);
3769
3770
52.8k
  if (stroff >= sym->strsize)
3771
222
    {
3772
222
      _bfd_error_handler
3773
  /* xgettext:c-format */
3774
222
  (_("bfd_mach_o_read_symtab_symbol: name out of range (%lu >= %u)"),
3775
222
   stroff,
3776
222
   sym->strsize);
3777
222
      return false;
3778
222
    }
3779
3780
52.6k
  s->symbol.the_bfd = abfd;
3781
52.6k
  s->symbol.name = sym->strtab + stroff;
3782
52.6k
  s->symbol.value = value;
3783
52.6k
  s->symbol.flags = 0x0;
3784
52.6k
  s->symbol.udata.i = i;
3785
52.6k
  s->n_type = type;
3786
52.6k
  s->n_sect = section;
3787
52.6k
  s->n_desc = desc;
3788
3789
52.6k
  if (type & BFD_MACH_O_N_STAB)
3790
13.9k
    {
3791
13.9k
      s->symbol.flags |= BSF_DEBUGGING;
3792
13.9k
      s->symbol.section = bfd_und_section_ptr;
3793
13.9k
      switch (type)
3794
13.9k
  {
3795
1.28k
  case N_FUN:
3796
1.36k
  case N_STSYM:
3797
1.45k
  case N_LCSYM:
3798
2.13k
  case N_BNSYM:
3799
2.22k
  case N_SLINE:
3800
2.89k
  case N_ENSYM:
3801
2.95k
  case N_ECOMM:
3802
2.98k
  case N_ECOML:
3803
3.33k
  case N_GSYM:
3804
3.33k
    if ((section > 0) && (section <= mdata->nsects))
3805
1.96k
      {
3806
1.96k
        s->symbol.section = mdata->sections[section - 1]->bfdsection;
3807
1.96k
        s->symbol.value =
3808
1.96k
    s->symbol.value - mdata->sections[section - 1]->addr;
3809
1.96k
      }
3810
3.33k
    break;
3811
13.9k
  }
3812
13.9k
    }
3813
38.6k
  else
3814
38.6k
    {
3815
38.6k
      if (type & (BFD_MACH_O_N_PEXT | BFD_MACH_O_N_EXT))
3816
20.4k
  s->symbol.flags |= BSF_GLOBAL;
3817
18.2k
      else
3818
18.2k
  s->symbol.flags |= BSF_LOCAL;
3819
3820
38.6k
      switch (symtype)
3821
38.6k
  {
3822
23.2k
  case BFD_MACH_O_N_UNDF:
3823
23.2k
    if (type == (BFD_MACH_O_N_UNDF | BFD_MACH_O_N_EXT)
3824
23.2k
        && s->symbol.value != 0)
3825
459
      {
3826
        /* A common symbol.  */
3827
459
        s->symbol.section = bfd_com_section_ptr;
3828
459
        s->symbol.flags = BSF_NO_FLAGS;
3829
459
      }
3830
22.7k
    else
3831
22.7k
      {
3832
22.7k
        s->symbol.section = bfd_und_section_ptr;
3833
22.7k
        if (s->n_desc & BFD_MACH_O_N_WEAK_REF)
3834
1.22k
    s->symbol.flags |= BSF_WEAK;
3835
22.7k
      }
3836
23.2k
    break;
3837
248
  case BFD_MACH_O_N_PBUD:
3838
248
    s->symbol.section = bfd_und_section_ptr;
3839
248
    break;
3840
490
  case BFD_MACH_O_N_ABS:
3841
490
    s->symbol.section = bfd_abs_section_ptr;
3842
490
    break;
3843
13.4k
  case BFD_MACH_O_N_SECT:
3844
13.4k
    if ((section > 0) && (section <= mdata->nsects))
3845
13.2k
      {
3846
13.2k
        s->symbol.section = mdata->sections[section - 1]->bfdsection;
3847
13.2k
        s->symbol.value =
3848
13.2k
    s->symbol.value - mdata->sections[section - 1]->addr;
3849
13.2k
      }
3850
132
    else
3851
132
      {
3852
        /* Mach-O uses 0 to mean "no section"; not an error.  */
3853
132
        if (section != 0)
3854
103
    {
3855
103
      _bfd_error_handler
3856
        /* xgettext:c-format */
3857
103
        (_("bfd_mach_o_read_symtab_symbol: "
3858
103
           "symbol \"%s\" specified invalid section %d (max %lu): "
3859
103
           "setting to undefined"),
3860
103
         s->symbol.name, section, mdata->nsects);
3861
103
    }
3862
132
        s->symbol.section = bfd_und_section_ptr;
3863
132
      }
3864
13.4k
    break;
3865
366
  case BFD_MACH_O_N_INDR:
3866
    /* FIXME: we don't follow the BFD convention as this indirect symbol
3867
       won't be followed by the referenced one.  This looks harmless
3868
       unless we start using the linker.  */
3869
366
    s->symbol.flags |= BSF_INDIRECT;
3870
366
    s->symbol.section = bfd_ind_section_ptr;
3871
366
    s->symbol.value = 0;
3872
366
    break;
3873
883
  default:
3874
883
    _bfd_error_handler
3875
      /* xgettext:c-format */
3876
883
      (_("bfd_mach_o_read_symtab_symbol: "
3877
883
         "symbol \"%s\" specified invalid type field 0x%x: "
3878
883
         "setting to undefined"), s->symbol.name, symtype);
3879
883
    s->symbol.section = bfd_und_section_ptr;
3880
883
    break;
3881
38.6k
  }
3882
38.6k
    }
3883
3884
52.6k
  return true;
3885
52.6k
}
3886
3887
bool
3888
bfd_mach_o_read_symtab_strtab (bfd *abfd)
3889
994
{
3890
994
  bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3891
994
  bfd_mach_o_symtab_command *sym = mdata->symtab;
3892
3893
  /* Fail if there is no symtab.  */
3894
994
  if (sym == NULL)
3895
0
    return false;
3896
3897
  /* Success if already loaded.  */
3898
994
  if (sym->strtab)
3899
0
    return true;
3900
3901
994
  if (abfd->flags & BFD_IN_MEMORY)
3902
0
    {
3903
0
      struct bfd_in_memory *b;
3904
3905
0
      b = (struct bfd_in_memory *) abfd->iostream;
3906
3907
0
      if ((sym->stroff + sym->strsize) > b->size)
3908
0
  {
3909
0
    bfd_set_error (bfd_error_file_truncated);
3910
0
    return false;
3911
0
  }
3912
0
      sym->strtab = (char *) b->buffer + sym->stroff;
3913
0
    }
3914
994
  else
3915
994
    {
3916
      /* See PR 21840 for a reproducer.  */
3917
994
      if ((sym->strsize + 1) == 0)
3918
0
  return false;
3919
994
      if (bfd_seek (abfd, sym->stroff, SEEK_SET) != 0)
3920
0
  return false;
3921
994
      sym->strtab = (char *) _bfd_alloc_and_read (abfd, sym->strsize + 1,
3922
994
              sym->strsize);
3923
994
      if (sym->strtab == NULL)
3924
0
  return false;
3925
3926
      /* Zero terminate the string table.  */
3927
994
      sym->strtab[sym->strsize] = 0;
3928
994
    }
3929
3930
994
  return true;
3931
994
}
3932
3933
bool
3934
bfd_mach_o_read_symtab_symbols (bfd *abfd)
3935
1.71k
{
3936
1.71k
  bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3937
1.71k
  bfd_mach_o_symtab_command *sym = mdata->symtab;
3938
1.71k
  unsigned long i;
3939
1.71k
  size_t amt;
3940
1.71k
  ufile_ptr filesize;
3941
3942
1.71k
  if (sym == NULL || sym->nsyms == 0 || sym->symbols)
3943
    /* Return now if there are no symbols or if already loaded.  */
3944
718
    return true;
3945
3946
997
  filesize = bfd_get_file_size (abfd);
3947
997
  if (filesize != 0)
3948
997
    {
3949
997
      unsigned int wide = mach_o_wide_p (&mdata->header);
3950
997
      unsigned int symwidth
3951
997
  = wide ? BFD_MACH_O_NLIST_64_SIZE : BFD_MACH_O_NLIST_SIZE;
3952
3953
997
      if (sym->symoff > filesize
3954
997
    || sym->nsyms > (filesize - sym->symoff) / symwidth)
3955
3
  {
3956
3
    bfd_set_error (bfd_error_file_truncated);
3957
3
    sym->nsyms = 0;
3958
3
    return false;
3959
3
  }
3960
997
    }
3961
994
  if (_bfd_mul_overflow (sym->nsyms, sizeof (bfd_mach_o_asymbol), &amt)
3962
994
      || (sym->symbols = bfd_alloc (abfd, amt)) == NULL)
3963
0
    {
3964
0
      bfd_set_error (bfd_error_no_memory);
3965
0
      sym->nsyms = 0;
3966
0
      return false;
3967
0
    }
3968
3969
994
  if (!bfd_mach_o_read_symtab_strtab (abfd))
3970
0
    goto fail;
3971
3972
53.6k
  for (i = 0; i < sym->nsyms; i++)
3973
52.8k
    if (!bfd_mach_o_read_symtab_symbol (abfd, sym, &sym->symbols[i], i))
3974
222
      goto fail;
3975
3976
772
  return true;
3977
3978
222
 fail:
3979
222
  bfd_release (abfd, sym->symbols);
3980
222
  sym->symbols = NULL;
3981
222
  sym->nsyms = 0;
3982
222
  return false;
3983
994
}
3984
3985
static const char *
3986
bfd_mach_o_i386_flavour_string (unsigned int flavour)
3987
62.5k
{
3988
62.5k
  switch ((int) flavour)
3989
62.5k
    {
3990
677
    case BFD_MACH_O_x86_THREAD_STATE32:    return "x86_THREAD_STATE32";
3991
11
    case BFD_MACH_O_x86_FLOAT_STATE32:     return "x86_FLOAT_STATE32";
3992
5
    case BFD_MACH_O_x86_EXCEPTION_STATE32: return "x86_EXCEPTION_STATE32";
3993
4.54k
    case BFD_MACH_O_x86_THREAD_STATE64:    return "x86_THREAD_STATE64";
3994
3
    case BFD_MACH_O_x86_FLOAT_STATE64:     return "x86_FLOAT_STATE64";
3995
7
    case BFD_MACH_O_x86_EXCEPTION_STATE64: return "x86_EXCEPTION_STATE64";
3996
0
    case BFD_MACH_O_x86_THREAD_STATE:      return "x86_THREAD_STATE";
3997
497
    case BFD_MACH_O_x86_FLOAT_STATE:       return "x86_FLOAT_STATE";
3998
968
    case BFD_MACH_O_x86_EXCEPTION_STATE:   return "x86_EXCEPTION_STATE";
3999
5
    case BFD_MACH_O_x86_DEBUG_STATE32:     return "x86_DEBUG_STATE32";
4000
25
    case BFD_MACH_O_x86_DEBUG_STATE64:     return "x86_DEBUG_STATE64";
4001
3
    case BFD_MACH_O_x86_DEBUG_STATE:       return "x86_DEBUG_STATE";
4002
5
    case BFD_MACH_O_x86_THREAD_STATE_NONE: return "x86_THREAD_STATE_NONE";
4003
55.8k
    default: return "UNKNOWN";
4004
62.5k
    }
4005
62.5k
}
4006
4007
static const char *
4008
bfd_mach_o_ppc_flavour_string (unsigned int flavour)
4009
31.6k
{
4010
31.6k
  switch ((int) flavour)
4011
31.6k
    {
4012
1.20k
    case BFD_MACH_O_PPC_THREAD_STATE:      return "PPC_THREAD_STATE";
4013
3
    case BFD_MACH_O_PPC_FLOAT_STATE:       return "PPC_FLOAT_STATE";
4014
2
    case BFD_MACH_O_PPC_EXCEPTION_STATE:   return "PPC_EXCEPTION_STATE";
4015
3
    case BFD_MACH_O_PPC_VECTOR_STATE:      return "PPC_VECTOR_STATE";
4016
500
    case BFD_MACH_O_PPC_THREAD_STATE64:    return "PPC_THREAD_STATE64";
4017
1
    case BFD_MACH_O_PPC_EXCEPTION_STATE64: return "PPC_EXCEPTION_STATE64";
4018
29.8k
    default: return "UNKNOWN";
4019
31.6k
    }
4020
31.6k
}
4021
4022
static unsigned char *
4023
bfd_mach_o_alloc_and_read (bfd *abfd, file_ptr filepos,
4024
         size_t size, size_t extra)
4025
15.5k
{
4026
15.5k
  if (bfd_seek (abfd, filepos, SEEK_SET) != 0)
4027
0
    return NULL;
4028
15.5k
  unsigned char *ret = _bfd_alloc_and_read (abfd, size + extra, size);
4029
15.5k
  if (ret && extra != 0)
4030
11.1k
    memset (ret + size, 0, extra);
4031
15.5k
  return ret;
4032
15.5k
}
4033
4034
static bool
4035
bfd_mach_o_read_dylinker (bfd *abfd, bfd_mach_o_load_command *command)
4036
5.72k
{
4037
5.72k
  bfd_mach_o_dylinker_command *cmd = &command->command.dylinker;
4038
5.72k
  struct mach_o_str_command_external raw;
4039
5.72k
  unsigned int nameoff;
4040
5.72k
  size_t namelen;
4041
4042
5.72k
  if (command->len < sizeof (raw) + 8)
4043
113
    return false;
4044
5.61k
  if (bfd_read (&raw, sizeof (raw), abfd) != sizeof (raw))
4045
842
    return false;
4046
4047
4.76k
  nameoff = bfd_h_get_32 (abfd, raw.str);
4048
4.76k
  if (nameoff > command->len)
4049
645
    return false;
4050
4051
4.12k
  cmd->name_offset = nameoff;
4052
4.12k
  namelen = command->len - nameoff;
4053
4.12k
  nameoff += command->offset;
4054
4.12k
  cmd->name_str = (char *) bfd_mach_o_alloc_and_read (abfd, nameoff,
4055
4.12k
                  namelen, 1);
4056
4.12k
  return cmd->name_str != NULL;
4057
4.76k
}
4058
4059
static bool
4060
bfd_mach_o_read_dylib (bfd *abfd, bfd_mach_o_load_command *command)
4061
8.63k
{
4062
8.63k
  bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
4063
8.63k
  bfd_mach_o_dylib_command *cmd = &command->command.dylib;
4064
8.63k
  struct mach_o_dylib_command_external raw;
4065
8.63k
  unsigned int nameoff;
4066
8.63k
  size_t namelen;
4067
8.63k
  file_ptr pos;
4068
4069
8.63k
  if (command->len < sizeof (raw) + 8)
4070
323
    return false;
4071
8.30k
  switch (command->type)
4072
8.30k
    {
4073
1.76k
    case BFD_MACH_O_LC_LOAD_DYLIB:
4074
2.53k
    case BFD_MACH_O_LC_LAZY_LOAD_DYLIB:
4075
3.51k
    case BFD_MACH_O_LC_LOAD_WEAK_DYLIB:
4076
4.33k
    case BFD_MACH_O_LC_ID_DYLIB:
4077
8.01k
    case BFD_MACH_O_LC_REEXPORT_DYLIB:
4078
8.30k
    case BFD_MACH_O_LC_LOAD_UPWARD_DYLIB:
4079
8.30k
      break;
4080
0
    default:
4081
0
      BFD_FAIL ();
4082
0
      return false;
4083
8.30k
    }
4084
4085
8.30k
  if (bfd_read (&raw, sizeof (raw), abfd) != sizeof (raw))
4086
1.18k
    return false;
4087
4088
7.12k
  nameoff = bfd_h_get_32 (abfd, raw.name);
4089
7.12k
  if (nameoff > command->len)
4090
1.06k
    return false;
4091
6.05k
  cmd->timestamp = bfd_h_get_32 (abfd, raw.timestamp);
4092
6.05k
  cmd->current_version = bfd_h_get_32 (abfd, raw.current_version);
4093
6.05k
  cmd->compatibility_version = bfd_h_get_32 (abfd, raw.compatibility_version);
4094
4095
6.05k
  cmd->name_offset = command->offset + nameoff;
4096
6.05k
  namelen = command->len - nameoff;
4097
6.05k
  pos = mdata->hdr_offset + cmd->name_offset;
4098
6.05k
  cmd->name_str = (char *) bfd_mach_o_alloc_and_read (abfd, pos, namelen, 1);
4099
6.05k
  return cmd->name_str != NULL;
4100
7.12k
}
4101
4102
static bool
4103
bfd_mach_o_read_prebound_dylib (bfd *abfd,
4104
        bfd_mach_o_load_command *command)
4105
4.97k
{
4106
4.97k
  bfd_mach_o_prebound_dylib_command *cmd = &command->command.prebound_dylib;
4107
4.97k
  struct mach_o_prebound_dylib_command_external raw;
4108
4.97k
  unsigned int nameoff;
4109
4.97k
  unsigned int modoff;
4110
4.97k
  unsigned int str_len;
4111
4.97k
  unsigned char *str;
4112
4113
4.97k
  if (command->len < sizeof (raw) + 8)
4114
24
    return false;
4115
4.94k
  if (bfd_read (&raw, sizeof (raw), abfd) != sizeof (raw))
4116
1.04k
    return false;
4117
4118
3.90k
  nameoff = bfd_h_get_32 (abfd, raw.name);
4119
3.90k
  modoff = bfd_h_get_32 (abfd, raw.linked_modules);
4120
3.90k
  if (nameoff > command->len || modoff > command->len)
4121
1.61k
    return false;
4122
4123
2.29k
  str_len = command->len - sizeof (raw);
4124
2.29k
  str = _bfd_alloc_and_read (abfd, str_len, str_len);
4125
2.29k
  if (str == NULL)
4126
1.83k
    return false;
4127
4128
456
  cmd->name_offset = command->offset + nameoff;
4129
456
  cmd->nmodules = bfd_h_get_32 (abfd, raw.nmodules);
4130
456
  cmd->linked_modules_offset = command->offset + modoff;
4131
4132
456
  cmd->name_str = (char *)str + nameoff - (sizeof (raw) + BFD_MACH_O_LC_SIZE);
4133
456
  cmd->linked_modules = str + modoff - (sizeof (raw) + BFD_MACH_O_LC_SIZE);
4134
456
  return true;
4135
2.29k
}
4136
4137
static bool
4138
bfd_mach_o_read_prebind_cksum (bfd *abfd,
4139
             bfd_mach_o_load_command *command)
4140
1.17k
{
4141
1.17k
  bfd_mach_o_prebind_cksum_command *cmd = &command->command.prebind_cksum;
4142
1.17k
  struct mach_o_prebind_cksum_command_external raw;
4143
4144
1.17k
  if (command->len < sizeof (raw) + 8)
4145
216
    return false;
4146
958
  if (bfd_read (&raw, sizeof (raw), abfd) != sizeof (raw))
4147
217
    return false;
4148
4149
741
  cmd->cksum = bfd_get_32 (abfd, raw.cksum);
4150
741
  return true;
4151
958
}
4152
4153
static bool
4154
bfd_mach_o_read_twolevel_hints (bfd *abfd,
4155
        bfd_mach_o_load_command *command)
4156
9.86k
{
4157
9.86k
  bfd_mach_o_twolevel_hints_command *cmd = &command->command.twolevel_hints;
4158
9.86k
  struct mach_o_twolevel_hints_command_external raw;
4159
4160
9.86k
  if (command->len < sizeof (raw) + 8)
4161
18
    return false;
4162
9.84k
  if (bfd_read (&raw, sizeof (raw), abfd) != sizeof (raw))
4163
23
    return false;
4164
4165
9.82k
  cmd->offset = bfd_get_32 (abfd, raw.offset);
4166
9.82k
  cmd->nhints = bfd_get_32 (abfd, raw.nhints);
4167
9.82k
  return true;
4168
9.84k
}
4169
4170
static bool
4171
bfd_mach_o_read_fvmlib (bfd *abfd, bfd_mach_o_load_command *command)
4172
2.60k
{
4173
2.60k
  bfd_mach_o_fvmlib_command *fvm = &command->command.fvmlib;
4174
2.60k
  struct mach_o_fvmlib_command_external raw;
4175
2.60k
  unsigned int nameoff;
4176
2.60k
  size_t namelen;
4177
4178
2.60k
  if (command->len < sizeof (raw) + 8)
4179
116
    return false;
4180
2.48k
  if (bfd_read (&raw, sizeof (raw), abfd) != sizeof (raw))
4181
837
    return false;
4182
4183
1.65k
  nameoff = bfd_h_get_32 (abfd, raw.name);
4184
1.65k
  if (nameoff > command->len)
4185
552
    return false;
4186
1.09k
  fvm->minor_version = bfd_h_get_32 (abfd, raw.minor_version);
4187
1.09k
  fvm->header_addr = bfd_h_get_32 (abfd, raw.header_addr);
4188
4189
1.09k
  fvm->name_offset = command->offset + nameoff;
4190
1.09k
  namelen = command->len - nameoff;
4191
1.09k
  fvm->name_str = (char *) bfd_mach_o_alloc_and_read (abfd, fvm->name_offset,
4192
1.09k
                  namelen, 1);
4193
1.09k
  return fvm->name_str != NULL;
4194
1.65k
}
4195
4196
static bool
4197
bfd_mach_o_read_thread (bfd *abfd, bfd_mach_o_load_command *command)
4198
19.1k
{
4199
19.1k
  bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
4200
19.1k
  bfd_mach_o_thread_command *cmd = &command->command.thread;
4201
19.1k
  unsigned int offset;
4202
19.1k
  unsigned int nflavours;
4203
19.1k
  unsigned int i;
4204
19.1k
  struct mach_o_thread_command_external raw;
4205
19.1k
  size_t amt;
4206
4207
19.1k
  BFD_ASSERT ((command->type == BFD_MACH_O_LC_THREAD)
4208
19.1k
        || (command->type == BFD_MACH_O_LC_UNIXTHREAD));
4209
4210
  /* Count the number of threads.  */
4211
19.1k
  offset = 8;
4212
19.1k
  nflavours = 0;
4213
130k
  while (offset + sizeof (raw) <= command->len)
4214
115k
    {
4215
115k
      unsigned int count;
4216
4217
115k
      if (bfd_seek (abfd, command->offset + offset, SEEK_SET) != 0
4218
115k
    || bfd_read (&raw, sizeof (raw), abfd) != sizeof (raw))
4219
1.51k
  return false;
4220
4221
113k
      count = bfd_h_get_32 (abfd, raw.count);
4222
113k
      if (count > (unsigned) -1 / 4
4223
113k
    || command->len - (offset + sizeof (raw)) < count * 4)
4224
2.73k
  return false;
4225
111k
      offset += sizeof (raw) + count * 4;
4226
111k
      nflavours++;
4227
111k
    }
4228
14.8k
  if (nflavours == 0 || offset != command->len)
4229
851
    return false;
4230
4231
  /* Allocate threads.  */
4232
14.0k
  if (_bfd_mul_overflow (nflavours, sizeof (bfd_mach_o_thread_flavour), &amt))
4233
0
    {
4234
0
      bfd_set_error (bfd_error_file_too_big);
4235
0
      return false;
4236
0
    }
4237
14.0k
  cmd->flavours = bfd_alloc (abfd, amt);
4238
14.0k
  if (cmd->flavours == NULL)
4239
0
    return false;
4240
14.0k
  cmd->nflavours = nflavours;
4241
4242
14.0k
  offset = 8;
4243
14.0k
  nflavours = 0;
4244
114k
  while (offset != command->len)
4245
100k
    {
4246
100k
      if (bfd_seek (abfd, command->offset + offset, SEEK_SET) != 0
4247
100k
    || bfd_read (&raw, sizeof (raw), abfd) != sizeof (raw))
4248
0
  return false;
4249
4250
100k
      cmd->flavours[nflavours].flavour = bfd_h_get_32 (abfd, raw.flavour);
4251
100k
      cmd->flavours[nflavours].offset = command->offset + offset + sizeof (raw);
4252
100k
      cmd->flavours[nflavours].size = bfd_h_get_32 (abfd, raw.count) * 4;
4253
100k
      offset += cmd->flavours[nflavours].size + sizeof (raw);
4254
100k
      nflavours++;
4255
100k
    }
4256
4257
114k
  for (i = 0; i < nflavours; i++)
4258
100k
    {
4259
100k
      asection *bfdsec;
4260
100k
      size_t snamelen;
4261
100k
      char *sname;
4262
100k
      const char *flavourstr;
4263
100k
      const char *prefix = "LC_THREAD";
4264
100k
      unsigned int j = 0;
4265
4266
100k
      switch (mdata->header.cputype)
4267
100k
  {
4268
6.52k
  case BFD_MACH_O_CPU_TYPE_POWERPC:
4269
31.6k
  case BFD_MACH_O_CPU_TYPE_POWERPC_64:
4270
31.6k
    flavourstr =
4271
31.6k
      bfd_mach_o_ppc_flavour_string (cmd->flavours[i].flavour);
4272
31.6k
    break;
4273
11.2k
  case BFD_MACH_O_CPU_TYPE_I386:
4274
62.5k
  case BFD_MACH_O_CPU_TYPE_X86_64:
4275
62.5k
    flavourstr =
4276
62.5k
      bfd_mach_o_i386_flavour_string (cmd->flavours[i].flavour);
4277
62.5k
    break;
4278
6.79k
  default:
4279
6.79k
    flavourstr = "UNKNOWN_ARCHITECTURE";
4280
6.79k
    break;
4281
100k
  }
4282
4283
100k
      snamelen = strlen (prefix) + 1 + 20 + 1 + strlen (flavourstr) + 1;
4284
100k
      sname = bfd_alloc (abfd, snamelen);
4285
100k
      if (sname == NULL)
4286
0
  return false;
4287
4288
100k
      for (;;)
4289
783k
  {
4290
783k
    sprintf (sname, "%s.%s.%u", prefix, flavourstr, j);
4291
783k
    if (bfd_get_section_by_name (abfd, sname) == NULL)
4292
100k
      break;
4293
682k
    j++;
4294
682k
  }
4295
4296
100k
      bfdsec = bfd_make_section_with_flags (abfd, sname, SEC_HAS_CONTENTS);
4297
4298
100k
      bfdsec->vma = 0;
4299
100k
      bfdsec->lma = 0;
4300
100k
      bfdsec->size = cmd->flavours[i].size;
4301
100k
      bfdsec->filepos = cmd->flavours[i].offset;
4302
100k
      bfdsec->alignment_power = 0x0;
4303
4304
100k
      cmd->section = bfdsec;
4305
100k
    }
4306
4307
14.0k
  return true;
4308
14.0k
}
4309
4310
static bool
4311
bfd_mach_o_read_dysymtab (bfd *abfd, bfd_mach_o_load_command *command,
4312
        ufile_ptr filesize)
4313
19.6k
{
4314
19.6k
  bfd_mach_o_dysymtab_command *cmd = &command->command.dysymtab;
4315
19.6k
  bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
4316
4317
19.6k
  BFD_ASSERT (command->type == BFD_MACH_O_LC_DYSYMTAB);
4318
4319
19.6k
  {
4320
19.6k
    struct mach_o_dysymtab_command_external raw;
4321
4322
19.6k
    if (command->len < sizeof (raw) + 8)
4323
242
      return false;
4324
19.4k
    if (bfd_read (&raw, sizeof (raw), abfd) != sizeof (raw))
4325
966
      return false;
4326
4327
18.4k
    cmd->ilocalsym = bfd_h_get_32 (abfd, raw.ilocalsym);
4328
18.4k
    cmd->nlocalsym = bfd_h_get_32 (abfd, raw.nlocalsym);
4329
18.4k
    cmd->iextdefsym = bfd_h_get_32 (abfd, raw.iextdefsym);
4330
18.4k
    cmd->nextdefsym = bfd_h_get_32 (abfd, raw.nextdefsym);
4331
18.4k
    cmd->iundefsym = bfd_h_get_32 (abfd, raw.iundefsym);
4332
18.4k
    cmd->nundefsym = bfd_h_get_32 (abfd, raw.nundefsym);
4333
18.4k
    cmd->tocoff = bfd_h_get_32 (abfd, raw.tocoff);
4334
18.4k
    cmd->ntoc = bfd_h_get_32 (abfd, raw.ntoc);
4335
18.4k
    cmd->modtaboff = bfd_h_get_32 (abfd, raw.modtaboff);
4336
18.4k
    cmd->nmodtab = bfd_h_get_32 (abfd, raw.nmodtab);
4337
18.4k
    cmd->extrefsymoff = bfd_h_get_32 (abfd, raw.extrefsymoff);
4338
18.4k
    cmd->nextrefsyms = bfd_h_get_32 (abfd, raw.nextrefsyms);
4339
18.4k
    cmd->indirectsymoff = bfd_h_get_32 (abfd, raw.indirectsymoff);
4340
18.4k
    cmd->nindirectsyms = bfd_h_get_32 (abfd, raw.nindirectsyms);
4341
18.4k
    cmd->extreloff = bfd_h_get_32 (abfd, raw.extreloff);
4342
18.4k
    cmd->nextrel = bfd_h_get_32 (abfd, raw.nextrel);
4343
18.4k
    cmd->locreloff = bfd_h_get_32 (abfd, raw.locreloff);
4344
18.4k
    cmd->nlocrel = bfd_h_get_32 (abfd, raw.nlocrel);
4345
18.4k
  }
4346
4347
18.4k
  if (cmd->nmodtab != 0)
4348
8.05k
    {
4349
8.05k
      unsigned int i;
4350
8.05k
      int wide = bfd_mach_o_wide_p (abfd);
4351
8.05k
      unsigned int module_len = wide ? 56 : 52;
4352
8.05k
      size_t amt;
4353
4354
8.05k
      if (cmd->modtaboff > filesize
4355
8.05k
    || cmd->nmodtab > (filesize - cmd->modtaboff) / module_len)
4356
3.12k
  {
4357
3.12k
    bfd_set_error (bfd_error_file_truncated);
4358
3.12k
    return false;
4359
3.12k
  }
4360
4.92k
      if (_bfd_mul_overflow (cmd->nmodtab,
4361
4.92k
           sizeof (bfd_mach_o_dylib_module), &amt))
4362
0
  {
4363
0
    bfd_set_error (bfd_error_file_too_big);
4364
0
    return false;
4365
0
  }
4366
4.92k
      cmd->dylib_module = bfd_alloc (abfd, amt);
4367
4.92k
      if (cmd->dylib_module == NULL)
4368
0
  return false;
4369
4370
4.92k
      if (bfd_seek (abfd, cmd->modtaboff, SEEK_SET) != 0)
4371
0
  return false;
4372
4373
27.5k
      for (i = 0; i < cmd->nmodtab; i++)
4374
23.5k
  {
4375
23.5k
    bfd_mach_o_dylib_module *module = &cmd->dylib_module[i];
4376
23.5k
    unsigned long v;
4377
23.5k
    unsigned char buf[56];
4378
4379
23.5k
    if (bfd_read (buf, module_len, abfd) != module_len)
4380
947
      return false;
4381
4382
22.5k
    module->module_name_idx = bfd_h_get_32 (abfd, buf + 0);
4383
22.5k
    module->iextdefsym = bfd_h_get_32 (abfd, buf + 4);
4384
22.5k
    module->nextdefsym = bfd_h_get_32 (abfd, buf + 8);
4385
22.5k
    module->irefsym = bfd_h_get_32 (abfd, buf + 12);
4386
22.5k
    module->nrefsym = bfd_h_get_32 (abfd, buf + 16);
4387
22.5k
    module->ilocalsym = bfd_h_get_32 (abfd, buf + 20);
4388
22.5k
    module->nlocalsym = bfd_h_get_32 (abfd, buf + 24);
4389
22.5k
    module->iextrel = bfd_h_get_32 (abfd, buf + 28);
4390
22.5k
    module->nextrel = bfd_h_get_32 (abfd, buf + 32);
4391
22.5k
    v = bfd_h_get_32 (abfd, buf +36);
4392
22.5k
    module->iinit = v & 0xffff;
4393
22.5k
    module->iterm = (v >> 16) & 0xffff;
4394
22.5k
    v = bfd_h_get_32 (abfd, buf + 40);
4395
22.5k
    module->ninit = v & 0xffff;
4396
22.5k
    module->nterm = (v >> 16) & 0xffff;
4397
22.5k
    if (wide)
4398
12.7k
      {
4399
12.7k
        module->objc_module_info_size = bfd_h_get_32 (abfd, buf + 44);
4400
12.7k
        module->objc_module_info_addr = bfd_h_get_64 (abfd, buf + 48);
4401
12.7k
      }
4402
9.86k
    else
4403
9.86k
      {
4404
9.86k
        module->objc_module_info_addr = bfd_h_get_32 (abfd, buf + 44);
4405
9.86k
        module->objc_module_info_size = bfd_h_get_32 (abfd, buf + 48);
4406
9.86k
      }
4407
22.5k
  }
4408
4.92k
    }
4409
4410
14.3k
  if (cmd->ntoc != 0)
4411
5.05k
    {
4412
5.05k
      unsigned long i;
4413
5.05k
      size_t amt;
4414
5.05k
      struct mach_o_dylib_table_of_contents_external raw;
4415
4416
5.05k
      if (cmd->tocoff > filesize
4417
5.05k
    || cmd->ntoc > (filesize - cmd->tocoff) / sizeof (raw))
4418
2.40k
  {
4419
2.40k
    bfd_set_error (bfd_error_file_truncated);
4420
2.40k
    return false;
4421
2.40k
  }
4422
2.65k
      if (_bfd_mul_overflow (cmd->ntoc,
4423
2.65k
           sizeof (bfd_mach_o_dylib_table_of_content), &amt))
4424
0
  {
4425
0
    bfd_set_error (bfd_error_file_too_big);
4426
0
    return false;
4427
0
  }
4428
2.65k
      cmd->dylib_toc = bfd_alloc (abfd, amt);
4429
2.65k
      if (cmd->dylib_toc == NULL)
4430
0
  return false;
4431
4432
2.65k
      if (bfd_seek (abfd, cmd->tocoff, SEEK_SET) != 0)
4433
0
  return false;
4434
4435
93.9k
      for (i = 0; i < cmd->ntoc; i++)
4436
92.0k
  {
4437
92.0k
    bfd_mach_o_dylib_table_of_content *toc = &cmd->dylib_toc[i];
4438
4439
92.0k
    if (bfd_read (&raw, sizeof (raw), abfd) != sizeof (raw))
4440
740
      return false;
4441
4442
91.2k
    toc->symbol_index = bfd_h_get_32 (abfd, raw.symbol_index);
4443
91.2k
    toc->module_index = bfd_h_get_32 (abfd, raw.module_index);
4444
91.2k
  }
4445
2.65k
    }
4446
4447
11.2k
  if (cmd->nindirectsyms != 0)
4448
7.03k
    {
4449
7.03k
      unsigned int i;
4450
7.03k
      size_t amt;
4451
4452
7.03k
      if (cmd->indirectsymoff > filesize
4453
7.03k
    || cmd->nindirectsyms > (filesize - cmd->indirectsymoff) / 4)
4454
3.50k
  {
4455
3.50k
    bfd_set_error (bfd_error_file_truncated);
4456
3.50k
    return false;
4457
3.50k
  }
4458
3.53k
      if (_bfd_mul_overflow (cmd->nindirectsyms, sizeof (unsigned int), &amt))
4459
0
  {
4460
0
    bfd_set_error (bfd_error_file_too_big);
4461
0
    return false;
4462
0
  }
4463
3.53k
      cmd->indirect_syms = bfd_alloc (abfd, amt);
4464
3.53k
      if (cmd->indirect_syms == NULL)
4465
0
  return false;
4466
4467
3.53k
      if (bfd_seek (abfd, cmd->indirectsymoff, SEEK_SET) != 0)
4468
0
  return false;
4469
4470
248k
      for (i = 0; i < cmd->nindirectsyms; i++)
4471
245k
  {
4472
245k
    unsigned char raw[4];
4473
245k
    unsigned int *is = &cmd->indirect_syms[i];
4474
4475
245k
    if (bfd_read (raw, sizeof (raw), abfd) != sizeof (raw))
4476
836
      return false;
4477
4478
244k
    *is = bfd_h_get_32 (abfd, raw);
4479
244k
  }
4480
3.53k
    }
4481
4482
6.89k
  if (cmd->nextrefsyms != 0)
4483
5.14k
    {
4484
5.14k
      unsigned long v;
4485
5.14k
      unsigned int i;
4486
5.14k
      size_t amt;
4487
4488
5.14k
      if (cmd->extrefsymoff > filesize
4489
5.14k
    || cmd->nextrefsyms > (filesize - cmd->extrefsymoff) / 4)
4490
1.53k
  {
4491
1.53k
    bfd_set_error (bfd_error_file_truncated);
4492
1.53k
    return false;
4493
1.53k
  }
4494
3.61k
      if (_bfd_mul_overflow (cmd->nextrefsyms,
4495
3.61k
           sizeof (bfd_mach_o_dylib_reference), &amt))
4496
0
  {
4497
0
    bfd_set_error (bfd_error_file_too_big);
4498
0
    return false;
4499
0
  }
4500
3.61k
      cmd->ext_refs = bfd_alloc (abfd, amt);
4501
3.61k
      if (cmd->ext_refs == NULL)
4502
0
  return false;
4503
4504
3.61k
      if (bfd_seek (abfd, cmd->extrefsymoff, SEEK_SET) != 0)
4505
0
  return false;
4506
4507
289k
      for (i = 0; i < cmd->nextrefsyms; i++)
4508
287k
  {
4509
287k
    unsigned char raw[4];
4510
287k
    bfd_mach_o_dylib_reference *ref = &cmd->ext_refs[i];
4511
4512
287k
    if (bfd_read (raw, sizeof (raw), abfd) != sizeof (raw))
4513
1.16k
      return false;
4514
4515
    /* Fields isym and flags are written as bit-fields, thus we need
4516
       a specific processing for endianness.  */
4517
286k
    v = bfd_h_get_32 (abfd, raw);
4518
286k
    if (bfd_big_endian (abfd))
4519
700
      {
4520
700
        ref->isym = (v >> 8) & 0xffffff;
4521
700
        ref->flags = v & 0xff;
4522
700
      }
4523
285k
    else
4524
285k
      {
4525
285k
        ref->isym = v & 0xffffff;
4526
285k
        ref->flags = (v >> 24) & 0xff;
4527
285k
      }
4528
286k
  }
4529
3.61k
    }
4530
4531
4.19k
  if (mdata->dysymtab)
4532
11
    return false;
4533
4.18k
  mdata->dysymtab = cmd;
4534
4535
4.18k
  return true;
4536
4.19k
}
4537
4538
static bool
4539
bfd_mach_o_read_symtab (bfd *abfd, bfd_mach_o_load_command *command,
4540
      ufile_ptr filesize)
4541
9.00k
{
4542
9.00k
  bfd_mach_o_symtab_command *symtab = &command->command.symtab;
4543
9.00k
  bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
4544
9.00k
  struct mach_o_symtab_command_external raw;
4545
4546
9.00k
  BFD_ASSERT (command->type == BFD_MACH_O_LC_SYMTAB);
4547
4548
9.00k
  if (command->len < sizeof (raw) + 8)
4549
241
    return false;
4550
8.76k
  if (bfd_read (&raw, sizeof (raw), abfd) != sizeof (raw))
4551
445
    return false;
4552
4553
8.31k
  symtab->symoff = bfd_h_get_32 (abfd, raw.symoff);
4554
8.31k
  symtab->nsyms = bfd_h_get_32 (abfd, raw.nsyms);
4555
8.31k
  symtab->stroff = bfd_h_get_32 (abfd, raw.stroff);
4556
8.31k
  symtab->strsize = bfd_h_get_32 (abfd, raw.strsize);
4557
8.31k
  symtab->symbols = NULL;
4558
8.31k
  symtab->strtab = NULL;
4559
4560
8.31k
  if (symtab->symoff > filesize
4561
8.31k
      || symtab->nsyms > (filesize - symtab->symoff) / BFD_MACH_O_NLIST_SIZE
4562
8.31k
      || symtab->stroff > filesize
4563
8.31k
      || symtab->strsize > filesize - symtab->stroff)
4564
4.26k
    {
4565
4.26k
      bfd_set_error (bfd_error_file_truncated);
4566
4.26k
      return false;
4567
4.26k
    }
4568
4569
4.05k
  if (symtab->nsyms != 0)
4570
2.98k
    abfd->flags |= HAS_SYMS;
4571
4572
4.05k
  if (mdata->symtab)
4573
10
    return false;
4574
4.04k
  mdata->symtab = symtab;
4575
4.04k
  return true;
4576
4.05k
}
4577
4578
static bool
4579
bfd_mach_o_read_uuid (bfd *abfd, bfd_mach_o_load_command *command)
4580
3.14k
{
4581
3.14k
  bfd_mach_o_uuid_command *cmd = &command->command.uuid;
4582
4583
3.14k
  BFD_ASSERT (command->type == BFD_MACH_O_LC_UUID);
4584
4585
3.14k
  if (command->len < 16 + 8)
4586
123
    return false;
4587
3.02k
  if (bfd_read (cmd->uuid, 16, abfd) != 16)
4588
833
    return false;
4589
4590
2.18k
  return true;
4591
3.02k
}
4592
4593
static bool
4594
bfd_mach_o_read_linkedit (bfd *abfd, bfd_mach_o_load_command *command)
4595
18.8k
{
4596
18.8k
  bfd_mach_o_linkedit_command *cmd = &command->command.linkedit;
4597
18.8k
  struct mach_o_linkedit_data_command_external raw;
4598
4599
18.8k
  if (command->len < sizeof (raw) + 8)
4600
1.04k
    return false;
4601
17.8k
  if (bfd_read (&raw, sizeof (raw), abfd) != sizeof (raw))
4602
1.81k
    return false;
4603
4604
16.0k
  cmd->dataoff = bfd_get_32 (abfd, raw.dataoff);
4605
16.0k
  cmd->datasize = bfd_get_32 (abfd, raw.datasize);
4606
16.0k
  return true;
4607
17.8k
}
4608
4609
static bool
4610
bfd_mach_o_read_str (bfd *abfd, bfd_mach_o_load_command *command)
4611
6.10k
{
4612
6.10k
  bfd_mach_o_str_command *cmd = &command->command.str;
4613
6.10k
  struct mach_o_str_command_external raw;
4614
6.10k
  unsigned long off;
4615
4616
6.10k
  if (command->len < sizeof (raw) + 8)
4617
232
    return false;
4618
5.86k
  if (bfd_read (&raw, sizeof (raw), abfd) != sizeof (raw))
4619
1.15k
    return false;
4620
4621
4.71k
  off = bfd_get_32 (abfd, raw.str);
4622
4.71k
  if (off > command->len)
4623
449
    return false;
4624
4625
4.26k
  cmd->stroff = command->offset + off;
4626
4.26k
  cmd->str_len = command->len - off;
4627
4.26k
  cmd->str = (char *) bfd_mach_o_alloc_and_read (abfd, cmd->stroff,
4628
4.26k
             cmd->str_len, 1);
4629
4.26k
  return cmd->str != NULL;
4630
4.71k
}
4631
4632
static bool
4633
bfd_mach_o_read_dyld_content (bfd *abfd, bfd_mach_o_dyld_info_command *cmd)
4634
0
{
4635
  /* Read rebase content.  */
4636
0
  if (cmd->rebase_content == NULL && cmd->rebase_size != 0)
4637
0
    {
4638
0
      cmd->rebase_content
4639
0
  = bfd_mach_o_alloc_and_read (abfd, cmd->rebase_off,
4640
0
             cmd->rebase_size, 0);
4641
0
      if (cmd->rebase_content == NULL)
4642
0
  return false;
4643
0
    }
4644
4645
  /* Read bind content.  */
4646
0
  if (cmd->bind_content == NULL && cmd->bind_size != 0)
4647
0
    {
4648
0
      cmd->bind_content
4649
0
  = bfd_mach_o_alloc_and_read (abfd, cmd->bind_off,
4650
0
             cmd->bind_size, 0);
4651
0
      if (cmd->bind_content == NULL)
4652
0
  return false;
4653
0
    }
4654
4655
  /* Read weak bind content.  */
4656
0
  if (cmd->weak_bind_content == NULL && cmd->weak_bind_size != 0)
4657
0
    {
4658
0
      cmd->weak_bind_content
4659
0
  = bfd_mach_o_alloc_and_read (abfd, cmd->weak_bind_off,
4660
0
             cmd->weak_bind_size, 0);
4661
0
      if (cmd->weak_bind_content == NULL)
4662
0
  return false;
4663
0
    }
4664
4665
  /* Read lazy bind content.  */
4666
0
  if (cmd->lazy_bind_content == NULL && cmd->lazy_bind_size != 0)
4667
0
    {
4668
0
      cmd->lazy_bind_content
4669
0
  = bfd_mach_o_alloc_and_read (abfd, cmd->lazy_bind_off,
4670
0
             cmd->lazy_bind_size, 0);
4671
0
      if (cmd->lazy_bind_content == NULL)
4672
0
  return false;
4673
0
    }
4674
4675
  /* Read export content.  */
4676
0
  if (cmd->export_content == NULL && cmd->export_size != 0)
4677
0
    {
4678
0
      cmd->export_content
4679
0
  = bfd_mach_o_alloc_and_read (abfd, cmd->export_off,
4680
0
             cmd->export_size, 0);
4681
0
      if (cmd->export_content == NULL)
4682
0
  return false;
4683
0
    }
4684
4685
0
  return true;
4686
0
}
4687
4688
static bool
4689
bfd_mach_o_read_dyld_info (bfd *abfd, bfd_mach_o_load_command *command)
4690
3.88k
{
4691
3.88k
  bfd_mach_o_dyld_info_command *cmd = &command->command.dyld_info;
4692
3.88k
  struct mach_o_dyld_info_command_external raw;
4693
4694
3.88k
  if (command->len < sizeof (raw) + 8)
4695
31
    return false;
4696
3.85k
  if (bfd_read (&raw, sizeof (raw), abfd) != sizeof (raw))
4697
636
    return false;
4698
4699
3.21k
  cmd->rebase_off = bfd_get_32 (abfd, raw.rebase_off);
4700
3.21k
  cmd->rebase_size = bfd_get_32 (abfd, raw.rebase_size);
4701
3.21k
  cmd->rebase_content = NULL;
4702
3.21k
  cmd->bind_off = bfd_get_32 (abfd, raw.bind_off);
4703
3.21k
  cmd->bind_size = bfd_get_32 (abfd, raw.bind_size);
4704
3.21k
  cmd->bind_content = NULL;
4705
3.21k
  cmd->weak_bind_off = bfd_get_32 (abfd, raw.weak_bind_off);
4706
3.21k
  cmd->weak_bind_size = bfd_get_32 (abfd, raw.weak_bind_size);
4707
3.21k
  cmd->weak_bind_content = NULL;
4708
3.21k
  cmd->lazy_bind_off = bfd_get_32 (abfd, raw.lazy_bind_off);
4709
3.21k
  cmd->lazy_bind_size = bfd_get_32 (abfd, raw.lazy_bind_size);
4710
3.21k
  cmd->lazy_bind_content = NULL;
4711
3.21k
  cmd->export_off = bfd_get_32 (abfd, raw.export_off);
4712
3.21k
  cmd->export_size = bfd_get_32 (abfd, raw.export_size);
4713
3.21k
  cmd->export_content = NULL;
4714
3.21k
  return true;
4715
3.85k
}
4716
4717
static bool
4718
bfd_mach_o_read_version_min (bfd *abfd, bfd_mach_o_load_command *command)
4719
8.58k
{
4720
8.58k
  bfd_mach_o_version_min_command *cmd = &command->command.version_min;
4721
8.58k
  struct mach_o_version_min_command_external raw;
4722
4723
8.58k
  if (command->len < sizeof (raw) + 8)
4724
234
    return false;
4725
8.34k
  if (bfd_read (&raw, sizeof (raw), abfd) != sizeof (raw))
4726
864
    return false;
4727
4728
7.48k
  cmd->version = bfd_get_32 (abfd, raw.version);
4729
7.48k
  cmd->sdk = bfd_get_32 (abfd, raw.sdk);
4730
7.48k
  return true;
4731
8.34k
}
4732
4733
static bool
4734
bfd_mach_o_read_encryption_info (bfd *abfd, bfd_mach_o_load_command *command)
4735
2.06k
{
4736
2.06k
  bfd_mach_o_encryption_info_command *cmd = &command->command.encryption_info;
4737
2.06k
  struct mach_o_encryption_info_command_external raw;
4738
4739
2.06k
  if (command->len < sizeof (raw) + 8)
4740
6
    return false;
4741
2.06k
  if (bfd_read (&raw, sizeof (raw), abfd) != sizeof (raw))
4742
429
    return false;
4743
4744
1.63k
  cmd->cryptoff = bfd_get_32 (abfd, raw.cryptoff);
4745
1.63k
  cmd->cryptsize = bfd_get_32 (abfd, raw.cryptsize);
4746
1.63k
  cmd->cryptid = bfd_get_32 (abfd, raw.cryptid);
4747
1.63k
  return true;
4748
2.06k
}
4749
4750
static bool
4751
bfd_mach_o_read_encryption_info_64 (bfd *abfd, bfd_mach_o_load_command *command)
4752
3.87k
{
4753
3.87k
  bfd_mach_o_encryption_info_command *cmd = &command->command.encryption_info;
4754
3.87k
  struct mach_o_encryption_info_64_command_external raw;
4755
4756
3.87k
  if (command->len < sizeof (raw) + 8)
4757
17
    return false;
4758
3.85k
  if (bfd_read (&raw, sizeof (raw), abfd) != sizeof (raw))
4759
24
    return false;
4760
4761
3.83k
  cmd->cryptoff = bfd_get_32 (abfd, raw.cryptoff);
4762
3.83k
  cmd->cryptsize = bfd_get_32 (abfd, raw.cryptsize);
4763
3.83k
  cmd->cryptid = bfd_get_32 (abfd, raw.cryptid);
4764
3.83k
  return true;
4765
3.85k
}
4766
4767
static bool
4768
bfd_mach_o_read_main (bfd *abfd, bfd_mach_o_load_command *command)
4769
10.9k
{
4770
10.9k
  bfd_mach_o_main_command *cmd = &command->command.main;
4771
10.9k
  struct mach_o_entry_point_command_external raw;
4772
4773
10.9k
  if (command->len < sizeof (raw) + 8)
4774
934
    return false;
4775
9.96k
  if (bfd_read (&raw, sizeof (raw), abfd) != sizeof (raw))
4776
934
    return false;
4777
4778
9.03k
  cmd->entryoff = bfd_get_64 (abfd, raw.entryoff);
4779
9.03k
  cmd->stacksize = bfd_get_64 (abfd, raw.stacksize);
4780
9.03k
  return true;
4781
9.96k
}
4782
4783
static bool
4784
bfd_mach_o_read_source_version (bfd *abfd, bfd_mach_o_load_command *command)
4785
3.07k
{
4786
3.07k
  bfd_mach_o_source_version_command *cmd = &command->command.source_version;
4787
3.07k
  struct mach_o_source_version_command_external raw;
4788
3.07k
  uint64_t ver;
4789
4790
3.07k
  if (command->len < sizeof (raw) + 8)
4791
242
    return false;
4792
2.83k
  if (bfd_read (&raw, sizeof (raw), abfd) != sizeof (raw))
4793
433
    return false;
4794
4795
2.40k
  ver = bfd_get_64 (abfd, raw.version);
4796
  /* Note: we use a serie of shift to avoid shift > 32 (for which gcc
4797
     generates warnings) in case of the host doesn't support 64 bit
4798
     integers.  */
4799
2.40k
  cmd->e = ver & 0x3ff;
4800
2.40k
  ver >>= 10;
4801
2.40k
  cmd->d = ver & 0x3ff;
4802
2.40k
  ver >>= 10;
4803
2.40k
  cmd->c = ver & 0x3ff;
4804
2.40k
  ver >>= 10;
4805
2.40k
  cmd->b = ver & 0x3ff;
4806
2.40k
  ver >>= 10;
4807
2.40k
  cmd->a = ver & 0xffffff;
4808
2.40k
  return true;
4809
2.83k
}
4810
4811
static bool
4812
bfd_mach_o_read_note (bfd *abfd, bfd_mach_o_load_command *command)
4813
4.90k
{
4814
4.90k
  bfd_mach_o_note_command *cmd = &command->command.note;
4815
4.90k
  struct mach_o_note_command_external raw;
4816
4817
4.90k
  if (command->len < sizeof (raw) + 8)
4818
425
    return false;
4819
4.48k
  if (bfd_read (&raw, sizeof (raw), abfd) != sizeof (raw))
4820
240
    return false;
4821
4822
4.24k
  memcpy (cmd->data_owner, raw.data_owner, 16);
4823
4.24k
  cmd->offset = bfd_get_64 (abfd, raw.offset);
4824
4.24k
  cmd->size = bfd_get_64 (abfd, raw.size);
4825
4.24k
  return true;
4826
4.48k
}
4827
4828
static bool
4829
bfd_mach_o_read_build_version (bfd *abfd, bfd_mach_o_load_command *command)
4830
4.67k
{
4831
4.67k
  bfd_mach_o_build_version_command *cmd = &command->command.build_version;
4832
4.67k
  struct mach_o_build_version_command_external raw;
4833
4834
4.67k
  if (command->len < sizeof (raw) + 8)
4835
437
    return false;
4836
4.24k
  if (bfd_read (&raw, sizeof (raw), abfd) != sizeof (raw))
4837
744
    return false;
4838
4839
3.49k
  cmd->platform = bfd_get_32 (abfd, raw.platform);
4840
3.49k
  cmd->minos = bfd_get_32 (abfd, raw.minos);
4841
3.49k
  cmd->sdk = bfd_get_32 (abfd, raw.sdk);
4842
3.49k
  cmd->ntools = bfd_get_32 (abfd, raw.ntools);
4843
3.49k
  return true;
4844
4.24k
}
4845
4846
static bool
4847
bfd_mach_o_read_segment (bfd *abfd,
4848
       bfd_mach_o_load_command *command,
4849
       unsigned int wide)
4850
28.5k
{
4851
28.5k
  bfd_mach_o_segment_command *seg = &command->command.segment;
4852
28.5k
  unsigned long i;
4853
4854
28.5k
  if (wide)
4855
17.2k
    {
4856
17.2k
      struct mach_o_segment_command_64_external raw;
4857
4858
17.2k
      BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT_64);
4859
4860
17.2k
      if (command->len < sizeof (raw) + 8)
4861
117
  return false;
4862
17.0k
      if (bfd_read (&raw, sizeof (raw), abfd) != sizeof (raw))
4863
866
  return false;
4864
4865
16.2k
      memcpy (seg->segname, raw.segname, 16);
4866
16.2k
      seg->segname[16] = '\0';
4867
4868
16.2k
      seg->vmaddr = bfd_h_get_64 (abfd, raw.vmaddr);
4869
16.2k
      seg->vmsize = bfd_h_get_64 (abfd, raw.vmsize);
4870
16.2k
      seg->fileoff = bfd_h_get_64 (abfd, raw.fileoff);
4871
16.2k
      seg->filesize = bfd_h_get_64 (abfd, raw.filesize);
4872
16.2k
      seg->maxprot = bfd_h_get_32 (abfd, raw.maxprot);
4873
16.2k
      seg->initprot = bfd_h_get_32 (abfd, raw.initprot);
4874
16.2k
      seg->nsects = bfd_h_get_32 (abfd, raw.nsects);
4875
16.2k
      seg->flags = bfd_h_get_32 (abfd, raw.flags);
4876
16.2k
    }
4877
11.3k
  else
4878
11.3k
    {
4879
11.3k
      struct mach_o_segment_command_32_external raw;
4880
4881
11.3k
      BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT);
4882
4883
11.3k
      if (command->len < sizeof (raw) + 8)
4884
632
  return false;
4885
10.7k
      if (bfd_read (&raw, sizeof (raw), abfd) != sizeof (raw))
4886
962
  return false;
4887
4888
9.76k
      memcpy (seg->segname, raw.segname, 16);
4889
9.76k
      seg->segname[16] = '\0';
4890
4891
9.76k
      seg->vmaddr = bfd_h_get_32 (abfd, raw.vmaddr);
4892
9.76k
      seg->vmsize = bfd_h_get_32 (abfd, raw.vmsize);
4893
9.76k
      seg->fileoff = bfd_h_get_32 (abfd, raw.fileoff);
4894
9.76k
      seg->filesize = bfd_h_get_32 (abfd, raw.filesize);
4895
9.76k
      seg->maxprot = bfd_h_get_32 (abfd, raw.maxprot);
4896
9.76k
      seg->initprot = bfd_h_get_32 (abfd, raw.initprot);
4897
9.76k
      seg->nsects = bfd_h_get_32 (abfd, raw.nsects);
4898
9.76k
      seg->flags = bfd_h_get_32 (abfd, raw.flags);
4899
9.76k
    }
4900
25.9k
  seg->sect_head = NULL;
4901
25.9k
  seg->sect_tail = NULL;
4902
4903
4.60M
  for (i = 0; i < seg->nsects; i++)
4904
4.58M
    {
4905
4.58M
      asection *sec;
4906
4907
4.58M
      sec = bfd_mach_o_read_section (abfd, seg->initprot, wide);
4908
4.58M
      if (sec == NULL)
4909
11.0k
  return false;
4910
4911
4.57M
      bfd_mach_o_append_section_to_segment
4912
4.57M
  (seg, bfd_mach_o_get_mach_o_section (sec));
4913
4.57M
    }
4914
4915
14.9k
  return true;
4916
25.9k
}
4917
4918
static bool
4919
bfd_mach_o_read_segment_32 (bfd *abfd, bfd_mach_o_load_command *command)
4920
11.3k
{
4921
11.3k
  return bfd_mach_o_read_segment (abfd, command, 0);
4922
11.3k
}
4923
4924
static bool
4925
bfd_mach_o_read_segment_64 (bfd *abfd, bfd_mach_o_load_command *command)
4926
17.2k
{
4927
17.2k
  return bfd_mach_o_read_segment (abfd, command, 1);
4928
17.2k
}
4929
4930
static bool
4931
bfd_mach_o_read_command (bfd *abfd, bfd_mach_o_load_command *command,
4932
       ufile_ptr filesize)
4933
205k
{
4934
205k
  bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
4935
205k
  struct mach_o_load_command_external raw;
4936
205k
  unsigned int cmd;
4937
4938
  /* Read command type and length.  */
4939
205k
  if (bfd_seek (abfd, mdata->hdr_offset + command->offset, SEEK_SET) != 0
4940
205k
      || bfd_read (&raw, BFD_MACH_O_LC_SIZE, abfd) != BFD_MACH_O_LC_SIZE)
4941
7.61k
    return false;
4942
4943
197k
  cmd = bfd_h_get_32 (abfd, raw.cmd);
4944
197k
  command->type = cmd & ~BFD_MACH_O_LC_REQ_DYLD;
4945
197k
  command->type_required = (cmd & BFD_MACH_O_LC_REQ_DYLD) != 0;
4946
197k
  command->len = bfd_h_get_32 (abfd, raw.cmdsize);
4947
197k
  if (command->len < 8 || command->len % 4 != 0)
4948
3.31k
    return false;
4949
4950
194k
  switch (command->type)
4951
194k
    {
4952
11.3k
    case BFD_MACH_O_LC_SEGMENT:
4953
11.3k
      if (!bfd_mach_o_read_segment_32 (abfd, command))
4954
6.40k
  return false;
4955
4.94k
      break;
4956
17.2k
    case BFD_MACH_O_LC_SEGMENT_64:
4957
17.2k
      if (!bfd_mach_o_read_segment_64 (abfd, command))
4958
7.21k
  return false;
4959
9.98k
      break;
4960
9.98k
    case BFD_MACH_O_LC_SYMTAB:
4961
9.00k
      if (!bfd_mach_o_read_symtab (abfd, command, filesize))
4962
4.96k
  return false;
4963
4.04k
      break;
4964
4.04k
    case BFD_MACH_O_LC_SYMSEG:
4965
1.17k
      break;
4966
9.91k
    case BFD_MACH_O_LC_THREAD:
4967
19.1k
    case BFD_MACH_O_LC_UNIXTHREAD:
4968
19.1k
      if (!bfd_mach_o_read_thread (abfd, command))
4969
5.09k
  return false;
4970
14.0k
      break;
4971
14.0k
    case BFD_MACH_O_LC_LOAD_DYLINKER:
4972
4.11k
    case BFD_MACH_O_LC_ID_DYLINKER:
4973
5.72k
    case BFD_MACH_O_LC_DYLD_ENVIRONMENT:
4974
5.72k
      if (!bfd_mach_o_read_dylinker (abfd, command))
4975
2.98k
  return false;
4976
2.74k
      break;
4977
2.74k
    case BFD_MACH_O_LC_LOAD_DYLIB:
4978
2.74k
    case BFD_MACH_O_LC_LAZY_LOAD_DYLIB:
4979
3.57k
    case BFD_MACH_O_LC_ID_DYLIB:
4980
4.55k
    case BFD_MACH_O_LC_LOAD_WEAK_DYLIB:
4981
8.33k
    case BFD_MACH_O_LC_REEXPORT_DYLIB:
4982
8.63k
    case BFD_MACH_O_LC_LOAD_UPWARD_DYLIB:
4983
8.63k
      if (!bfd_mach_o_read_dylib (abfd, command))
4984
3.27k
  return false;
4985
5.35k
      break;
4986
5.35k
    case BFD_MACH_O_LC_PREBOUND_DYLIB:
4987
4.97k
      if (!bfd_mach_o_read_prebound_dylib (abfd, command))
4988
4.51k
  return false;
4989
456
      break;
4990
560
    case BFD_MACH_O_LC_LOADFVMLIB:
4991
2.60k
    case BFD_MACH_O_LC_IDFVMLIB:
4992
2.60k
      if (!bfd_mach_o_read_fvmlib (abfd, command))
4993
2.45k
  return false;
4994
147
      break;
4995
1.91k
    case BFD_MACH_O_LC_IDENT:
4996
2.35k
    case BFD_MACH_O_LC_FVMFILE:
4997
7.90k
    case BFD_MACH_O_LC_PREPAGE:
4998
9.45k
    case BFD_MACH_O_LC_ROUTINES:
4999
10.4k
    case BFD_MACH_O_LC_ROUTINES_64:
5000
10.4k
      break;
5001
1.28k
    case BFD_MACH_O_LC_SUB_FRAMEWORK:
5002
1.97k
    case BFD_MACH_O_LC_SUB_UMBRELLA:
5003
4.18k
    case BFD_MACH_O_LC_SUB_LIBRARY:
5004
5.73k
    case BFD_MACH_O_LC_SUB_CLIENT:
5005
6.10k
    case BFD_MACH_O_LC_RPATH:
5006
6.10k
      if (!bfd_mach_o_read_str (abfd, command))
5007
3.23k
  return false;
5008
2.86k
      break;
5009
19.6k
    case BFD_MACH_O_LC_DYSYMTAB:
5010
19.6k
      if (!bfd_mach_o_read_dysymtab (abfd, command, filesize))
5011
15.4k
  return false;
5012
4.18k
      break;
5013
4.18k
    case BFD_MACH_O_LC_PREBIND_CKSUM:
5014
1.17k
      if (!bfd_mach_o_read_prebind_cksum (abfd, command))
5015
433
  return false;
5016
741
      break;
5017
9.86k
    case BFD_MACH_O_LC_TWOLEVEL_HINTS:
5018
9.86k
      if (!bfd_mach_o_read_twolevel_hints (abfd, command))
5019
41
  return false;
5020
9.82k
      break;
5021
9.82k
    case BFD_MACH_O_LC_UUID:
5022
3.14k
      if (!bfd_mach_o_read_uuid (abfd, command))
5023
956
  return false;
5024
2.18k
      break;
5025
2.18k
    case BFD_MACH_O_LC_CODE_SIGNATURE:
5026
2.49k
    case BFD_MACH_O_LC_SEGMENT_SPLIT_INFO:
5027
4.72k
    case BFD_MACH_O_LC_FUNCTION_STARTS:
5028
6.79k
    case BFD_MACH_O_LC_DATA_IN_CODE:
5029
8.79k
    case BFD_MACH_O_LC_DYLIB_CODE_SIGN_DRS:
5030
10.3k
    case BFD_MACH_O_LC_LINKER_OPTIMIZATION_HINT:
5031
15.2k
    case BFD_MACH_O_LC_DYLD_EXPORTS_TRIE:
5032
18.8k
    case BFD_MACH_O_LC_DYLD_CHAINED_FIXUPS:
5033
18.8k
      if (!bfd_mach_o_read_linkedit (abfd, command))
5034
2.86k
  return false;
5035
16.0k
      break;
5036
16.0k
    case BFD_MACH_O_LC_ENCRYPTION_INFO:
5037
2.06k
      if (!bfd_mach_o_read_encryption_info (abfd, command))
5038
435
  return false;
5039
1.63k
      break;
5040
3.87k
    case BFD_MACH_O_LC_ENCRYPTION_INFO_64:
5041
3.87k
      if (!bfd_mach_o_read_encryption_info_64 (abfd, command))
5042
41
  return false;
5043
3.83k
      break;
5044
3.88k
    case BFD_MACH_O_LC_DYLD_INFO:
5045
3.88k
      if (!bfd_mach_o_read_dyld_info (abfd, command))
5046
667
  return false;
5047
3.21k
      break;
5048
3.21k
    case BFD_MACH_O_LC_VERSION_MIN_MACOSX:
5049
4.71k
    case BFD_MACH_O_LC_VERSION_MIN_IPHONEOS:
5050
6.72k
    case BFD_MACH_O_LC_VERSION_MIN_WATCHOS:
5051
8.58k
    case BFD_MACH_O_LC_VERSION_MIN_TVOS:
5052
8.58k
      if (!bfd_mach_o_read_version_min (abfd, command))
5053
1.09k
  return false;
5054
7.48k
      break;
5055
10.9k
    case BFD_MACH_O_LC_MAIN:
5056
10.9k
      if (!bfd_mach_o_read_main (abfd, command))
5057
1.86k
  return false;
5058
9.03k
      break;
5059
9.03k
    case BFD_MACH_O_LC_SOURCE_VERSION:
5060
3.07k
      if (!bfd_mach_o_read_source_version (abfd, command))
5061
675
  return false;
5062
2.40k
      break;
5063
2.40k
    case BFD_MACH_O_LC_LINKER_OPTIONS:
5064
1.11k
      break;
5065
4.90k
    case BFD_MACH_O_LC_NOTE:
5066
4.90k
      if (!bfd_mach_o_read_note (abfd, command))
5067
665
  return false;
5068
4.24k
      break;
5069
4.67k
    case BFD_MACH_O_LC_BUILD_VERSION:
5070
4.67k
      if (!bfd_mach_o_read_build_version (abfd, command))
5071
1.18k
  return false;
5072
3.49k
      break;
5073
3.49k
    default:
5074
1.96k
      command->len = 0;
5075
1.96k
      _bfd_error_handler (_("%pB: unknown load command %#x"),
5076
1.96k
        abfd, command->type);
5077
1.96k
      return false;
5078
194k
    }
5079
5080
125k
  return true;
5081
194k
}
5082
5083
static bool
5084
bfd_mach_o_flatten_sections (bfd *abfd)
5085
51.7k
{
5086
51.7k
  bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
5087
51.7k
  bfd_mach_o_load_command *cmd;
5088
51.7k
  long csect = 0;
5089
51.7k
  size_t amt;
5090
5091
  /* Count total number of sections.  */
5092
51.7k
  mdata->nsects = 0;
5093
5094
164k
  for (cmd = mdata->first_command; cmd != NULL; cmd = cmd->next)
5095
112k
    {
5096
112k
      if (cmd->type == BFD_MACH_O_LC_SEGMENT
5097
112k
    || cmd->type == BFD_MACH_O_LC_SEGMENT_64)
5098
13.6k
  {
5099
13.6k
    bfd_mach_o_segment_command *seg = &cmd->command.segment;
5100
5101
13.6k
    mdata->nsects += seg->nsects;
5102
13.6k
  }
5103
112k
    }
5104
5105
  /* Allocate sections array.  */
5106
51.7k
  if (_bfd_mul_overflow (mdata->nsects, sizeof (bfd_mach_o_section *), &amt))
5107
0
    {
5108
0
      bfd_set_error (bfd_error_file_too_big);
5109
0
      return false;
5110
0
    }
5111
51.7k
  mdata->sections = bfd_alloc (abfd, amt);
5112
51.7k
  if (mdata->sections == NULL && mdata->nsects != 0)
5113
0
    return false;
5114
5115
  /* Fill the array.  */
5116
51.7k
  csect = 0;
5117
5118
164k
  for (cmd = mdata->first_command; cmd != NULL; cmd = cmd->next)
5119
112k
    {
5120
112k
      if (cmd->type == BFD_MACH_O_LC_SEGMENT
5121
112k
    || cmd->type == BFD_MACH_O_LC_SEGMENT_64)
5122
13.6k
  {
5123
13.6k
    bfd_mach_o_segment_command *seg = &cmd->command.segment;
5124
13.6k
    bfd_mach_o_section *sec;
5125
5126
13.6k
    BFD_ASSERT (csect + seg->nsects <= mdata->nsects);
5127
5128
4.05M
    for (sec = seg->sect_head; sec != NULL; sec = sec->next)
5129
4.04M
      mdata->sections[csect++] = sec;
5130
13.6k
  }
5131
112k
    }
5132
51.7k
  return true;
5133
51.7k
}
5134
5135
static bool
5136
bfd_mach_o_scan_start_address (bfd *abfd)
5137
51.7k
{
5138
51.7k
  bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
5139
51.7k
  bfd_mach_o_thread_command *thr = NULL;
5140
51.7k
  bfd_mach_o_load_command *cmd;
5141
51.7k
  unsigned long i;
5142
5143
142k
  for (cmd = mdata->first_command; cmd != NULL; cmd = cmd->next)
5144
105k
    if (cmd->type == BFD_MACH_O_LC_THREAD
5145
105k
  || cmd->type == BFD_MACH_O_LC_UNIXTHREAD)
5146
13.0k
      {
5147
13.0k
  thr = &cmd->command.thread;
5148
13.0k
  break;
5149
13.0k
      }
5150
92.2k
    else if (cmd->type == BFD_MACH_O_LC_MAIN && mdata->nsects > 1)
5151
1.34k
      {
5152
1.34k
  bfd_mach_o_main_command *main_cmd = &cmd->command.main;
5153
1.34k
  bfd_mach_o_section *text_sect = mdata->sections[0];
5154
5155
1.34k
  if (text_sect)
5156
1.34k
    {
5157
1.34k
      abfd->start_address = main_cmd->entryoff
5158
1.34k
        + (text_sect->addr - text_sect->offset);
5159
1.34k
      return true;
5160
1.34k
    }
5161
1.34k
      }
5162
5163
  /* An object file has no start address, so do not fail if not found.  */
5164
50.4k
  if (thr == NULL)
5165
37.3k
    return true;
5166
5167
  /* FIXME: create a subtarget hook ?  */
5168
112k
  for (i = 0; i < thr->nflavours; i++)
5169
99.2k
    {
5170
99.2k
      if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_I386)
5171
99.2k
    && (thr->flavours[i].flavour == BFD_MACH_O_x86_THREAD_STATE32))
5172
620
  {
5173
620
    unsigned char buf[4];
5174
5175
620
    if (bfd_seek (abfd, thr->flavours[i].offset + 40, SEEK_SET) != 0
5176
620
        || bfd_read (buf, 4, abfd) != 4)
5177
44
      return false;
5178
5179
576
    abfd->start_address = bfd_h_get_32 (abfd, buf);
5180
576
  }
5181
98.6k
      else if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_POWERPC)
5182
98.6k
         && (thr->flavours[i].flavour == BFD_MACH_O_PPC_THREAD_STATE))
5183
463
  {
5184
463
    unsigned char buf[4];
5185
5186
463
    if (bfd_seek (abfd, thr->flavours[i].offset + 0, SEEK_SET) != 0
5187
463
        || bfd_read (buf, 4, abfd) != 4)
5188
0
      return false;
5189
5190
463
    abfd->start_address = bfd_h_get_32 (abfd, buf);
5191
463
  }
5192
98.2k
      else if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_POWERPC_64)
5193
98.2k
         && (thr->flavours[i].flavour == BFD_MACH_O_PPC_THREAD_STATE64))
5194
489
  {
5195
489
    unsigned char buf[8];
5196
5197
489
    if (bfd_seek (abfd, thr->flavours[i].offset + 0, SEEK_SET) != 0
5198
489
        || bfd_read (buf, 8, abfd) != 8)
5199
1
      return false;
5200
5201
488
    abfd->start_address = bfd_h_get_64 (abfd, buf);
5202
488
  }
5203
97.7k
      else if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_X86_64)
5204
97.7k
         && (thr->flavours[i].flavour == BFD_MACH_O_x86_THREAD_STATE64))
5205
4.51k
  {
5206
4.51k
    unsigned char buf[8];
5207
5208
4.51k
    if (bfd_seek (abfd, thr->flavours[i].offset + (16 * 8), SEEK_SET) != 0
5209
4.51k
        || bfd_read (buf, 8, abfd) != 8)
5210
42
      return false;
5211
5212
4.47k
    abfd->start_address = bfd_h_get_64 (abfd, buf);
5213
4.47k
  }
5214
99.2k
    }
5215
5216
12.9k
  return true;
5217
13.0k
}
5218
5219
bool
5220
bfd_mach_o_set_arch_mach (bfd *abfd,
5221
        enum bfd_architecture arch,
5222
        unsigned long machine)
5223
134k
{
5224
134k
  bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
5225
5226
  /* If this isn't the right architecture for this backend, and this
5227
     isn't the generic backend, fail.  */
5228
134k
  if (arch != bed->arch
5229
134k
      && arch != bfd_arch_unknown
5230
134k
      && bed->arch != bfd_arch_unknown)
5231
0
    return false;
5232
5233
134k
  return bfd_default_set_arch_mach (abfd, arch, machine);
5234
134k
}
5235
5236
static bool
5237
bfd_mach_o_scan (bfd *abfd,
5238
     bfd_mach_o_header *header,
5239
     bfd_mach_o_data_struct *mdata)
5240
135k
{
5241
135k
  unsigned int i;
5242
135k
  enum bfd_architecture cpu_type;
5243
135k
  unsigned long cpu_subtype;
5244
135k
  unsigned int hdrsize;
5245
5246
135k
  hdrsize = mach_o_wide_p (header) ?
5247
99.4k
    BFD_MACH_O_HEADER_64_SIZE : BFD_MACH_O_HEADER_SIZE;
5248
5249
135k
  mdata->header = *header;
5250
5251
135k
  abfd->flags = abfd->flags & BFD_IN_MEMORY;
5252
135k
  switch (header->filetype)
5253
135k
    {
5254
5.46k
    case BFD_MACH_O_MH_OBJECT:
5255
5.46k
      abfd->flags |= HAS_RELOC;
5256
5.46k
      break;
5257
1.91k
    case BFD_MACH_O_MH_EXECUTE:
5258
1.91k
      abfd->flags |= EXEC_P;
5259
1.91k
      break;
5260
154
    case BFD_MACH_O_MH_DYLIB:
5261
180
    case BFD_MACH_O_MH_BUNDLE:
5262
180
      abfd->flags |= DYNAMIC;
5263
180
      break;
5264
135k
    }
5265
5266
135k
  abfd->tdata.mach_o_data = mdata;
5267
5268
135k
  bfd_mach_o_convert_architecture (header->cputype, header->cpusubtype,
5269
135k
           &cpu_type, &cpu_subtype);
5270
135k
  if (cpu_type == bfd_arch_unknown)
5271
1.21k
    {
5272
1.21k
      _bfd_error_handler
5273
  /* xgettext:c-format */
5274
1.21k
  (_("bfd_mach_o_scan: unknown architecture 0x%lx/0x%lx"),
5275
1.21k
   header->cputype, header->cpusubtype);
5276
1.21k
      return false;
5277
1.21k
    }
5278
5279
133k
  bfd_set_arch_mach (abfd, cpu_type, cpu_subtype);
5280
5281
133k
  if (header->ncmds != 0)
5282
124k
    {
5283
124k
      bfd_mach_o_load_command *cmd;
5284
124k
      size_t amt;
5285
124k
      ufile_ptr filesize = bfd_get_file_size (abfd);
5286
5287
124k
      if (filesize == 0)
5288
0
  filesize = (ufile_ptr) -1;
5289
5290
124k
      mdata->first_command = NULL;
5291
124k
      mdata->last_command = NULL;
5292
5293
124k
      if (header->ncmds > (filesize - hdrsize) / BFD_MACH_O_LC_SIZE)
5294
2.74k
  {
5295
2.74k
    bfd_set_error (bfd_error_file_truncated);
5296
2.74k
    return false;
5297
2.74k
  }
5298
122k
      if (_bfd_mul_overflow (header->ncmds,
5299
122k
           sizeof (bfd_mach_o_load_command), &amt))
5300
0
  {
5301
0
    bfd_set_error (bfd_error_file_too_big);
5302
0
    return false;
5303
0
  }
5304
122k
      cmd = bfd_alloc (abfd, amt);
5305
122k
      if (cmd == NULL)
5306
0
  return false;
5307
5308
247k
      for (i = 0; i < header->ncmds; i++)
5309
205k
  {
5310
205k
    bfd_mach_o_load_command *cur = &cmd[i];
5311
5312
205k
    bfd_mach_o_append_command (abfd, cur);
5313
5314
205k
    if (i == 0)
5315
122k
      cur->offset = hdrsize;
5316
82.9k
    else
5317
82.9k
      {
5318
82.9k
        bfd_mach_o_load_command *prev = &cmd[i - 1];
5319
82.9k
        cur->offset = prev->offset + prev->len;
5320
82.9k
      }
5321
5322
205k
    if (!bfd_mach_o_read_command (abfd, cur, filesize))
5323
79.4k
      return false;
5324
205k
  }
5325
122k
    }
5326
5327
  /* Sections should be flatten before scanning start address.  */
5328
51.7k
  if (!bfd_mach_o_flatten_sections (abfd))
5329
0
    return false;
5330
51.7k
  if (!bfd_mach_o_scan_start_address (abfd))
5331
87
    return false;
5332
5333
51.6k
  return true;
5334
51.7k
}
5335
5336
bool
5337
bfd_mach_o_mkobject_init (bfd *abfd)
5338
9
{
5339
9
  bfd_mach_o_data_struct *mdata = NULL;
5340
5341
9
  mdata = bfd_zalloc (abfd, sizeof (bfd_mach_o_data_struct));
5342
9
  if (mdata == NULL)
5343
0
    return false;
5344
9
  abfd->tdata.mach_o_data = mdata;
5345
5346
9
  mdata->header.magic = 0;
5347
9
  mdata->header.cputype = 0;
5348
9
  mdata->header.cpusubtype = 0;
5349
9
  mdata->header.filetype = 0;
5350
9
  mdata->header.ncmds = 0;
5351
9
  mdata->header.sizeofcmds = 0;
5352
9
  mdata->header.flags = 0;
5353
9
  mdata->header.byteorder = BFD_ENDIAN_UNKNOWN;
5354
9
  mdata->first_command = NULL;
5355
9
  mdata->last_command = NULL;
5356
9
  mdata->nsects = 0;
5357
9
  mdata->sections = NULL;
5358
9
  mdata->dyn_reloc_cache = NULL;
5359
5360
9
  return true;
5361
9
}
5362
5363
static bool
5364
bfd_mach_o_gen_mkobject (bfd *abfd)
5365
8
{
5366
8
  bfd_mach_o_data_struct *mdata;
5367
5368
8
  if (!bfd_mach_o_mkobject_init (abfd))
5369
0
    return false;
5370
5371
8
  mdata = bfd_mach_o_get_data (abfd);
5372
8
  mdata->header.magic = BFD_MACH_O_MH_MAGIC;
5373
8
  mdata->header.cputype = 0;
5374
8
  mdata->header.cpusubtype = 0;
5375
8
  mdata->header.byteorder = abfd->xvec->byteorder;
5376
8
  mdata->header.version = 1;
5377
5378
8
  return true;
5379
8
}
5380
5381
bfd_cleanup
5382
bfd_mach_o_header_p (bfd *abfd,
5383
         file_ptr hdr_off,
5384
         bfd_mach_o_filetype file_type,
5385
         bfd_mach_o_cpu_type cpu_type)
5386
10.2M
{
5387
10.2M
  bfd_mach_o_header header;
5388
10.2M
  bfd_mach_o_data_struct *mdata;
5389
5390
10.2M
  if (!bfd_mach_o_read_header (abfd, hdr_off, &header))
5391
9.74M
    goto wrong;
5392
5393
521k
  if (! (header.byteorder == BFD_ENDIAN_BIG
5394
521k
   || header.byteorder == BFD_ENDIAN_LITTLE))
5395
0
    {
5396
0
      _bfd_error_handler (_("unknown header byte-order value %#x"),
5397
0
        header.byteorder);
5398
0
      goto wrong;
5399
0
    }
5400
5401
521k
  if (! ((header.byteorder == BFD_ENDIAN_BIG
5402
521k
    && abfd->xvec->byteorder == BFD_ENDIAN_BIG
5403
521k
    && abfd->xvec->header_byteorder == BFD_ENDIAN_BIG)
5404
521k
   || (header.byteorder == BFD_ENDIAN_LITTLE
5405
520k
       && abfd->xvec->byteorder == BFD_ENDIAN_LITTLE
5406
520k
       && abfd->xvec->header_byteorder == BFD_ENDIAN_LITTLE)))
5407
89.0k
    goto wrong;
5408
5409
  /* Check cputype and filetype.
5410
     In case of wildcard, do not accept magics that are handled by existing
5411
     targets.  */
5412
432k
  if (cpu_type)
5413
346k
    {
5414
346k
      if (header.cputype != cpu_type)
5415
296k
  goto wrong;
5416
346k
    }
5417
85.6k
  else
5418
85.6k
    {
5419
#ifndef BFD64
5420
      /* Do not recognize 64 architectures if not configured for 64bit targets.
5421
   This could happen only for generic targets.  */
5422
      if (mach_o_wide_p (&header))
5423
   goto wrong;
5424
#endif
5425
85.6k
    }
5426
5427
136k
  if (file_type)
5428
666
    {
5429
666
      if (header.filetype != file_type)
5430
663
  goto wrong;
5431
666
    }
5432
135k
  else
5433
135k
    {
5434
135k
      switch (header.filetype)
5435
135k
  {
5436
230
  case BFD_MACH_O_MH_CORE:
5437
    /* Handled by core_p */
5438
230
    goto wrong;
5439
135k
  default:
5440
135k
    break;
5441
135k
  }
5442
135k
    }
5443
5444
135k
  mdata = (bfd_mach_o_data_struct *) bfd_zalloc (abfd, sizeof (*mdata));
5445
135k
  if (mdata == NULL)
5446
0
    goto fail;
5447
135k
  mdata->hdr_offset = hdr_off;
5448
5449
135k
  if (!bfd_mach_o_scan (abfd, &header, mdata))
5450
83.4k
    goto wrong;
5451
5452
51.6k
  return _bfd_no_cleanup;
5453
5454
10.2M
 wrong:
5455
10.2M
  bfd_set_error (bfd_error_wrong_format);
5456
5457
10.2M
 fail:
5458
10.2M
  return NULL;
5459
10.2M
}
5460
5461
static bfd_cleanup
5462
bfd_mach_o_gen_object_p (bfd *abfd)
5463
3.40M
{
5464
3.40M
  return bfd_mach_o_header_p (abfd, 0, 0, 0);
5465
3.40M
}
5466
5467
static bfd_cleanup
5468
bfd_mach_o_gen_core_p (bfd *abfd)
5469
17.2k
{
5470
17.2k
  return bfd_mach_o_header_p (abfd, 0, BFD_MACH_O_MH_CORE, 0);
5471
17.2k
}
5472
5473
/* Return the base address of ABFD, ie the address at which the image is
5474
   mapped.  The possible initial pagezero is ignored.  */
5475
5476
bfd_vma
5477
bfd_mach_o_get_base_address (bfd *abfd)
5478
0
{
5479
0
  bfd_mach_o_data_struct *mdata;
5480
0
  bfd_mach_o_load_command *cmd;
5481
5482
  /* Check for Mach-O.  */
5483
0
  if (!bfd_mach_o_valid (abfd))
5484
0
    return 0;
5485
0
  mdata = bfd_mach_o_get_data (abfd);
5486
5487
0
  for (cmd = mdata->first_command; cmd != NULL; cmd = cmd->next)
5488
0
    {
5489
0
      if ((cmd->type == BFD_MACH_O_LC_SEGMENT
5490
0
     || cmd->type == BFD_MACH_O_LC_SEGMENT_64))
5491
0
  {
5492
0
    struct bfd_mach_o_segment_command *segcmd = &cmd->command.segment;
5493
5494
0
    if (segcmd->initprot != 0)
5495
0
      return segcmd->vmaddr;
5496
0
  }
5497
0
    }
5498
0
  return 0;
5499
0
}
5500
5501
typedef struct mach_o_fat_archentry
5502
{
5503
  unsigned long cputype;
5504
  unsigned long cpusubtype;
5505
  unsigned long offset;
5506
  unsigned long size;
5507
  unsigned long align;
5508
} mach_o_fat_archentry;
5509
5510
typedef struct mach_o_fat_data_struct
5511
{
5512
  unsigned long magic;
5513
  unsigned long nfat_arch;
5514
  mach_o_fat_archentry *archentries;
5515
} mach_o_fat_data_struct;
5516
5517
/* Check for overlapping archive elements.  Note that we can't allow
5518
   multiple elements at the same offset even if one is empty, because
5519
   bfd_mach_o_fat_openr_next_archived_file assume distinct offsets.  */
5520
static bool
5521
overlap_previous (const mach_o_fat_archentry *elt, unsigned long i)
5522
350
{
5523
350
  unsigned long j = i;
5524
625
  while (j-- != 0)
5525
298
    if (elt[i].offset == elt[j].offset
5526
298
  || (elt[i].offset > elt[j].offset
5527
288
      ? elt[i].offset - elt[j].offset < elt[j].size
5528
288
      : elt[j].offset - elt[i].offset < elt[i].size))
5529
23
      return true;
5530
327
  return false;
5531
350
}
5532
5533
bfd_cleanup
5534
bfd_mach_o_fat_archive_p (bfd *abfd)
5535
88.2k
{
5536
88.2k
  mach_o_fat_data_struct *adata = NULL;
5537
88.2k
  struct mach_o_fat_header_external hdr;
5538
88.2k
  unsigned long i;
5539
88.2k
  size_t amt;
5540
88.2k
  ufile_ptr filesize;
5541
5542
88.2k
  if (bfd_seek (abfd, 0, SEEK_SET) != 0
5543
88.2k
      || bfd_read (&hdr, sizeof (hdr), abfd) != sizeof (hdr))
5544
401
    goto error;
5545
5546
87.8k
  adata = bfd_alloc (abfd, sizeof (mach_o_fat_data_struct));
5547
87.8k
  if (adata == NULL)
5548
0
    goto error;
5549
5550
87.8k
  adata->magic = bfd_getb32 (hdr.magic);
5551
87.8k
  adata->nfat_arch = bfd_getb32 (hdr.nfat_arch);
5552
87.8k
  if (adata->magic != 0xcafebabe)
5553
87.4k
    goto error;
5554
  /* Avoid matching Java bytecode files, which have the same magic number.
5555
     In the Java bytecode file format this field contains the JVM version,
5556
     which starts at 43.0.  */
5557
397
  if (adata->nfat_arch > 30)
5558
59
    goto error;
5559
5560
338
  if (_bfd_mul_overflow (adata->nfat_arch,
5561
338
       sizeof (mach_o_fat_archentry), &amt))
5562
0
    {
5563
0
      bfd_set_error (bfd_error_file_too_big);
5564
0
      goto error;
5565
0
    }
5566
338
  adata->archentries = bfd_alloc (abfd, amt);
5567
338
  if (adata->archentries == NULL)
5568
0
    goto error;
5569
5570
338
  filesize = bfd_get_file_size (abfd);
5571
665
  for (i = 0; i < adata->nfat_arch; i++)
5572
562
    {
5573
562
      struct mach_o_fat_arch_external arch;
5574
562
      if (bfd_read (&arch, sizeof (arch), abfd) != sizeof (arch))
5575
18
  goto error;
5576
544
      adata->archentries[i].cputype = bfd_getb32 (arch.cputype);
5577
544
      adata->archentries[i].cpusubtype = bfd_getb32 (arch.cpusubtype);
5578
544
      adata->archentries[i].offset = bfd_getb32 (arch.offset);
5579
544
      adata->archentries[i].size = bfd_getb32 (arch.size);
5580
544
      adata->archentries[i].align = bfd_getb32 (arch.align);
5581
544
      if ((filesize != 0
5582
544
     && (adata->archentries[i].offset > filesize
5583
544
         || (adata->archentries[i].size
5584
447
       > filesize - adata->archentries[i].offset)))
5585
544
    || (adata->archentries[i].offset
5586
365
        < sizeof (hdr) + adata->nfat_arch * sizeof (arch))
5587
544
    || overlap_previous (adata->archentries, i))
5588
217
  {
5589
217
    bfd_release (abfd, adata);
5590
217
    bfd_set_error (bfd_error_malformed_archive);
5591
217
    return NULL;
5592
217
  }
5593
544
    }
5594
5595
103
  abfd->tdata.mach_o_fat_data = adata;
5596
5597
103
  return _bfd_no_cleanup;
5598
5599
87.9k
 error:
5600
87.9k
  if (adata != NULL)
5601
87.5k
    bfd_release (abfd, adata);
5602
87.9k
  bfd_set_error (bfd_error_wrong_format);
5603
87.9k
  return NULL;
5604
338
}
5605
5606
/* Set the filename for a fat binary member ABFD, whose bfd architecture is
5607
   ARCH_TYPE/ARCH_SUBTYPE and corresponding entry in header is ENTRY.
5608
   Set arelt_data and origin fields too.  */
5609
5610
static bool
5611
bfd_mach_o_fat_member_init (bfd *abfd,
5612
          enum bfd_architecture arch_type,
5613
          unsigned long arch_subtype,
5614
          mach_o_fat_archentry *entry)
5615
150
{
5616
150
  struct areltdata *areltdata;
5617
  /* Create the member filename. Use ARCH_NAME.  */
5618
150
  const bfd_arch_info_type *ap = bfd_lookup_arch (arch_type, arch_subtype);
5619
150
  const char *filename;
5620
5621
150
  if (ap)
5622
128
    {
5623
      /* Use the architecture name if known.  */
5624
128
      filename = bfd_set_filename (abfd, ap->printable_name);
5625
128
    }
5626
22
  else
5627
22
    {
5628
      /* Forge a uniq id.  */
5629
22
      char buf[2 + 8 + 1 + 2 + 8 + 1];
5630
22
      snprintf (buf, sizeof (buf), "0x%lx-0x%lx",
5631
22
    entry->cputype, entry->cpusubtype);
5632
22
      filename = bfd_set_filename (abfd, buf);
5633
22
    }
5634
150
  if (!filename)
5635
0
    return false;
5636
5637
150
  areltdata = bfd_zmalloc (sizeof (struct areltdata));
5638
150
  if (areltdata == NULL)
5639
0
    return false;
5640
150
  areltdata->parsed_size = entry->size;
5641
150
  abfd->arelt_data = areltdata;
5642
150
  abfd->iostream = NULL;
5643
150
  abfd->origin = entry->offset;
5644
150
  return true;
5645
150
}
5646
5647
bfd *
5648
bfd_mach_o_fat_openr_next_archived_file (bfd *archive, bfd *prev)
5649
240
{
5650
240
  mach_o_fat_data_struct *adata;
5651
240
  mach_o_fat_archentry *entry = NULL;
5652
240
  unsigned long i;
5653
240
  bfd *nbfd;
5654
240
  enum bfd_architecture arch_type;
5655
240
  unsigned long arch_subtype;
5656
5657
240
  adata = (mach_o_fat_data_struct *) archive->tdata.mach_o_fat_data;
5658
240
  BFD_ASSERT (adata != NULL);
5659
5660
  /* Find index of previous entry.  */
5661
240
  if (prev == NULL)
5662
90
    {
5663
      /* Start at first one.  */
5664
90
      i = 0;
5665
90
    }
5666
150
  else
5667
150
    {
5668
      /* Find index of PREV.  */
5669
219
      for (i = 0; i < adata->nfat_arch; i++)
5670
219
  {
5671
219
    if (adata->archentries[i].offset == prev->origin)
5672
150
      break;
5673
219
  }
5674
5675
150
      if (i == adata->nfat_arch)
5676
0
  {
5677
    /* Not found.  */
5678
0
    bfd_set_error (bfd_error_bad_value);
5679
0
    return NULL;
5680
0
  }
5681
5682
      /* Get next entry.  */
5683
150
      i++;
5684
150
    }
5685
5686
240
  if (i >= adata->nfat_arch)
5687
90
    {
5688
90
      bfd_set_error (bfd_error_no_more_archived_files);
5689
90
      return NULL;
5690
90
    }
5691
5692
150
  entry = &adata->archentries[i];
5693
150
  nbfd = _bfd_new_bfd_contained_in (archive);
5694
150
  if (nbfd == NULL)
5695
0
    return NULL;
5696
5697
150
  bfd_mach_o_convert_architecture (entry->cputype, entry->cpusubtype,
5698
150
           &arch_type, &arch_subtype);
5699
5700
150
  if (!bfd_mach_o_fat_member_init (nbfd, arch_type, arch_subtype, entry))
5701
0
    {
5702
0
      bfd_close (nbfd);
5703
0
      return NULL;
5704
0
    }
5705
5706
150
  bfd_set_arch_mach (nbfd, arch_type, arch_subtype);
5707
5708
150
  return nbfd;
5709
150
}
5710
5711
/* Analogous to stat call.  */
5712
5713
static int
5714
bfd_mach_o_fat_stat_arch_elt (bfd *abfd, struct stat *buf)
5715
26
{
5716
26
  if (abfd->arelt_data == NULL)
5717
0
    {
5718
0
      bfd_set_error (bfd_error_invalid_operation);
5719
0
      return -1;
5720
0
    }
5721
5722
26
  buf->st_mtime = 0;
5723
26
  buf->st_uid = 0;
5724
26
  buf->st_gid = 0;
5725
26
  buf->st_mode = 0644;
5726
26
  buf->st_size = arelt_size (abfd);
5727
5728
26
  return 0;
5729
26
}
5730
5731
/* If ABFD format is FORMAT and architecture is ARCH, return it.
5732
   If ABFD is a fat image containing a member that corresponds to FORMAT
5733
   and ARCH, returns it.
5734
   In other case, returns NULL.
5735
   This function allows transparent uses of fat images.  */
5736
5737
bfd *
5738
bfd_mach_o_fat_extract (bfd *abfd,
5739
      bfd_format format,
5740
      const bfd_arch_info_type *arch)
5741
0
{
5742
0
  bfd *res;
5743
0
  mach_o_fat_data_struct *adata;
5744
0
  unsigned int i;
5745
5746
0
  if (bfd_check_format (abfd, format))
5747
0
    {
5748
0
      if (bfd_get_arch_info (abfd) == arch)
5749
0
  return abfd;
5750
0
      return NULL;
5751
0
    }
5752
0
  if (!bfd_check_format (abfd, bfd_archive)
5753
0
      || abfd->xvec != &mach_o_fat_vec)
5754
0
    return NULL;
5755
5756
  /* This is a Mach-O fat image.  */
5757
0
  adata = (mach_o_fat_data_struct *) abfd->tdata.mach_o_fat_data;
5758
0
  BFD_ASSERT (adata != NULL);
5759
5760
0
  for (i = 0; i < adata->nfat_arch; i++)
5761
0
    {
5762
0
      struct mach_o_fat_archentry *e = &adata->archentries[i];
5763
0
      enum bfd_architecture cpu_type;
5764
0
      unsigned long cpu_subtype;
5765
5766
0
      bfd_mach_o_convert_architecture (e->cputype, e->cpusubtype,
5767
0
               &cpu_type, &cpu_subtype);
5768
0
      if (cpu_type != arch->arch || cpu_subtype != arch->mach)
5769
0
  continue;
5770
5771
      /* The architecture is found.  */
5772
0
      res = _bfd_new_bfd_contained_in (abfd);
5773
0
      if (res == NULL)
5774
0
  return NULL;
5775
5776
0
      if (bfd_mach_o_fat_member_init (res, cpu_type, cpu_subtype, e)
5777
0
    && bfd_check_format (res, format))
5778
0
  {
5779
0
    BFD_ASSERT (bfd_get_arch_info (res) == arch);
5780
0
    return res;
5781
0
  }
5782
0
      bfd_close (res);
5783
0
      return NULL;
5784
0
    }
5785
5786
0
  return NULL;
5787
0
}
5788
5789
static bool
5790
bfd_mach_o_fat_close_and_cleanup (bfd *abfd)
5791
205
{
5792
205
  _bfd_unlink_from_archive_parent (abfd);
5793
205
  return true;
5794
205
}
5795
5796
int
5797
bfd_mach_o_lookup_command (bfd *abfd,
5798
         bfd_mach_o_load_command_type type,
5799
         bfd_mach_o_load_command **mcommand)
5800
54
{
5801
54
  struct mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
5802
54
  struct bfd_mach_o_load_command *cmd;
5803
54
  unsigned int num;
5804
5805
54
  BFD_ASSERT (mdata != NULL);
5806
54
  BFD_ASSERT (mcommand != NULL);
5807
5808
54
  num = 0;
5809
725
  for (cmd = mdata->first_command; cmd != NULL; cmd = cmd->next)
5810
671
    {
5811
671
      if (cmd->type != type)
5812
629
  continue;
5813
5814
42
      if (num == 0)
5815
31
  *mcommand = cmd;
5816
42
      num++;
5817
42
    }
5818
5819
54
  return num;
5820
54
}
5821
5822
unsigned long
5823
bfd_mach_o_stack_addr (enum bfd_mach_o_cpu_type type)
5824
0
{
5825
0
  switch (type)
5826
0
    {
5827
0
    case BFD_MACH_O_CPU_TYPE_MC680x0:
5828
0
      return 0x04000000;
5829
0
    case BFD_MACH_O_CPU_TYPE_POWERPC:
5830
0
      return 0xc0000000;
5831
0
    case BFD_MACH_O_CPU_TYPE_I386:
5832
0
      return 0xc0000000;
5833
0
    case BFD_MACH_O_CPU_TYPE_SPARC:
5834
0
      return 0xf0000000;
5835
0
    case BFD_MACH_O_CPU_TYPE_HPPA:
5836
0
      return 0xc0000000 - 0x04000000;
5837
0
    default:
5838
0
      return 0;
5839
0
    }
5840
0
}
5841
5842
/* The following two tables should be kept, as far as possible, in order of
5843
   most frequently used entries to optimize their use from gas.  */
5844
5845
const bfd_mach_o_xlat_name bfd_mach_o_section_type_name[] =
5846
{
5847
  { "regular", BFD_MACH_O_S_REGULAR},
5848
  { "coalesced", BFD_MACH_O_S_COALESCED},
5849
  { "zerofill", BFD_MACH_O_S_ZEROFILL},
5850
  { "cstring_literals", BFD_MACH_O_S_CSTRING_LITERALS},
5851
  { "4byte_literals", BFD_MACH_O_S_4BYTE_LITERALS},
5852
  { "8byte_literals", BFD_MACH_O_S_8BYTE_LITERALS},
5853
  { "16byte_literals", BFD_MACH_O_S_16BYTE_LITERALS},
5854
  { "literal_pointers", BFD_MACH_O_S_LITERAL_POINTERS},
5855
  { "mod_init_func_pointers", BFD_MACH_O_S_MOD_INIT_FUNC_POINTERS},
5856
  { "mod_fini_func_pointers", BFD_MACH_O_S_MOD_FINI_FUNC_POINTERS},
5857
  { "gb_zerofill", BFD_MACH_O_S_GB_ZEROFILL},
5858
  { "interposing", BFD_MACH_O_S_INTERPOSING},
5859
  { "dtrace_dof", BFD_MACH_O_S_DTRACE_DOF},
5860
  { "non_lazy_symbol_pointers", BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS},
5861
  { "lazy_symbol_pointers", BFD_MACH_O_S_LAZY_SYMBOL_POINTERS},
5862
  { "symbol_stubs", BFD_MACH_O_S_SYMBOL_STUBS},
5863
  { "lazy_dylib_symbol_pointers", BFD_MACH_O_S_LAZY_DYLIB_SYMBOL_POINTERS},
5864
  { NULL, 0}
5865
};
5866
5867
const bfd_mach_o_xlat_name bfd_mach_o_section_attribute_name[] =
5868
{
5869
  { "pure_instructions", BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS },
5870
  { "some_instructions", BFD_MACH_O_S_ATTR_SOME_INSTRUCTIONS },
5871
  { "loc_reloc", BFD_MACH_O_S_ATTR_LOC_RELOC },
5872
  { "ext_reloc", BFD_MACH_O_S_ATTR_EXT_RELOC },
5873
  { "debug", BFD_MACH_O_S_ATTR_DEBUG },
5874
  { "live_support", BFD_MACH_O_S_ATTR_LIVE_SUPPORT },
5875
  { "no_dead_strip", BFD_MACH_O_S_ATTR_NO_DEAD_STRIP },
5876
  { "strip_static_syms", BFD_MACH_O_S_ATTR_STRIP_STATIC_SYMS },
5877
  { "no_toc", BFD_MACH_O_S_ATTR_NO_TOC },
5878
  { "self_modifying_code", BFD_MACH_O_S_SELF_MODIFYING_CODE },
5879
  { "modifying_code", BFD_MACH_O_S_SELF_MODIFYING_CODE },
5880
  { NULL, 0}
5881
};
5882
5883
/* Get the section type from NAME.  Return 256 if NAME is unknown.  */
5884
5885
unsigned int
5886
bfd_mach_o_get_section_type_from_name (bfd *abfd, const char *name)
5887
0
{
5888
0
  const bfd_mach_o_xlat_name *x;
5889
0
  bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
5890
5891
0
  for (x = bfd_mach_o_section_type_name; x->name; x++)
5892
0
    if (strcmp (x->name, name) == 0)
5893
0
      {
5894
  /* We found it... does the target support it?  */
5895
0
  if (bed->bfd_mach_o_section_type_valid_for_target == NULL
5896
0
      || bed->bfd_mach_o_section_type_valid_for_target (x->val))
5897
0
    return x->val; /* OK.  */
5898
0
  else
5899
0
    break; /* Not supported.  */
5900
0
      }
5901
  /* Maximum section ID = 0xff.  */
5902
0
  return 256;
5903
0
}
5904
5905
/* Get the section attribute from NAME.  Return -1 if NAME is unknown.  */
5906
5907
unsigned int
5908
bfd_mach_o_get_section_attribute_from_name (const char *name)
5909
0
{
5910
0
  const bfd_mach_o_xlat_name *x;
5911
5912
0
  for (x = bfd_mach_o_section_attribute_name; x->name; x++)
5913
0
    if (strcmp (x->name, name) == 0)
5914
0
      return x->val;
5915
0
  return (unsigned int)-1;
5916
0
}
5917
5918
int
5919
bfd_mach_o_core_fetch_environment (bfd *abfd,
5920
           unsigned char **rbuf,
5921
           unsigned int *rlen)
5922
0
{
5923
0
  bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
5924
0
  unsigned long stackaddr = bfd_mach_o_stack_addr (mdata->header.cputype);
5925
0
  bfd_mach_o_load_command *cmd;
5926
5927
0
  for (cmd = mdata->first_command; cmd != NULL; cmd = cmd->next)
5928
0
    {
5929
0
      bfd_mach_o_segment_command *seg;
5930
5931
0
      if (cmd->type != BFD_MACH_O_LC_SEGMENT)
5932
0
  continue;
5933
5934
0
      seg = &cmd->command.segment;
5935
5936
0
      if ((seg->vmaddr + seg->vmsize) == stackaddr)
5937
0
  {
5938
0
    unsigned long start = seg->fileoff;
5939
0
    unsigned long end = seg->fileoff + seg->filesize;
5940
0
    unsigned char *buf = bfd_malloc (1024);
5941
0
    unsigned long size = 1024;
5942
5943
0
    if (buf == NULL)
5944
0
      return -1;
5945
0
    for (;;)
5946
0
      {
5947
0
        bfd_size_type nread = 0;
5948
0
        unsigned long offset;
5949
0
        int found_nonnull = 0;
5950
5951
0
        if (size > (end - start))
5952
0
    size = (end - start);
5953
5954
0
        buf = bfd_realloc_or_free (buf, size);
5955
0
        if (buf == NULL)
5956
0
    return -1;
5957
5958
0
        if (bfd_seek (abfd, end - size, SEEK_SET) != 0)
5959
0
    {
5960
0
      free (buf);
5961
0
      return -1;
5962
0
    }
5963
5964
0
        nread = bfd_read (buf, size, abfd);
5965
5966
0
        if (nread != size)
5967
0
    {
5968
0
      free (buf);
5969
0
      return -1;
5970
0
    }
5971
5972
0
        for (offset = 4; offset <= size; offset += 4)
5973
0
    {
5974
0
      unsigned long val;
5975
5976
0
      val = bfd_get_32(abfd, buf + size - offset);
5977
5978
0
      if (! found_nonnull)
5979
0
        {
5980
0
          if (val != 0)
5981
0
      found_nonnull = 1;
5982
0
        }
5983
0
      else if (val == 0x0)
5984
0
        {
5985
0
          unsigned long bottom;
5986
0
          unsigned long top;
5987
5988
0
          bottom = seg->fileoff + seg->filesize - offset;
5989
0
          top = seg->fileoff + seg->filesize - 4;
5990
0
          *rbuf = bfd_malloc (top - bottom);
5991
0
          if (*rbuf == NULL)
5992
0
      return -1;
5993
0
          *rlen = top - bottom;
5994
5995
0
          memcpy (*rbuf, buf + size - *rlen, *rlen);
5996
0
          free (buf);
5997
0
          return 0;
5998
0
        }
5999
0
    }
6000
6001
0
        if (size == (end - start))
6002
0
    break;
6003
6004
0
        size *= 2;
6005
0
      }
6006
6007
0
    free (buf);
6008
0
  }
6009
0
    }
6010
6011
0
  return -1;
6012
0
}
6013
6014
char *
6015
bfd_mach_o_core_file_failing_command (bfd *abfd)
6016
0
{
6017
0
  unsigned char *buf = NULL;
6018
0
  unsigned int len = 0;
6019
0
  int ret;
6020
6021
0
  ret = bfd_mach_o_core_fetch_environment (abfd, &buf, &len);
6022
0
  if (ret < 0)
6023
0
    return NULL;
6024
6025
0
  return (char *) buf;
6026
0
}
6027
6028
int
6029
bfd_mach_o_core_file_failing_signal (bfd *abfd ATTRIBUTE_UNUSED)
6030
0
{
6031
0
  return 0;
6032
0
}
6033
6034
static bfd_mach_o_uuid_command *
6035
bfd_mach_o_lookup_uuid_command (bfd *abfd)
6036
54
{
6037
54
  bfd_mach_o_load_command *uuid_cmd = NULL;
6038
54
  int ncmd = bfd_mach_o_lookup_command (abfd, BFD_MACH_O_LC_UUID, &uuid_cmd);
6039
54
  if (ncmd != 1 || uuid_cmd == NULL)
6040
34
    return false;
6041
20
  return &uuid_cmd->command.uuid;
6042
54
}
6043
6044
/* Return true if ABFD is a dSYM file and its UUID matches UUID_CMD. */
6045
6046
static bool
6047
bfd_mach_o_dsym_for_uuid_p (bfd *abfd, const bfd_mach_o_uuid_command *uuid_cmd)
6048
0
{
6049
0
  bfd_mach_o_uuid_command *dsym_uuid_cmd;
6050
6051
0
  BFD_ASSERT (abfd);
6052
0
  BFD_ASSERT (uuid_cmd);
6053
6054
0
  if (!bfd_check_format (abfd, bfd_object))
6055
0
    return false;
6056
6057
0
  if (bfd_get_flavour (abfd) != bfd_target_mach_o_flavour
6058
0
      || bfd_mach_o_get_data (abfd) == NULL
6059
0
      || bfd_mach_o_get_data (abfd)->header.filetype != BFD_MACH_O_MH_DSYM)
6060
0
    return false;
6061
6062
0
  dsym_uuid_cmd = bfd_mach_o_lookup_uuid_command (abfd);
6063
0
  if (dsym_uuid_cmd == NULL)
6064
0
    return false;
6065
6066
0
  if (memcmp (uuid_cmd->uuid, dsym_uuid_cmd->uuid,
6067
0
        sizeof (uuid_cmd->uuid)) != 0)
6068
0
    return false;
6069
6070
0
  return true;
6071
0
}
6072
6073
/* Find a BFD in DSYM_FILENAME which matches ARCH and UUID_CMD.
6074
   The caller is responsible for closing the returned BFD object and
6075
   its my_archive if the returned BFD is in a fat dSYM. */
6076
6077
static bfd *
6078
bfd_mach_o_find_dsym (const char *dsym_filename,
6079
          const bfd_mach_o_uuid_command *uuid_cmd,
6080
          const bfd_arch_info_type *arch)
6081
20
{
6082
20
  bfd *base_dsym_bfd, *dsym_bfd;
6083
6084
20
  BFD_ASSERT (uuid_cmd);
6085
6086
20
  base_dsym_bfd = bfd_openr (dsym_filename, NULL);
6087
20
  if (base_dsym_bfd == NULL)
6088
20
    return NULL;
6089
6090
0
  dsym_bfd = bfd_mach_o_fat_extract (base_dsym_bfd, bfd_object, arch);
6091
0
  if (bfd_mach_o_dsym_for_uuid_p (dsym_bfd, uuid_cmd))
6092
0
    return dsym_bfd;
6093
6094
0
  bfd_close (dsym_bfd);
6095
0
  if (base_dsym_bfd != dsym_bfd)
6096
0
    bfd_close (base_dsym_bfd);
6097
6098
0
  return NULL;
6099
0
}
6100
6101
/* Return a BFD created from a dSYM file for ABFD.
6102
   The caller is responsible for closing the returned BFD object, its
6103
   filename, and its my_archive if the returned BFD is in a fat dSYM. */
6104
6105
static bfd *
6106
bfd_mach_o_follow_dsym (bfd *abfd)
6107
54
{
6108
54
  char *dsym_filename;
6109
54
  bfd_mach_o_uuid_command *uuid_cmd;
6110
54
  bfd *dsym_bfd, *base_bfd = abfd;
6111
54
  const char *base_basename;
6112
6113
54
  if (abfd == NULL || bfd_get_flavour (abfd) != bfd_target_mach_o_flavour)
6114
0
    return NULL;
6115
6116
54
  if (abfd->my_archive && !bfd_is_thin_archive (abfd->my_archive))
6117
7
    base_bfd = abfd->my_archive;
6118
  /* BFD may have been opened from a stream. */
6119
54
  if (bfd_get_filename (base_bfd) == NULL)
6120
0
    {
6121
0
      bfd_set_error (bfd_error_invalid_operation);
6122
0
      return NULL;
6123
0
    }
6124
54
  base_basename = lbasename (bfd_get_filename (base_bfd));
6125
6126
54
  uuid_cmd = bfd_mach_o_lookup_uuid_command (abfd);
6127
54
  if (uuid_cmd == NULL)
6128
34
    return NULL;
6129
6130
  /* TODO: We assume the DWARF file has the same as the binary's.
6131
     It seems apple's GDB checks all files in the dSYM bundle directory.
6132
     http://opensource.apple.com/source/gdb/gdb-1708/src/gdb/macosx/macosx-tdep.c
6133
  */
6134
20
  dsym_filename = (char *)bfd_malloc (strlen (bfd_get_filename (base_bfd))
6135
20
               + strlen (dsym_subdir) + 1
6136
20
               + strlen (base_basename) + 1);
6137
20
  if (dsym_filename == NULL)
6138
0
    return NULL;
6139
6140
20
  sprintf (dsym_filename, "%s%s/%s",
6141
20
     bfd_get_filename (base_bfd), dsym_subdir, base_basename);
6142
6143
20
  dsym_bfd = bfd_mach_o_find_dsym (dsym_filename, uuid_cmd,
6144
20
           bfd_get_arch_info (abfd));
6145
20
  if (dsym_bfd == NULL)
6146
20
    free (dsym_filename);
6147
6148
20
  return dsym_bfd;
6149
20
}
6150
6151
bool
6152
bfd_mach_o_find_nearest_line (bfd *abfd,
6153
            asymbol **symbols,
6154
            asection *section,
6155
            bfd_vma offset,
6156
            const char **filename_ptr,
6157
            const char **functionname_ptr,
6158
            unsigned int *line_ptr,
6159
            unsigned int *discriminator_ptr)
6160
14.5k
{
6161
14.5k
  bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
6162
14.5k
  if (mdata == NULL)
6163
0
    return false;
6164
14.5k
  switch (mdata->header.filetype)
6165
14.5k
    {
6166
8
    case BFD_MACH_O_MH_OBJECT:
6167
8
      break;
6168
5.58k
    case BFD_MACH_O_MH_EXECUTE:
6169
5.74k
    case BFD_MACH_O_MH_DYLIB:
6170
5.81k
    case BFD_MACH_O_MH_BUNDLE:
6171
5.83k
    case BFD_MACH_O_MH_KEXT_BUNDLE:
6172
5.83k
      if (mdata->dwarf2_find_line_info == NULL)
6173
54
  {
6174
54
    mdata->dsym_bfd = bfd_mach_o_follow_dsym (abfd);
6175
    /* When we couldn't find dSYM for this binary, we look for
6176
       the debug information in the binary itself. In this way,
6177
       we won't try finding separated dSYM again because
6178
       mdata->dwarf2_find_line_info will be filled. */
6179
54
    if (! mdata->dsym_bfd)
6180
54
      break;
6181
0
    if (! _bfd_dwarf2_slurp_debug_info (abfd, mdata->dsym_bfd,
6182
0
                dwarf_debug_sections, symbols,
6183
0
                &mdata->dwarf2_find_line_info,
6184
0
                false))
6185
0
      return false;
6186
0
  }
6187
5.78k
      break;
6188
8.69k
    default:
6189
8.69k
      return false;
6190
14.5k
    }
6191
5.84k
  return _bfd_dwarf2_find_nearest_line (abfd, symbols, NULL, section, offset,
6192
5.84k
          filename_ptr, functionname_ptr,
6193
5.84k
          line_ptr, discriminator_ptr,
6194
5.84k
          dwarf_debug_sections,
6195
5.84k
          &mdata->dwarf2_find_line_info);
6196
14.5k
}
6197
6198
bool
6199
bfd_mach_o_close_and_cleanup (bfd *abfd)
6200
31.7k
{
6201
31.7k
  bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
6202
31.7k
  if (bfd_get_format (abfd) == bfd_object && mdata != NULL)
6203
28.2k
    {
6204
28.2k
      if (mdata->dsym_bfd != NULL)
6205
0
  {
6206
0
    bfd *fat_bfd = mdata->dsym_bfd->my_archive;
6207
#if 0
6208
    /* FIXME: PR 19435: This calculation to find the memory allocated by
6209
       bfd_mach_o_follow_dsym for the filename does not always end up
6210
       selecting the correct pointer.  Unfortunately this problem is
6211
       very hard to reproduce on a non Mach-O native system, so until it
6212
       can be traced and fixed on such a system, this code will remain
6213
       commented out.  This does mean that there will be a memory leak,
6214
       but it is small, and happens when we are closing down, so it
6215
       should not matter too much.  */
6216
    char *dsym_filename = (char *)(fat_bfd
6217
           ? bfd_get_filename (fat_bfd)
6218
           : bfd_get_filename (mdata->dsym_bfd));
6219
#endif
6220
0
    bfd_close (mdata->dsym_bfd);
6221
0
    mdata->dsym_bfd = NULL;
6222
0
    if (fat_bfd)
6223
0
      bfd_close (fat_bfd);
6224
#if 0
6225
    free (dsym_filename);
6226
#endif
6227
0
  }
6228
28.2k
    }
6229
6230
31.7k
  return _bfd_generic_close_and_cleanup (abfd);
6231
31.7k
}
6232
6233
bool
6234
bfd_mach_o_bfd_free_cached_info (bfd *abfd)
6235
31.9k
{
6236
31.9k
  bfd_mach_o_data_struct *mdata;
6237
6238
31.9k
  if ((bfd_get_format (abfd) == bfd_object
6239
31.9k
       || bfd_get_format (abfd) == bfd_core)
6240
31.9k
      && (mdata = bfd_mach_o_get_data (abfd)) != NULL)
6241
28.2k
    {
6242
28.2k
      _bfd_dwarf2_cleanup_debug_info (abfd, &mdata->dwarf2_find_line_info);
6243
28.2k
      free (mdata->dyn_reloc_cache);
6244
28.2k
      mdata->dyn_reloc_cache = NULL;
6245
6246
1.83M
      for (asection *asect = abfd->sections; asect; asect = asect->next)
6247
1.80M
  {
6248
1.80M
    free (asect->relocation);
6249
1.80M
    asect->relocation = NULL;
6250
1.80M
  }
6251
28.2k
    }
6252
6253
  /* Do not call _bfd_generic_bfd_free_cached_info here.
6254
     bfd_mach_o_close_and_cleanup uses tdata.  */
6255
31.9k
  return true;
6256
31.9k
}
6257
6258
#define bfd_mach_o_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
6259
#define bfd_mach_o_bfd_reloc_name_lookup _bfd_norelocs_bfd_reloc_name_lookup
6260
6261
#define bfd_mach_o_canonicalize_one_reloc NULL
6262
#define bfd_mach_o_swap_reloc_out NULL
6263
#define bfd_mach_o_print_thread NULL
6264
#define bfd_mach_o_tgt_seg_table NULL
6265
#define bfd_mach_o_section_type_valid_for_tgt NULL
6266
6267
#define TARGET_NAME   mach_o_be_vec
6268
#define TARGET_STRING   "mach-o-be"
6269
#define TARGET_ARCHITECTURE bfd_arch_unknown
6270
#define TARGET_PAGESIZE   1
6271
#define TARGET_BIG_ENDIAN 1
6272
#define TARGET_ARCHIVE    0
6273
#define TARGET_PRIORITY   1
6274
#include "mach-o-target.c"
6275
6276
#undef TARGET_NAME
6277
#undef TARGET_STRING
6278
#undef TARGET_ARCHITECTURE
6279
#undef TARGET_PAGESIZE
6280
#undef TARGET_BIG_ENDIAN
6281
#undef TARGET_ARCHIVE
6282
#undef TARGET_PRIORITY
6283
6284
#define TARGET_NAME   mach_o_le_vec
6285
#define TARGET_STRING   "mach-o-le"
6286
#define TARGET_ARCHITECTURE bfd_arch_unknown
6287
#define TARGET_PAGESIZE   1
6288
#define TARGET_BIG_ENDIAN 0
6289
#define TARGET_ARCHIVE    0
6290
#define TARGET_PRIORITY   1
6291
6292
#include "mach-o-target.c"
6293
6294
#undef TARGET_NAME
6295
#undef TARGET_STRING
6296
#undef TARGET_ARCHITECTURE
6297
#undef TARGET_PAGESIZE
6298
#undef TARGET_BIG_ENDIAN
6299
#undef TARGET_ARCHIVE
6300
#undef TARGET_PRIORITY
6301
6302
/* Not yet handled: creating an archive.  */
6303
#define bfd_mach_o_mkarchive        _bfd_noarchive_mkarchive
6304
6305
#define bfd_mach_o_close_and_cleanup      bfd_mach_o_fat_close_and_cleanup
6306
6307
/* Not used.  */
6308
#define bfd_mach_o_generic_stat_arch_elt    bfd_mach_o_fat_stat_arch_elt
6309
#define bfd_mach_o_openr_next_archived_file   bfd_mach_o_fat_openr_next_archived_file
6310
#define bfd_mach_o_archive_p  bfd_mach_o_fat_archive_p
6311
6312
#define TARGET_NAME   mach_o_fat_vec
6313
#define TARGET_STRING   "mach-o-fat"
6314
#define TARGET_ARCHITECTURE bfd_arch_unknown
6315
#define TARGET_PAGESIZE   1
6316
#define TARGET_BIG_ENDIAN 1
6317
#define TARGET_ARCHIVE    1
6318
#define TARGET_PRIORITY   0
6319
6320
#include "mach-o-target.c"
6321
6322
#undef TARGET_NAME
6323
#undef TARGET_STRING
6324
#undef TARGET_ARCHITECTURE
6325
#undef TARGET_PAGESIZE
6326
#undef TARGET_BIG_ENDIAN
6327
#undef TARGET_ARCHIVE
6328
#undef TARGET_PRIORITY