projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
PowerPC64, support medium model access to common symbols
[deliverable/binutils-gdb.git] / bfd / mach-o.c
CommitLineData
3af9a47b 1/* Mach-O support for BFD.
82704155 2 Copyright (C) 1999-2019 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;
154a1ee5 440 const char *name = bfd_get_section_name (abfd, 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 *
621cpusubtype (unsigned long cputype, unsigned long cpusubtype)
622{
623 static char buffer[128];
624
625 buffer[0] = 0;
626 switch (cpusubtype & BFD_MACH_O_CPU_SUBTYPE_MASK)
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
636 cpusubtype &= ~ BFD_MACH_O_CPU_SUBTYPE_MASK;
637
638 switch (cputype)
639 {
640 case BFD_MACH_O_CPU_TYPE_X86_64:
641 case BFD_MACH_O_CPU_TYPE_I386:
642 switch (cpusubtype)
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
NC		 651 case BFD_MACH_O_CPU_TYPE_ARM:
652 switch (cpusubtype)
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
NC		 671 case BFD_MACH_O_CPU_TYPE_ARM64:
672 switch (cpusubtype)
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
687 if (cpusubtype != 0)
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;
2557
2558 nsect = bfd_count_sections (abfd);
68ffbac6 2559
7f307238
IS		 2560 /* Don't do it if it's already set - assume the application knows what it's
2561 doing. */
2562 if (mdata->nsects == nsect
2563 && (mdata->nsects == 0 || mdata->sections != NULL))
2564 return TRUE;
2565
a1165289
NC		 2566 /* We need to check that this can be done... */
2567 if (nsect > 255)
2568 {
4eca0228
AM		 2569 _bfd_error_handler (_("mach-o: there are too many sections (%u)"
2570 " maximum is 255,\n"), nsect);
a1165289
NC		 2571 return FALSE;
2572 }
2573
7f307238 2574 mdata->nsects = nsect;
64d29018
NC		 2575 mdata->sections = bfd_alloc2 (abfd,
2576 mdata->nsects, sizeof (bfd_mach_o_section *));
7f307238
IS		 2577 if (mdata->sections == NULL)
2578 return FALSE;
2579
7f307238 2580 /* Create Mach-O sections.
68ffbac6 2581 Section type, attribute and align should have been set when the
7f307238
IS		 2582 section was created - either read in or specified. */
2583 target_index = 0;
2584 for (sec = abfd->sections; sec; sec = sec->next)
2585 {
2586 unsigned bfd_align = bfd_get_section_alignment (abfd, sec);
2587 bfd_mach_o_section *msect = bfd_mach_o_get_mach_o_section (sec);
2588
2589 mdata->sections[target_index] = msect;
2590
2591 msect->addr = bfd_get_section_vma (abfd, sec);
2592 msect->size = bfd_get_section_size (sec);
2593
68ffbac6 2594 /* Use the largest alignment set, in case it was bumped after the
7f307238
IS		 2595 section was created. */
2596 msect->align = msect->align > bfd_align ? msect->align : bfd_align;
2597
2598 msect->offset = 0;
2599 sec->target_index = ++target_index;
92bc0e80 2600 }
7f307238 2601
92bc0e80
TG		 2602 return TRUE;
2603}
2604
154a1ee5 2605bfd_boolean
116c20d2 2606bfd_mach_o_write_contents (bfd *abfd)
3af9a47b 2607{
046b007d 2608 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
c9ffd2ea
TG		 2609 bfd_mach_o_load_command *cmd;
2610 bfd_mach_o_symtab_command *symtab = NULL;
2611 bfd_mach_o_dysymtab_command *dysymtab = NULL;
2612 bfd_mach_o_segment_command *linkedit = NULL;
3af9a47b 2613
7f307238 2614 /* Make the commands, if not already present. */
c9ffd2ea
TG		 2615 if (!abfd->output_has_begun && !bfd_mach_o_build_commands (abfd))
2616 return FALSE;
2617 abfd->output_has_begun = TRUE;
92bc0e80 2618
c9ffd2ea 2619 /* Write the header. */
154a1ee5 2620 if (!bfd_mach_o_write_header (abfd, &mdata->header))
b34976b6 2621 return FALSE;
3af9a47b 2622
c9ffd2ea
TG		 2623 /* First pass: allocate the linkedit segment. */
2624 for (cmd = mdata->first_command; cmd != NULL; cmd = cmd->next)
2625 switch (cmd->type)
2626 {
2627 case BFD_MACH_O_LC_SEGMENT_64:
2628 case BFD_MACH_O_LC_SEGMENT:
2629 if (strcmp (cmd->command.segment.segname, "__LINKEDIT") == 0)
2630 linkedit = &cmd->command.segment;
2631 break;
2632 case BFD_MACH_O_LC_SYMTAB:
2633 symtab = &cmd->command.symtab;
2634 break;
2635 case BFD_MACH_O_LC_DYSYMTAB:
2636 dysymtab = &cmd->command.dysymtab;
2637 break;
2638 case BFD_MACH_O_LC_DYLD_INFO:
2639 {
2640 bfd_mach_o_dyld_info_command *di = &cmd->command.dyld_info;
2641
2642 if (di->rebase_size != 0)
2643 {
2644 di->rebase_off = mdata->filelen;
2645 mdata->filelen += di->rebase_size;
2646 }
2647 if (di->bind_size != 0)
2648 {
2649 di->bind_off = mdata->filelen;
2650 mdata->filelen += di->bind_size;
2651 }
2652 if (di->weak_bind_size != 0)
2653 {
2654 di->weak_bind_off = mdata->filelen;
2655 mdata->filelen += di->weak_bind_size;
2656 }
2657 if (di->lazy_bind_size != 0)
2658 {
2659 di->lazy_bind_off = mdata->filelen;
2660 mdata->filelen += di->lazy_bind_size;
2661 }
2662 if (di->export_size != 0)
2663 {
2664 di->export_off = mdata->filelen;
2665 mdata->filelen += di->export_size;
2666 }
2667 }
2668 break;
2669 case BFD_MACH_O_LC_LOAD_DYLIB:
2670 case BFD_MACH_O_LC_LOAD_DYLINKER:
2671 case BFD_MACH_O_LC_MAIN:
2672 /* Nothing to do. */
2673 break;
2674 default:
4eca0228 2675 _bfd_error_handler
d42c267e
AM		 2676 (_("unable to allocate data for load command %#x"),
2677 cmd->type);
c9ffd2ea
TG		 2678 break;
2679 }
2680
2681 /* Specially handle symtab and dysymtab. */
2682
2683 /* Pre-allocate the symbol table (but not the string table). The reason
2684 is that the dysymtab is after the symbol table but before the string
2685 table (required by the native strip tool). */
2686 if (symtab != NULL)
2687 {
2688 unsigned int symlen;
2689 unsigned int wide = bfd_mach_o_wide_p (abfd);
2690
2691 symlen = wide ? BFD_MACH_O_NLIST_64_SIZE : BFD_MACH_O_NLIST_SIZE;
2692
2693 /* Align for symbols. */
2694 mdata->filelen = FILE_ALIGN (mdata->filelen, wide ? 3 : 2);
2695 symtab->symoff = mdata->filelen;
2696
2697 symtab->nsyms = bfd_get_symcount (abfd);
2698 mdata->filelen += symtab->nsyms * symlen;
2699 }
2700
2701 /* Build the dysymtab. */
2702 if (dysymtab != NULL)
2703 if (!bfd_mach_o_build_dysymtab (abfd, dysymtab))
2704 return FALSE;
2705
2706 /* Write symtab and strtab. */
2707 if (symtab != NULL)
2708 if (!bfd_mach_o_write_symtab_content (abfd, symtab))
2709 return FALSE;
2710
2711 /* Adjust linkedit size. */
2712 if (linkedit != NULL)
2713 {
2714 /* bfd_vma pagemask = bfd_mach_o_get_backend_data (abfd)->page_size - 1; */
2715
2716 linkedit->vmsize = mdata->filelen - linkedit->fileoff;
2717 /* linkedit->vmsize = (linkedit->vmsize + pagemask) & ~pagemask; */
2718 linkedit->filesize = mdata->filelen - linkedit->fileoff;
2719
2720 linkedit->initprot = BFD_MACH_O_PROT_READ;
2721 linkedit->maxprot = BFD_MACH_O_PROT_READ | BFD_MACH_O_PROT_WRITE
2722 | BFD_MACH_O_PROT_EXECUTE;
2723 }
2724
2725 /* Second pass: write commands. */
2726 for (cmd = mdata->first_command; cmd != NULL; cmd = cmd->next)
3af9a47b 2727 {
46d1c23b 2728 struct mach_o_load_command_external raw;
3af9a47b
NC		 2729 unsigned long typeflag;
2730
c9ffd2ea 2731 typeflag = cmd->type | (cmd->type_required ? BFD_MACH_O_LC_REQ_DYLD : 0);
3af9a47b 2732
46d1c23b 2733 bfd_h_put_32 (abfd, typeflag, raw.cmd);
c9ffd2ea 2734 bfd_h_put_32 (abfd, cmd->len, raw.cmdsize);
3af9a47b 2735
c9ffd2ea 2736 if (bfd_seek (abfd, cmd->offset, SEEK_SET) != 0
07d6d2b8 2737 || bfd_bwrite (&raw, BFD_MACH_O_LC_SIZE, abfd) != 8)
b34976b6 2738 return FALSE;
3af9a47b 2739
c9ffd2ea 2740 switch (cmd->type)
3af9a47b
NC		 2741 {
2742 case BFD_MACH_O_LC_SEGMENT:
c9ffd2ea 2743 if (!bfd_mach_o_write_segment_32 (abfd, cmd))
1e8a024a
TG		 2744 return FALSE;
2745 break;
2746 case BFD_MACH_O_LC_SEGMENT_64:
c9ffd2ea 2747 if (!bfd_mach_o_write_segment_64 (abfd, cmd))
b34976b6 2748 return FALSE;
3af9a47b
NC		 2749 break;
2750 case BFD_MACH_O_LC_SYMTAB:
c9ffd2ea 2751 if (!bfd_mach_o_write_symtab (abfd, cmd))
b34976b6 2752 return FALSE;
3af9a47b 2753 break;
7f307238 2754 case BFD_MACH_O_LC_DYSYMTAB:
c9ffd2ea 2755 if (!bfd_mach_o_write_dysymtab (abfd, cmd))
7f307238
IS		 2756 return FALSE;
2757 break;
3af9a47b
NC		 2758 case BFD_MACH_O_LC_THREAD:
2759 case BFD_MACH_O_LC_UNIXTHREAD:
c9ffd2ea 2760 if (!bfd_mach_o_write_thread (abfd, cmd))
b34976b6 2761 return FALSE;
3af9a47b 2762 break;
3af9a47b 2763 case BFD_MACH_O_LC_LOAD_DYLIB:
c9ffd2ea
TG		 2764 if (!bfd_mach_o_write_dylib (abfd, cmd))
2765 return FALSE;
2766 break;
3af9a47b 2767 case BFD_MACH_O_LC_LOAD_DYLINKER:
c9ffd2ea
TG		 2768 if (!bfd_mach_o_write_dylinker (abfd, cmd))
2769 return FALSE;
2770 break;
2771 case BFD_MACH_O_LC_MAIN:
2772 if (!bfd_mach_o_write_main (abfd, cmd))
2773 return FALSE;
2774 break;
2775 case BFD_MACH_O_LC_DYLD_INFO:
2776 if (!bfd_mach_o_write_dyld_info (abfd, cmd))
2777 return FALSE;
3af9a47b
NC		 2778 break;
2779 default:
4eca0228 2780 _bfd_error_handler
d42c267e
AM		 2781 (_("unable to write unknown load command %#x"),
2782 cmd->type);
b34976b6 2783 return FALSE;
3af9a47b
NC		 2784 }
2785 }
2786
b34976b6 2787 return TRUE;
3af9a47b
NC		 2788}
2789
f1bde64c
TG		 2790static void
2791bfd_mach_o_append_section_to_segment (bfd_mach_o_segment_command *seg,
07d6d2b8 2792 bfd_mach_o_section *s)
f1bde64c 2793{
f1bde64c
TG		 2794 if (seg->sect_head == NULL)
2795 seg->sect_head = s;
2796 else
2797 seg->sect_tail->next = s;
2798 seg->sect_tail = s;
2799}
2800
2801/* Create section Mach-O flags from BFD flags. */
2802
2803static void
3cc27770
TG		 2804bfd_mach_o_set_section_flags_from_bfd (bfd *abfd ATTRIBUTE_UNUSED,
2805 asection *sec)
f1bde64c
TG		 2806{
2807 flagword bfd_flags;
2808 bfd_mach_o_section *s = bfd_mach_o_get_mach_o_section (sec);
2809
2810 /* Create default flags. */
2811 bfd_flags = bfd_get_section_flags (abfd, sec);
2812 if ((bfd_flags & SEC_CODE) == SEC_CODE)
2813 s->flags = BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS
2814 | BFD_MACH_O_S_ATTR_SOME_INSTRUCTIONS
2815 | BFD_MACH_O_S_REGULAR;
2816 else if ((bfd_flags & (SEC_ALLOC | SEC_LOAD)) == SEC_ALLOC)
2817 s->flags = BFD_MACH_O_S_ZEROFILL;
2818 else if (bfd_flags & SEC_DEBUGGING)
2819 s->flags = BFD_MACH_O_S_REGULAR | BFD_MACH_O_S_ATTR_DEBUG;
2820 else
2821 s->flags = BFD_MACH_O_S_REGULAR;
2822}
2823
7f307238 2824static bfd_boolean
c9ffd2ea 2825bfd_mach_o_build_obj_seg_command (bfd *abfd, bfd_mach_o_segment_command *seg)
7f307238 2826{
c9ffd2ea
TG		 2827 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
2828 unsigned int i, j;
7f307238 2829
7f307238 2830 seg->vmaddr = 0;
7f307238 2831 seg->fileoff = mdata->filelen;
c9ffd2ea
TG		 2832 seg->initprot = BFD_MACH_O_PROT_READ | BFD_MACH_O_PROT_WRITE
2833 | BFD_MACH_O_PROT_EXECUTE;
2834 seg->maxprot = seg->initprot;
7f307238 2835
68ffbac6 2836 /* Append sections to the segment.
09903f4b
IS		 2837
2838 This is a little tedious, we have to honor the need to account zerofill
2839 sections after all the rest. This forces us to do the calculation of
68ffbac6 2840 total vmsize in three passes so that any alignment increments are
09903f4b 2841 properly accounted. */
7f307238
IS		 2842 for (i = 0; i < mdata->nsects; ++i)
2843 {
2844 bfd_mach_o_section *s = mdata->sections[i];
2845 asection *sec = s->bfdsection;
2846
09903f4b
IS		 2847 /* Although we account for zerofill section sizes in vm order, they are
2848 placed in the file in source sequence. */
c9ffd2ea 2849 bfd_mach_o_append_section_to_segment (seg, s);
e5081f2f 2850 s->offset = 0;
68ffbac6 2851
c9ffd2ea
TG		 2852 /* Zerofill sections have zero file size & offset, the only content
2853 written to the file is the symbols. */
e5081f2f 2854 if ((s->flags & BFD_MACH_O_SECTION_TYPE_MASK) == BFD_MACH_O_S_ZEROFILL
07d6d2b8 2855 || ((s->flags & BFD_MACH_O_SECTION_TYPE_MASK)
c9ffd2ea 2856 == BFD_MACH_O_S_GB_ZEROFILL))
07d6d2b8 2857 continue;
e5081f2f 2858
c9ffd2ea
TG		 2859 /* The Darwin system tools (in MH_OBJECT files, at least) always account
2860 sections, even those with zero size. */
e5081f2f 2861 if (s->size > 0)
c9ffd2ea 2862 {
09903f4b
IS		 2863 seg->vmsize = FILE_ALIGN (seg->vmsize, s->align);
2864 seg->vmsize += s->size;
2865
c9ffd2ea
TG		 2866 /* MH_OBJECT files have unaligned content. */
2867 if (1)
2868 {
2869 seg->filesize = FILE_ALIGN (seg->filesize, s->align);
07d6d2b8
AM		 2870 mdata->filelen = FILE_ALIGN (mdata->filelen, s->align);
2871 }
09903f4b
IS		 2872 seg->filesize += s->size;
2873
c9ffd2ea
TG		 2874 /* The system tools write even zero-sized sections with an offset
2875 field set to the current file position. */
07d6d2b8 2876 s->offset = mdata->filelen;
c9ffd2ea 2877 }
7f307238
IS		 2878
2879 sec->filepos = s->offset;
7f307238
IS		 2880 mdata->filelen += s->size;
2881 }
2882
3cc27770 2883 /* Now pass through again, for zerofill, only now we just update the
c9ffd2ea
TG		 2884 vmsize, and then for zerofill_GB. */
2885 for (j = 0; j < 2; j++)
09903f4b 2886 {
c9ffd2ea 2887 unsigned int stype;
68ffbac6 2888
c9ffd2ea
TG		 2889 if (j == 0)
2890 stype = BFD_MACH_O_S_ZEROFILL;
2891 else
2892 stype = BFD_MACH_O_S_GB_ZEROFILL;
09903f4b 2893
c9ffd2ea
TG		 2894 for (i = 0; i < mdata->nsects; ++i)
2895 {
2896 bfd_mach_o_section *s = mdata->sections[i];
2897
2898 if ((s->flags & BFD_MACH_O_SECTION_TYPE_MASK) != stype)
2899 continue;
2900
2901 if (s->size > 0)
2902 {
2903 seg->vmsize = FILE_ALIGN (seg->vmsize, s->align);
2904 seg->vmsize += s->size;
2905 }
09903f4b
IS		 2906 }
2907 }
bb76d940 2908
09903f4b 2909 /* Allocate space for the relocations. */
707e555b 2910 mdata->filelen = FILE_ALIGN (mdata->filelen, 2);
bb76d940
IS		 2911
2912 for (i = 0; i < mdata->nsects; ++i)
2913 {
2914 bfd_mach_o_section *ms = mdata->sections[i];
2915 asection *sec = ms->bfdsection;
68ffbac6 2916
c9ffd2ea
TG		 2917 ms->nreloc = sec->reloc_count;
2918 if (ms->nreloc == 0)
07d6d2b8 2919 {
c9ffd2ea 2920 /* Clear nreloc and reloff if there is no relocs. */
bb76d940
IS		 2921 ms->reloff = 0;
2922 continue;
07d6d2b8 2923 }
bb76d940
IS		 2924 sec->rel_filepos = mdata->filelen;
2925 ms->reloff = sec->rel_filepos;
2926 mdata->filelen += sec->reloc_count * BFD_MACH_O_RELENT_SIZE;
2927 }
7f307238
IS		 2928
2929 return TRUE;
2930}
2931
c9ffd2ea
TG		 2932static bfd_boolean
2933bfd_mach_o_build_exec_seg_command (bfd *abfd, bfd_mach_o_segment_command *seg)
50d10658 2934{
c9ffd2ea 2935 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
50d10658 2936 unsigned int i;
c9ffd2ea
TG		 2937 bfd_vma pagemask = bfd_mach_o_get_backend_data (abfd)->page_size - 1;
2938 bfd_vma vma;
2939 bfd_mach_o_section *s;
2940
2941 seg->vmsize = 0;
50d10658 2942
c9ffd2ea
TG		 2943 seg->fileoff = mdata->filelen;
2944 seg->maxprot = 0;
2945 seg->initprot = 0;
2946 seg->flags = 0;
2947
2948 /* Append sections to the segment. We assume they are properly ordered
2949 by vma (but we check that). */
2950 vma = 0;
50d10658
IS		 2951 for (i = 0; i < mdata->nsects; ++i)
2952 {
c9ffd2ea 2953 s = mdata->sections[i];
50d10658 2954
c9ffd2ea
TG		 2955 /* Consider only sections for this segment. */
2956 if (strcmp (seg->segname, s->segname) != 0)
2957 continue;
50d10658 2958
c9ffd2ea 2959 bfd_mach_o_append_section_to_segment (seg, s);
7f307238 2960
86eafac0
NC		 2961 if (s->addr < vma)
2962 {
4eca0228 2963 _bfd_error_handler
695344c0 2964 /* xgettext:c-format */
2dcf00ce
AM		 2965 (_("section address (%#" PRIx64 ") "
2966 "below start of segment (%#" PRIx64 ")"),
2967 (uint64_t) s->addr, (uint64_t) vma);
86eafac0
NC		 2968 return FALSE;
2969 }
2970
c9ffd2ea 2971 vma = s->addr + s->size;
7f307238
IS		 2972 }
2973
c9ffd2ea
TG		 2974 /* Set segment file offset: make it page aligned. */
2975 vma = seg->sect_head->addr;
2976 seg->vmaddr = vma & ~pagemask;
2977 if ((mdata->filelen & pagemask) > (vma & pagemask))
2978 mdata->filelen += pagemask + 1;
2979 seg->fileoff = mdata->filelen & ~pagemask;
2980 mdata->filelen = seg->fileoff + (vma & pagemask);
7f307238 2981
c9ffd2ea
TG		 2982 /* Set section file offset. */
2983 for (s = seg->sect_head; s != NULL; s = s->next)
7f307238 2984 {
c9ffd2ea
TG		 2985 asection *sec = s->bfdsection;
2986 flagword flags = bfd_get_section_flags (abfd, sec);
b22161d6 2987
c9ffd2ea
TG		 2988 /* Adjust segment size. */
2989 seg->vmsize = FILE_ALIGN (seg->vmsize, s->align);
2990 seg->vmsize += s->size;
2991
2992 /* File offset and length. */
2993 seg->filesize = FILE_ALIGN (seg->filesize, s->align);
2994
2995 if ((s->flags & BFD_MACH_O_SECTION_TYPE_MASK) != BFD_MACH_O_S_ZEROFILL
07d6d2b8 2996 && ((s->flags & BFD_MACH_O_SECTION_TYPE_MASK)
c9ffd2ea 2997 != BFD_MACH_O_S_GB_ZEROFILL))
b22161d6 2998 {
c9ffd2ea
TG		 2999 mdata->filelen = FILE_ALIGN (mdata->filelen, s->align);
3000
3001 s->offset = mdata->filelen;
3002 s->bfdsection->filepos = s->offset;
3003
3004 seg->filesize += s->size;
3005 mdata->filelen += s->size;
b22161d6 3006 }
c9ffd2ea 3007 else
b22161d6 3008 {
c9ffd2ea
TG		 3009 s->offset = 0;
3010 s->bfdsection->filepos = 0;
3011 }
3012
3013 /* Set protection. */
3014 if (flags & SEC_LOAD)
3015 {
3016 if (flags & SEC_CODE)
3017 seg->initprot |= BFD_MACH_O_PROT_READ | BFD_MACH_O_PROT_EXECUTE;
3018 if ((flags & (SEC_DATA | SEC_READONLY)) == SEC_DATA)
3019 seg->initprot |= BFD_MACH_O_PROT_WRITE | BFD_MACH_O_PROT_READ;
b22161d6 3020 }
c9ffd2ea
TG		 3021
3022 /* Relocs shouldn't appear in non-object files. */
3023 if (s->bfdsection->reloc_count != 0)
3024 return FALSE;
b22161d6 3025 }
c9ffd2ea
TG		 3026
3027 /* Set maxprot. */
3028 if (seg->initprot != 0)
3029 seg->maxprot = BFD_MACH_O_PROT_READ | BFD_MACH_O_PROT_WRITE
3030 | BFD_MACH_O_PROT_EXECUTE;
b22161d6 3031 else
c9ffd2ea 3032 seg->maxprot = 0;
b22161d6 3033
c9ffd2ea
TG		 3034 /* Round segment size (and file size). */
3035 seg->vmsize = (seg->vmsize + pagemask) & ~pagemask;
3036 seg->filesize = (seg->filesize + pagemask) & ~pagemask;
3037 mdata->filelen = (mdata->filelen + pagemask) & ~pagemask;
7f307238 3038
c9ffd2ea
TG		 3039 return TRUE;
3040}
68ffbac6 3041
c9ffd2ea
TG		 3042/* Layout the commands: set commands size and offset, set ncmds and sizeofcmds
3043 fields in header. */
68ffbac6 3044
86eafac0 3045static bfd_boolean
c9ffd2ea
TG		 3046bfd_mach_o_layout_commands (bfd_mach_o_data_struct *mdata)
3047{
3048 unsigned wide = mach_o_wide_p (&mdata->header);
3049 unsigned int hdrlen;
3050 ufile_ptr offset;
3051 bfd_mach_o_load_command *cmd;
3052 unsigned int align;
86eafac0 3053 bfd_boolean ret = TRUE;
c9ffd2ea
TG		 3054
3055 hdrlen = wide ? BFD_MACH_O_HEADER_64_SIZE : BFD_MACH_O_HEADER_SIZE;
3056 align = wide ? 8 - 1 : 4 - 1;
3057 offset = hdrlen;
3058 mdata->header.ncmds = 0;
50d10658 3059
c9ffd2ea
TG		 3060 for (cmd = mdata->first_command; cmd; cmd = cmd->next)
3061 {
3062 mdata->header.ncmds++;
3063 cmd->offset = offset;
68ffbac6 3064
c9ffd2ea
TG		 3065 switch (cmd->type)
3066 {
3067 case BFD_MACH_O_LC_SEGMENT_64:
3068 cmd->len = BFD_MACH_O_LC_SEGMENT_64_SIZE
3069 + BFD_MACH_O_SECTION_64_SIZE * cmd->command.segment.nsects;
3070 break;
3071 case BFD_MACH_O_LC_SEGMENT:
3072 cmd->len = BFD_MACH_O_LC_SEGMENT_SIZE
3073 + BFD_MACH_O_SECTION_SIZE * cmd->command.segment.nsects;
3074 break;
3075 case BFD_MACH_O_LC_SYMTAB:
3076 cmd->len = sizeof (struct mach_o_symtab_command_external)
3077 + BFD_MACH_O_LC_SIZE;
3078 break;
3079 case BFD_MACH_O_LC_DYSYMTAB:
3080 cmd->len = sizeof (struct mach_o_dysymtab_command_external)
3081 + BFD_MACH_O_LC_SIZE;
3082 break;
3083 case BFD_MACH_O_LC_LOAD_DYLIB:
3084 cmd->len = sizeof (struct mach_o_dylib_command_external)
3085 + BFD_MACH_O_LC_SIZE;
3086 cmd->command.dylib.name_offset = cmd->len;
3087 cmd->len += strlen (cmd->command.dylib.name_str);
3088 cmd->len = (cmd->len + align) & ~align;
3089 break;
3090 case BFD_MACH_O_LC_LOAD_DYLINKER:
3091 cmd->len = sizeof (struct mach_o_str_command_external)
3092 + BFD_MACH_O_LC_SIZE;
3093 cmd->command.dylinker.name_offset = cmd->len;
3094 cmd->len += strlen (cmd->command.dylinker.name_str);
3095 cmd->len = (cmd->len + align) & ~align;
3096 break;
3097 case BFD_MACH_O_LC_MAIN:
3098 cmd->len = sizeof (struct mach_o_entry_point_command_external)
3099 + BFD_MACH_O_LC_SIZE;
3100 break;
3101 case BFD_MACH_O_LC_DYLD_INFO:
3102 cmd->len = sizeof (struct mach_o_dyld_info_command_external)
3103 + BFD_MACH_O_LC_SIZE;
3104 break;
3105 default:
4eca0228 3106 _bfd_error_handler
d42c267e
AM		 3107 (_("unable to layout unknown load command %#x"),
3108 cmd->type);
86eafac0 3109 ret = FALSE;
c9ffd2ea 3110 break;
7f307238 3111 }
c9ffd2ea
TG		 3112
3113 BFD_ASSERT (cmd->len % (align + 1) == 0);
3114 offset += cmd->len;
7f307238 3115 }
c9ffd2ea
TG		 3116 mdata->header.sizeofcmds = offset - hdrlen;
3117 mdata->filelen = offset;
86eafac0
NC		 3118
3119 return ret;
c9ffd2ea 3120}
7f307238 3121
c9ffd2ea
TG		 3122/* Subroutine of bfd_mach_o_build_commands: set type, name and nsects of a
3123 segment. */
3124
3125static void
3126bfd_mach_o_init_segment (bfd_mach_o_data_struct *mdata,
3127 bfd_mach_o_load_command *cmd,
3128 const char *segname, unsigned int nbr_sect)
3129{
3130 bfd_mach_o_segment_command *seg = &cmd->command.segment;
3131 unsigned wide = mach_o_wide_p (&mdata->header);
3132
3133 /* Init segment command. */
3134 cmd->type = wide ? BFD_MACH_O_LC_SEGMENT_64 : BFD_MACH_O_LC_SEGMENT;
3135 cmd->type_required = FALSE;
3136
3137 strcpy (seg->segname, segname);
3138 seg->nsects = nbr_sect;
3139
3140 seg->vmaddr = 0;
3141 seg->vmsize = 0;
3142
3143 seg->fileoff = 0;
3144 seg->filesize = 0;
3145 seg->maxprot = 0;
3146 seg->initprot = 0;
3147 seg->flags = 0;
3148 seg->sect_head = NULL;
3149 seg->sect_tail = NULL;
7f307238
IS		 3150}
3151
3152/* Build Mach-O load commands (currently assuming an MH_OBJECT file).
3153 TODO: Other file formats, rebuilding symtab/dysymtab commands for strip
3154 and copy functionality. */
154a1ee5
TG		 3155
3156bfd_boolean
3157bfd_mach_o_build_commands (bfd *abfd)
3158{
046b007d 3159 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
bbd56171 3160 unsigned wide = mach_o_wide_p (&mdata->header);
c9ffd2ea
TG		 3161 unsigned int nbr_segcmd = 0;
3162 bfd_mach_o_load_command *commands;
3163 unsigned int nbr_commands;
bbd56171
IS		 3164 int symtab_idx = -1;
3165 int dysymtab_idx = -1;
c9ffd2ea
TG		 3166 int main_idx = -1;
3167 unsigned int i;
154a1ee5 3168
c9ffd2ea
TG		 3169 /* Return now if already built. */
3170 if (mdata->header.ncmds != 0)
3171 return TRUE;
154a1ee5 3172
7f307238 3173 /* Fill in the file type, if not already set. */
7f307238 3174 if (mdata->header.filetype == 0)
154a1ee5 3175 {
7f307238 3176 if (abfd->flags & EXEC_P)
07d6d2b8 3177 mdata->header.filetype = BFD_MACH_O_MH_EXECUTE;
7f307238 3178 else if (abfd->flags & DYNAMIC)
07d6d2b8 3179 mdata->header.filetype = BFD_MACH_O_MH_DYLIB;
7f307238 3180 else
07d6d2b8 3181 mdata->header.filetype = BFD_MACH_O_MH_OBJECT;
154a1ee5 3182 }
7f307238
IS		 3183
3184 /* If hasn't already been done, flatten sections list, and sort
3185 if/when required. Must be done before the symbol table is adjusted,
3186 since that depends on properly numbered sections. */
3187 if (mdata->nsects == 0 || mdata->sections == NULL)
3188 if (! bfd_mach_o_mangle_sections (abfd, mdata))
3189 return FALSE;
3190
3191 /* Order the symbol table, fill-in/check mach-o specific fields and
3192 partition out any indirect symbols. */
b22161d6 3193 if (!bfd_mach_o_mangle_symbols (abfd))
7f307238
IS		 3194 return FALSE;
3195
c9ffd2ea
TG		 3196 /* Segment commands. */
3197 if (mdata->header.filetype == BFD_MACH_O_MH_OBJECT)
3198 {
3199 /* Only one segment for all the sections. But the segment is
3200 optional if there is no sections. */
3201 nbr_segcmd = (mdata->nsects > 0) ? 1 : 0;
3202 }
3203 else
3204 {
3205 bfd_mach_o_section *prev_sect = NULL;
bbd56171 3206
c9ffd2ea
TG		 3207 /* One pagezero segment and one linkedit segment. */
3208 nbr_segcmd = 2;
bbd56171 3209
c9ffd2ea
TG		 3210 /* Create one segment for associated segment name in sections.
3211 Assume that sections with the same segment name are consecutive. */
3212 for (i = 0; i < mdata->nsects; i++)
3213 {
3214 bfd_mach_o_section *this_sect = mdata->sections[i];
bbd56171 3215
c9ffd2ea
TG		 3216 if (prev_sect == NULL
3217 || strcmp (prev_sect->segname, this_sect->segname) != 0)
3218 {
3219 nbr_segcmd++;
3220 prev_sect = this_sect;
3221 }
3222 }
154a1ee5 3223 }
154a1ee5 3224
c9ffd2ea
TG		 3225 nbr_commands = nbr_segcmd;
3226
3227 /* One command for the symbol table (only if there are symbols. */
7f307238 3228 if (bfd_get_symcount (abfd) > 0)
c9ffd2ea 3229 symtab_idx = nbr_commands++;
c2f09c75 3230
bbd56171
IS		 3231 /* FIXME:
3232 This is a rather crude test for whether we should build a dysymtab. */
3233 if (bfd_mach_o_should_emit_dysymtab ()
3234 && bfd_get_symcount (abfd))
3235 {
bbd56171
IS		 3236 /* If there should be a case where a dysymtab could be emitted without
3237 a symtab (seems improbable), this would need amending. */
c9ffd2ea 3238 dysymtab_idx = nbr_commands++;
bbd56171 3239 }
154a1ee5 3240
c9ffd2ea
TG		 3241 /* Add an entry point command. */
3242 if (mdata->header.filetype == BFD_MACH_O_MH_EXECUTE
3243 && bfd_get_start_address (abfd) != 0)
3244 main_idx = nbr_commands++;
c2f09c75 3245
bbd56171 3246 /* Well, we must have a header, at least. */
c9ffd2ea 3247 mdata->filelen = wide ? BFD_MACH_O_HEADER_64_SIZE : BFD_MACH_O_HEADER_SIZE;
f1bde64c 3248
bbd56171 3249 /* A bit unusual, but no content is valid;
7f307238 3250 as -n empty.s -o empty.o */
c9ffd2ea
TG		 3251 if (nbr_commands == 0)
3252 {
3253 /* Layout commands (well none...) and set headers command fields. */
86eafac0 3254 return bfd_mach_o_layout_commands (mdata);
c9ffd2ea 3255 }
f1bde64c 3256
c9ffd2ea
TG		 3257 /* Create commands for segments (and symtabs), prepend them. */
3258 commands = bfd_zalloc (abfd, nbr_commands * sizeof (bfd_mach_o_load_command));
3259 if (commands == NULL)
7f307238 3260 return FALSE;
c9ffd2ea
TG		 3261 for (i = 0; i < nbr_commands - 1; i++)
3262 commands[i].next = &commands[i + 1];
3263 commands[nbr_commands - 1].next = mdata->first_command;
3264 if (mdata->first_command == NULL)
3265 mdata->last_command = &commands[nbr_commands - 1];
3266 mdata->first_command = &commands[0];
3267
3268 if (mdata->header.filetype == BFD_MACH_O_MH_OBJECT && nbr_segcmd != 0)
3269 {
3270 /* For object file, there is only one segment. */
3271 bfd_mach_o_init_segment (mdata, &commands[0], "", mdata->nsects);
3272 }
3273 else if (nbr_segcmd != 0)
68ffbac6 3274 {
c9ffd2ea 3275 bfd_mach_o_load_command *cmd;
7f307238 3276
c9ffd2ea 3277 BFD_ASSERT (nbr_segcmd >= 2);
7f307238 3278
c9ffd2ea
TG		 3279 /* The pagezero. */
3280 cmd = &commands[0];
3281 bfd_mach_o_init_segment (mdata, cmd, "__PAGEZERO", 0);
3282
3283 /* Segments from sections. */
3284 cmd++;
3285 for (i = 0; i < mdata->nsects;)
7f307238 3286 {
c9ffd2ea
TG		 3287 const char *segname = mdata->sections[i]->segname;
3288 unsigned int nbr_sect = 1;
3289
3290 /* Count number of sections for this segment. */
3291 for (i++; i < mdata->nsects; i++)
3292 if (strcmp (mdata->sections[i]->segname, segname) == 0)
3293 nbr_sect++;
3294 else
3295 break;
3296
3297 bfd_mach_o_init_segment (mdata, cmd, segname, nbr_sect);
3298 cmd++;
7f307238 3299 }
bbd56171 3300
c9ffd2ea
TG		 3301 /* The linkedit. */
3302 bfd_mach_o_init_segment (mdata, cmd, "__LINKEDIT", 0);
7f307238 3303 }
f1bde64c 3304
bbd56171 3305 if (symtab_idx >= 0)
7f307238
IS		 3306 {
3307 /* Init symtab command. */
c9ffd2ea 3308 bfd_mach_o_load_command *cmd = &commands[symtab_idx];
68ffbac6 3309
bbd56171 3310 cmd->type = BFD_MACH_O_LC_SYMTAB;
bbd56171 3311 cmd->type_required = FALSE;
7f307238 3312 }
154a1ee5 3313
bbd56171
IS		 3314 /* If required, setup symtab command, see comment above about the quality
3315 of this test. */
3316 if (dysymtab_idx >= 0)
7f307238 3317 {
c9ffd2ea 3318 bfd_mach_o_load_command *cmd = &commands[dysymtab_idx];
bbd56171 3319
7f307238 3320 cmd->type = BFD_MACH_O_LC_DYSYMTAB;
7f307238 3321 cmd->type_required = FALSE;
c9ffd2ea
TG		 3322 }
3323
3324 /* Create the main command. */
3325 if (main_idx >= 0)
3326 {
3327 bfd_mach_o_load_command *cmd = &commands[main_idx];
7f307238 3328
c9ffd2ea
TG		 3329 cmd->type = BFD_MACH_O_LC_MAIN;
3330 cmd->type_required = TRUE;
3331
3332 cmd->command.main.entryoff = 0;
3333 cmd->command.main.stacksize = 0;
154a1ee5 3334 }
154a1ee5 3335
c9ffd2ea 3336 /* Layout commands. */
86eafac0
NC		 3337 if (! bfd_mach_o_layout_commands (mdata))
3338 return FALSE;
c9ffd2ea 3339
7f307238
IS		 3340 /* So, now we have sized the commands and the filelen set to that.
3341 Now we can build the segment command and set the section file offsets. */
c9ffd2ea
TG		 3342 if (mdata->header.filetype == BFD_MACH_O_MH_OBJECT)
3343 {
3344 for (i = 0; i < nbr_segcmd; i++)
3345 if (!bfd_mach_o_build_obj_seg_command
3346 (abfd, &commands[i].command.segment))
3347 return FALSE;
3348 }
3349 else
3350 {
3351 bfd_vma maxvma = 0;
7f307238 3352
c9ffd2ea
TG		 3353 /* Skip pagezero and linkedit segments. */
3354 for (i = 1; i < nbr_segcmd - 1; i++)
3355 {
3356 bfd_mach_o_segment_command *seg = &commands[i].command.segment;
3357
3358 if (!bfd_mach_o_build_exec_seg_command (abfd, seg))
3359 return FALSE;
3360
3361 if (seg->vmaddr + seg->vmsize > maxvma)
3362 maxvma = seg->vmaddr + seg->vmsize;
3363 }
3364
3365 /* Set the size of __PAGEZERO. */
3366 commands[0].command.segment.vmsize =
3367 commands[1].command.segment.vmaddr;
3368
3369 /* Set the vma and fileoff of __LINKEDIT. */
3370 commands[nbr_segcmd - 1].command.segment.vmaddr = maxvma;
3371 commands[nbr_segcmd - 1].command.segment.fileoff = mdata->filelen;
3372
3373 /* Set entry point (once segments have been laid out). */
3374 if (main_idx >= 0)
3375 commands[main_idx].command.main.entryoff =
3376 bfd_get_start_address (abfd) - commands[1].command.segment.vmaddr;
3377 }
7f307238 3378
154a1ee5
TG		 3379 return TRUE;
3380}
3381
3382/* Set the contents of a section. */
3383
3384bfd_boolean
3385bfd_mach_o_set_section_contents (bfd *abfd,
3386 asection *section,
3387 const void * location,
3388 file_ptr offset,
3389 bfd_size_type count)
3390{
3391 file_ptr pos;
3392
7f307238
IS		 3393 /* Trying to write the first section contents will trigger the creation of
3394 the load commands if they are not already present. */
c9ffd2ea 3395 if (!abfd->output_has_begun && !bfd_mach_o_build_commands (abfd))
154a1ee5
TG		 3396 return FALSE;
3397
3398 if (count == 0)
3399 return TRUE;
3400
3401 pos = section->filepos + offset;
3402 if (bfd_seek (abfd, pos, SEEK_SET) != 0
3403 || bfd_bwrite (location, count, abfd) != count)
3404 return FALSE;
3405
3406 return TRUE;
3407}
3408
3409int
116c20d2 3410bfd_mach_o_sizeof_headers (bfd *a ATTRIBUTE_UNUSED,
a6b96beb 3411 struct bfd_link_info *info ATTRIBUTE_UNUSED)
3af9a47b
NC		 3412{
3413 return 0;
3414}
3415
3416/* Make an empty symbol. This is required only because
3417 bfd_make_section_anyway wants to create a symbol for the section. */
3418
154a1ee5 3419asymbol *
116c20d2 3420bfd_mach_o_make_empty_symbol (bfd *abfd)
3af9a47b 3421{
d3ce72d0
NC		 3422 asymbol *new_symbol;
3423
3424 new_symbol = bfd_zalloc (abfd, sizeof (bfd_mach_o_asymbol));
3425 if (new_symbol == NULL)
3426 return new_symbol;
3427 new_symbol->the_bfd = abfd;
b22161d6 3428 new_symbol->udata.i = SYM_MACHO_FIELDS_UNSET;
d3ce72d0 3429 return new_symbol;
3af9a47b
NC		 3430}
3431
154a1ee5 3432static bfd_boolean
47daa70f 3433bfd_mach_o_read_header (bfd *abfd, file_ptr hdr_off, bfd_mach_o_header *header)
3af9a47b 3434{
46d1c23b 3435 struct mach_o_header_external raw;
1e8a024a 3436 unsigned int size;
edeb6e24 3437 bfd_vma (*get32) (const void *) = NULL;
3af9a47b 3438
1e8a024a 3439 /* Just read the magic number. */
47daa70f 3440 if (bfd_seek (abfd, hdr_off, SEEK_SET) != 0
46d1c23b 3441 || bfd_bread (raw.magic, sizeof (raw.magic), abfd) != 4)
154a1ee5 3442 return FALSE;
3af9a47b 3443
46d1c23b 3444 if (bfd_getb32 (raw.magic) == BFD_MACH_O_MH_MAGIC)
3af9a47b
NC		 3445 {
3446 header->byteorder = BFD_ENDIAN_BIG;
154a1ee5 3447 header->magic = BFD_MACH_O_MH_MAGIC;
1e8a024a 3448 header->version = 1;
3af9a47b
NC		 3449 get32 = bfd_getb32;
3450 }
46d1c23b 3451 else if (bfd_getl32 (raw.magic) == BFD_MACH_O_MH_MAGIC)
3af9a47b 3452 {
a95a4550 3453 header->byteorder = BFD_ENDIAN_LITTLE;
154a1ee5 3454 header->magic = BFD_MACH_O_MH_MAGIC;
1e8a024a
TG		 3455 header->version = 1;
3456 get32 = bfd_getl32;
3457 }
46d1c23b 3458 else if (bfd_getb32 (raw.magic) == BFD_MACH_O_MH_MAGIC_64)
1e8a024a
TG		 3459 {
3460 header->byteorder = BFD_ENDIAN_BIG;
154a1ee5 3461 header->magic = BFD_MACH_O_MH_MAGIC_64;
1e8a024a
TG		 3462 header->version = 2;
3463 get32 = bfd_getb32;
3464 }
46d1c23b 3465 else if (bfd_getl32 (raw.magic) == BFD_MACH_O_MH_MAGIC_64)
1e8a024a
TG		 3466 {
3467 header->byteorder = BFD_ENDIAN_LITTLE;
154a1ee5 3468 header->magic = BFD_MACH_O_MH_MAGIC_64;
1e8a024a 3469 header->version = 2;
3af9a47b
NC		 3470 get32 = bfd_getl32;
3471 }
3472 else
3473 {
3474 header->byteorder = BFD_ENDIAN_UNKNOWN;
154a1ee5 3475 return FALSE;
3af9a47b 3476 }
a95a4550 3477
1e8a024a 3478 /* Once the size of the header is known, read the full header. */
c2f09c75 3479 size = mach_o_wide_p (header) ?
154a1ee5 3480 BFD_MACH_O_HEADER_64_SIZE : BFD_MACH_O_HEADER_SIZE;
1e8a024a 3481
47daa70f 3482 if (bfd_seek (abfd, hdr_off, SEEK_SET) != 0
46d1c23b 3483 || bfd_bread (&raw, size, abfd) != size)
154a1ee5 3484 return FALSE;
1e8a024a 3485
46d1c23b
TG		 3486 header->cputype = (*get32) (raw.cputype);
3487 header->cpusubtype = (*get32) (raw.cpusubtype);
3488 header->filetype = (*get32) (raw.filetype);
3489 header->ncmds = (*get32) (raw.ncmds);
3490 header->sizeofcmds = (*get32) (raw.sizeofcmds);
3491 header->flags = (*get32) (raw.flags);
3af9a47b 3492
c2f09c75 3493 if (mach_o_wide_p (header))
46d1c23b 3494 header->reserved = (*get32) (raw.reserved);
facf03f2
TG		 3495 else
3496 header->reserved = 0;
1e8a024a 3497
154a1ee5 3498 return TRUE;
3af9a47b
NC		 3499}
3500
f1bde64c
TG		 3501bfd_boolean
3502bfd_mach_o_new_section_hook (bfd *abfd, asection *sec)
3503{
3504 bfd_mach_o_section *s;
a4551119 3505 unsigned bfdalign = bfd_get_section_alignment (abfd, sec);
f1bde64c
TG		 3506
3507 s = bfd_mach_o_get_mach_o_section (sec);
3508 if (s == NULL)
3509 {
3510 flagword bfd_flags;
a4551119 3511 static const mach_o_section_name_xlat * xlat;
f1bde64c
TG		 3512
3513 s = (bfd_mach_o_section *) bfd_zalloc (abfd, sizeof (*s));
3514 if (s == NULL)
3515 return FALSE;
3516 sec->used_by_bfd = s;
3517 s->bfdsection = sec;
3518
a4551119
TG		 3519 /* Create the Darwin seg/sect name pair from the bfd name.
3520 If this is a canonical name for which a specific paiting exists
3521 there will also be defined flags, type, attribute and alignment
3522 values. */
3523 xlat = bfd_mach_o_convert_section_name_to_mach_o (abfd, sec, s);
3524 if (xlat != NULL)
3525 {
3526 s->flags = xlat->macho_sectype | xlat->macho_secattr;
68ffbac6 3527 s->align = xlat->sectalign > bfdalign ? xlat->sectalign
a4551119 3528 : bfdalign;
a253d456 3529 (void) bfd_set_section_alignment (abfd, sec, s->align);
a4551119
TG		 3530 bfd_flags = bfd_get_section_flags (abfd, sec);
3531 if (bfd_flags == SEC_NO_FLAGS)
3532 bfd_set_section_flags (abfd, sec, xlat->bfd_flags);
3533 }
f1bde64c 3534 else
a4551119
TG		 3535 /* Create default flags. */
3536 bfd_mach_o_set_section_flags_from_bfd (abfd, sec);
f1bde64c
TG		 3537 }
3538
3539 return _bfd_generic_new_section_hook (abfd, sec);
3540}
3541
3542static void
3543bfd_mach_o_init_section_from_mach_o (bfd *abfd, asection *sec,
07d6d2b8 3544 unsigned long prot)
3af9a47b 3545{
117ed4f8 3546 flagword flags;
f1bde64c 3547 bfd_mach_o_section *section;
3af9a47b 3548
f1bde64c
TG		 3549 flags = bfd_get_section_flags (abfd, sec);
3550 section = bfd_mach_o_get_mach_o_section (sec);
3af9a47b 3551
a4551119
TG		 3552 /* TODO: see if we should use the xlat system for doing this by
3553 preference and fall back to this for unknown sections. */
3554
8462aec7 3555 if (flags == SEC_NO_FLAGS)
ef17cb22 3556 {
8462aec7
TG		 3557 /* Try to guess flags. */
3558 if (section->flags & BFD_MACH_O_S_ATTR_DEBUG)
07d6d2b8 3559 flags = SEC_DEBUGGING;
8462aec7 3560 else
07d6d2b8
AM		 3561 {
3562 flags = SEC_ALLOC;
3563 if ((section->flags & BFD_MACH_O_SECTION_TYPE_MASK)
3564 != BFD_MACH_O_S_ZEROFILL)
3565 {
3566 flags |= SEC_LOAD;
3567 if (prot & BFD_MACH_O_PROT_EXECUTE)
3568 flags |= SEC_CODE;
3569 if (prot & BFD_MACH_O_PROT_WRITE)
3570 flags |= SEC_DATA;
3571 else if (prot & BFD_MACH_O_PROT_READ)
3572 flags |= SEC_READONLY;
3573 }
3574 }
ef17cb22 3575 }
15e1c58a
TG		 3576 else
3577 {
8462aec7 3578 if ((flags & SEC_DEBUGGING) == 0)
07d6d2b8 3579 flags |= SEC_ALLOC;
15e1c58a 3580 }
8462aec7
TG		 3581
3582 if (section->offset != 0)
3583 flags |= SEC_HAS_CONTENTS;
92bc0e80
TG		 3584 if (section->nreloc != 0)
3585 flags |= SEC_RELOC;
3586
f1bde64c
TG		 3587 bfd_set_section_flags (abfd, sec, flags);
3588
3589 sec->vma = section->addr;
3590 sec->lma = section->addr;
3591 sec->size = section->size;
3592 sec->filepos = section->offset;
3593 sec->alignment_power = section->align;
3594 sec->segment_mark = 0;
3595 sec->reloc_count = section->nreloc;
3596 sec->rel_filepos = section->reloff;
3597}
3598
3599static asection *
3600bfd_mach_o_make_bfd_section (bfd *abfd,
07d6d2b8
AM		 3601 const unsigned char *segname,
3602 const unsigned char *sectname)
f1bde64c
TG		 3603{
3604 const char *sname;
3605 flagword flags;
a95a4550 3606
f1bde64c
TG		 3607 bfd_mach_o_convert_section_name_to_bfd
3608 (abfd, (const char *)segname, (const char *)sectname, &sname, &flags);
3609 if (sname == NULL)
3610 return NULL;
3af9a47b 3611
f1bde64c 3612 return bfd_make_section_anyway_with_flags (abfd, sname, flags);
3af9a47b
NC		 3613}
3614
f1bde64c 3615static asection *
47daa70f 3616bfd_mach_o_read_section_32 (bfd *abfd, unsigned long prot)
3af9a47b 3617{
46d1c23b 3618 struct mach_o_section_32_external raw;
f1bde64c
TG		 3619 asection *sec;
3620 bfd_mach_o_section *section;
3af9a47b 3621
47daa70f
TG		 3622 if (bfd_bread (&raw, BFD_MACH_O_SECTION_SIZE, abfd)
3623 != BFD_MACH_O_SECTION_SIZE)
f1bde64c 3624 return NULL;
a95a4550 3625
5a5cbf72 3626 sec = bfd_mach_o_make_bfd_section (abfd, raw.segname, raw.sectname);
f1bde64c
TG		 3627 if (sec == NULL)
3628 return NULL;
3629
3630 section = bfd_mach_o_get_mach_o_section (sec);
3631 memcpy (section->segname, raw.segname, sizeof (raw.segname));
3632 section->segname[BFD_MACH_O_SEGNAME_SIZE] = 0;
3633 memcpy (section->sectname, raw.sectname, sizeof (raw.sectname));
69499dca 3634 section->sectname[BFD_MACH_O_SECTNAME_SIZE] = 0;
46d1c23b
TG		 3635 section->addr = bfd_h_get_32 (abfd, raw.addr);
3636 section->size = bfd_h_get_32 (abfd, raw.size);
3637 section->offset = bfd_h_get_32 (abfd, raw.offset);
3638 section->align = bfd_h_get_32 (abfd, raw.align);
c86934ce
NC		 3639 /* PR 17512: file: 0017eb76. */
3640 if (section->align > 64)
3641 {
4eca0228 3642 _bfd_error_handler
d42c267e 3643 (_("bfd_mach_o_read_section_32: overlarge alignment value: %#lx, "
4eca0228 3644 "using 32 instead"), section->align);
c86934ce
NC		 3645 section->align = 32;
3646 }
46d1c23b
TG		 3647 section->reloff = bfd_h_get_32 (abfd, raw.reloff);
3648 section->nreloc = bfd_h_get_32 (abfd, raw.nreloc);
3649 section->flags = bfd_h_get_32 (abfd, raw.flags);
3650 section->reserved1 = bfd_h_get_32 (abfd, raw.reserved1);
3651 section->reserved2 = bfd_h_get_32 (abfd, raw.reserved2);
1e8a024a 3652 section->reserved3 = 0;
1e8a024a 3653
f1bde64c 3654 bfd_mach_o_init_section_from_mach_o (abfd, sec, prot);
1e8a024a 3655
f1bde64c 3656 return sec;
1e8a024a
TG		 3657}
3658
f1bde64c 3659static asection *
47daa70f 3660bfd_mach_o_read_section_64 (bfd *abfd, unsigned long prot)
1e8a024a 3661{
46d1c23b 3662 struct mach_o_section_64_external raw;
f1bde64c
TG		 3663 asection *sec;
3664 bfd_mach_o_section *section;
1e8a024a 3665
47daa70f
TG		 3666 if (bfd_bread (&raw, BFD_MACH_O_SECTION_64_SIZE, abfd)
3667 != BFD_MACH_O_SECTION_64_SIZE)
f1bde64c
TG		 3668 return NULL;
3669
5a5cbf72 3670 sec = bfd_mach_o_make_bfd_section (abfd, raw.segname, raw.sectname);
f1bde64c
TG		 3671 if (sec == NULL)
3672 return NULL;
1e8a024a 3673
f1bde64c
TG		 3674 section = bfd_mach_o_get_mach_o_section (sec);
3675 memcpy (section->segname, raw.segname, sizeof (raw.segname));
3676 section->segname[BFD_MACH_O_SEGNAME_SIZE] = 0;
3677 memcpy (section->sectname, raw.sectname, sizeof (raw.sectname));
69499dca 3678 section->sectname[BFD_MACH_O_SECTNAME_SIZE] = 0;
46d1c23b
TG		 3679 section->addr = bfd_h_get_64 (abfd, raw.addr);
3680 section->size = bfd_h_get_64 (abfd, raw.size);
3681 section->offset = bfd_h_get_32 (abfd, raw.offset);
3682 section->align = bfd_h_get_32 (abfd, raw.align);
c86934ce
NC		 3683 if (section->align > 64)
3684 {
4eca0228 3685 _bfd_error_handler
d42c267e 3686 (_("bfd_mach_o_read_section_64: overlarge alignment value: %#lx, "
4eca0228 3687 "using 32 instead"), section->align);
c86934ce
NC		 3688 section->align = 32;
3689 }
46d1c23b
TG		 3690 section->reloff = bfd_h_get_32 (abfd, raw.reloff);
3691 section->nreloc = bfd_h_get_32 (abfd, raw.nreloc);
3692 section->flags = bfd_h_get_32 (abfd, raw.flags);
3693 section->reserved1 = bfd_h_get_32 (abfd, raw.reserved1);
3694 section->reserved2 = bfd_h_get_32 (abfd, raw.reserved2);
3695 section->reserved3 = bfd_h_get_32 (abfd, raw.reserved3);
3af9a47b 3696
f1bde64c 3697 bfd_mach_o_init_section_from_mach_o (abfd, sec, prot);
3af9a47b 3698
f1bde64c 3699 return sec;
3af9a47b
NC		 3700}
3701
f1bde64c 3702static asection *
47daa70f 3703bfd_mach_o_read_section (bfd *abfd, unsigned long prot, unsigned int wide)
1e8a024a
TG		 3704{
3705 if (wide)
47daa70f 3706 return bfd_mach_o_read_section_64 (abfd, prot);
1e8a024a 3707 else
47daa70f 3708 return bfd_mach_o_read_section_32 (abfd, prot);
1e8a024a
TG		 3709}
3710
afbb9e17 3711static bfd_boolean
ab273af8 3712bfd_mach_o_read_symtab_symbol (bfd *abfd,
07d6d2b8
AM		 3713 bfd_mach_o_symtab_command *sym,
3714 bfd_mach_o_asymbol *s,
3715 unsigned long i)
3af9a47b 3716{
046b007d 3717 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
c2f09c75 3718 unsigned int wide = mach_o_wide_p (&mdata->header);
046b007d
TG		 3719 unsigned int symwidth =
3720 wide ? BFD_MACH_O_NLIST_64_SIZE : BFD_MACH_O_NLIST_SIZE;
92bc0e80 3721 unsigned int symoff = sym->symoff + (i * symwidth);
46d1c23b 3722 struct mach_o_nlist_64_external raw;
3af9a47b
NC		 3723 unsigned char type = -1;
3724 unsigned char section = -1;
3725 short desc = -1;
1e8a024a 3726 symvalue value = -1;
3af9a47b
NC		 3727 unsigned long stroff = -1;
3728 unsigned int symtype = -1;
3729
3730 BFD_ASSERT (sym->strtab != NULL);
3731
c2f09c75 3732 if (bfd_seek (abfd, symoff, SEEK_SET) != 0
46d1c23b 3733 || bfd_bread (&raw, symwidth, abfd) != symwidth)
3af9a47b 3734 {
4eca0228 3735 _bfd_error_handler
695344c0 3736 /* xgettext:c-format */
07d6d2b8
AM		 3737 (_("bfd_mach_o_read_symtab_symbol: unable to read %d bytes at %u"),
3738 symwidth, symoff);
afbb9e17 3739 return FALSE;
3af9a47b
NC		 3740 }
3741
46d1c23b
TG		 3742 stroff = bfd_h_get_32 (abfd, raw.n_strx);
3743 type = bfd_h_get_8 (abfd, raw.n_type);
c2f09c75 3744 symtype = type & BFD_MACH_O_N_TYPE;
46d1c23b
TG		 3745 section = bfd_h_get_8 (abfd, raw.n_sect);
3746 desc = bfd_h_get_16 (abfd, raw.n_desc);
1e8a024a 3747 if (wide)
46d1c23b 3748 value = bfd_h_get_64 (abfd, raw.n_value);
1e8a024a 3749 else
46d1c23b 3750 value = bfd_h_get_32 (abfd, raw.n_value);
3af9a47b
NC		 3751
3752 if (stroff >= sym->strsize)
3753 {
4eca0228 3754 _bfd_error_handler
695344c0 3755 /* xgettext:c-format */
07d6d2b8
AM		 3756 (_("bfd_mach_o_read_symtab_symbol: name out of range (%lu >= %u)"),
3757 stroff,
3758 sym->strsize);
afbb9e17 3759 return FALSE;
3af9a47b
NC		 3760 }
3761
92bc0e80
TG		 3762 s->symbol.the_bfd = abfd;
3763 s->symbol.name = sym->strtab + stroff;
3764 s->symbol.value = value;
3765 s->symbol.flags = 0x0;
b22161d6 3766 s->symbol.udata.i = i;
92bc0e80
TG		 3767 s->n_type = type;
3768 s->n_sect = section;
3769 s->n_desc = desc;
3af9a47b
NC		 3770
3771 if (type & BFD_MACH_O_N_STAB)
3772 {
92bc0e80
TG		 3773 s->symbol.flags |= BSF_DEBUGGING;
3774 s->symbol.section = bfd_und_section_ptr;
15e1c58a
TG		 3775 switch (type)
3776 {
3777 case N_FUN:
3778 case N_STSYM:
3779 case N_LCSYM:
3780 case N_BNSYM:
3781 case N_SLINE:
3782 case N_ENSYM:
3783 case N_ECOMM:
3784 case N_ECOML:
3785 case N_GSYM:
3786 if ((section > 0) && (section <= mdata->nsects))
3787 {
92bc0e80
TG		 3788 s->symbol.section = mdata->sections[section - 1]->bfdsection;
3789 s->symbol.value =
07d6d2b8 3790 s->symbol.value - mdata->sections[section - 1]->addr;
15e1c58a
TG		 3791 }
3792 break;
3793 }
3af9a47b
NC		 3794 }
3795 else
3796 {
b22161d6 3797 if (type & (BFD_MACH_O_N_PEXT | BFD_MACH_O_N_EXT))
92bc0e80 3798 s->symbol.flags |= BSF_GLOBAL;
b22161d6 3799 else
92bc0e80 3800 s->symbol.flags |= BSF_LOCAL;
3af9a47b
NC		 3801
3802 switch (symtype)
3803 {
3804 case BFD_MACH_O_N_UNDF:
07d6d2b8
AM		 3805 if (type == (BFD_MACH_O_N_UNDF | BFD_MACH_O_N_EXT)
3806 && s->symbol.value != 0)
3807 {
3808 /* A common symbol. */
3809 s->symbol.section = bfd_com_section_ptr;
3810 s->symbol.flags = BSF_NO_FLAGS;
3811 }
3812 else
3813 {
3814 s->symbol.section = bfd_und_section_ptr;
3815 if (s->n_desc & BFD_MACH_O_N_WEAK_REF)
3816 s->symbol.flags |= BSF_WEAK;
3817 }
3af9a47b
NC		 3818 break;
3819 case BFD_MACH_O_N_PBUD:
92bc0e80 3820 s->symbol.section = bfd_und_section_ptr;
3af9a47b
NC		 3821 break;
3822 case BFD_MACH_O_N_ABS:
92bc0e80 3823 s->symbol.section = bfd_abs_section_ptr;
3af9a47b
NC		 3824 break;
3825 case BFD_MACH_O_N_SECT:
3826 if ((section > 0) && (section <= mdata->nsects))
3827 {
92bc0e80
TG		 3828 s->symbol.section = mdata->sections[section - 1]->bfdsection;
3829 s->symbol.value =
07d6d2b8 3830 s->symbol.value - mdata->sections[section - 1]->addr;
3af9a47b
NC		 3831 }
3832 else
3833 {
3834 /* Mach-O uses 0 to mean "no section"; not an error. */
3835 if (section != 0)
3836 {
4eca0228 3837 _bfd_error_handler
695344c0 3838 /* xgettext:c-format */
4eca0228
AM		 3839 (_("bfd_mach_o_read_symtab_symbol: "
3840 "symbol \"%s\" specified invalid section %d (max %lu): "
3841 "setting to undefined"),
3842 s->symbol.name, section, mdata->nsects);
3af9a47b 3843 }
92bc0e80 3844 s->symbol.section = bfd_und_section_ptr;
3af9a47b
NC		 3845 }
3846 break;
3847 case BFD_MACH_O_N_INDR:
0596a831
TG		 3848 /* FIXME: we don't follow the BFD convention as this indirect symbol
3849 won't be followed by the referenced one. This looks harmless
3850 unless we start using the linker. */
3851 s->symbol.flags |= BSF_INDIRECT;
3852 s->symbol.section = bfd_ind_section_ptr;
3853 s->symbol.value = 0;
3af9a47b
NC		 3854 break;
3855 default:
4eca0228 3856 _bfd_error_handler
695344c0 3857 /* xgettext:c-format */
4eca0228
AM		 3858 (_("bfd_mach_o_read_symtab_symbol: "
3859 "symbol \"%s\" specified invalid type field 0x%x: "
3860 "setting to undefined"), s->symbol.name, symtype);
92bc0e80 3861 s->symbol.section = bfd_und_section_ptr;
3af9a47b
NC		 3862 break;
3863 }
3864 }
3865
afbb9e17 3866 return TRUE;
3af9a47b
NC		 3867}
3868
c5012cd8 3869bfd_boolean
ab273af8 3870bfd_mach_o_read_symtab_strtab (bfd *abfd)
3af9a47b 3871{
046b007d
TG		 3872 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3873 bfd_mach_o_symtab_command *sym = mdata->symtab;
3874
3875 /* Fail if there is no symtab. */
3876 if (sym == NULL)
afbb9e17 3877 return FALSE;
046b007d
TG		 3878
3879 /* Success if already loaded. */
3880 if (sym->strtab)
afbb9e17 3881 return TRUE;
3af9a47b
NC		 3882
3883 if (abfd->flags & BFD_IN_MEMORY)
3884 {
3885 struct bfd_in_memory *b;
3886
3887 b = (struct bfd_in_memory *) abfd->iostream;
3888
3889 if ((sym->stroff + sym->strsize) > b->size)
3890 {
3891 bfd_set_error (bfd_error_file_truncated);
afbb9e17 3892 return FALSE;
3af9a47b 3893 }
f075ee0c 3894 sym->strtab = (char *) b->buffer + sym->stroff;
3af9a47b 3895 }
046b007d 3896 else
3af9a47b 3897 {
8bdf0be1
NC		 3898 /* See PR 21840 for a reproducer. */
3899 if ((sym->strsize + 1) == 0)
3900 return FALSE;
e7287c7f 3901 sym->strtab = bfd_alloc (abfd, sym->strsize + 1);
046b007d 3902 if (sym->strtab == NULL)
07d6d2b8 3903 return FALSE;
046b007d
TG		 3904
3905 if (bfd_seek (abfd, sym->stroff, SEEK_SET) != 0
07d6d2b8
AM		 3906 || bfd_bread (sym->strtab, sym->strsize, abfd) != sym->strsize)
3907 {
a1165289
NC		 3908 /* PR 17512: file: 10888-1609-0.004. */
3909 bfd_release (abfd, sym->strtab);
3910 sym->strtab = NULL;
07d6d2b8
AM		 3911 bfd_set_error (bfd_error_file_truncated);
3912 return FALSE;
3913 }
e7287c7f
NC		 3914 /* Zero terminate the string table. */
3915 sym->strtab[sym->strsize] = 0;
3af9a47b
NC		 3916 }
3917
afbb9e17 3918 return TRUE;
3af9a47b
NC		 3919}
3920
c5012cd8 3921bfd_boolean
ab273af8 3922bfd_mach_o_read_symtab_symbols (bfd *abfd)
3af9a47b 3923{
046b007d
TG		 3924 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3925 bfd_mach_o_symtab_command *sym = mdata->symtab;
3af9a47b 3926 unsigned long i;
3af9a47b 3927
092d27ff 3928 if (sym == NULL || sym->symbols)
0a9d414a
NC		 3929 /* Return now if there are no symbols or if already loaded. */
3930 return TRUE;
046b007d 3931
64d29018 3932 sym->symbols = bfd_alloc2 (abfd, sym->nsyms, sizeof (bfd_mach_o_asymbol));
3af9a47b
NC		 3933 if (sym->symbols == NULL)
3934 {
4eca0228
AM		 3935 _bfd_error_handler (_("bfd_mach_o_read_symtab_symbols: "
3936 "unable to allocate memory for symbols"));
64d29018 3937 sym->nsyms = 0;
afbb9e17 3938 return FALSE;
3af9a47b 3939 }
a95a4550 3940
afbb9e17 3941 if (!bfd_mach_o_read_symtab_strtab (abfd))
64d29018 3942 goto fail;
3af9a47b
NC		 3943
3944 for (i = 0; i < sym->nsyms; i++)
64d29018
NC		 3945 if (!bfd_mach_o_read_symtab_symbol (abfd, sym, &sym->symbols[i], i))
3946 goto fail;
a95a4550 3947
afbb9e17 3948 return TRUE;
64d29018
NC		 3949
3950 fail:
3951 bfd_release (abfd, sym->symbols);
3952 sym->symbols = NULL;
3953 sym->nsyms = 0;
3954 return FALSE;
3af9a47b
NC		 3955}
3956
3957static const char *
116c20d2 3958bfd_mach_o_i386_flavour_string (unsigned int flavour)
3af9a47b
NC		 3959{
3960 switch ((int) flavour)
3961 {
15e1c58a
TG		 3962 case BFD_MACH_O_x86_THREAD_STATE32: return "x86_THREAD_STATE32";
3963 case BFD_MACH_O_x86_FLOAT_STATE32: return "x86_FLOAT_STATE32";
3964 case BFD_MACH_O_x86_EXCEPTION_STATE32: return "x86_EXCEPTION_STATE32";
3965 case BFD_MACH_O_x86_THREAD_STATE64: return "x86_THREAD_STATE64";
3966 case BFD_MACH_O_x86_FLOAT_STATE64: return "x86_FLOAT_STATE64";
3967 case BFD_MACH_O_x86_EXCEPTION_STATE64: return "x86_EXCEPTION_STATE64";
3968 case BFD_MACH_O_x86_THREAD_STATE: return "x86_THREAD_STATE";
3969 case BFD_MACH_O_x86_FLOAT_STATE: return "x86_FLOAT_STATE";
3970 case BFD_MACH_O_x86_EXCEPTION_STATE: return "x86_EXCEPTION_STATE";
3971 case BFD_MACH_O_x86_DEBUG_STATE32: return "x86_DEBUG_STATE32";
3972 case BFD_MACH_O_x86_DEBUG_STATE64: return "x86_DEBUG_STATE64";
3973 case BFD_MACH_O_x86_DEBUG_STATE: return "x86_DEBUG_STATE";
b32e07d7 3974 case BFD_MACH_O_x86_THREAD_STATE_NONE: return "x86_THREAD_STATE_NONE";
3af9a47b
NC		 3975 default: return "UNKNOWN";
3976 }
3977}
3978
3979static const char *
116c20d2 3980bfd_mach_o_ppc_flavour_string (unsigned int flavour)
3af9a47b
NC		 3981{
3982 switch ((int) flavour)
3983 {
b32e07d7
TG		 3984 case BFD_MACH_O_PPC_THREAD_STATE: return "PPC_THREAD_STATE";
3985 case BFD_MACH_O_PPC_FLOAT_STATE: return "PPC_FLOAT_STATE";
3986 case BFD_MACH_O_PPC_EXCEPTION_STATE: return "PPC_EXCEPTION_STATE";
3987 case BFD_MACH_O_PPC_VECTOR_STATE: return "PPC_VECTOR_STATE";
3988 case BFD_MACH_O_PPC_THREAD_STATE64: return "PPC_THREAD_STATE64";
3989 case BFD_MACH_O_PPC_EXCEPTION_STATE64: return "PPC_EXCEPTION_STATE64";
3af9a47b
NC		 3990 default: return "UNKNOWN";
3991 }
3992}
3993
452216ab 3994static bfd_boolean
ab273af8 3995bfd_mach_o_read_dylinker (bfd *abfd, bfd_mach_o_load_command *command)
3af9a47b
NC		 3996{
3997 bfd_mach_o_dylinker_command *cmd = &command->command.dylinker;
46d1c23b 3998 struct mach_o_str_command_external raw;
3af9a47b 3999 unsigned int nameoff;
4525c51a 4000 unsigned int namelen;
3af9a47b 4001
47daa70f 4002 if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
452216ab 4003 return FALSE;
3af9a47b 4004
46d1c23b 4005 nameoff = bfd_h_get_32 (abfd, raw.str);
3af9a47b 4006
4525c51a
TG		 4007 cmd->name_offset = nameoff;
4008 namelen = command->len - nameoff;
4009 nameoff += command->offset;
4010 cmd->name_str = bfd_alloc (abfd, namelen);
b32e07d7 4011 if (cmd->name_str == NULL)
452216ab 4012 return FALSE;
4525c51a
TG		 4013 if (bfd_seek (abfd, nameoff, SEEK_SET) != 0
4014 || bfd_bread (cmd->name_str, namelen, abfd) != namelen)
452216ab
TG		 4015 return FALSE;
4016 return TRUE;
3af9a47b
NC		 4017}
4018
452216ab 4019static bfd_boolean
ab273af8 4020bfd_mach_o_read_dylib (bfd *abfd, bfd_mach_o_load_command *command)
3af9a47b 4021{
47daa70f 4022 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3af9a47b 4023 bfd_mach_o_dylib_command *cmd = &command->command.dylib;
46d1c23b 4024 struct mach_o_dylib_command_external raw;
3af9a47b 4025 unsigned int nameoff;
4525c51a 4026 unsigned int namelen;
3af9a47b 4027
046b007d
TG		 4028 switch (command->type)
4029 {
4030 case BFD_MACH_O_LC_LOAD_DYLIB:
fbe383b9 4031 case BFD_MACH_O_LC_LAZY_LOAD_DYLIB:
046b007d 4032 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB:
046b007d 4033 case BFD_MACH_O_LC_ID_DYLIB:
046b007d 4034 case BFD_MACH_O_LC_REEXPORT_DYLIB:
73017762 4035 case BFD_MACH_O_LC_LOAD_UPWARD_DYLIB:
046b007d
TG		 4036 break;
4037 default:
b32e07d7 4038 BFD_FAIL ();
452216ab 4039 return FALSE;
046b007d 4040 }
3af9a47b 4041
47daa70f 4042 if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
452216ab 4043 return FALSE;
3af9a47b 4044
46d1c23b
TG		 4045 nameoff = bfd_h_get_32 (abfd, raw.name);
4046 cmd->timestamp = bfd_h_get_32 (abfd, raw.timestamp);
4047 cmd->current_version = bfd_h_get_32 (abfd, raw.current_version);
4048 cmd->compatibility_version = bfd_h_get_32 (abfd, raw.compatibility_version);
3af9a47b
NC		 4049
4050 cmd->name_offset = command->offset + nameoff;
4525c51a
TG		 4051 namelen = command->len - nameoff;
4052 cmd->name_str = bfd_alloc (abfd, namelen);
b32e07d7 4053 if (cmd->name_str == NULL)
452216ab 4054 return FALSE;
47daa70f 4055 if (bfd_seek (abfd, mdata->hdr_offset + cmd->name_offset, SEEK_SET) != 0
4525c51a 4056 || bfd_bread (cmd->name_str, namelen, abfd) != namelen)
452216ab
TG		 4057 return FALSE;
4058 return TRUE;
3af9a47b
NC		 4059}
4060
452216ab 4061static bfd_boolean
7a79c514 4062bfd_mach_o_read_prebound_dylib (bfd *abfd,
07d6d2b8 4063 bfd_mach_o_load_command *command)
3af9a47b 4064{
7a79c514
TG		 4065 bfd_mach_o_prebound_dylib_command *cmd = &command->command.prebound_dylib;
4066 struct mach_o_prebound_dylib_command_external raw;
4067 unsigned int nameoff;
4068 unsigned int modoff;
4069 unsigned int str_len;
4070 unsigned char *str;
4071
47daa70f 4072 if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
452216ab 4073 return FALSE;
7a79c514
TG		 4074
4075 nameoff = bfd_h_get_32 (abfd, raw.name);
4076 modoff = bfd_h_get_32 (abfd, raw.linked_modules);
4077 if (nameoff > command->len || modoff > command->len)
452216ab 4078 return FALSE;
7a79c514
TG		 4079
4080 str_len = command->len - sizeof (raw);
4081 str = bfd_alloc (abfd, str_len);
4082 if (str == NULL)
452216ab 4083 return FALSE;
7a79c514 4084 if (bfd_bread (str, str_len, abfd) != str_len)
452216ab 4085 return FALSE;
7a79c514
TG		 4086
4087 cmd->name_offset = command->offset + nameoff;
4088 cmd->nmodules = bfd_h_get_32 (abfd, raw.nmodules);
4089 cmd->linked_modules_offset = command->offset + modoff;
4090
4091 cmd->name_str = (char *)str + nameoff - (sizeof (raw) + BFD_MACH_O_LC_SIZE);
4092 cmd->linked_modules = str + modoff - (sizeof (raw) + BFD_MACH_O_LC_SIZE);
452216ab 4093 return TRUE;
7a79c514
TG		 4094}
4095
452216ab 4096static bfd_boolean
7a79c514
TG		 4097bfd_mach_o_read_prebind_cksum (bfd *abfd,
4098 bfd_mach_o_load_command *command)
4099{
4100 bfd_mach_o_prebind_cksum_command *cmd = &command->command.prebind_cksum;
4101 struct mach_o_prebind_cksum_command_external raw;
3af9a47b 4102
47daa70f 4103 if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
452216ab 4104 return FALSE;
7a79c514
TG		 4105
4106 cmd->cksum = bfd_get_32 (abfd, raw.cksum);
452216ab 4107 return TRUE;
7a79c514
TG		 4108}
4109
452216ab 4110static bfd_boolean
7a79c514
TG		 4111bfd_mach_o_read_twolevel_hints (bfd *abfd,
4112 bfd_mach_o_load_command *command)
4113{
4114 bfd_mach_o_twolevel_hints_command *cmd = &command->command.twolevel_hints;
4115 struct mach_o_twolevel_hints_command_external raw;
4116
47daa70f 4117 if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
452216ab 4118 return FALSE;
7a79c514
TG		 4119
4120 cmd->offset = bfd_get_32 (abfd, raw.offset);
4121 cmd->nhints = bfd_get_32 (abfd, raw.nhints);
452216ab 4122 return TRUE;
3af9a47b
NC		 4123}
4124
452216ab 4125static bfd_boolean
9f4a5bd1
TG		 4126bfd_mach_o_read_fvmlib (bfd *abfd, bfd_mach_o_load_command *command)
4127{
4128 bfd_mach_o_fvmlib_command *fvm = &command->command.fvmlib;
4129 struct mach_o_fvmlib_command_external raw;
4130 unsigned int nameoff;
4525c51a 4131 unsigned int namelen;
9f4a5bd1 4132
47daa70f 4133 if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
452216ab 4134 return FALSE;
9f4a5bd1
TG		 4135
4136 nameoff = bfd_h_get_32 (abfd, raw.name);
4137 fvm->minor_version = bfd_h_get_32 (abfd, raw.minor_version);
4138 fvm->header_addr = bfd_h_get_32 (abfd, raw.header_addr);
4139
4140 fvm->name_offset = command->offset + nameoff;
4525c51a
TG		 4141 namelen = command->len - nameoff;
4142 fvm->name_str = bfd_alloc (abfd, namelen);
9f4a5bd1 4143 if (fvm->name_str == NULL)
452216ab 4144 return FALSE;
9f4a5bd1 4145 if (bfd_seek (abfd, fvm->name_offset, SEEK_SET) != 0
4525c51a 4146 || bfd_bread (fvm->name_str, namelen, abfd) != namelen)
452216ab
TG		 4147 return FALSE;
4148 return TRUE;
9f4a5bd1
TG		 4149}
4150
452216ab 4151static bfd_boolean
ab273af8 4152bfd_mach_o_read_thread (bfd *abfd, bfd_mach_o_load_command *command)
3af9a47b 4153{
b32e07d7 4154 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3af9a47b 4155 bfd_mach_o_thread_command *cmd = &command->command.thread;
92bc0e80 4156 unsigned int offset;
3af9a47b
NC		 4157 unsigned int nflavours;
4158 unsigned int i;
4159
4160 BFD_ASSERT ((command->type == BFD_MACH_O_LC_THREAD)
4161 || (command->type == BFD_MACH_O_LC_UNIXTHREAD));
4162
b32e07d7 4163 /* Count the number of threads. */
3af9a47b
NC		 4164 offset = 8;
4165 nflavours = 0;
4166 while (offset != command->len)
4167 {
46d1c23b
TG		 4168 struct mach_o_thread_command_external raw;
4169
3af9a47b 4170 if (offset >= command->len)
452216ab 4171 return FALSE;
3af9a47b 4172
c2f09c75 4173 if (bfd_seek (abfd, command->offset + offset, SEEK_SET) != 0
07d6d2b8 4174 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
452216ab 4175 return FALSE;
3af9a47b 4176
46d1c23b 4177 offset += sizeof (raw) + bfd_h_get_32 (abfd, raw.count) * 4;
3af9a47b
NC		 4178 nflavours++;
4179 }
4180
b32e07d7 4181 /* Allocate threads. */
64d29018
NC		 4182 cmd->flavours = bfd_alloc2
4183 (abfd, nflavours, sizeof (bfd_mach_o_thread_flavour));
3af9a47b 4184 if (cmd->flavours == NULL)
452216ab 4185 return FALSE;
3af9a47b
NC		 4186 cmd->nflavours = nflavours;
4187
4188 offset = 8;
4189 nflavours = 0;
4190 while (offset != command->len)
4191 {
46d1c23b
TG		 4192 struct mach_o_thread_command_external raw;
4193
3af9a47b 4194 if (offset >= command->len)
452216ab 4195 return FALSE;
3af9a47b
NC		 4196
4197 if (nflavours >= cmd->nflavours)
452216ab 4198 return FALSE;
3af9a47b 4199
c2f09c75 4200 if (bfd_seek (abfd, command->offset + offset, SEEK_SET) != 0
07d6d2b8 4201 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
452216ab 4202 return FALSE;
3af9a47b 4203
46d1c23b
TG		 4204 cmd->flavours[nflavours].flavour = bfd_h_get_32 (abfd, raw.flavour);
4205 cmd->flavours[nflavours].offset = command->offset + offset + sizeof (raw);
4206 cmd->flavours[nflavours].size = bfd_h_get_32 (abfd, raw.count) * 4;
4207 offset += cmd->flavours[nflavours].size + sizeof (raw);
3af9a47b
NC		 4208 nflavours++;
4209 }
4210
4211 for (i = 0; i < nflavours; i++)
4212 {
4213 asection *bfdsec;
4214 unsigned int snamelen;
4215 char *sname;
4216 const char *flavourstr;
4217 const char *prefix = "LC_THREAD";
a95a4550
AM		 4218 unsigned int j = 0;
4219
3af9a47b
NC		 4220 switch (mdata->header.cputype)
4221 {
4222 case BFD_MACH_O_CPU_TYPE_POWERPC:
1e8a024a 4223 case BFD_MACH_O_CPU_TYPE_POWERPC_64:
707e555b
TG		 4224 flavourstr =
4225 bfd_mach_o_ppc_flavour_string (cmd->flavours[i].flavour);
3af9a47b
NC		 4226 break;
4227 case BFD_MACH_O_CPU_TYPE_I386:
1e8a024a 4228 case BFD_MACH_O_CPU_TYPE_X86_64:
707e555b
TG		 4229 flavourstr =
4230 bfd_mach_o_i386_flavour_string (cmd->flavours[i].flavour);
3af9a47b
NC		 4231 break;
4232 default:
4233 flavourstr = "UNKNOWN_ARCHITECTURE";
4234 break;
4235 }
a95a4550 4236
3af9a47b 4237 snamelen = strlen (prefix) + 1 + 20 + 1 + strlen (flavourstr) + 1;
116c20d2 4238 sname = bfd_alloc (abfd, snamelen);
3af9a47b 4239 if (sname == NULL)
452216ab 4240 return FALSE;
3af9a47b
NC		 4241
4242 for (;;)
4243 {
a95a4550
AM		 4244 sprintf (sname, "%s.%s.%u", prefix, flavourstr, j);
4245 if (bfd_get_section_by_name (abfd, sname) == NULL)
3af9a47b 4246 break;
a95a4550 4247 j++;
3af9a47b
NC		 4248 }
4249
117ed4f8 4250 bfdsec = bfd_make_section_with_flags (abfd, sname, SEC_HAS_CONTENTS);
a95a4550 4251
3af9a47b
NC		 4252 bfdsec->vma = 0;
4253 bfdsec->lma = 0;
eea6121a 4254 bfdsec->size = cmd->flavours[i].size;
3af9a47b
NC		 4255 bfdsec->filepos = cmd->flavours[i].offset;
4256 bfdsec->alignment_power = 0x0;
3af9a47b
NC		 4257
4258 cmd->section = bfdsec;
4259 }
4260
452216ab 4261 return TRUE;
3af9a47b
NC		 4262}
4263
452216ab 4264static bfd_boolean
ab273af8 4265bfd_mach_o_read_dysymtab (bfd *abfd, bfd_mach_o_load_command *command)
3af9a47b 4266{
046b007d 4267 bfd_mach_o_dysymtab_command *cmd = &command->command.dysymtab;
b32e07d7 4268 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3af9a47b
NC		 4269
4270 BFD_ASSERT (command->type == BFD_MACH_O_LC_DYSYMTAB);
4271
46d1c23b
TG		 4272 {
4273 struct mach_o_dysymtab_command_external raw;
4274
47daa70f 4275 if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
452216ab 4276 return FALSE;
3af9a47b 4277
46d1c23b
TG		 4278 cmd->ilocalsym = bfd_h_get_32 (abfd, raw.ilocalsym);
4279 cmd->nlocalsym = bfd_h_get_32 (abfd, raw.nlocalsym);
4280 cmd->iextdefsym = bfd_h_get_32 (abfd, raw.iextdefsym);
4281 cmd->nextdefsym = bfd_h_get_32 (abfd, raw.nextdefsym);
4282 cmd->iundefsym = bfd_h_get_32 (abfd, raw.iundefsym);
4283 cmd->nundefsym = bfd_h_get_32 (abfd, raw.nundefsym);
4284 cmd->tocoff = bfd_h_get_32 (abfd, raw.tocoff);
4285 cmd->ntoc = bfd_h_get_32 (abfd, raw.ntoc);
4286 cmd->modtaboff = bfd_h_get_32 (abfd, raw.modtaboff);
4287 cmd->nmodtab = bfd_h_get_32 (abfd, raw.nmodtab);
4288 cmd->extrefsymoff = bfd_h_get_32 (abfd, raw.extrefsymoff);
4289 cmd->nextrefsyms = bfd_h_get_32 (abfd, raw.nextrefsyms);
4290 cmd->indirectsymoff = bfd_h_get_32 (abfd, raw.indirectsymoff);
4291 cmd->nindirectsyms = bfd_h_get_32 (abfd, raw.nindirectsyms);
4292 cmd->extreloff = bfd_h_get_32 (abfd, raw.extreloff);
4293 cmd->nextrel = bfd_h_get_32 (abfd, raw.nextrel);
4294 cmd->locreloff = bfd_h_get_32 (abfd, raw.locreloff);
4295 cmd->nlocrel = bfd_h_get_32 (abfd, raw.nlocrel);
4296 }
046b007d
TG		 4297
4298 if (cmd->nmodtab != 0)
4299 {
046b007d
TG		 4300 unsigned int i;
4301 int wide = bfd_mach_o_wide_p (abfd);
4302 unsigned int module_len = wide ? 56 : 52;
4303
4304 cmd->dylib_module =
07d6d2b8 4305 bfd_alloc2 (abfd, cmd->nmodtab, sizeof (bfd_mach_o_dylib_module));
046b007d 4306 if (cmd->dylib_module == NULL)
07d6d2b8 4307 return FALSE;
046b007d
TG		 4308
4309 if (bfd_seek (abfd, cmd->modtaboff, SEEK_SET) != 0)
07d6d2b8 4310 return FALSE;
046b007d
TG		 4311
4312 for (i = 0; i < cmd->nmodtab; i++)
07d6d2b8
AM		 4313 {
4314 bfd_mach_o_dylib_module *module = &cmd->dylib_module[i];
4315 unsigned long v;
4316 unsigned char buf[56];
4317
4318 if (bfd_bread ((void *) buf, module_len, abfd) != module_len)
4319 return FALSE;
4320
4321 module->module_name_idx = bfd_h_get_32 (abfd, buf + 0);
4322 module->iextdefsym = bfd_h_get_32 (abfd, buf + 4);
4323 module->nextdefsym = bfd_h_get_32 (abfd, buf + 8);
4324 module->irefsym = bfd_h_get_32 (abfd, buf + 12);
4325 module->nrefsym = bfd_h_get_32 (abfd, buf + 16);
4326 module->ilocalsym = bfd_h_get_32 (abfd, buf + 20);
4327 module->nlocalsym = bfd_h_get_32 (abfd, buf + 24);
4328 module->iextrel = bfd_h_get_32 (abfd, buf + 28);
4329 module->nextrel = bfd_h_get_32 (abfd, buf + 32);
4330 v = bfd_h_get_32 (abfd, buf +36);
4331 module->iinit = v & 0xffff;
4332 module->iterm = (v >> 16) & 0xffff;
4333 v = bfd_h_get_32 (abfd, buf + 40);
4334 module->ninit = v & 0xffff;
4335 module->nterm = (v >> 16) & 0xffff;
4336 if (wide)
4337 {
4338 module->objc_module_info_size = bfd_h_get_32 (abfd, buf + 44);
4339 module->objc_module_info_addr = bfd_h_get_64 (abfd, buf + 48);
4340 }
4341 else
4342 {
4343 module->objc_module_info_addr = bfd_h_get_32 (abfd, buf + 44);
4344 module->objc_module_info_size = bfd_h_get_32 (abfd, buf + 48);
4345 }
4346 }
046b007d 4347 }
afbb9e17 4348
046b007d
TG		 4349 if (cmd->ntoc != 0)
4350 {
64d29018 4351 unsigned long i;
046b007d 4352
64d29018 4353 cmd->dylib_toc = bfd_alloc2
07d6d2b8 4354 (abfd, cmd->ntoc, sizeof (bfd_mach_o_dylib_table_of_content));
046b007d 4355 if (cmd->dylib_toc == NULL)
07d6d2b8 4356 return FALSE;
046b007d
TG		 4357
4358 if (bfd_seek (abfd, cmd->tocoff, SEEK_SET) != 0)
07d6d2b8 4359 return FALSE;
046b007d
TG		 4360
4361 for (i = 0; i < cmd->ntoc; i++)
07d6d2b8
AM		 4362 {
4363 struct mach_o_dylib_table_of_contents_external raw;
4364 bfd_mach_o_dylib_table_of_content *toc = &cmd->dylib_toc[i];
046b007d 4365
07d6d2b8
AM		 4366 if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
4367 return FALSE;
046b007d 4368
07d6d2b8
AM		 4369 toc->symbol_index = bfd_h_get_32 (abfd, raw.symbol_index);
4370 toc->module_index = bfd_h_get_32 (abfd, raw.module_index);
4371 }
046b007d
TG		 4372 }
4373
4374 if (cmd->nindirectsyms != 0)
4375 {
046b007d
TG		 4376 unsigned int i;
4377
64d29018 4378 cmd->indirect_syms = bfd_alloc2
07d6d2b8 4379 (abfd, cmd->nindirectsyms, sizeof (unsigned int));
046b007d 4380 if (cmd->indirect_syms == NULL)
07d6d2b8 4381 return FALSE;
046b007d
TG		 4382
4383 if (bfd_seek (abfd, cmd->indirectsymoff, SEEK_SET) != 0)
07d6d2b8 4384 return FALSE;
046b007d
TG		 4385
4386 for (i = 0; i < cmd->nindirectsyms; i++)
07d6d2b8
AM		 4387 {
4388 unsigned char raw[4];
4389 unsigned int *is = &cmd->indirect_syms[i];
046b007d 4390
07d6d2b8
AM		 4391 if (bfd_bread (raw, sizeof (raw), abfd) != sizeof (raw))
4392 return FALSE;
046b007d 4393
07d6d2b8
AM		 4394 *is = bfd_h_get_32 (abfd, raw);
4395 }
046b007d
TG		 4396 }
4397
4398 if (cmd->nextrefsyms != 0)
4399 {
046b007d
TG		 4400 unsigned long v;
4401 unsigned int i;
4402
64d29018 4403 cmd->ext_refs = bfd_alloc2
07d6d2b8 4404 (abfd, cmd->nextrefsyms, sizeof (bfd_mach_o_dylib_reference));
046b007d 4405 if (cmd->ext_refs == NULL)
07d6d2b8 4406 return FALSE;
046b007d
TG		 4407
4408 if (bfd_seek (abfd, cmd->extrefsymoff, SEEK_SET) != 0)
07d6d2b8 4409 return FALSE;
046b007d
TG		 4410
4411 for (i = 0; i < cmd->nextrefsyms; i++)
07d6d2b8
AM		 4412 {
4413 unsigned char raw[4];
4414 bfd_mach_o_dylib_reference *ref = &cmd->ext_refs[i];
4415
4416 if (bfd_bread (raw, sizeof (raw), abfd) != sizeof (raw))
4417 return FALSE;
4418
4419 /* Fields isym and flags are written as bit-fields, thus we need
4420 a specific processing for endianness. */
4421 v = bfd_h_get_32 (abfd, raw);
4422 if (bfd_big_endian (abfd))
4423 {
4424 ref->isym = (v >> 8) & 0xffffff;
4425 ref->flags = v & 0xff;
4426 }
4427 else
4428 {
4429 ref->isym = v & 0xffffff;
4430 ref->flags = (v >> 24) & 0xff;
4431 }
4432 }
046b007d 4433 }
3af9a47b 4434
b32e07d7 4435 if (mdata->dysymtab)
452216ab 4436 return FALSE;
b32e07d7
TG		 4437 mdata->dysymtab = cmd;
4438
452216ab 4439 return TRUE;
3af9a47b
NC		 4440}
4441
452216ab 4442static bfd_boolean
ab273af8 4443bfd_mach_o_read_symtab (bfd *abfd, bfd_mach_o_load_command *command)
3af9a47b 4444{
046b007d
TG		 4445 bfd_mach_o_symtab_command *symtab = &command->command.symtab;
4446 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
46d1c23b 4447 struct mach_o_symtab_command_external raw;
3af9a47b
NC		 4448
4449 BFD_ASSERT (command->type == BFD_MACH_O_LC_SYMTAB);
4450
47daa70f 4451 if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
452216ab 4452 return FALSE;
a95a4550 4453
46d1c23b
TG		 4454 symtab->symoff = bfd_h_get_32 (abfd, raw.symoff);
4455 symtab->nsyms = bfd_h_get_32 (abfd, raw.nsyms);
4456 symtab->stroff = bfd_h_get_32 (abfd, raw.stroff);
4457 symtab->strsize = bfd_h_get_32 (abfd, raw.strsize);
046b007d
TG		 4458 symtab->symbols = NULL;
4459 symtab->strtab = NULL;
3af9a47b 4460
046b007d 4461 if (symtab->nsyms != 0)
15e1c58a
TG		 4462 abfd->flags |= HAS_SYMS;
4463
046b007d 4464 if (mdata->symtab)
452216ab 4465 return FALSE;
046b007d 4466 mdata->symtab = symtab;
452216ab 4467 return TRUE;
3af9a47b
NC		 4468}
4469
452216ab 4470static bfd_boolean
ab273af8 4471bfd_mach_o_read_uuid (bfd *abfd, bfd_mach_o_load_command *command)
15e1c58a
TG		 4472{
4473 bfd_mach_o_uuid_command *cmd = &command->command.uuid;
15e1c58a
TG		 4474
4475 BFD_ASSERT (command->type == BFD_MACH_O_LC_UUID);
4476
47daa70f 4477 if (bfd_bread (cmd->uuid, 16, abfd) != 16)
452216ab 4478 return FALSE;
15e1c58a 4479
452216ab 4480 return TRUE;
15e1c58a
TG		 4481}
4482
452216ab 4483static bfd_boolean
ab273af8 4484bfd_mach_o_read_linkedit (bfd *abfd, bfd_mach_o_load_command *command)
046b007d
TG		 4485{
4486 bfd_mach_o_linkedit_command *cmd = &command->command.linkedit;
46d1c23b 4487 struct mach_o_linkedit_data_command_external raw;
046b007d 4488
47daa70f 4489 if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
452216ab 4490 return FALSE;
046b007d 4491
46d1c23b
TG		 4492 cmd->dataoff = bfd_get_32 (abfd, raw.dataoff);
4493 cmd->datasize = bfd_get_32 (abfd, raw.datasize);
452216ab 4494 return TRUE;
046b007d
TG		 4495}
4496
452216ab 4497static bfd_boolean
ab273af8 4498bfd_mach_o_read_str (bfd *abfd, bfd_mach_o_load_command *command)
046b007d
TG		 4499{
4500 bfd_mach_o_str_command *cmd = &command->command.str;
46d1c23b 4501 struct mach_o_str_command_external raw;
046b007d
TG		 4502 unsigned long off;
4503
47daa70f 4504 if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
452216ab 4505 return FALSE;
046b007d 4506
46d1c23b 4507 off = bfd_get_32 (abfd, raw.str);
046b007d
TG		 4508 cmd->stroff = command->offset + off;
4509 cmd->str_len = command->len - off;
4510 cmd->str = bfd_alloc (abfd, cmd->str_len);
4511 if (cmd->str == NULL)
452216ab 4512 return FALSE;
046b007d 4513 if (bfd_seek (abfd, cmd->stroff, SEEK_SET) != 0
91d6fa6a 4514 || bfd_bread ((void *) cmd->str, cmd->str_len, abfd) != cmd->str_len)
452216ab
TG		 4515 return FALSE;
4516 return TRUE;
046b007d
TG		 4517}
4518
c9ffd2ea
TG		 4519static unsigned char *
4520bfd_mach_o_alloc_and_read (bfd *abfd, unsigned int off, unsigned int size)
4521{
4522 unsigned char *buf;
4523
4524 buf = bfd_alloc (abfd, size);
4525 if (buf == NULL)
4526 return NULL;
4527 if (bfd_seek (abfd, off, SEEK_SET) != 0
4528 || bfd_bread (buf, size, abfd) != size)
4529 return NULL;
4530 return buf;
4531}
4532
4533static bfd_boolean
4534bfd_mach_o_read_dyld_content (bfd *abfd, bfd_mach_o_dyld_info_command *cmd)
4535{
4536 /* Read rebase content. */
4537 if (cmd->rebase_content == NULL && cmd->rebase_size != 0)
4538 {
4539 cmd->rebase_content =
4540 bfd_mach_o_alloc_and_read (abfd, cmd->rebase_off, cmd->rebase_size);
4541 if (cmd->rebase_content == NULL)
4542 return FALSE;
4543 }
4544
4545 /* Read bind content. */
4546 if (cmd->bind_content == NULL && cmd->bind_size != 0)
4547 {
4548 cmd->bind_content =
4549 bfd_mach_o_alloc_and_read (abfd, cmd->bind_off, cmd->bind_size);
4550 if (cmd->bind_content == NULL)
4551 return FALSE;
4552 }
4553
4554 /* Read weak bind content. */
4555 if (cmd->weak_bind_content == NULL && cmd->weak_bind_size != 0)
4556 {
4557 cmd->weak_bind_content = bfd_mach_o_alloc_and_read
4558 (abfd, cmd->weak_bind_off, cmd->weak_bind_size);
4559 if (cmd->weak_bind_content == NULL)
4560 return FALSE;
4561 }
4562
4563 /* Read lazy bind content. */
4564 if (cmd->lazy_bind_content == NULL && cmd->lazy_bind_size != 0)
4565 {
4566 cmd->lazy_bind_content = bfd_mach_o_alloc_and_read
4567 (abfd, cmd->lazy_bind_off, cmd->lazy_bind_size);
4568 if (cmd->lazy_bind_content == NULL)
4569 return FALSE;
4570 }
4571
4572 /* Read export content. */
4573 if (cmd->export_content == NULL && cmd->export_size != 0)
4574 {
4575 cmd->export_content = bfd_mach_o_alloc_and_read
4576 (abfd, cmd->export_off, cmd->export_size);
4577 if (cmd->export_content == NULL)
4578 return FALSE;
4579 }
4580
4581 return TRUE;
4582}
4583
452216ab 4584static bfd_boolean
ab273af8 4585bfd_mach_o_read_dyld_info (bfd *abfd, bfd_mach_o_load_command *command)
ad86f1fb
TG		 4586{
4587 bfd_mach_o_dyld_info_command *cmd = &command->command.dyld_info;
46d1c23b 4588 struct mach_o_dyld_info_command_external raw;
ad86f1fb 4589
47daa70f 4590 if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
452216ab 4591 return FALSE;
ad86f1fb 4592
46d1c23b
TG		 4593 cmd->rebase_off = bfd_get_32 (abfd, raw.rebase_off);
4594 cmd->rebase_size = bfd_get_32 (abfd, raw.rebase_size);
c9ffd2ea 4595 cmd->rebase_content = NULL;
46d1c23b
TG		 4596 cmd->bind_off = bfd_get_32 (abfd, raw.bind_off);
4597 cmd->bind_size = bfd_get_32 (abfd, raw.bind_size);
c9ffd2ea 4598 cmd->bind_content = NULL;
46d1c23b
TG		 4599 cmd->weak_bind_off = bfd_get_32 (abfd, raw.weak_bind_off);
4600 cmd->weak_bind_size = bfd_get_32 (abfd, raw.weak_bind_size);
c9ffd2ea 4601 cmd->weak_bind_content = NULL;
46d1c23b
TG		 4602 cmd->lazy_bind_off = bfd_get_32 (abfd, raw.lazy_bind_off);
4603 cmd->lazy_bind_size = bfd_get_32 (abfd, raw.lazy_bind_size);
c9ffd2ea 4604 cmd->lazy_bind_content = NULL;
46d1c23b
TG		 4605 cmd->export_off = bfd_get_32 (abfd, raw.export_off);
4606 cmd->export_size = bfd_get_32 (abfd, raw.export_size);
c9ffd2ea 4607 cmd->export_content = NULL;
452216ab 4608 return TRUE;
ad86f1fb
TG		 4609}
4610
edbdea0e
TG		 4611static bfd_boolean
4612bfd_mach_o_read_version_min (bfd *abfd, bfd_mach_o_load_command *command)
4613{
4614 bfd_mach_o_version_min_command *cmd = &command->command.version_min;
4615 struct mach_o_version_min_command_external raw;
edbdea0e 4616
47daa70f 4617 if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
edbdea0e
TG		 4618 return FALSE;
4619
fc7b364a
RB		 4620 cmd->version = bfd_get_32 (abfd, raw.version);
4621 cmd->sdk = bfd_get_32 (abfd, raw.sdk);
edbdea0e
TG		 4622 return TRUE;
4623}
4624
fc55a902
TG		 4625static bfd_boolean
4626bfd_mach_o_read_encryption_info (bfd *abfd, bfd_mach_o_load_command *command)
4627{
4628 bfd_mach_o_encryption_info_command *cmd = &command->command.encryption_info;
4629 struct mach_o_encryption_info_command_external raw;
4630
47daa70f
TG		 4631 if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
4632 return FALSE;
4633
4634 cmd->cryptoff = bfd_get_32 (abfd, raw.cryptoff);
4635 cmd->cryptsize = bfd_get_32 (abfd, raw.cryptsize);
4636 cmd->cryptid = bfd_get_32 (abfd, raw.cryptid);
4637 return TRUE;
4638}
4639
4640static bfd_boolean
4641bfd_mach_o_read_encryption_info_64 (bfd *abfd, bfd_mach_o_load_command *command)
4642{
4643 bfd_mach_o_encryption_info_command *cmd = &command->command.encryption_info;
4644 struct mach_o_encryption_info_64_command_external raw;
4645
4646 if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
fc55a902
TG		 4647 return FALSE;
4648
4649 cmd->cryptoff = bfd_get_32 (abfd, raw.cryptoff);
4650 cmd->cryptsize = bfd_get_32 (abfd, raw.cryptsize);
4651 cmd->cryptid = bfd_get_32 (abfd, raw.cryptid);
4652 return TRUE;
4653}
4654
1778ad74
TG		 4655static bfd_boolean
4656bfd_mach_o_read_main (bfd *abfd, bfd_mach_o_load_command *command)
4657{
4658 bfd_mach_o_main_command *cmd = &command->command.main;
4659 struct mach_o_entry_point_command_external raw;
4660
47daa70f 4661 if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
1778ad74
TG		 4662 return FALSE;
4663
4664 cmd->entryoff = bfd_get_64 (abfd, raw.entryoff);
4665 cmd->stacksize = bfd_get_64 (abfd, raw.stacksize);
4666 return TRUE;
4667}
4668
4669static bfd_boolean
4670bfd_mach_o_read_source_version (bfd *abfd, bfd_mach_o_load_command *command)
4671{
4672 bfd_mach_o_source_version_command *cmd = &command->command.source_version;
4673 struct mach_o_source_version_command_external raw;
4674 bfd_uint64_t ver;
4675
47daa70f 4676 if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
1778ad74
TG		 4677 return FALSE;
4678
4679 ver = bfd_get_64 (abfd, raw.version);
4680 /* Note: we use a serie of shift to avoid shift > 32 (for which gcc
4681 generates warnings) in case of the host doesn't support 64 bit
4682 integers. */
4683 cmd->e = ver & 0x3ff;
4684 ver >>= 10;
4685 cmd->d = ver & 0x3ff;
4686 ver >>= 10;
4687 cmd->c = ver & 0x3ff;
4688 ver >>= 10;
4689 cmd->b = ver & 0x3ff;
4690 ver >>= 10;
4691 cmd->a = ver & 0xffffff;
4692 return TRUE;
4693}
4694
fc7b364a
RB		 4695static bfd_boolean
4696bfd_mach_o_read_note (bfd *abfd, bfd_mach_o_load_command *command)
4697{
4698 bfd_mach_o_note_command *cmd = &command->command.note;
4699 struct mach_o_note_command_external raw;
4700
4701 if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
4702 return FALSE;
4703
4704 memcpy (cmd->data_owner, raw.data_owner, 16);
4705 cmd->offset = bfd_get_64 (abfd, raw.offset);
4706 cmd->size = bfd_get_64 (abfd, raw.size);
4707 return TRUE;
4708}
4709
4710static bfd_boolean
4711bfd_mach_o_read_build_version (bfd *abfd, bfd_mach_o_load_command *command)
4712{
4713 bfd_mach_o_build_version_command *cmd = &command->command.build_version;
4714 struct mach_o_build_version_command_external raw;
4715
4716 if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
4717 return FALSE;
4718
4719 cmd->platform = bfd_get_32 (abfd, raw.platform);
4720 cmd->minos = bfd_get_32 (abfd, raw.minos);
4721 cmd->sdk = bfd_get_32 (abfd, raw.sdk);
4722 cmd->ntools = bfd_get_32 (abfd, raw.ntools);
4723 return TRUE;
4724}
4725
452216ab 4726static bfd_boolean
ab273af8 4727bfd_mach_o_read_segment (bfd *abfd,
07d6d2b8
AM		 4728 bfd_mach_o_load_command *command,
4729 unsigned int wide)
3af9a47b 4730{
3af9a47b
NC		 4731 bfd_mach_o_segment_command *seg = &command->command.segment;
4732 unsigned long i;
a95a4550 4733
1e8a024a
TG		 4734 if (wide)
4735 {
46d1c23b
TG		 4736 struct mach_o_segment_command_64_external raw;
4737
1e8a024a 4738 BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT_64);
3af9a47b 4739
47daa70f 4740 if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
07d6d2b8 4741 return FALSE;
3af9a47b 4742
46d1c23b 4743 memcpy (seg->segname, raw.segname, 16);
15e1c58a 4744 seg->segname[16] = '\0';
1e8a024a 4745
46d1c23b
TG		 4746 seg->vmaddr = bfd_h_get_64 (abfd, raw.vmaddr);
4747 seg->vmsize = bfd_h_get_64 (abfd, raw.vmsize);
4748 seg->fileoff = bfd_h_get_64 (abfd, raw.fileoff);
4749 seg->filesize = bfd_h_get_64 (abfd, raw.filesize);
4750 seg->maxprot = bfd_h_get_32 (abfd, raw.maxprot);
4751 seg->initprot = bfd_h_get_32 (abfd, raw.initprot);
4752 seg->nsects = bfd_h_get_32 (abfd, raw.nsects);
4753 seg->flags = bfd_h_get_32 (abfd, raw.flags);
1e8a024a
TG		 4754 }
4755 else
4756 {
46d1c23b
TG		 4757 struct mach_o_segment_command_32_external raw;
4758
1e8a024a
TG		 4759 BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT);
4760
47daa70f 4761 if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
07d6d2b8 4762 return FALSE;
1e8a024a 4763
46d1c23b 4764 memcpy (seg->segname, raw.segname, 16);
15e1c58a 4765 seg->segname[16] = '\0';
1e8a024a 4766
46d1c23b
TG		 4767 seg->vmaddr = bfd_h_get_32 (abfd, raw.vmaddr);
4768 seg->vmsize = bfd_h_get_32 (abfd, raw.vmsize);
4769 seg->fileoff = bfd_h_get_32 (abfd, raw.fileoff);
4770 seg->filesize = bfd_h_get_32 (abfd, raw.filesize);
4771 seg->maxprot = bfd_h_get_32 (abfd, raw.maxprot);
4772 seg->initprot = bfd_h_get_32 (abfd, raw.initprot);
4773 seg->nsects = bfd_h_get_32 (abfd, raw.nsects);
4774 seg->flags = bfd_h_get_32 (abfd, raw.flags);
1e8a024a 4775 }
9d4b6009
TG		 4776 seg->sect_head = NULL;
4777 seg->sect_tail = NULL;
3af9a47b 4778
f1bde64c 4779 for (i = 0; i < seg->nsects; i++)
3af9a47b 4780 {
f1bde64c 4781 asection *sec;
a95a4550 4782
47daa70f 4783 sec = bfd_mach_o_read_section (abfd, seg->initprot, wide);
f1bde64c 4784 if (sec == NULL)
07d6d2b8 4785 return FALSE;
f1bde64c 4786
c9ffd2ea
TG		 4787 bfd_mach_o_append_section_to_segment
4788 (seg, bfd_mach_o_get_mach_o_section (sec));
3af9a47b
NC		 4789 }
4790
452216ab 4791 return TRUE;
3af9a47b
NC		 4792}
4793
452216ab 4794static bfd_boolean
ab273af8 4795bfd_mach_o_read_segment_32 (bfd *abfd, bfd_mach_o_load_command *command)
1e8a024a 4796{
ab273af8 4797 return bfd_mach_o_read_segment (abfd, command, 0);
1e8a024a
TG		 4798}
4799
452216ab 4800static bfd_boolean
ab273af8 4801bfd_mach_o_read_segment_64 (bfd *abfd, bfd_mach_o_load_command *command)
1e8a024a 4802{
ab273af8 4803 return bfd_mach_o_read_segment (abfd, command, 1);
1e8a024a
TG		 4804}
4805
452216ab 4806static bfd_boolean
ab273af8 4807bfd_mach_o_read_command (bfd *abfd, bfd_mach_o_load_command *command)
3af9a47b 4808{
47daa70f 4809 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
46d1c23b
TG		 4810 struct mach_o_load_command_external raw;
4811 unsigned int cmd;
3af9a47b 4812
046b007d 4813 /* Read command type and length. */
47daa70f 4814 if (bfd_seek (abfd, mdata->hdr_offset + command->offset, SEEK_SET) != 0
46d1c23b 4815 || bfd_bread (&raw, BFD_MACH_O_LC_SIZE, abfd) != BFD_MACH_O_LC_SIZE)
452216ab 4816 return FALSE;
3af9a47b 4817
46d1c23b
TG		 4818 cmd = bfd_h_get_32 (abfd, raw.cmd);
4819 command->type = cmd & ~BFD_MACH_O_LC_REQ_DYLD;
4820 command->type_required = cmd & BFD_MACH_O_LC_REQ_DYLD ? TRUE : FALSE;
4821 command->len = bfd_h_get_32 (abfd, raw.cmdsize);
3af9a47b
NC		 4822
4823 switch (command->type)
4824 {
4825 case BFD_MACH_O_LC_SEGMENT:
452216ab
TG		 4826 if (!bfd_mach_o_read_segment_32 (abfd, command))
4827 return FALSE;
1e8a024a
TG		 4828 break;
4829 case BFD_MACH_O_LC_SEGMENT_64:
452216ab
TG		 4830 if (!bfd_mach_o_read_segment_64 (abfd, command))
4831 return FALSE;
3af9a47b
NC		 4832 break;
4833 case BFD_MACH_O_LC_SYMTAB:
452216ab
TG		 4834 if (!bfd_mach_o_read_symtab (abfd, command))
4835 return FALSE;
3af9a47b
NC		 4836 break;
4837 case BFD_MACH_O_LC_SYMSEG:
4838 break;
4839 case BFD_MACH_O_LC_THREAD:
4840 case BFD_MACH_O_LC_UNIXTHREAD:
452216ab
TG		 4841 if (!bfd_mach_o_read_thread (abfd, command))
4842 return FALSE;
3af9a47b
NC		 4843 break;
4844 case BFD_MACH_O_LC_LOAD_DYLINKER:
4845 case BFD_MACH_O_LC_ID_DYLINKER:
10be66a4 4846 case BFD_MACH_O_LC_DYLD_ENVIRONMENT:
452216ab
TG		 4847 if (!bfd_mach_o_read_dylinker (abfd, command))
4848 return FALSE;
3af9a47b
NC		 4849 break;
4850 case BFD_MACH_O_LC_LOAD_DYLIB:
fbe383b9 4851 case BFD_MACH_O_LC_LAZY_LOAD_DYLIB:
3af9a47b
NC		 4852 case BFD_MACH_O_LC_ID_DYLIB:
4853 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB:
046b007d 4854 case BFD_MACH_O_LC_REEXPORT_DYLIB:
73017762 4855 case BFD_MACH_O_LC_LOAD_UPWARD_DYLIB:
452216ab
TG		 4856 if (!bfd_mach_o_read_dylib (abfd, command))
4857 return FALSE;
3af9a47b
NC		 4858 break;
4859 case BFD_MACH_O_LC_PREBOUND_DYLIB:
452216ab
TG		 4860 if (!bfd_mach_o_read_prebound_dylib (abfd, command))
4861 return FALSE;
3af9a47b
NC		 4862 break;
4863 case BFD_MACH_O_LC_LOADFVMLIB:
4864 case BFD_MACH_O_LC_IDFVMLIB:
452216ab
TG		 4865 if (!bfd_mach_o_read_fvmlib (abfd, command))
4866 return FALSE;
9f4a5bd1 4867 break;
3af9a47b
NC		 4868 case BFD_MACH_O_LC_IDENT:
4869 case BFD_MACH_O_LC_FVMFILE:
4870 case BFD_MACH_O_LC_PREPAGE:
4871 case BFD_MACH_O_LC_ROUTINES:
9b02d212 4872 case BFD_MACH_O_LC_ROUTINES_64:
046b007d 4873 break;
3af9a47b 4874 case BFD_MACH_O_LC_SUB_FRAMEWORK:
046b007d
TG		 4875 case BFD_MACH_O_LC_SUB_UMBRELLA:
4876 case BFD_MACH_O_LC_SUB_LIBRARY:
4877 case BFD_MACH_O_LC_SUB_CLIENT:
0c9b2b4c 4878 case BFD_MACH_O_LC_RPATH:
452216ab 4879 if (!bfd_mach_o_read_str (abfd, command))
07d6d2b8 4880 return FALSE;
3af9a47b
NC		 4881 break;
4882 case BFD_MACH_O_LC_DYSYMTAB:
452216ab
TG		 4883 if (!bfd_mach_o_read_dysymtab (abfd, command))
4884 return FALSE;
3af9a47b 4885 break;
3af9a47b 4886 case BFD_MACH_O_LC_PREBIND_CKSUM:
452216ab
TG		 4887 if (!bfd_mach_o_read_prebind_cksum (abfd, command))
4888 return FALSE;
7a79c514
TG		 4889 break;
4890 case BFD_MACH_O_LC_TWOLEVEL_HINTS:
452216ab
TG		 4891 if (!bfd_mach_o_read_twolevel_hints (abfd, command))
4892 return FALSE;
3af9a47b 4893 break;
15e1c58a 4894 case BFD_MACH_O_LC_UUID:
452216ab
TG		 4895 if (!bfd_mach_o_read_uuid (abfd, command))
4896 return FALSE;
15e1c58a
TG		 4897 break;
4898 case BFD_MACH_O_LC_CODE_SIGNATURE:
846b9259 4899 case BFD_MACH_O_LC_SEGMENT_SPLIT_INFO:
edbdea0e 4900 case BFD_MACH_O_LC_FUNCTION_STARTS:
1778ad74
TG		 4901 case BFD_MACH_O_LC_DATA_IN_CODE:
4902 case BFD_MACH_O_LC_DYLIB_CODE_SIGN_DRS:
47daa70f 4903 case BFD_MACH_O_LC_LINKER_OPTIMIZATION_HINT:
452216ab
TG		 4904 if (!bfd_mach_o_read_linkedit (abfd, command))
4905 return FALSE;
15e1c58a 4906 break;
fc55a902
TG		 4907 case BFD_MACH_O_LC_ENCRYPTION_INFO:
4908 if (!bfd_mach_o_read_encryption_info (abfd, command))
452216ab 4909 return FALSE;
fc55a902 4910 break;
47daa70f
TG		 4911 case BFD_MACH_O_LC_ENCRYPTION_INFO_64:
4912 if (!bfd_mach_o_read_encryption_info_64 (abfd, command))
4913 return FALSE;
4914 break;
ad86f1fb 4915 case BFD_MACH_O_LC_DYLD_INFO:
452216ab
TG		 4916 if (!bfd_mach_o_read_dyld_info (abfd, command))
4917 return FALSE;
ad86f1fb 4918 break;
edbdea0e
TG		 4919 case BFD_MACH_O_LC_VERSION_MIN_MACOSX:
4920 case BFD_MACH_O_LC_VERSION_MIN_IPHONEOS:
47daa70f 4921 case BFD_MACH_O_LC_VERSION_MIN_WATCHOS:
fc7b364a 4922 case BFD_MACH_O_LC_VERSION_MIN_TVOS:
edbdea0e 4923 if (!bfd_mach_o_read_version_min (abfd, command))
452216ab 4924 return FALSE;
edbdea0e 4925 break;
1778ad74
TG		 4926 case BFD_MACH_O_LC_MAIN:
4927 if (!bfd_mach_o_read_main (abfd, command))
452216ab 4928 return FALSE;
1778ad74
TG		 4929 break;
4930 case BFD_MACH_O_LC_SOURCE_VERSION:
4931 if (!bfd_mach_o_read_source_version (abfd, command))
452216ab 4932 return FALSE;
1778ad74 4933 break;
ddea148b 4934 case BFD_MACH_O_LC_LINKER_OPTIONS:
fc7b364a
RB		 4935 break;
4936 case BFD_MACH_O_LC_NOTE:
4937 if (!bfd_mach_o_read_note (abfd, command))
4b24dd1a 4938 return FALSE;
fc7b364a 4939 break;
ddea148b 4940 case BFD_MACH_O_LC_BUILD_VERSION:
fc7b364a 4941 if (!bfd_mach_o_read_build_version (abfd, command))
4b24dd1a 4942 return FALSE;
ddea148b 4943 break;
3af9a47b 4944 default:
86eafac0 4945 command->len = 0;
871b3ab2 4946 _bfd_error_handler (_("%pB: unknown load command %#x"),
d42c267e 4947 abfd, command->type);
86eafac0 4948 return FALSE;
3af9a47b
NC		 4949 }
4950
452216ab 4951 return TRUE;
3af9a47b
NC		 4952}
4953
4954static void
116c20d2 4955bfd_mach_o_flatten_sections (bfd *abfd)
3af9a47b 4956{
046b007d 4957 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
c9ffd2ea 4958 bfd_mach_o_load_command *cmd;
3af9a47b 4959 long csect = 0;
a95a4550 4960
15e1c58a 4961 /* Count total number of sections. */
3af9a47b
NC		 4962 mdata->nsects = 0;
4963
c9ffd2ea 4964 for (cmd = mdata->first_command; cmd != NULL; cmd = cmd->next)
3af9a47b 4965 {
c9ffd2ea
TG		 4966 if (cmd->type == BFD_MACH_O_LC_SEGMENT
4967 || cmd->type == BFD_MACH_O_LC_SEGMENT_64)
3af9a47b 4968 {
c9ffd2ea 4969 bfd_mach_o_segment_command *seg = &cmd->command.segment;
e84d6fca 4970
3af9a47b
NC		 4971 mdata->nsects += seg->nsects;
4972 }
4973 }
4974
15e1c58a 4975 /* Allocate sections array. */
64d29018
NC		 4976 mdata->sections = bfd_alloc2 (abfd,
4977 mdata->nsects, sizeof (bfd_mach_o_section *));
15e1c58a
TG		 4978
4979 /* Fill the array. */
3af9a47b
NC		 4980 csect = 0;
4981
c9ffd2ea 4982 for (cmd = mdata->first_command; cmd != NULL; cmd = cmd->next)
3af9a47b 4983 {
c9ffd2ea
TG		 4984 if (cmd->type == BFD_MACH_O_LC_SEGMENT
4985 || cmd->type == BFD_MACH_O_LC_SEGMENT_64)
3af9a47b 4986 {
c9ffd2ea 4987 bfd_mach_o_segment_command *seg = &cmd->command.segment;
07d6d2b8 4988 bfd_mach_o_section *sec;
3af9a47b
NC		 4989
4990 BFD_ASSERT (csect + seg->nsects <= mdata->nsects);
4991
07d6d2b8 4992 for (sec = seg->sect_head; sec != NULL; sec = sec->next)
f1bde64c 4993 mdata->sections[csect++] = sec;
3af9a47b
NC		 4994 }
4995 }
4996}
4997
afbb9e17 4998static bfd_boolean
116c20d2 4999bfd_mach_o_scan_start_address (bfd *abfd)
3af9a47b 5000{
046b007d 5001 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
c9ffd2ea
TG		 5002 bfd_mach_o_thread_command *thr = NULL;
5003 bfd_mach_o_load_command *cmd;
3af9a47b
NC		 5004 unsigned long i;
5005
c9ffd2ea
TG		 5006 for (cmd = mdata->first_command; cmd != NULL; cmd = cmd->next)
5007 if (cmd->type == BFD_MACH_O_LC_THREAD
5008 || cmd->type == BFD_MACH_O_LC_UNIXTHREAD)
afbb9e17 5009 {
07d6d2b8
AM		 5010 thr = &cmd->command.thread;
5011 break;
afbb9e17 5012 }
c9ffd2ea 5013 else if (cmd->type == BFD_MACH_O_LC_MAIN && mdata->nsects > 1)
c0fd7846 5014 {
c9ffd2ea 5015 bfd_mach_o_main_command *main_cmd = &cmd->command.main;
c0fd7846 5016 bfd_mach_o_section *text_sect = mdata->sections[0];
c9ffd2ea 5017
c0fd7846
TG		 5018 if (text_sect)
5019 {
5020 abfd->start_address = main_cmd->entryoff
5021 + (text_sect->addr - text_sect->offset);
5022 return TRUE;
5023 }
5024 }
3af9a47b 5025
5ee43bc4 5026 /* An object file has no start address, so do not fail if not found. */
c9ffd2ea 5027 if (thr == NULL)
5ee43bc4 5028 return TRUE;
3af9a47b 5029
afbb9e17 5030 /* FIXME: create a subtarget hook ? */
c9ffd2ea 5031 for (i = 0; i < thr->nflavours; i++)
3af9a47b 5032 {
a95a4550 5033 if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_I386)
c9ffd2ea 5034 && (thr->flavours[i].flavour == BFD_MACH_O_x86_THREAD_STATE32))
3af9a47b
NC		 5035 {
5036 unsigned char buf[4];
5037
c9ffd2ea 5038 if (bfd_seek (abfd, thr->flavours[i].offset + 40, SEEK_SET) != 0
07d6d2b8 5039 || bfd_bread (buf, 4, abfd) != 4)
afbb9e17 5040 return FALSE;
3af9a47b
NC		 5041
5042 abfd->start_address = bfd_h_get_32 (abfd, buf);
5043 }
a95a4550 5044 else if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_POWERPC)
c9ffd2ea 5045 && (thr->flavours[i].flavour == BFD_MACH_O_PPC_THREAD_STATE))
3af9a47b
NC		 5046 {
5047 unsigned char buf[4];
5048
c9ffd2ea 5049 if (bfd_seek (abfd, thr->flavours[i].offset + 0, SEEK_SET) != 0
07d6d2b8 5050 || bfd_bread (buf, 4, abfd) != 4)
afbb9e17 5051 return FALSE;
3af9a47b
NC		 5052
5053 abfd->start_address = bfd_h_get_32 (abfd, buf);
5054 }
1e8a024a 5055 else if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_POWERPC_64)
07d6d2b8
AM		 5056 && (thr->flavours[i].flavour == BFD_MACH_O_PPC_THREAD_STATE64))
5057 {
5058 unsigned char buf[8];
1e8a024a 5059
07d6d2b8
AM		 5060 if (bfd_seek (abfd, thr->flavours[i].offset + 0, SEEK_SET) != 0
5061 || bfd_bread (buf, 8, abfd) != 8)
5062 return FALSE;
1e8a024a 5063
07d6d2b8
AM		 5064 abfd->start_address = bfd_h_get_64 (abfd, buf);
5065 }
1e8a024a 5066 else if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_X86_64)
07d6d2b8
AM		 5067 && (thr->flavours[i].flavour == BFD_MACH_O_x86_THREAD_STATE64))
5068 {
5069 unsigned char buf[8];
1e8a024a 5070
07d6d2b8
AM		 5071 if (bfd_seek (abfd, thr->flavours[i].offset + (16 * 8), SEEK_SET) != 0
5072 || bfd_bread (buf, 8, abfd) != 8)
5073 return FALSE;
1e8a024a 5074
07d6d2b8
AM		 5075 abfd->start_address = bfd_h_get_64 (abfd, buf);
5076 }
3af9a47b
NC		 5077 }
5078
afbb9e17 5079 return TRUE;
3af9a47b
NC		 5080}
5081
42fa0891
TG		 5082bfd_boolean
5083bfd_mach_o_set_arch_mach (bfd *abfd,
07d6d2b8
AM		 5084 enum bfd_architecture arch,
5085 unsigned long machine)
42fa0891
TG		 5086{
5087 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
5088
5089 /* If this isn't the right architecture for this backend, and this
5090 isn't the generic backend, fail. */
5091 if (arch != bed->arch
5092 && arch != bfd_arch_unknown
5093 && bed->arch != bfd_arch_unknown)
5094 return FALSE;
5095
5096 return bfd_default_set_arch_mach (abfd, arch, machine);
5097}
5098
afbb9e17 5099static bfd_boolean
116c20d2
NC		 5100bfd_mach_o_scan (bfd *abfd,
5101 bfd_mach_o_header *header,
5102 bfd_mach_o_data_struct *mdata)
3af9a47b
NC		 5103{
5104 unsigned int i;
3af9a47b
NC		 5105 enum bfd_architecture cputype;
5106 unsigned long cpusubtype;
1e8a024a
TG		 5107 unsigned int hdrsize;
5108
c2f09c75 5109 hdrsize = mach_o_wide_p (header) ?
154a1ee5 5110 BFD_MACH_O_HEADER_64_SIZE : BFD_MACH_O_HEADER_SIZE;
3af9a47b 5111
3af9a47b 5112 mdata->header = *header;
3af9a47b 5113
154a1ee5 5114 abfd->flags = abfd->flags & BFD_IN_MEMORY;
15e1c58a
TG		 5115 switch (header->filetype)
5116 {
5117 case BFD_MACH_O_MH_OBJECT:
5118 abfd->flags |= HAS_RELOC;
5119 break;
5120 case BFD_MACH_O_MH_EXECUTE:
5121 abfd->flags |= EXEC_P;
5122 break;
5123 case BFD_MACH_O_MH_DYLIB:
5124 case BFD_MACH_O_MH_BUNDLE:
5125 abfd->flags |= DYNAMIC;
5126 break;
5127 }
5128
3af9a47b
NC		 5129 abfd->tdata.mach_o_data = mdata;
5130
e84d6fca
AM		 5131 bfd_mach_o_convert_architecture (header->cputype, header->cpusubtype,
5132 &cputype, &cpusubtype);
3af9a47b
NC		 5133 if (cputype == bfd_arch_unknown)
5134 {
4eca0228 5135 _bfd_error_handler
695344c0 5136 /* xgettext:c-format */
07d6d2b8
AM		 5137 (_("bfd_mach_o_scan: unknown architecture 0x%lx/0x%lx"),
5138 header->cputype, header->cpusubtype);
afbb9e17 5139 return FALSE;
3af9a47b
NC		 5140 }
5141
5142 bfd_set_arch_mach (abfd, cputype, cpusubtype);
a95a4550 5143
3af9a47b
NC		 5144 if (header->ncmds != 0)
5145 {
c9ffd2ea
TG		 5146 bfd_mach_o_load_command *cmd;
5147
5148 mdata->first_command = NULL;
5149 mdata->last_command = NULL;
64d29018
NC		 5150
5151 cmd = bfd_alloc2 (abfd, header->ncmds, sizeof (bfd_mach_o_load_command));
c9ffd2ea 5152 if (cmd == NULL)
afbb9e17 5153 return FALSE;
a95a4550 5154
3af9a47b
NC		 5155 for (i = 0; i < header->ncmds; i++)
5156 {
c9ffd2ea
TG		 5157 bfd_mach_o_load_command *cur = &cmd[i];
5158
5159 bfd_mach_o_append_command (abfd, cur);
3af9a47b
NC		 5160
5161 if (i == 0)
1e8a024a 5162 cur->offset = hdrsize;
3af9a47b
NC		 5163 else
5164 {
c9ffd2ea 5165 bfd_mach_o_load_command *prev = &cmd[i - 1];
3af9a47b
NC		 5166 cur->offset = prev->offset + prev->len;
5167 }
5168
452216ab 5169 if (!bfd_mach_o_read_command (abfd, cur))
afbb9e17 5170 return FALSE;
a95a4550 5171 }
3af9a47b
NC		 5172 }
5173
c0fd7846
TG		 5174 /* Sections should be flatten before scanning start address. */
5175 bfd_mach_o_flatten_sections (abfd);
5176 if (!bfd_mach_o_scan_start_address (abfd))
afbb9e17 5177 return FALSE;
3af9a47b 5178
afbb9e17 5179 return TRUE;
3af9a47b
NC		 5180}
5181
b34976b6 5182bfd_boolean
154a1ee5 5183bfd_mach_o_mkobject_init (bfd *abfd)
3af9a47b
NC		 5184{
5185 bfd_mach_o_data_struct *mdata = NULL;
5186
b30a5d18 5187 mdata = bfd_zalloc (abfd, sizeof (bfd_mach_o_data_struct));
3af9a47b 5188 if (mdata == NULL)
b34976b6 5189 return FALSE;
3af9a47b
NC		 5190 abfd->tdata.mach_o_data = mdata;
5191
5192 mdata->header.magic = 0;
5193 mdata->header.cputype = 0;
5194 mdata->header.cpusubtype = 0;
5195 mdata->header.filetype = 0;
5196 mdata->header.ncmds = 0;
5197 mdata->header.sizeofcmds = 0;
5198 mdata->header.flags = 0;
5199 mdata->header.byteorder = BFD_ENDIAN_UNKNOWN;
c9ffd2ea
TG		 5200 mdata->first_command = NULL;
5201 mdata->last_command = NULL;
3af9a47b
NC		 5202 mdata->nsects = 0;
5203 mdata->sections = NULL;
4434114c 5204 mdata->dyn_reloc_cache = NULL;
3af9a47b 5205
b34976b6 5206 return TRUE;
3af9a47b
NC		 5207}
5208
42fa0891
TG		 5209static bfd_boolean
5210bfd_mach_o_gen_mkobject (bfd *abfd)
5211{
5212 bfd_mach_o_data_struct *mdata;
5213
5214 if (!bfd_mach_o_mkobject_init (abfd))
5215 return FALSE;
5216
5217 mdata = bfd_mach_o_get_data (abfd);
5218 mdata->header.magic = BFD_MACH_O_MH_MAGIC;
5219 mdata->header.cputype = 0;
5220 mdata->header.cpusubtype = 0;
5221 mdata->header.byteorder = abfd->xvec->byteorder;
5222 mdata->header.version = 1;
5223
5224 return TRUE;
5225}
5226
3af9a47b 5227const bfd_target *
154a1ee5 5228bfd_mach_o_header_p (bfd *abfd,
47daa70f 5229 file_ptr hdr_off,
07d6d2b8
AM		 5230 bfd_mach_o_filetype filetype,
5231 bfd_mach_o_cpu_type cputype)
3af9a47b
NC		 5232{
5233 bfd_mach_o_header header;
c9ba0c87 5234 bfd_mach_o_data_struct *mdata;
3af9a47b 5235
47daa70f 5236 if (!bfd_mach_o_read_header (abfd, hdr_off, &header))
e84d6fca 5237 goto wrong;
3af9a47b 5238
e84d6fca
AM		 5239 if (! (header.byteorder == BFD_ENDIAN_BIG
5240 || header.byteorder == BFD_ENDIAN_LITTLE))
3af9a47b 5241 {
d42c267e
AM		 5242 _bfd_error_handler (_("unknown header byte-order value %#x"),
5243 header.byteorder);
e84d6fca 5244 goto wrong;
3af9a47b
NC		 5245 }
5246
e84d6fca
AM		 5247 if (! ((header.byteorder == BFD_ENDIAN_BIG
5248 && abfd->xvec->byteorder == BFD_ENDIAN_BIG
5249 && abfd->xvec->header_byteorder == BFD_ENDIAN_BIG)
5250 || (header.byteorder == BFD_ENDIAN_LITTLE
5251 && abfd->xvec->byteorder == BFD_ENDIAN_LITTLE
5252 && abfd->xvec->header_byteorder == BFD_ENDIAN_LITTLE)))
5253 goto wrong;
3af9a47b 5254
154a1ee5
TG		 5255 /* Check cputype and filetype.
5256 In case of wildcard, do not accept magics that are handled by existing
5257 targets. */
5258 if (cputype)
5259 {
5260 if (header.cputype != cputype)
07d6d2b8 5261 goto wrong;
154a1ee5 5262 }
26954155
TG		 5263 else
5264 {
5265#ifndef BFD64
5266 /* Do not recognize 64 architectures if not configured for 64bit targets.
5267 This could happen only for generic targets. */
5268 if (mach_o_wide_p (&header))
5269 goto wrong;
5270#endif
5271 }
b22161d6 5272
154a1ee5
TG		 5273 if (filetype)
5274 {
5275 if (header.filetype != filetype)
07d6d2b8 5276 goto wrong;
154a1ee5
TG		 5277 }
5278 else
5279 {
5280 switch (header.filetype)
07d6d2b8
AM		 5281 {
5282 case BFD_MACH_O_MH_CORE:
5283 /* Handled by core_p */
5284 goto wrong;
5285 default:
5286 break;
5287 }
154a1ee5
TG		 5288 }
5289
c9ba0c87
AM		 5290 mdata = (bfd_mach_o_data_struct *) bfd_zalloc (abfd, sizeof (*mdata));
5291 if (mdata == NULL)
e84d6fca 5292 goto fail;
47daa70f 5293 mdata->hdr_offset = hdr_off;
3af9a47b 5294
c9ba0c87 5295 if (!bfd_mach_o_scan (abfd, &header, mdata))
e84d6fca 5296 goto wrong;
a95a4550 5297
3af9a47b 5298 return abfd->xvec;
e84d6fca
AM		 5299
5300 wrong:
5301 bfd_set_error (bfd_error_wrong_format);
5302
5303 fail:
e84d6fca 5304 return NULL;
3af9a47b
NC		 5305}
5306
154a1ee5
TG		 5307static const bfd_target *
5308bfd_mach_o_gen_object_p (bfd *abfd)
3af9a47b 5309{
47daa70f 5310 return bfd_mach_o_header_p (abfd, 0, 0, 0);
154a1ee5 5311}
e84d6fca 5312
154a1ee5
TG		 5313static const bfd_target *
5314bfd_mach_o_gen_core_p (bfd *abfd)
5315{
47daa70f 5316 return bfd_mach_o_header_p (abfd, 0, BFD_MACH_O_MH_CORE, 0);
3af9a47b
NC		 5317}
5318
3cc27770
TG		 5319/* Return the base address of ABFD, ie the address at which the image is
5320 mapped. The possible initial pagezero is ignored. */
5321
5322bfd_vma
5323bfd_mach_o_get_base_address (bfd *abfd)
5324{
5325 bfd_mach_o_data_struct *mdata;
c9ffd2ea 5326 bfd_mach_o_load_command *cmd;
3cc27770
TG		 5327
5328 /* Check for Mach-O. */
5329 if (!bfd_mach_o_valid (abfd))
5330 return 0;
5331 mdata = bfd_mach_o_get_data (abfd);
5332
c9ffd2ea 5333 for (cmd = mdata->first_command; cmd != NULL; cmd = cmd->next)
3cc27770 5334 {
3cc27770
TG		 5335 if ((cmd->type == BFD_MACH_O_LC_SEGMENT
5336 || cmd->type == BFD_MACH_O_LC_SEGMENT_64))
5337 {
5338 struct bfd_mach_o_segment_command *segcmd = &cmd->command.segment;
5339
5340 if (segcmd->initprot != 0)
5341 return segcmd->vmaddr;
5342 }
5343 }
5344 return 0;
5345}
5346
3af9a47b
NC		 5347typedef struct mach_o_fat_archentry
5348{
5349 unsigned long cputype;
5350 unsigned long cpusubtype;
5351 unsigned long offset;
5352 unsigned long size;
5353 unsigned long align;
3af9a47b
NC		 5354} mach_o_fat_archentry;
5355
5356typedef struct mach_o_fat_data_struct
5357{
5358 unsigned long magic;
5359 unsigned long nfat_arch;
5360 mach_o_fat_archentry *archentries;
5361} mach_o_fat_data_struct;
5362
5363const bfd_target *
47daa70f 5364bfd_mach_o_fat_archive_p (bfd *abfd)
3af9a47b 5365{
e84d6fca 5366 mach_o_fat_data_struct *adata = NULL;
46d1c23b 5367 struct mach_o_fat_header_external hdr;
3af9a47b
NC		 5368 unsigned long i;
5369
c2f09c75 5370 if (bfd_seek (abfd, 0, SEEK_SET) != 0
46d1c23b 5371 || bfd_bread (&hdr, sizeof (hdr), abfd) != sizeof (hdr))
e84d6fca 5372 goto error;
3af9a47b 5373
116c20d2 5374 adata = bfd_alloc (abfd, sizeof (mach_o_fat_data_struct));
3af9a47b 5375 if (adata == NULL)
e84d6fca 5376 goto error;
a95a4550 5377
46d1c23b
TG		 5378 adata->magic = bfd_getb32 (hdr.magic);
5379 adata->nfat_arch = bfd_getb32 (hdr.nfat_arch);
3af9a47b 5380 if (adata->magic != 0xcafebabe)
e84d6fca 5381 goto error;
27cc28f9
AS		 5382 /* Avoid matching Java bytecode files, which have the same magic number.
5383 In the Java bytecode file format this field contains the JVM version,
5384 which starts at 43.0. */
5385 if (adata->nfat_arch > 30)
5386 goto error;
3af9a47b 5387
c2f09c75 5388 adata->archentries =
64d29018 5389 bfd_alloc2 (abfd, adata->nfat_arch, sizeof (mach_o_fat_archentry));
3af9a47b 5390 if (adata->archentries == NULL)
e84d6fca 5391 goto error;
3af9a47b
NC		 5392
5393 for (i = 0; i < adata->nfat_arch; i++)
5394 {
46d1c23b
TG		 5395 struct mach_o_fat_arch_external arch;
5396 if (bfd_bread (&arch, sizeof (arch), abfd) != sizeof (arch))
e84d6fca 5397 goto error;
46d1c23b
TG		 5398 adata->archentries[i].cputype = bfd_getb32 (arch.cputype);
5399 adata->archentries[i].cpusubtype = bfd_getb32 (arch.cpusubtype);
5400 adata->archentries[i].offset = bfd_getb32 (arch.offset);
5401 adata->archentries[i].size = bfd_getb32 (arch.size);
5402 adata->archentries[i].align = bfd_getb32 (arch.align);
3af9a47b
NC		 5403 }
5404
5405 abfd->tdata.mach_o_fat_data = adata;
64d29018 5406
3af9a47b 5407 return abfd->xvec;
e84d6fca
AM		 5408
5409 error:
5410 if (adata != NULL)
5411 bfd_release (abfd, adata);
5412 bfd_set_error (bfd_error_wrong_format);
5413 return NULL;
3af9a47b
NC		 5414}
5415
a4e241ca
TG		 5416/* Set the filename for a fat binary member ABFD, whose bfd architecture is
5417 ARCH_TYPE/ARCH_SUBTYPE and corresponding entry in header is ENTRY.
5418 Set arelt_data and origin fields too. */
5419
5420static void
5421bfd_mach_o_fat_member_init (bfd *abfd,
07d6d2b8
AM		 5422 enum bfd_architecture arch_type,
5423 unsigned long arch_subtype,
5424 mach_o_fat_archentry *entry)
a4e241ca
TG		 5425{
5426 struct areltdata *areltdata;
5427 /* Create the member filename. Use ARCH_NAME. */
5428 const bfd_arch_info_type *ap = bfd_lookup_arch (arch_type, arch_subtype);
5429
5430 if (ap)
5431 {
5432 /* Use the architecture name if known. */
1be5090b 5433 abfd->filename = xstrdup (ap->printable_name);
a4e241ca
TG		 5434 }
5435 else
5436 {
5437 /* Forge a uniq id. */
5438 const size_t namelen = 2 + 8 + 1 + 2 + 8 + 1;
1be5090b 5439 char *name = xmalloc (namelen);
a4e241ca 5440 snprintf (name, namelen, "0x%lx-0x%lx",
07d6d2b8 5441 entry->cputype, entry->cpusubtype);
a4e241ca
TG		 5442 abfd->filename = name;
5443 }
5444
06e7acd7 5445 areltdata = bfd_zmalloc (sizeof (struct areltdata));
a4e241ca
TG		 5446 areltdata->parsed_size = entry->size;
5447 abfd->arelt_data = areltdata;
5448 abfd->iostream = NULL;
5449 abfd->origin = entry->offset;
5450}
5451
3af9a47b 5452bfd *
47daa70f 5453bfd_mach_o_fat_openr_next_archived_file (bfd *archive, bfd *prev)
3af9a47b 5454{
e84d6fca 5455 mach_o_fat_data_struct *adata;
3af9a47b
NC		 5456 mach_o_fat_archentry *entry = NULL;
5457 unsigned long i;
15e1c58a 5458 bfd *nbfd;
15e1c58a
TG		 5459 enum bfd_architecture arch_type;
5460 unsigned long arch_subtype;
3af9a47b 5461
e84d6fca 5462 adata = (mach_o_fat_data_struct *) archive->tdata.mach_o_fat_data;
3af9a47b
NC		 5463 BFD_ASSERT (adata != NULL);
5464
5465 /* Find index of previous entry. */
5466 if (prev == NULL)
a4e241ca
TG		 5467 {
5468 /* Start at first one. */
5469 i = 0;
5470 }
3af9a47b
NC		 5471 else
5472 {
a4e241ca 5473 /* Find index of PREV. */
3af9a47b
NC		 5474 for (i = 0; i < adata->nfat_arch; i++)
5475 {
15e1c58a 5476 if (adata->archentries[i].offset == prev->origin)
3af9a47b
NC		 5477 break;
5478 }
5479
5480 if (i == adata->nfat_arch)
5481 {
5482 /* Not found. */
5483 bfd_set_error (bfd_error_bad_value);
a95a4550 5484 return NULL;
3af9a47b 5485 }
a4e241ca
TG		 5486
5487 /* Get next entry. */
5488 i++;
5489 }
a95a4550 5490
3af9a47b
NC		 5491 if (i >= adata->nfat_arch)
5492 {
5493 bfd_set_error (bfd_error_no_more_archived_files);
5494 return NULL;
5495 }
5496
5497 entry = &adata->archentries[i];
15e1c58a
TG		 5498 nbfd = _bfd_new_bfd_contained_in (archive);
5499 if (nbfd == NULL)
5500 return NULL;
5501
15e1c58a
TG		 5502 bfd_mach_o_convert_architecture (entry->cputype, entry->cpusubtype,
5503 &arch_type, &arch_subtype);
846b9259 5504
a4e241ca
TG		 5505 bfd_mach_o_fat_member_init (nbfd, arch_type, arch_subtype, entry);
5506
846b9259 5507 bfd_set_arch_mach (nbfd, arch_type, arch_subtype);
3af9a47b 5508
15e1c58a 5509 return nbfd;
3af9a47b
NC		 5510}
5511
15bbba8d
TG		 5512/* Analogous to stat call. */
5513
5514static int
5515bfd_mach_o_fat_stat_arch_elt (bfd *abfd, struct stat *buf)
5516{
5517 if (abfd->arelt_data == NULL)
5518 {
5519 bfd_set_error (bfd_error_invalid_operation);
5520 return -1;
5521 }
5522
5523 buf->st_mtime = 0;
5524 buf->st_uid = 0;
5525 buf->st_gid = 0;
5526 buf->st_mode = 0644;
5527 buf->st_size = arelt_size (abfd);
5528
5529 return 0;
5530}
5531
846b9259
TG		 5532/* If ABFD format is FORMAT and architecture is ARCH, return it.
5533 If ABFD is a fat image containing a member that corresponds to FORMAT
5534 and ARCH, returns it.
5535 In other case, returns NULL.
5536 This function allows transparent uses of fat images. */
a4e241ca 5537
846b9259
TG		 5538bfd *
5539bfd_mach_o_fat_extract (bfd *abfd,
5540 bfd_format format,
5541 const bfd_arch_info_type *arch)
5542{
5543 bfd *res;
5544 mach_o_fat_data_struct *adata;
5545 unsigned int i;
5546
5547 if (bfd_check_format (abfd, format))
5548 {
5549 if (bfd_get_arch_info (abfd) == arch)
5550 return abfd;
5551 return NULL;
5552 }
5553 if (!bfd_check_format (abfd, bfd_archive)
5554 || abfd->xvec != &mach_o_fat_vec)
5555 return NULL;
c2f09c75 5556
846b9259
TG		 5557 /* This is a Mach-O fat image. */
5558 adata = (mach_o_fat_data_struct *) abfd->tdata.mach_o_fat_data;
5559 BFD_ASSERT (adata != NULL);
5560
5561 for (i = 0; i < adata->nfat_arch; i++)
5562 {
5563 struct mach_o_fat_archentry *e = &adata->archentries[i];
5564 enum bfd_architecture cpu_type;
5565 unsigned long cpu_subtype;
5566
5567 bfd_mach_o_convert_architecture (e->cputype, e->cpusubtype,
5568 &cpu_type, &cpu_subtype);
5569 if (cpu_type != arch->arch || cpu_subtype != arch->mach)
5570 continue;
5571
5572 /* The architecture is found. */
5573 res = _bfd_new_bfd_contained_in (abfd);
5574 if (res == NULL)
5575 return NULL;
5576
a4e241ca 5577 bfd_mach_o_fat_member_init (res, cpu_type, cpu_subtype, e);
846b9259
TG		 5578
5579 if (bfd_check_format (res, format))
5580 {
5581 BFD_ASSERT (bfd_get_arch_info (res) == arch);
5582 return res;
5583 }
5584 bfd_close (res);
5585 return NULL;
5586 }
5587
5588 return NULL;
5589}
5590
eac61af6
TT		 5591static bfd_boolean
5592bfd_mach_o_fat_close_and_cleanup (bfd *abfd)
5593{
5594 _bfd_unlink_from_archive_parent (abfd);
5595 return TRUE;
5596}
5597
3af9a47b 5598int
116c20d2
NC		 5599bfd_mach_o_lookup_command (bfd *abfd,
5600 bfd_mach_o_load_command_type type,
5601 bfd_mach_o_load_command **mcommand)
3af9a47b 5602{
c9ffd2ea
TG		 5603 struct mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
5604 struct bfd_mach_o_load_command *cmd;
5605 unsigned int num;
3af9a47b 5606
c9ffd2ea 5607 BFD_ASSERT (mdata != NULL);
3af9a47b
NC		 5608 BFD_ASSERT (mcommand != NULL);
5609
5610 num = 0;
c9ffd2ea 5611 for (cmd = mdata->first_command; cmd != NULL; cmd = cmd->next)
3af9a47b 5612 {
3af9a47b
NC		 5613 if (cmd->type != type)
5614 continue;
5615
5616 if (num == 0)
c9ffd2ea 5617 *mcommand = cmd;
3af9a47b
NC		 5618 num++;
5619 }
5620
3af9a47b
NC		 5621 return num;
5622}
5623
5624unsigned long
116c20d2 5625bfd_mach_o_stack_addr (enum bfd_mach_o_cpu_type type)
3af9a47b
NC		 5626{
5627 switch (type)
5628 {
5629 case BFD_MACH_O_CPU_TYPE_MC680x0:
5630 return 0x04000000;
3af9a47b
NC		 5631 case BFD_MACH_O_CPU_TYPE_POWERPC:
5632 return 0xc0000000;
5633 case BFD_MACH_O_CPU_TYPE_I386:
5634 return 0xc0000000;
5635 case BFD_MACH_O_CPU_TYPE_SPARC:
5636 return 0xf0000000;
3af9a47b 5637 case BFD_MACH_O_CPU_TYPE_HPPA:
e84d6fca 5638 return 0xc0000000 - 0x04000000;
3af9a47b
NC		 5639 default:
5640 return 0;
5641 }
5642}
5643
ab76eeaf
IS		 5644/* The following two tables should be kept, as far as possible, in order of
5645 most frequently used entries to optimize their use from gas. */
5646
c5012cd8 5647const bfd_mach_o_xlat_name bfd_mach_o_section_type_name[] =
046b007d
TG		 5648{
5649 { "regular", BFD_MACH_O_S_REGULAR},
ab76eeaf 5650 { "coalesced", BFD_MACH_O_S_COALESCED},
046b007d
TG		 5651 { "zerofill", BFD_MACH_O_S_ZEROFILL},
5652 { "cstring_literals", BFD_MACH_O_S_CSTRING_LITERALS},
5653 { "4byte_literals", BFD_MACH_O_S_4BYTE_LITERALS},
5654 { "8byte_literals", BFD_MACH_O_S_8BYTE_LITERALS},
ab76eeaf 5655 { "16byte_literals", BFD_MACH_O_S_16BYTE_LITERALS},
046b007d 5656 { "literal_pointers", BFD_MACH_O_S_LITERAL_POINTERS},
046b007d
TG		 5657 { "mod_init_func_pointers", BFD_MACH_O_S_MOD_INIT_FUNC_POINTERS},
5658 { "mod_fini_func_pointers", BFD_MACH_O_S_MOD_FINI_FUNC_POINTERS},
046b007d
TG		 5659 { "gb_zerofill", BFD_MACH_O_S_GB_ZEROFILL},
5660 { "interposing", BFD_MACH_O_S_INTERPOSING},
046b007d 5661 { "dtrace_dof", BFD_MACH_O_S_DTRACE_DOF},
ab76eeaf
IS		 5662 { "non_lazy_symbol_pointers", BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS},
5663 { "lazy_symbol_pointers", BFD_MACH_O_S_LAZY_SYMBOL_POINTERS},
a4551119 5664 { "symbol_stubs", BFD_MACH_O_S_SYMBOL_STUBS},
046b007d
TG		 5665 { "lazy_dylib_symbol_pointers", BFD_MACH_O_S_LAZY_DYLIB_SYMBOL_POINTERS},
5666 { NULL, 0}
5667};
5668
c5012cd8 5669const bfd_mach_o_xlat_name bfd_mach_o_section_attribute_name[] =
046b007d 5670{
ab76eeaf
IS		 5671 { "pure_instructions", BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS },
5672 { "some_instructions", BFD_MACH_O_S_ATTR_SOME_INSTRUCTIONS },
046b007d
TG		 5673 { "loc_reloc", BFD_MACH_O_S_ATTR_LOC_RELOC },
5674 { "ext_reloc", BFD_MACH_O_S_ATTR_EXT_RELOC },
046b007d 5675 { "debug", BFD_MACH_O_S_ATTR_DEBUG },
046b007d
TG		 5676 { "live_support", BFD_MACH_O_S_ATTR_LIVE_SUPPORT },
5677 { "no_dead_strip", BFD_MACH_O_S_ATTR_NO_DEAD_STRIP },
5678 { "strip_static_syms", BFD_MACH_O_S_ATTR_STRIP_STATIC_SYMS },
5679 { "no_toc", BFD_MACH_O_S_ATTR_NO_TOC },
a4551119 5680 { "self_modifying_code", BFD_MACH_O_S_SELF_MODIFYING_CODE },
ab76eeaf 5681 { "modifying_code", BFD_MACH_O_S_SELF_MODIFYING_CODE },
046b007d
TG		 5682 { NULL, 0}
5683};
5684
a4551119 5685/* Get the section type from NAME. Return 256 if NAME is unknown. */
53d58d96
TG		 5686
5687unsigned int
ab76eeaf 5688bfd_mach_o_get_section_type_from_name (bfd *abfd, const char *name)
53d58d96 5689{
afbb9e17 5690 const bfd_mach_o_xlat_name *x;
ab76eeaf 5691 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
53d58d96
TG		 5692
5693 for (x = bfd_mach_o_section_type_name; x->name; x++)
5694 if (strcmp (x->name, name) == 0)
ab76eeaf
IS		 5695 {
5696 /* We found it... does the target support it? */
5697 if (bed->bfd_mach_o_section_type_valid_for_target == NULL
5698 || bed->bfd_mach_o_section_type_valid_for_target (x->val))
5699 return x->val; /* OK. */
5700 else
5701 break; /* Not supported. */
5702 }
a4551119
TG		 5703 /* Maximum section ID = 0xff. */
5704 return 256;
53d58d96
TG		 5705}
5706
5707/* Get the section attribute from NAME. Return -1 if NAME is unknown. */
5708
5709unsigned int
5710bfd_mach_o_get_section_attribute_from_name (const char *name)
5711{
afbb9e17 5712 const bfd_mach_o_xlat_name *x;
53d58d96
TG		 5713
5714 for (x = bfd_mach_o_section_attribute_name; x->name; x++)
5715 if (strcmp (x->name, name) == 0)
5716 return x->val;
5717 return (unsigned int)-1;
5718}
5719
3af9a47b 5720int
116c20d2
NC		 5721bfd_mach_o_core_fetch_environment (bfd *abfd,
5722 unsigned char **rbuf,
5723 unsigned int *rlen)
3af9a47b 5724{
046b007d 5725 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3af9a47b 5726 unsigned long stackaddr = bfd_mach_o_stack_addr (mdata->header.cputype);
c9ffd2ea 5727 bfd_mach_o_load_command *cmd;
3af9a47b 5728
c9ffd2ea 5729 for (cmd = mdata->first_command; cmd != NULL; cmd = cmd->next)
3af9a47b 5730 {
c9ffd2ea 5731 bfd_mach_o_segment_command *seg;
3af9a47b 5732
c9ffd2ea 5733 if (cmd->type != BFD_MACH_O_LC_SEGMENT)
3af9a47b
NC		 5734 continue;
5735
c9ffd2ea 5736 seg = &cmd->command.segment;
3af9a47b
NC		 5737
5738 if ((seg->vmaddr + seg->vmsize) == stackaddr)
5739 {
5740 unsigned long start = seg->fileoff;
5741 unsigned long end = seg->fileoff + seg->filesize;
5742 unsigned char *buf = bfd_malloc (1024);
5743 unsigned long size = 1024;
5744
5745 for (;;)
5746 {
5747 bfd_size_type nread = 0;
5748 unsigned long offset;
5749 int found_nonnull = 0;
5750
5751 if (size > (end - start))
5752 size = (end - start);
5753
515ef31d
NC		 5754 buf = bfd_realloc_or_free (buf, size);
5755 if (buf == NULL)
5756 return -1;
c2f09c75
TG		 5757
5758 if (bfd_seek (abfd, end - size, SEEK_SET) != 0)
07d6d2b8
AM		 5759 {
5760 free (buf);
5761 return -1;
5762 }
c2f09c75 5763
3af9a47b 5764 nread = bfd_bread (buf, size, abfd);
a95a4550 5765
3af9a47b 5766 if (nread != size)
515ef31d
NC		 5767 {
5768 free (buf);
5769 return -1;
5770 }
a95a4550 5771
3af9a47b
NC		 5772 for (offset = 4; offset <= size; offset += 4)
5773 {
e84d6fca 5774 unsigned long val;
3af9a47b 5775
e84d6fca 5776 val = *((unsigned long *) (buf + size - offset));
3af9a47b
NC		 5777 if (! found_nonnull)
5778 {
5779 if (val != 0)
5780 found_nonnull = 1;
5781 }
5782 else if (val == 0x0)
5783 {
e84d6fca
AM		 5784 unsigned long bottom;
5785 unsigned long top;
3af9a47b 5786
e84d6fca
AM		 5787 bottom = seg->fileoff + seg->filesize - offset;
5788 top = seg->fileoff + seg->filesize - 4;
3af9a47b
NC		 5789 *rbuf = bfd_malloc (top - bottom);
5790 *rlen = top - bottom;
5791
5792 memcpy (*rbuf, buf + size - *rlen, *rlen);
515ef31d 5793 free (buf);
3af9a47b
NC		 5794 return 0;
5795 }
5796 }
5797
5798 if (size == (end - start))
5799 break;
5800
5801 size *= 2;
5802 }
515ef31d
NC		 5803
5804 free (buf);
3af9a47b
NC		 5805 }
5806 }
5807
5808 return -1;
5809}
5810
5811char *
116c20d2 5812bfd_mach_o_core_file_failing_command (bfd *abfd)
3af9a47b
NC		 5813{
5814 unsigned char *buf = NULL;
5815 unsigned int len = 0;
452216ab 5816 int ret;
3af9a47b
NC		 5817
5818 ret = bfd_mach_o_core_fetch_environment (abfd, &buf, &len);
5819 if (ret < 0)
5820 return NULL;
5821
f075ee0c 5822 return (char *) buf;
3af9a47b
NC		 5823}
5824
5825int
116c20d2 5826bfd_mach_o_core_file_failing_signal (bfd *abfd ATTRIBUTE_UNUSED)
3af9a47b
NC		 5827{
5828 return 0;
5829}
5830
2ca7691a
TG		 5831static bfd_mach_o_uuid_command *
5832bfd_mach_o_lookup_uuid_command (bfd *abfd)
5833{
09fe2662 5834 bfd_mach_o_load_command *uuid_cmd = NULL;
2ca7691a 5835 int ncmd = bfd_mach_o_lookup_command (abfd, BFD_MACH_O_LC_UUID, &uuid_cmd);
09fe2662 5836 if (ncmd != 1 || uuid_cmd == NULL)
2ca7691a
TG		 5837 return FALSE;
5838 return &uuid_cmd->command.uuid;
5839}
5840
5841/* Return true if ABFD is a dSYM file and its UUID matches UUID_CMD. */
5842
5843static bfd_boolean
5844bfd_mach_o_dsym_for_uuid_p (bfd *abfd, const bfd_mach_o_uuid_command *uuid_cmd)
5845{
5846 bfd_mach_o_uuid_command *dsym_uuid_cmd;
5847
5848 BFD_ASSERT (abfd);
5849 BFD_ASSERT (uuid_cmd);
5850
5851 if (!bfd_check_format (abfd, bfd_object))
5852 return FALSE;
5853
5854 if (bfd_get_flavour (abfd) != bfd_target_mach_o_flavour
5855 || bfd_mach_o_get_data (abfd) == NULL
5856 || bfd_mach_o_get_data (abfd)->header.filetype != BFD_MACH_O_MH_DSYM)
5857 return FALSE;
5858
5859 dsym_uuid_cmd = bfd_mach_o_lookup_uuid_command (abfd);
5860 if (dsym_uuid_cmd == NULL)
5861 return FALSE;
5862
5863 if (memcmp (uuid_cmd->uuid, dsym_uuid_cmd->uuid,
07d6d2b8 5864 sizeof (uuid_cmd->uuid)) != 0)
2ca7691a
TG		 5865 return FALSE;
5866
5867 return TRUE;
5868}
5869
5870/* Find a BFD in DSYM_FILENAME which matches ARCH and UUID_CMD.
5871 The caller is responsible for closing the returned BFD object and
5872 its my_archive if the returned BFD is in a fat dSYM. */
5873
5874static bfd *
5875bfd_mach_o_find_dsym (const char *dsym_filename,
07d6d2b8
AM		 5876 const bfd_mach_o_uuid_command *uuid_cmd,
5877 const bfd_arch_info_type *arch)
2ca7691a
TG		 5878{
5879 bfd *base_dsym_bfd, *dsym_bfd;
5880
5881 BFD_ASSERT (uuid_cmd);
5882
5883 base_dsym_bfd = bfd_openr (dsym_filename, NULL);
5884 if (base_dsym_bfd == NULL)
5885 return NULL;
5886
5887 dsym_bfd = bfd_mach_o_fat_extract (base_dsym_bfd, bfd_object, arch);
5888 if (bfd_mach_o_dsym_for_uuid_p (dsym_bfd, uuid_cmd))
5889 return dsym_bfd;
5890
5891 bfd_close (dsym_bfd);
5892 if (base_dsym_bfd != dsym_bfd)
5893 bfd_close (base_dsym_bfd);
5894
5895 return NULL;
5896}
5897
5898/* Return a BFD created from a dSYM file for ABFD.
5899 The caller is responsible for closing the returned BFD object, its
5900 filename, and its my_archive if the returned BFD is in a fat dSYM. */
5901
5902static bfd *
5903bfd_mach_o_follow_dsym (bfd *abfd)
5904{
5905 char *dsym_filename;
5906 bfd_mach_o_uuid_command *uuid_cmd;
5907 bfd *dsym_bfd, *base_bfd = abfd;
5908 const char *base_basename;
5909
5910 if (abfd == NULL || bfd_get_flavour (abfd) != bfd_target_mach_o_flavour)
5911 return NULL;
5912
b0cffb47 5913 if (abfd->my_archive && !bfd_is_thin_archive (abfd->my_archive))
2ca7691a
TG		 5914 base_bfd = abfd->my_archive;
5915 /* BFD may have been opened from a stream. */
5916 if (base_bfd->filename == NULL)
5917 {
5918 bfd_set_error (bfd_error_invalid_operation);
5919 return NULL;
5920 }
5921 base_basename = lbasename (base_bfd->filename);
5922
5923 uuid_cmd = bfd_mach_o_lookup_uuid_command (abfd);
5924 if (uuid_cmd == NULL)
5925 return NULL;
5926
5927 /* TODO: We assume the DWARF file has the same as the binary's.
5928 It seems apple's GDB checks all files in the dSYM bundle directory.
5929 http://opensource.apple.com/source/gdb/gdb-1708/src/gdb/macosx/macosx-tdep.c
5930 */
5931 dsym_filename = (char *)bfd_malloc (strlen (base_bfd->filename)
07d6d2b8
AM		 5932 + strlen (dsym_subdir) + 1
5933 + strlen (base_basename) + 1);
2ca7691a 5934 sprintf (dsym_filename, "%s%s/%s",
07d6d2b8 5935 base_bfd->filename, dsym_subdir, base_basename);
2ca7691a
TG		 5936
5937 dsym_bfd = bfd_mach_o_find_dsym (dsym_filename, uuid_cmd,
07d6d2b8 5938 bfd_get_arch_info (abfd));
2ca7691a
TG		 5939 if (dsym_bfd == NULL)
5940 free (dsym_filename);
5941
5942 return dsym_bfd;
5943}
5944
d9071b0c
TG		 5945bfd_boolean
5946bfd_mach_o_find_nearest_line (bfd *abfd,
d9071b0c 5947 asymbol **symbols,
fb167eb2 5948 asection *section,
d9071b0c
TG		 5949 bfd_vma offset,
5950 const char **filename_ptr,
5951 const char **functionname_ptr,
fb167eb2
AM		 5952 unsigned int *line_ptr,
5953 unsigned int *discriminator_ptr)
d9071b0c
TG		 5954{
5955 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
2ca7691a 5956 if (mdata == NULL)
d9071b0c 5957 return FALSE;
2ca7691a
TG		 5958 switch (mdata->header.filetype)
5959 {
5960 case BFD_MACH_O_MH_OBJECT:
5961 break;
5962 case BFD_MACH_O_MH_EXECUTE:
5963 case BFD_MACH_O_MH_DYLIB:
5964 case BFD_MACH_O_MH_BUNDLE:
5965 case BFD_MACH_O_MH_KEXT_BUNDLE:
5966 if (mdata->dwarf2_find_line_info == NULL)
07d6d2b8
AM		 5967 {
5968 mdata->dsym_bfd = bfd_mach_o_follow_dsym (abfd);
5969 /* When we couldn't find dSYM for this binary, we look for
5970 the debug information in the binary itself. In this way,
5971 we won't try finding separated dSYM again because
5972 mdata->dwarf2_find_line_info will be filled. */
5973 if (! mdata->dsym_bfd)
5974 break;
5975 if (! _bfd_dwarf2_slurp_debug_info (abfd, mdata->dsym_bfd,
5976 dwarf_debug_sections, symbols,
5977 &mdata->dwarf2_find_line_info,
93ee1e36 5978 FALSE))
07d6d2b8
AM		 5979 return FALSE;
5980 }
2ca7691a
TG		 5981 break;
5982 default:
5983 return FALSE;
5984 }
fb167eb2
AM		 5985 return _bfd_dwarf2_find_nearest_line (abfd, symbols, NULL, section, offset,
5986 filename_ptr, functionname_ptr,
5987 line_ptr, discriminator_ptr,
9defd221 5988 dwarf_debug_sections,
fb167eb2 5989 &mdata->dwarf2_find_line_info);
d9071b0c
TG		 5990}
5991
5992bfd_boolean
5993bfd_mach_o_close_and_cleanup (bfd *abfd)
5994{
5995 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
5996 if (bfd_get_format (abfd) == bfd_object && mdata != NULL)
4434114c
TG		 5997 {
5998 _bfd_dwarf2_cleanup_debug_info (abfd, &mdata->dwarf2_find_line_info);
5999 bfd_mach_o_free_cached_info (abfd);
2ca7691a 6000 if (mdata->dsym_bfd != NULL)
07d6d2b8
AM		 6001 {
6002 bfd *fat_bfd = mdata->dsym_bfd->my_archive;
cf466c2a
NC		 6003#if 0
6004 /* FIXME: PR 19435: This calculation to find the memory allocated by
6005 bfd_mach_o_follow_dsym for the filename does not always end up
6006 selecting the correct pointer. Unfortunately this problem is
6007 very hard to reproduce on a non Mach-O native system, so until it
6008 can be traced and fixed on such a system, this code will remain
6009 commented out. This does mean that there will be a memory leak,
6010 but it is small, and happens when we are closing down, so it
c244074c 6011 should not matter too much. */
07d6d2b8
AM		 6012 char *dsym_filename = (char *)(fat_bfd
6013 ? fat_bfd->filename
6014 : mdata->dsym_bfd->filename);
cf466c2a 6015#endif
07d6d2b8
AM		 6016 bfd_close (mdata->dsym_bfd);
6017 mdata->dsym_bfd = NULL;
6018 if (fat_bfd)
6019 bfd_close (fat_bfd);
cf466c2a 6020#if 0
07d6d2b8 6021 free (dsym_filename);
cf466c2a 6022#endif
07d6d2b8 6023 }
4434114c 6024 }
dff55db0 6025
d9071b0c
TG		 6026 return _bfd_generic_close_and_cleanup (abfd);
6027}
6028
c6643fcc
NC		 6029bfd_boolean
6030bfd_mach_o_free_cached_info (bfd *abfd)
dff55db0
TG		 6031{
6032 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
6033 asection *asect;
6034 free (mdata->dyn_reloc_cache);
6035 mdata->dyn_reloc_cache = NULL;
6036 for (asect = abfd->sections; asect != NULL; asect = asect->next)
6037 {
6038 free (asect->relocation);
6039 asect->relocation = NULL;
6040 }
6041
6042 return TRUE;
6043}
6044
68ffbac6 6045#define bfd_mach_o_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
92bc0e80
TG		 6046#define bfd_mach_o_bfd_reloc_name_lookup _bfd_norelocs_bfd_reloc_name_lookup
6047
bcb51645 6048#define bfd_mach_o_canonicalize_one_reloc NULL
92bc0e80 6049#define bfd_mach_o_swap_reloc_out NULL
b32e07d7 6050#define bfd_mach_o_print_thread NULL
a4551119 6051#define bfd_mach_o_tgt_seg_table NULL
ab76eeaf 6052#define bfd_mach_o_section_type_valid_for_tgt NULL
92bc0e80 6053
07d6d2b8
AM		 6054#define TARGET_NAME mach_o_be_vec
6055#define TARGET_STRING "mach-o-be"
42fa0891 6056#define TARGET_ARCHITECTURE bfd_arch_unknown
4384b284 6057#define TARGET_PAGESIZE 1
07d6d2b8
AM		 6058#define TARGET_BIG_ENDIAN 1
6059#define TARGET_ARCHIVE 0
b93a1992 6060#define TARGET_PRIORITY 1
3af9a47b
NC		 6061#include "mach-o-target.c"
6062
6063#undef TARGET_NAME
6064#undef TARGET_STRING
42fa0891 6065#undef TARGET_ARCHITECTURE
4384b284 6066#undef TARGET_PAGESIZE
3af9a47b
NC		 6067#undef TARGET_BIG_ENDIAN
6068#undef TARGET_ARCHIVE
b93a1992 6069#undef TARGET_PRIORITY
3af9a47b 6070
07d6d2b8
AM		 6071#define TARGET_NAME mach_o_le_vec
6072#define TARGET_STRING "mach-o-le"
42fa0891 6073#define TARGET_ARCHITECTURE bfd_arch_unknown
4384b284 6074#define TARGET_PAGESIZE 1
07d6d2b8
AM		 6075#define TARGET_BIG_ENDIAN 0
6076#define TARGET_ARCHIVE 0
b93a1992 6077#define TARGET_PRIORITY 1
3af9a47b
NC		 6078
6079#include "mach-o-target.c"
6080
6081#undef TARGET_NAME
6082#undef TARGET_STRING
42fa0891 6083#undef TARGET_ARCHITECTURE
4384b284 6084#undef TARGET_PAGESIZE
3af9a47b
NC		 6085#undef TARGET_BIG_ENDIAN
6086#undef TARGET_ARCHIVE
b93a1992 6087#undef TARGET_PRIORITY
3af9a47b 6088
8f95b6e4 6089/* Not yet handled: creating an archive. */
07d6d2b8 6090#define bfd_mach_o_mkarchive _bfd_noarchive_mkarchive
8f95b6e4 6091
eac61af6 6092#define bfd_mach_o_close_and_cleanup bfd_mach_o_fat_close_and_cleanup
47daa70f 6093
8f95b6e4 6094/* Not used. */
07d6d2b8 6095#define bfd_mach_o_generic_stat_arch_elt bfd_mach_o_fat_stat_arch_elt
47daa70f
TG		 6096#define bfd_mach_o_openr_next_archived_file bfd_mach_o_fat_openr_next_archived_file
6097#define bfd_mach_o_archive_p bfd_mach_o_fat_archive_p
8f95b6e4 6098
07d6d2b8
AM		 6099#define TARGET_NAME mach_o_fat_vec
6100#define TARGET_STRING "mach-o-fat"
42fa0891 6101#define TARGET_ARCHITECTURE bfd_arch_unknown
4384b284 6102#define TARGET_PAGESIZE 1
07d6d2b8
AM		 6103#define TARGET_BIG_ENDIAN 1
6104#define TARGET_ARCHIVE 1
b93a1992 6105#define TARGET_PRIORITY 0
3af9a47b
NC		 6106
6107#include "mach-o-target.c"
6108
6109#undef TARGET_NAME
6110#undef TARGET_STRING
42fa0891 6111#undef TARGET_ARCHITECTURE
4384b284 6112#undef TARGET_PAGESIZE
3af9a47b
NC		 6113#undef TARGET_BIG_ENDIAN
6114#undef TARGET_ARCHIVE
b93a1992 6115#undef TARGET_PRIORITY
GDB Binutils - Deliverables
This page took 2.171032 seconds and 4 git commands to generate.