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