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