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