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