]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blame - bfd/mach-o.c
projects / thirdparty / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
bfd/
[thirdparty/binutils-gdb.git] / bfd / mach-o.c
CommitLineData
3af9a47b 1/* Mach-O support for BFD.
4f608e79 2 Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
7f307238 3 2009, 2010, 2011, 2012
3af9a47b
NC		 4 Free Software Foundation, Inc.
5
6 This file is part of BFD, the Binary File Descriptor library.
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
cd123cb7 10 the Free Software Foundation; either version 3 of the License, or
3af9a47b
NC		 11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
a95a4550 19 along with this program; if not, write to the Free Software
cd123cb7
NC		 20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
3af9a47b 22
3db64b00 23#include "sysdep.h"
3af9a47b
NC		 24#include "mach-o.h"
25#include "bfd.h"
3af9a47b
NC		 26#include "libbfd.h"
27#include "libiberty.h"
15e1c58a 28#include "aout/stab_gnu.h"
46d1c23b
TG		 29#include "mach-o/reloc.h"
30#include "mach-o/external.h"
3af9a47b 31#include <ctype.h>
7f307238
IS		 32#include <stdlib.h>
33#include <string.h>
3af9a47b 34
154a1ee5
TG		 35#define bfd_mach_o_object_p bfd_mach_o_gen_object_p
36#define bfd_mach_o_core_p bfd_mach_o_gen_core_p
42fa0891 37#define bfd_mach_o_mkobject bfd_mach_o_gen_mkobject
116c20d2 38
92bc0e80
TG		 39#define FILE_ALIGN(off, algn) \
40 (((off) + ((file_ptr) 1 << (algn)) - 1) & ((file_ptr) -1 << (algn)))
41
c2f09c75 42unsigned int
1e8a024a
TG		 43bfd_mach_o_version (bfd *abfd)
44{
45 bfd_mach_o_data_struct *mdata = NULL;
46
47 BFD_ASSERT (bfd_mach_o_valid (abfd));
046b007d 48 mdata = bfd_mach_o_get_data (abfd);
1e8a024a
TG		 49
50 return mdata->header.version;
51}
52
b34976b6 53bfd_boolean
116c20d2 54bfd_mach_o_valid (bfd *abfd)
3af9a47b
NC		 55{
56 if (abfd == NULL || abfd->xvec == NULL)
154a1ee5 57 return FALSE;
3af9a47b 58
154a1ee5
TG		 59 if (abfd->xvec->flavour != bfd_target_mach_o_flavour)
60 return FALSE;
3af9a47b 61
046b007d 62 if (bfd_mach_o_get_data (abfd) == NULL)
154a1ee5
TG		 63 return FALSE;
64 return TRUE;
65}
66
c2f09c75
TG		 67static INLINE bfd_boolean
68mach_o_wide_p (bfd_mach_o_header *header)
69{
70 switch (header->version)
71 {
72 case 1:
73 return FALSE;
74 case 2:
75 return TRUE;
76 default:
77 BFD_FAIL ();
78 return FALSE;
79 }
80}
81
82static INLINE bfd_boolean
83bfd_mach_o_wide_p (bfd *abfd)
84{
046b007d 85 return mach_o_wide_p (&bfd_mach_o_get_data (abfd)->header);
c2f09c75
TG		 86}
87
154a1ee5
TG		 88/* Tables to translate well known Mach-O segment/section names to bfd
89 names. Use of canonical names (such as .text or .debug_frame) is required
90 by gdb. */
91
a4551119
TG		 92/* __TEXT Segment. */
93static const mach_o_section_name_xlat text_section_names_xlat[] =
154a1ee5 94 {
a4551119
TG		 95 { ".text", "__text",
96 SEC_CODE | SEC_LOAD, BFD_MACH_O_S_REGULAR,
97 BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS, 0},
98 { ".const", "__const",
99 SEC_READONLY | SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
100 BFD_MACH_O_S_ATTR_NONE, 0},
101 { ".static_const", "__static_const",
102 SEC_READONLY | SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
103 BFD_MACH_O_S_ATTR_NONE, 0},
104 { ".cstring", "__cstring",
105 SEC_READONLY | SEC_DATA | SEC_LOAD | SEC_MERGE | SEC_STRINGS,
106 BFD_MACH_O_S_CSTRING_LITERALS,
107 BFD_MACH_O_S_ATTR_NONE, 0},
108 { ".literal4", "__literal4",
109 SEC_READONLY | SEC_DATA | SEC_LOAD, BFD_MACH_O_S_4BYTE_LITERALS,
110 BFD_MACH_O_S_ATTR_NONE, 2},
111 { ".literal8", "__literal8",
112 SEC_READONLY | SEC_DATA | SEC_LOAD, BFD_MACH_O_S_8BYTE_LITERALS,
113 BFD_MACH_O_S_ATTR_NONE, 3},
114 { ".literal16", "__literal16",
115 SEC_READONLY | SEC_DATA | SEC_LOAD, BFD_MACH_O_S_16BYTE_LITERALS,
116 BFD_MACH_O_S_ATTR_NONE, 4},
117 { ".constructor", "__constructor",
118 SEC_CODE | SEC_LOAD, BFD_MACH_O_S_REGULAR,
119 BFD_MACH_O_S_ATTR_NONE, 0},
120 { ".destructor", "__destructor",
121 SEC_CODE | SEC_LOAD, BFD_MACH_O_S_REGULAR,
122 BFD_MACH_O_S_ATTR_NONE, 0},
123 { ".eh_frame", "__eh_frame",
124 SEC_READONLY | SEC_LOAD, BFD_MACH_O_S_COALESCED,
125 BFD_MACH_O_S_ATTR_LIVE_SUPPORT
126 | BFD_MACH_O_S_ATTR_STRIP_STATIC_SYMS
127 | BFD_MACH_O_S_ATTR_NO_TOC, 3},
128 { NULL, NULL, 0, 0, 0, 0}
154a1ee5
TG		 129 };
130
a4551119
TG		 131/* __DATA Segment. */
132static const mach_o_section_name_xlat data_section_names_xlat[] =
154a1ee5 133 {
a4551119
TG		 134 { ".data", "__data",
135 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
136 BFD_MACH_O_S_ATTR_NONE, 0},
137 { ".bss", "__bss",
138 SEC_NO_FLAGS, BFD_MACH_O_S_ZEROFILL,
139 BFD_MACH_O_S_ATTR_NONE, 0},
140 { ".const_data", "__const",
141 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
142 BFD_MACH_O_S_ATTR_NONE, 0},
143 { ".static_data", "__static_data",
144 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
145 BFD_MACH_O_S_ATTR_NONE, 0},
146 { ".mod_init_func", "__mod_init_func",
147 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_MOD_INIT_FUNC_POINTERS,
148 BFD_MACH_O_S_ATTR_NONE, 2},
149 { ".mod_term_func", "__mod_term_func",
150 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_MOD_FINI_FUNC_POINTERS,
151 BFD_MACH_O_S_ATTR_NONE, 2},
152 { ".dyld", "__dyld",
153 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
154 BFD_MACH_O_S_ATTR_NONE, 0},
155 { ".cfstring", "__cfstring",
156 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
157 BFD_MACH_O_S_ATTR_NONE, 2},
158 { NULL, NULL, 0, 0, 0, 0}
154a1ee5
TG		 159 };
160
a4551119
TG		 161/* __DWARF Segment. */
162static const mach_o_section_name_xlat dwarf_section_names_xlat[] =
154a1ee5 163 {
a4551119
TG		 164 { ".debug_frame", "__debug_frame",
165 SEC_DEBUGGING, BFD_MACH_O_S_REGULAR,
166 BFD_MACH_O_S_ATTR_DEBUG, 0},
167 { ".debug_info", "__debug_info",
168 SEC_DEBUGGING, BFD_MACH_O_S_REGULAR,
169 BFD_MACH_O_S_ATTR_DEBUG, 0},
170 { ".debug_abbrev", "__debug_abbrev",
171 SEC_DEBUGGING, BFD_MACH_O_S_REGULAR,
172 BFD_MACH_O_S_ATTR_DEBUG, 0},
173 { ".debug_aranges", "__debug_aranges",
174 SEC_DEBUGGING, BFD_MACH_O_S_REGULAR,
175 BFD_MACH_O_S_ATTR_DEBUG, 0},
176 { ".debug_macinfo", "__debug_macinfo",
177 SEC_DEBUGGING, BFD_MACH_O_S_REGULAR,
178 BFD_MACH_O_S_ATTR_DEBUG, 0},
179 { ".debug_line", "__debug_line",
180 SEC_DEBUGGING, BFD_MACH_O_S_REGULAR,
181 BFD_MACH_O_S_ATTR_DEBUG, 0},
182 { ".debug_loc", "__debug_loc",
183 SEC_DEBUGGING, BFD_MACH_O_S_REGULAR,
184 BFD_MACH_O_S_ATTR_DEBUG, 0},
185 { ".debug_pubnames", "__debug_pubnames",
186 SEC_DEBUGGING, BFD_MACH_O_S_REGULAR,
187 BFD_MACH_O_S_ATTR_DEBUG, 0},
188 { ".debug_pubtypes", "__debug_pubtypes",
189 SEC_DEBUGGING, BFD_MACH_O_S_REGULAR,
190 BFD_MACH_O_S_ATTR_DEBUG, 0},
191 { ".debug_str", "__debug_str",
192 SEC_DEBUGGING, BFD_MACH_O_S_REGULAR,
193 BFD_MACH_O_S_ATTR_DEBUG, 0},
194 { ".debug_ranges", "__debug_ranges",
195 SEC_DEBUGGING, BFD_MACH_O_S_REGULAR,
196 BFD_MACH_O_S_ATTR_DEBUG, 0},
197 { ".debug_macro", "__debug_macro",
198 SEC_DEBUGGING, BFD_MACH_O_S_REGULAR,
199 BFD_MACH_O_S_ATTR_DEBUG, 0},
200 { NULL, NULL, 0, 0, 0, 0}
154a1ee5
TG		 201 };
202
a4551119
TG		 203/* __OBJC Segment. */
204static const mach_o_section_name_xlat objc_section_names_xlat[] =
205 {
206 { ".objc_class", "__class",
207 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
208 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
209 { ".objc_meta_class", "__meta_class",
210 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
211 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
212 { ".objc_cat_cls_meth", "__cat_cls_meth",
213 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
214 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
215 { ".objc_cat_inst_meth", "__cat_inst_meth",
216 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
217 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
218 { ".objc_protocol", "__protocol",
219 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
220 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
221 { ".objc_string_object", "__string_object",
222 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
223 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
224 { ".objc_cls_meth", "__cls_meth",
225 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
226 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
227 { ".objc_inst_meth", "__inst_meth",
228 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
229 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
230 { ".objc_cls_refs", "__cls_refs",
231 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_LITERAL_POINTERS,
232 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
233 { ".objc_message_refs", "__message_refs",
234 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_LITERAL_POINTERS,
235 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
236 { ".objc_symbols", "__symbols",
237 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
238 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
239 { ".objc_category", "__category",
240 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
241 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
242 { ".objc_class_vars", "__class_vars",
243 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
244 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
245 { ".objc_instance_vars", "__instance_vars",
246 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
247 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
248 { ".objc_module_info", "__module_info",
249 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
250 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
251 { ".objc_selector_strs", "__selector_strs",
252 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_CSTRING_LITERALS,
253 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
254 { ".objc_image_info", "__image_info",
255 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
256 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
257 { ".objc_selector_fixup", "__sel_fixup",
258 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
259 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
260 /* Objc V1 */
261 { ".objc1_class_ext", "__class_ext",
262 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
263 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
264 { ".objc1_property_list", "__property",
265 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
266 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
267 { ".objc1_protocol_ext", "__protocol_ext",
268 SEC_DATA | SEC_LOAD, BFD_MACH_O_S_REGULAR,
269 BFD_MACH_O_S_ATTR_NO_DEAD_STRIP, 0},
270 { NULL, NULL, 0, 0, 0, 0}
271 };
5a5cbf72 272
a4551119 273static const mach_o_segment_name_xlat segsec_names_xlat[] =
154a1ee5 274 {
154a1ee5
TG		 275 { "__TEXT", text_section_names_xlat },
276 { "__DATA", data_section_names_xlat },
5a5cbf72 277 { "__DWARF", dwarf_section_names_xlat },
a4551119 278 { "__OBJC", objc_section_names_xlat },
154a1ee5
TG		 279 { NULL, NULL }
280 };
281
2ca7691a
TG		 282static const char dsym_subdir[] = ".dSYM/Contents/Resources/DWARF";
283
a4551119
TG		 284/* For both cases bfd-name => mach-o name and vice versa, the specific target
285 is checked before the generic. This allows a target (e.g. ppc for cstring)
286 to override the generic definition with a more specific one. */
154a1ee5 287
a4551119
TG		 288/* Fetch the translation from a Mach-O section designation (segment, section)
289 as a bfd short name, if one exists. Otherwise return NULL.
290
291 Allow the segment and section names to be unterminated 16 byte arrays. */
292
293const mach_o_section_name_xlat *
294bfd_mach_o_section_data_for_mach_sect (bfd *abfd, const char *segname,
295 const char *sectname)
154a1ee5
TG		 296{
297 const struct mach_o_segment_name_xlat *seg;
a4551119
TG		 298 const mach_o_section_name_xlat *sec;
299 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
154a1ee5 300
a4551119
TG		 301 /* First try any target-specific translations defined... */
302 if (bed->segsec_names_xlat)
303 for (seg = bed->segsec_names_xlat; seg->segname; seg++)
304 if (strncmp (seg->segname, segname, BFD_MACH_O_SEGNAME_SIZE) == 0)
305 for (sec = seg->sections; sec->mach_o_name; sec++)
306 if (strncmp (sec->mach_o_name, sectname,
307 BFD_MACH_O_SECTNAME_SIZE) == 0)
308 return sec;
8462aec7 309
a4551119 310 /* ... and then the Mach-O generic ones. */
154a1ee5 311 for (seg = segsec_names_xlat; seg->segname; seg++)
a4551119
TG		 312 if (strncmp (seg->segname, segname, BFD_MACH_O_SEGNAME_SIZE) == 0)
313 for (sec = seg->sections; sec->mach_o_name; sec++)
314 if (strncmp (sec->mach_o_name, sectname,
315 BFD_MACH_O_SECTNAME_SIZE) == 0)
316 return sec;
154a1ee5 317
a4551119 318 return NULL;
53d58d96
TG		 319}
320
a4551119
TG		 321/* If the bfd_name for this section is a 'canonical' form for which we
322 know the Mach-O data, return the segment name and the data for the
323 Mach-O equivalent. Otherwise return NULL. */
7ba695a9 324
a4551119
TG		 325const mach_o_section_name_xlat *
326bfd_mach_o_section_data_for_bfd_name (bfd *abfd, const char *bfd_name,
327 const char **segname)
53d58d96 328{
a4551119
TG		 329 const struct mach_o_segment_name_xlat *seg;
330 const mach_o_section_name_xlat *sec;
331 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
332 *segname = NULL;
333
334 if (bfd_name[0] != '.')
335 return NULL;
336
337 /* First try any target-specific translations defined... */
338 if (bed->segsec_names_xlat)
339 for (seg = bed->segsec_names_xlat; seg->segname; seg++)
340 for (sec = seg->sections; sec->bfd_name; sec++)
341 if (strcmp (bfd_name, sec->bfd_name) == 0)
342 {
343 *segname = seg->segname;
344 return sec;
345 }
346
347 /* ... and then the Mach-O generic ones. */
348 for (seg = segsec_names_xlat; seg->segname; seg++)
349 for (sec = seg->sections; sec->bfd_name; sec++)
350 if (strcmp (bfd_name, sec->bfd_name) == 0)
351 {
352 *segname = seg->segname;
353 return sec;
354 }
355
356 return NULL;
357}
358
359/* Convert Mach-O section name to BFD.
360
361 Try to use standard/canonical names, for which we have tables including
362 default flag settings - which are returned. Otherwise forge a new name
363 in the form "<segmentname>.<sectionname>" this will be prefixed with
364 LC_SEGMENT. if the segment name does not begin with an underscore.
365
366 SEGNAME and SECTNAME are 16 byte arrays (they do not need to be NUL-
367 terminated if the name length is exactly 16 bytes - but must be if the name
368 length is less than 16 characters). */
369
370void
371bfd_mach_o_convert_section_name_to_bfd (bfd *abfd, const char *segname,
372 const char *secname, const char **name,
373 flagword *flags)
374{
375 const mach_o_section_name_xlat *xlat;
53d58d96
TG		 376 char *res;
377 unsigned int len;
378 const char *pfx = "";
379
a4551119
TG		 380 *name = NULL;
381 *flags = SEC_NO_FLAGS;
53d58d96 382
a4551119
TG		 383 /* First search for a canonical name...
384 xlat will be non-null if there is an entry for segname, secname. */
385 xlat = bfd_mach_o_section_data_for_mach_sect (abfd, segname, secname);
386 if (xlat)
387 {
388 len = strlen (xlat->bfd_name);
389 res = bfd_alloc (abfd, len+1);
390 if (res == NULL)
391 return;
392 memcpy (res, xlat->bfd_name, len+1);
393 *name = res;
394 *flags = xlat->bfd_flags;
395 return;
396 }
397
398 /* ... else we make up a bfd name from the segment concatenated with the
399 section. */
154a1ee5 400
7ba695a9 401 len = 16 + 1 + 16 + 1;
154a1ee5 402
c2f09c75
TG		 403 /* Put "LC_SEGMENT." prefix if the segment name is weird (ie doesn't start
404 with an underscore. */
f1bde64c 405 if (segname[0] != '_')
c2f09c75
TG		 406 {
407 static const char seg_pfx[] = "LC_SEGMENT.";
408
409 pfx = seg_pfx;
410 len += sizeof (seg_pfx) - 1;
411 }
412
154a1ee5
TG		 413 res = bfd_alloc (abfd, len);
414 if (res == NULL)
8462aec7 415 return;
a4551119 416 snprintf (res, len, "%s%.16s.%.16s", pfx, segname, secname);
8462aec7 417 *name = res;
154a1ee5
TG		 418}
419
a4551119 420/* Convert a bfd section name to a Mach-O segment + section name.
154a1ee5 421
a4551119
TG		 422 If the name is a canonical one for which we have a Darwin match
423 return the translation table - which contains defaults for flags,
424 type, attribute and default alignment data.
425
426 Otherwise, expand the bfd_name (assumed to be in the form
427 "[LC_SEGMENT.]<segmentname>.<sectionname>") and return NULL. */
428
429static const mach_o_section_name_xlat *
154a1ee5
TG		 430bfd_mach_o_convert_section_name_to_mach_o (bfd *abfd ATTRIBUTE_UNUSED,
431 asection *sect,
432 bfd_mach_o_section *section)
433{
a4551119 434 const mach_o_section_name_xlat *xlat;
154a1ee5 435 const char *name = bfd_get_section_name (abfd, sect);
a4551119 436 const char *segname;
154a1ee5
TG		 437 const char *dot;
438 unsigned int len;
439 unsigned int seglen;
440 unsigned int seclen;
441
a4551119
TG		 442 memset (section->segname, 0, BFD_MACH_O_SEGNAME_SIZE + 1);
443 memset (section->sectname, 0, BFD_MACH_O_SECTNAME_SIZE + 1);
444
445 /* See if is a canonical name ... */
446 xlat = bfd_mach_o_section_data_for_bfd_name (abfd, name, &segname);
447 if (xlat)
448 {
449 strcpy (section->segname, segname);
450 strcpy (section->sectname, xlat->mach_o_name);
451 return xlat;
452 }
154a1ee5 453
a4551119
TG		 454 /* .. else we convert our constructed one back to Mach-O.
455 Strip LC_SEGMENT. prefix, if present. */
154a1ee5
TG		 456 if (strncmp (name, "LC_SEGMENT.", 11) == 0)
457 name += 11;
458
459 /* Find a dot. */
460 dot = strchr (name, '.');
461 len = strlen (name);
462
463 /* Try to split name into segment and section names. */
464 if (dot && dot != name)
465 {
466 seglen = dot - name;
467 seclen = len - (dot + 1 - name);
468
469 if (seglen < 16 && seclen < 16)
470 {
471 memcpy (section->segname, name, seglen);
472 section->segname[seglen] = 0;
473 memcpy (section->sectname, dot + 1, seclen);
474 section->sectname[seclen] = 0;
a4551119 475 return NULL;
154a1ee5
TG		 476 }
477 }
478
a4551119
TG		 479 /* The segment and section names are both missing - don't make them
480 into dots. */
481 if (dot && dot == name)
482 return NULL;
483
484 /* Just duplicate the name into both segment and section. */
154a1ee5
TG		 485 if (len > 16)
486 len = 16;
487 memcpy (section->segname, name, len);
488 section->segname[len] = 0;
489 memcpy (section->sectname, name, len);
490 section->sectname[len] = 0;
a4551119 491 return NULL;
3af9a47b
NC		 492}
493
b2b62060
TG		 494/* Return the size of an entry for section SEC.
495 Must be called only for symbol pointer section and symbol stubs
496 sections. */
497
c5012cd8 498unsigned int
b2b62060
TG		 499bfd_mach_o_section_get_entry_size (bfd *abfd, bfd_mach_o_section *sec)
500{
501 switch (sec->flags & BFD_MACH_O_SECTION_TYPE_MASK)
502 {
503 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS:
504 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS:
505 return bfd_mach_o_wide_p (abfd) ? 8 : 4;
506 case BFD_MACH_O_S_SYMBOL_STUBS:
507 return sec->reserved2;
508 default:
509 BFD_FAIL ();
510 return 0;
511 }
512}
513
514/* Return the number of indirect symbols for a section.
515 Must be called only for symbol pointer section and symbol stubs
516 sections. */
517
c5012cd8 518unsigned int
b2b62060
TG		 519bfd_mach_o_section_get_nbr_indirect (bfd *abfd, bfd_mach_o_section *sec)
520{
521 unsigned int elsz;
522
523 elsz = bfd_mach_o_section_get_entry_size (abfd, sec);
524 if (elsz == 0)
525 return 0;
526 else
527 return sec->size / elsz;
528}
529
530
3af9a47b
NC		 531/* Copy any private info we understand from the input symbol
532 to the output symbol. */
533
154a1ee5 534bfd_boolean
116c20d2
NC		 535bfd_mach_o_bfd_copy_private_symbol_data (bfd *ibfd ATTRIBUTE_UNUSED,
536 asymbol *isymbol ATTRIBUTE_UNUSED,
537 bfd *obfd ATTRIBUTE_UNUSED,
538 asymbol *osymbol ATTRIBUTE_UNUSED)
3af9a47b 539{
b34976b6 540 return TRUE;
3af9a47b
NC		 541}
542
543/* Copy any private info we understand from the input section
544 to the output section. */
545
154a1ee5 546bfd_boolean
116c20d2 547bfd_mach_o_bfd_copy_private_section_data (bfd *ibfd ATTRIBUTE_UNUSED,
a4551119 548 asection *isection,
116c20d2 549 bfd *obfd ATTRIBUTE_UNUSED,
a4551119
TG		 550 asection *osection)
551{
552 if (osection->used_by_bfd == NULL)
553 osection->used_by_bfd = isection->used_by_bfd;
554 else
555 if (isection->used_by_bfd != NULL)
556 memcpy (osection->used_by_bfd, isection->used_by_bfd,
557 sizeof (bfd_mach_o_section));
558
559 if (osection->used_by_bfd != NULL)
560 ((bfd_mach_o_section *)osection->used_by_bfd)->bfdsection = osection;
561
b34976b6 562 return TRUE;
3af9a47b
NC		 563}
564
565/* Copy any private info we understand from the input bfd
566 to the output bfd. */
567
154a1ee5 568bfd_boolean
116c20d2 569bfd_mach_o_bfd_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
3af9a47b 570{
154a1ee5
TG		 571 if (bfd_get_flavour (ibfd) != bfd_target_mach_o_flavour
572 || bfd_get_flavour (obfd) != bfd_target_mach_o_flavour)
573 return TRUE;
574
3af9a47b
NC		 575 BFD_ASSERT (bfd_mach_o_valid (ibfd));
576 BFD_ASSERT (bfd_mach_o_valid (obfd));
577
154a1ee5
TG		 578 /* FIXME: copy commands. */
579
b34976b6 580 return TRUE;
3af9a47b
NC		 581}
582
0c9ef0f0
TG		 583/* This allows us to set up to 32 bits of flags (unless we invent some
584 fiendish scheme to subdivide). For now, we'll just set the file flags
585 without error checking - just overwrite. */
586
587bfd_boolean
588bfd_mach_o_bfd_set_private_flags (bfd *abfd, flagword flags)
589{
590 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
591
592 if (!mdata)
593 return FALSE;
594
595 mdata->header.flags = flags;
596 return TRUE;
597}
598
046b007d 599/* Count the total number of symbols. */
154a1ee5 600
3af9a47b 601static long
116c20d2 602bfd_mach_o_count_symbols (bfd *abfd)
3af9a47b 603{
046b007d 604 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3af9a47b 605
046b007d
TG		 606 if (mdata->symtab == NULL)
607 return 0;
608 return mdata->symtab->nsyms;
3af9a47b
NC		 609}
610
154a1ee5 611long
116c20d2 612bfd_mach_o_get_symtab_upper_bound (bfd *abfd)
3af9a47b
NC		 613{
614 long nsyms = bfd_mach_o_count_symbols (abfd);
615
3af9a47b
NC		 616 return ((nsyms + 1) * sizeof (asymbol *));
617}
618
154a1ee5 619long
116c20d2 620bfd_mach_o_canonicalize_symtab (bfd *abfd, asymbol **alocation)
3af9a47b 621{
046b007d 622 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3af9a47b 623 long nsyms = bfd_mach_o_count_symbols (abfd);
046b007d
TG		 624 bfd_mach_o_symtab_command *sym = mdata->symtab;
625 unsigned long j;
3af9a47b
NC		 626
627 if (nsyms < 0)
628 return nsyms;
629
092d27ff
TG		 630 if (nsyms == 0)
631 {
632 /* Do not try to read symbols if there are none. */
633 alocation[0] = NULL;
634 return 0;
635 }
636
afbb9e17 637 if (!bfd_mach_o_read_symtab_symbols (abfd))
3af9a47b 638 {
afbb9e17
TG		 639 (*_bfd_error_handler)
640 (_("bfd_mach_o_canonicalize_symtab: unable to load symbols"));
046b007d
TG		 641 return 0;
642 }
3af9a47b 643
046b007d 644 BFD_ASSERT (sym->symbols != NULL);
3af9a47b 645
046b007d
TG		 646 for (j = 0; j < sym->nsyms; j++)
647 alocation[j] = &sym->symbols[j].symbol;
3af9a47b 648
046b007d 649 alocation[j] = NULL;
a95a4550 650
3af9a47b
NC		 651 return nsyms;
652}
653
b2b62060
TG		 654long
655bfd_mach_o_get_synthetic_symtab (bfd *abfd,
656 long symcount ATTRIBUTE_UNUSED,
657 asymbol **syms ATTRIBUTE_UNUSED,
658 long dynsymcount ATTRIBUTE_UNUSED,
659 asymbol **dynsyms ATTRIBUTE_UNUSED,
660 asymbol **ret)
661{
662 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
663 bfd_mach_o_dysymtab_command *dysymtab = mdata->dysymtab;
664 bfd_mach_o_symtab_command *symtab = mdata->symtab;
665 asymbol *s;
666 unsigned long count, i, j, n;
667 size_t size;
668 char *names;
669 char *nul_name;
670
671 *ret = NULL;
672
673 if (dysymtab == NULL || symtab == NULL || symtab->symbols == NULL)
674 return 0;
675
676 if (dysymtab->nindirectsyms == 0)
677 return 0;
678
679 count = dysymtab->nindirectsyms;
680 size = count * sizeof (asymbol) + 1;
681
682 for (j = 0; j < count; j++)
683 {
684 unsigned int isym = dysymtab->indirect_syms[j];
685
686 if (isym < symtab->nsyms && symtab->symbols[isym].symbol.name)
687 size += strlen (symtab->symbols[isym].symbol.name) + sizeof ("$stub");
688 }
689
690 s = *ret = (asymbol *) bfd_malloc (size);
691 if (s == NULL)
692 return -1;
693 names = (char *) (s + count);
694 nul_name = names;
695 *names++ = 0;
696
697 n = 0;
698 for (i = 0; i < mdata->nsects; i++)
699 {
700 bfd_mach_o_section *sec = mdata->sections[i];
91d6fa6a 701 unsigned int first, last;
b2b62060
TG		 702 bfd_vma addr;
703 bfd_vma entry_size;
704
705 switch (sec->flags & BFD_MACH_O_SECTION_TYPE_MASK)
706 {
707 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS:
708 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS:
709 case BFD_MACH_O_S_SYMBOL_STUBS:
710 first = sec->reserved1;
711 last = first + bfd_mach_o_section_get_nbr_indirect (abfd, sec);
712 addr = sec->addr;
713 entry_size = bfd_mach_o_section_get_entry_size (abfd, sec);
714 for (j = first; j < last; j++)
715 {
716 unsigned int isym = dysymtab->indirect_syms[j];
717
718 s->flags = BSF_GLOBAL | BSF_SYNTHETIC;
719 s->section = sec->bfdsection;
720 s->value = addr - sec->addr;
721 s->udata.p = NULL;
722
723 if (isym < symtab->nsyms
724 && symtab->symbols[isym].symbol.name)
725 {
726 const char *sym = symtab->symbols[isym].symbol.name;
727 size_t len;
728
729 s->name = names;
730 len = strlen (sym);
731 memcpy (names, sym, len);
732 names += len;
733 memcpy (names, "$stub", sizeof ("$stub"));
734 names += sizeof ("$stub");
735 }
736 else
737 s->name = nul_name;
738
739 addr += entry_size;
740 s++;
741 n++;
742 }
743 break;
744 default:
745 break;
746 }
747 }
748
749 return n;
750}
751
154a1ee5 752void
116c20d2
NC		 753bfd_mach_o_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED,
754 asymbol *symbol,
755 symbol_info *ret)
3af9a47b
NC		 756{
757 bfd_symbol_info (symbol, ret);
758}
759
154a1ee5 760void
116c20d2 761bfd_mach_o_print_symbol (bfd *abfd,
91d6fa6a 762 void * afile,
116c20d2
NC		 763 asymbol *symbol,
764 bfd_print_symbol_type how)
3af9a47b
NC		 765{
766 FILE *file = (FILE *) afile;
15e1c58a 767 const char *name;
92bc0e80 768 bfd_mach_o_asymbol *asym = (bfd_mach_o_asymbol *)symbol;
3af9a47b
NC		 769
770 switch (how)
771 {
772 case bfd_print_symbol_name:
773 fprintf (file, "%s", symbol->name);
774 break;
775 default:
91d6fa6a 776 bfd_print_symbol_vandf (abfd, (void *) file, symbol);
92bc0e80
TG		 777 if (asym->n_type & BFD_MACH_O_N_STAB)
778 name = bfd_get_stab_name (asym->n_type);
15e1c58a 779 else
92bc0e80 780 switch (asym->n_type & BFD_MACH_O_N_TYPE)
15e1c58a
TG		 781 {
782 case BFD_MACH_O_N_UNDF:
e0ce1005
TG		 783 if (symbol->value == 0)
784 name = "UND";
785 else
786 name = "COM";
15e1c58a
TG		 787 break;
788 case BFD_MACH_O_N_ABS:
789 name = "ABS";
790 break;
791 case BFD_MACH_O_N_INDR:
792 name = "INDR";
793 break;
794 case BFD_MACH_O_N_PBUD:
795 name = "PBUD";
796 break;
797 case BFD_MACH_O_N_SECT:
798 name = "SECT";
799 break;
800 default:
801 name = "???";
802 break;
803 }
804 if (name == NULL)
805 name = "";
92bc0e80
TG		 806 fprintf (file, " %02x %-6s %02x %04x",
807 asym->n_type, name, asym->n_sect, asym->n_desc);
808 if ((asym->n_type & BFD_MACH_O_N_STAB) == 0
809 && (asym->n_type & BFD_MACH_O_N_TYPE) == BFD_MACH_O_N_SECT)
e0ce1005 810 fprintf (file, " [%s]", symbol->section->name);
15e1c58a 811 fprintf (file, " %s", symbol->name);
3af9a47b
NC		 812 }
813}
814
815static void
116c20d2
NC		 816bfd_mach_o_convert_architecture (bfd_mach_o_cpu_type mtype,
817 bfd_mach_o_cpu_subtype msubtype ATTRIBUTE_UNUSED,
818 enum bfd_architecture *type,
819 unsigned long *subtype)
3af9a47b
NC		 820{
821 *subtype = bfd_arch_unknown;
822
823 switch (mtype)
824 {
825 case BFD_MACH_O_CPU_TYPE_VAX: *type = bfd_arch_vax; break;
826 case BFD_MACH_O_CPU_TYPE_MC680x0: *type = bfd_arch_m68k; break;
1e8a024a
TG		 827 case BFD_MACH_O_CPU_TYPE_I386:
828 *type = bfd_arch_i386;
829 *subtype = bfd_mach_i386_i386;
830 break;
831 case BFD_MACH_O_CPU_TYPE_X86_64:
832 *type = bfd_arch_i386;
833 *subtype = bfd_mach_x86_64;
834 break;
3af9a47b
NC		 835 case BFD_MACH_O_CPU_TYPE_MIPS: *type = bfd_arch_mips; break;
836 case BFD_MACH_O_CPU_TYPE_MC98000: *type = bfd_arch_m98k; break;
837 case BFD_MACH_O_CPU_TYPE_HPPA: *type = bfd_arch_hppa; break;
838 case BFD_MACH_O_CPU_TYPE_ARM: *type = bfd_arch_arm; break;
839 case BFD_MACH_O_CPU_TYPE_MC88000: *type = bfd_arch_m88k; break;
1e8a024a
TG		 840 case BFD_MACH_O_CPU_TYPE_SPARC:
841 *type = bfd_arch_sparc;
842 *subtype = bfd_mach_sparc;
843 break;
3af9a47b
NC		 844 case BFD_MACH_O_CPU_TYPE_I860: *type = bfd_arch_i860; break;
845 case BFD_MACH_O_CPU_TYPE_ALPHA: *type = bfd_arch_alpha; break;
1e8a024a
TG		 846 case BFD_MACH_O_CPU_TYPE_POWERPC:
847 *type = bfd_arch_powerpc;
c2f09c75 848 *subtype = bfd_mach_ppc;
1e8a024a
TG		 849 break;
850 case BFD_MACH_O_CPU_TYPE_POWERPC_64:
851 *type = bfd_arch_powerpc;
c2f09c75 852 *subtype = bfd_mach_ppc64;
1e8a024a 853 break;
3af9a47b 854 default:
1e8a024a
TG		 855 *type = bfd_arch_unknown;
856 break;
3af9a47b
NC		 857 }
858}
a95a4550 859
154a1ee5 860static bfd_boolean
116c20d2
NC		 861bfd_mach_o_write_header (bfd *abfd, bfd_mach_o_header *header)
862{
46d1c23b 863 struct mach_o_header_external raw;
1e8a024a
TG		 864 unsigned int size;
865
c2f09c75 866 size = mach_o_wide_p (header) ?
154a1ee5 867 BFD_MACH_O_HEADER_64_SIZE : BFD_MACH_O_HEADER_SIZE;
116c20d2 868
46d1c23b
TG		 869 bfd_h_put_32 (abfd, header->magic, raw.magic);
870 bfd_h_put_32 (abfd, header->cputype, raw.cputype);
871 bfd_h_put_32 (abfd, header->cpusubtype, raw.cpusubtype);
872 bfd_h_put_32 (abfd, header->filetype, raw.filetype);
873 bfd_h_put_32 (abfd, header->ncmds, raw.ncmds);
874 bfd_h_put_32 (abfd, header->sizeofcmds, raw.sizeofcmds);
875 bfd_h_put_32 (abfd, header->flags, raw.flags);
116c20d2 876
c2f09c75 877 if (mach_o_wide_p (header))
46d1c23b 878 bfd_h_put_32 (abfd, header->reserved, raw.reserved);
1e8a024a 879
c2f09c75 880 if (bfd_seek (abfd, 0, SEEK_SET) != 0
46d1c23b 881 || bfd_bwrite (&raw, size, abfd) != size)
154a1ee5 882 return FALSE;
116c20d2 883
154a1ee5 884 return TRUE;
116c20d2
NC		 885}
886
887static int
ab273af8 888bfd_mach_o_write_thread (bfd *abfd, bfd_mach_o_load_command *command)
116c20d2
NC		 889{
890 bfd_mach_o_thread_command *cmd = &command->command.thread;
891 unsigned int i;
46d1c23b 892 struct mach_o_thread_command_external raw;
92bc0e80 893 unsigned int offset;
116c20d2
NC		 894
895 BFD_ASSERT ((command->type == BFD_MACH_O_LC_THREAD)
896 || (command->type == BFD_MACH_O_LC_UNIXTHREAD));
897
898 offset = 8;
116c20d2
NC		 899 for (i = 0; i < cmd->nflavours; i++)
900 {
901 BFD_ASSERT ((cmd->flavours[i].size % 4) == 0);
46d1c23b
TG		 902 BFD_ASSERT (cmd->flavours[i].offset ==
903 (command->offset + offset + BFD_MACH_O_LC_SIZE));
116c20d2 904
46d1c23b
TG		 905 bfd_h_put_32 (abfd, cmd->flavours[i].flavour, raw.flavour);
906 bfd_h_put_32 (abfd, (cmd->flavours[i].size / 4), raw.count);
116c20d2 907
c2f09c75 908 if (bfd_seek (abfd, command->offset + offset, SEEK_SET) != 0
46d1c23b 909 || bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
116c20d2
NC		 910 return -1;
911
46d1c23b 912 offset += cmd->flavours[i].size + sizeof (raw);
116c20d2
NC		 913 }
914
915 return 0;
916}
917
92bc0e80
TG		 918long
919bfd_mach_o_get_reloc_upper_bound (bfd *abfd ATTRIBUTE_UNUSED,
920 asection *asect)
921{
922 return (asect->reloc_count + 1) * sizeof (arelent *);
923}
924
b32e07d7 925static int
46d1c23b
TG		 926bfd_mach_o_canonicalize_one_reloc (bfd *abfd,
927 struct mach_o_reloc_info_external *raw,
b32e07d7 928 arelent *res, asymbol **syms)
92bc0e80 929{
046b007d 930 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
92bc0e80 931 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
b32e07d7
TG		 932 bfd_mach_o_reloc_info reloc;
933 bfd_vma addr;
934 bfd_vma symnum;
935 asymbol **sym;
936
46d1c23b
TG		 937 addr = bfd_get_32 (abfd, raw->r_address);
938 symnum = bfd_get_32 (abfd, raw->r_symbolnum);
b32e07d7
TG		 939
940 if (addr & BFD_MACH_O_SR_SCATTERED)
941 {
942 unsigned int j;
943
944 /* Scattered relocation.
945 Extract section and offset from r_value. */
946 res->sym_ptr_ptr = NULL;
947 res->addend = 0;
948 for (j = 0; j < mdata->nsects; j++)
949 {
950 bfd_mach_o_section *sect = mdata->sections[j];
951 if (symnum >= sect->addr && symnum < sect->addr + sect->size)
952 {
953 res->sym_ptr_ptr = sect->bfdsection->symbol_ptr_ptr;
954 res->addend = symnum - sect->addr;
955 break;
956 }
957 }
958 res->address = BFD_MACH_O_GET_SR_ADDRESS (addr);
959 reloc.r_type = BFD_MACH_O_GET_SR_TYPE (addr);
960 reloc.r_length = BFD_MACH_O_GET_SR_LENGTH (addr);
961 reloc.r_pcrel = addr & BFD_MACH_O_SR_PCREL;
962 reloc.r_scattered = 1;
963 }
964 else
965 {
966 unsigned int num = BFD_MACH_O_GET_R_SYMBOLNUM (symnum);
967 res->addend = 0;
968 res->address = addr;
969 if (symnum & BFD_MACH_O_R_EXTERN)
06988dfc
TG		 970 {
971 sym = syms + num;
972 reloc.r_extern = 1;
973 }
b32e07d7
TG		 974 else
975 {
976 BFD_ASSERT (num != 0);
977 BFD_ASSERT (num <= mdata->nsects);
978 sym = mdata->sections[num - 1]->bfdsection->symbol_ptr_ptr;
1523fa24
TG		 979 /* For a symbol defined in section S, the addend (stored in the
980 binary) contains the address of the section. To comply with
981 bfd conventio, substract the section address.
982 Use the address from the header, so that the user can modify
983 the vma of the section. */
984 res->addend = -mdata->sections[num - 1]->addr;
06988dfc 985 reloc.r_extern = 0;
b32e07d7
TG		 986 }
987 res->sym_ptr_ptr = sym;
988 reloc.r_type = BFD_MACH_O_GET_R_TYPE (symnum);
989 reloc.r_length = BFD_MACH_O_GET_R_LENGTH (symnum);
990 reloc.r_pcrel = (symnum & BFD_MACH_O_R_PCREL) ? 1 : 0;
991 reloc.r_scattered = 0;
992 }
993
994 if (!(*bed->_bfd_mach_o_swap_reloc_in)(res, &reloc))
995 return -1;
996 return 0;
997}
998
999static int
1000bfd_mach_o_canonicalize_relocs (bfd *abfd, unsigned long filepos,
1001 unsigned long count,
1002 arelent *res, asymbol **syms)
1003{
92bc0e80 1004 unsigned long i;
46d1c23b 1005 struct mach_o_reloc_info_external *native_relocs;
92bc0e80
TG		 1006 bfd_size_type native_size;
1007
92bc0e80 1008 /* Allocate and read relocs. */
b32e07d7 1009 native_size = count * BFD_MACH_O_RELENT_SIZE;
46d1c23b
TG		 1010 native_relocs =
1011 (struct mach_o_reloc_info_external *) bfd_malloc (native_size);
92bc0e80
TG		 1012 if (native_relocs == NULL)
1013 return -1;
1014
b32e07d7 1015 if (bfd_seek (abfd, filepos, SEEK_SET) != 0
92bc0e80 1016 || bfd_bread (native_relocs, native_size, abfd) != native_size)
b32e07d7
TG		 1017 goto err;
1018
1019 for (i = 0; i < count; i++)
92bc0e80 1020 {
46d1c23b
TG		 1021 if (bfd_mach_o_canonicalize_one_reloc (abfd, &native_relocs[i],
1022 &res[i], syms) < 0)
b32e07d7 1023 goto err;
92bc0e80 1024 }
b32e07d7
TG		 1025 free (native_relocs);
1026 return i;
1027 err:
1028 free (native_relocs);
1029 return -1;
1030}
1031
1032long
1033bfd_mach_o_canonicalize_reloc (bfd *abfd, asection *asect,
1034 arelent **rels, asymbol **syms)
1035{
1036 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
1037 unsigned long i;
1038 arelent *res;
1039
1040 if (asect->reloc_count == 0)
1041 return 0;
1042
1043 /* No need to go further if we don't know how to read relocs. */
1044 if (bed->_bfd_mach_o_swap_reloc_in == NULL)
1045 return 0;
92bc0e80 1046
dff55db0 1047 if (asect->relocation == NULL)
92bc0e80 1048 {
dff55db0
TG		 1049 res = bfd_malloc (asect->reloc_count * sizeof (arelent));
1050 if (res == NULL)
1051 return -1;
1052
1053 if (bfd_mach_o_canonicalize_relocs (abfd, asect->rel_filepos,
1054 asect->reloc_count, res, syms) < 0)
1055 {
1056 free (res);
1057 return -1;
1058 }
1059 asect->relocation = res;
92bc0e80
TG		 1060 }
1061
dff55db0 1062 res = asect->relocation;
92bc0e80 1063 for (i = 0; i < asect->reloc_count; i++)
b32e07d7
TG		 1064 rels[i] = &res[i];
1065 rels[i] = NULL;
92bc0e80 1066
b32e07d7
TG		 1067 return i;
1068}
92bc0e80 1069
b32e07d7
TG		 1070long
1071bfd_mach_o_get_dynamic_reloc_upper_bound (bfd *abfd)
1072{
1073 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
92bc0e80 1074
b32e07d7
TG		 1075 if (mdata->dysymtab == NULL)
1076 return 1;
dff55db0 1077 return (mdata->dysymtab->nextrel + mdata->dysymtab->nlocrel + 1)
b32e07d7
TG		 1078 * sizeof (arelent *);
1079}
92bc0e80 1080
b32e07d7
TG		 1081long
1082bfd_mach_o_canonicalize_dynamic_reloc (bfd *abfd, arelent **rels,
1083 struct bfd_symbol **syms)
1084{
1085 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
1086 bfd_mach_o_dysymtab_command *dysymtab = mdata->dysymtab;
1087 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
1088 unsigned long i;
1089 arelent *res;
1090
1091 if (dysymtab == NULL)
1092 return 0;
1093 if (dysymtab->nextrel == 0 && dysymtab->nlocrel == 0)
1094 return 0;
1095
1096 /* No need to go further if we don't know how to read relocs. */
1097 if (bed->_bfd_mach_o_swap_reloc_in == NULL)
1098 return 0;
1099
dff55db0 1100 if (mdata->dyn_reloc_cache == NULL)
b32e07d7 1101 {
dff55db0
TG		 1102 res = bfd_malloc ((dysymtab->nextrel + dysymtab->nlocrel)
1103 * sizeof (arelent));
1104 if (res == NULL)
1105 return -1;
b32e07d7 1106
dff55db0
TG		 1107 if (bfd_mach_o_canonicalize_relocs (abfd, dysymtab->extreloff,
1108 dysymtab->nextrel, res, syms) < 0)
1109 {
1110 free (res);
1111 return -1;
1112 }
1113
1114 if (bfd_mach_o_canonicalize_relocs (abfd, dysymtab->locreloff,
1115 dysymtab->nlocrel,
1116 res + dysymtab->nextrel, syms) < 0)
1117 {
1118 free (res);
1119 return -1;
1120 }
1121
1122 mdata->dyn_reloc_cache = res;
b32e07d7
TG		 1123 }
1124
dff55db0 1125 res = mdata->dyn_reloc_cache;
b32e07d7
TG		 1126 for (i = 0; i < dysymtab->nextrel + dysymtab->nlocrel; i++)
1127 rels[i] = &res[i];
1128 rels[i] = NULL;
92bc0e80
TG		 1129 return i;
1130}
1131
1132static bfd_boolean
ab273af8 1133bfd_mach_o_write_relocs (bfd *abfd, bfd_mach_o_section *section)
92bc0e80 1134{
046b007d 1135 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
92bc0e80
TG		 1136 unsigned int i;
1137 arelent **entries;
1138 asection *sec;
1139 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
1140
1141 sec = section->bfdsection;
1142 if (sec->reloc_count == 0)
1143 return TRUE;
1144
1145 if (bed->_bfd_mach_o_swap_reloc_out == NULL)
1146 return TRUE;
1147
1148 /* Allocate relocation room. */
1149 mdata->filelen = FILE_ALIGN(mdata->filelen, 2);
1150 section->nreloc = sec->reloc_count;
1151 sec->rel_filepos = mdata->filelen;
1152 section->reloff = sec->rel_filepos;
1153 mdata->filelen += sec->reloc_count * BFD_MACH_O_RELENT_SIZE;
1154
1155 if (bfd_seek (abfd, section->reloff, SEEK_SET) != 0)
1156 return FALSE;
1157
1158 /* Convert and write. */
1159 entries = section->bfdsection->orelocation;
1160 for (i = 0; i < section->nreloc; i++)
1161 {
1162 arelent *rel = entries[i];
46d1c23b 1163 struct mach_o_reloc_info_external raw;
92bc0e80
TG		 1164 bfd_mach_o_reloc_info info, *pinfo = &info;
1165
1166 /* Convert relocation to an intermediate representation. */
1167 if (!(*bed->_bfd_mach_o_swap_reloc_out) (rel, pinfo))
1168 return FALSE;
1169
1170 /* Lower the relocation info. */
1171 if (pinfo->r_scattered)
1172 {
1173 unsigned long v;
1174
1175 v = BFD_MACH_O_SR_SCATTERED
1176 | (pinfo->r_pcrel ? BFD_MACH_O_SR_PCREL : 0)
1177 | BFD_MACH_O_SET_SR_LENGTH(pinfo->r_length)
1178 | BFD_MACH_O_SET_SR_TYPE(pinfo->r_type)
1179 | BFD_MACH_O_SET_SR_ADDRESS(pinfo->r_address);
46d1c23b
TG		 1180 /* Note: scattered relocs have field in reverse order... */
1181 bfd_put_32 (abfd, v, raw.r_address);
1182 bfd_put_32 (abfd, pinfo->r_value, raw.r_symbolnum);
92bc0e80
TG		 1183 }
1184 else
1185 {
1186 unsigned long v;
1187
46d1c23b 1188 bfd_put_32 (abfd, pinfo->r_address, raw.r_address);
92bc0e80
TG		 1189 v = BFD_MACH_O_SET_R_SYMBOLNUM (pinfo->r_value)
1190 | (pinfo->r_pcrel ? BFD_MACH_O_R_PCREL : 0)
1191 | BFD_MACH_O_SET_R_LENGTH (pinfo->r_length)
1192 | (pinfo->r_extern ? BFD_MACH_O_R_EXTERN : 0)
1193 | BFD_MACH_O_SET_R_TYPE (pinfo->r_type);
46d1c23b 1194 bfd_put_32 (abfd, v, raw.r_symbolnum);
92bc0e80
TG		 1195 }
1196
46d1c23b 1197 if (bfd_bwrite (&raw, BFD_MACH_O_RELENT_SIZE, abfd)
92bc0e80
TG		 1198 != BFD_MACH_O_RELENT_SIZE)
1199 return FALSE;
1200 }
1201 return TRUE;
1202}
1203
116c20d2 1204static int
ab273af8 1205bfd_mach_o_write_section_32 (bfd *abfd, bfd_mach_o_section *section)
116c20d2 1206{
46d1c23b
TG		 1207 struct mach_o_section_32_external raw;
1208
1209 memcpy (raw.sectname, section->sectname, 16);
72b5104c 1210 memcpy (raw.segname, section->segname, 16);
46d1c23b
TG		 1211 bfd_h_put_32 (abfd, section->addr, raw.addr);
1212 bfd_h_put_32 (abfd, section->size, raw.size);
1213 bfd_h_put_32 (abfd, section->offset, raw.offset);
1214 bfd_h_put_32 (abfd, section->align, raw.align);
1215 bfd_h_put_32 (abfd, section->reloff, raw.reloff);
1216 bfd_h_put_32 (abfd, section->nreloc, raw.nreloc);
1217 bfd_h_put_32 (abfd, section->flags, raw.flags);
1218 bfd_h_put_32 (abfd, section->reserved1, raw.reserved1);
1219 bfd_h_put_32 (abfd, section->reserved2, raw.reserved2);
1220
1221 if (bfd_bwrite (&raw, BFD_MACH_O_SECTION_SIZE, abfd)
92bc0e80 1222 != BFD_MACH_O_SECTION_SIZE)
116c20d2
NC		 1223 return -1;
1224
1225 return 0;
1226}
1227
1228static int
ab273af8 1229bfd_mach_o_write_section_64 (bfd *abfd, bfd_mach_o_section *section)
116c20d2 1230{
46d1c23b
TG		 1231 struct mach_o_section_64_external raw;
1232
1233 memcpy (raw.sectname, section->sectname, 16);
1234 memcpy (raw.segname, section->segname, 16);
1235 bfd_h_put_64 (abfd, section->addr, raw.addr);
1236 bfd_h_put_64 (abfd, section->size, raw.size);
1237 bfd_h_put_32 (abfd, section->offset, raw.offset);
1238 bfd_h_put_32 (abfd, section->align, raw.align);
1239 bfd_h_put_32 (abfd, section->reloff, raw.reloff);
1240 bfd_h_put_32 (abfd, section->nreloc, raw.nreloc);
1241 bfd_h_put_32 (abfd, section->flags, raw.flags);
1242 bfd_h_put_32 (abfd, section->reserved1, raw.reserved1);
1243 bfd_h_put_32 (abfd, section->reserved2, raw.reserved2);
1244 bfd_h_put_32 (abfd, section->reserved3, raw.reserved3);
1245
1246 if (bfd_bwrite (&raw, BFD_MACH_O_SECTION_64_SIZE, abfd)
92bc0e80 1247 != BFD_MACH_O_SECTION_64_SIZE)
116c20d2
NC		 1248 return -1;
1249
1e8a024a
TG		 1250 return 0;
1251}
1252
1253static int
ab273af8 1254bfd_mach_o_write_segment_32 (bfd *abfd, bfd_mach_o_load_command *command)
1e8a024a 1255{
46d1c23b 1256 struct mach_o_segment_command_32_external raw;
1e8a024a 1257 bfd_mach_o_segment_command *seg = &command->command.segment;
f1bde64c 1258 bfd_mach_o_section *sec;
1e8a024a 1259
c2f09c75
TG		 1260 BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT);
1261
f1bde64c
TG		 1262 for (sec = seg->sect_head; sec != NULL; sec = sec->next)
1263 if (!bfd_mach_o_write_relocs (abfd, sec))
92bc0e80 1264 return -1;
c2f09c75 1265
46d1c23b
TG		 1266 memcpy (raw.segname, seg->segname, 16);
1267 bfd_h_put_32 (abfd, seg->vmaddr, raw.vmaddr);
1268 bfd_h_put_32 (abfd, seg->vmsize, raw.vmsize);
1269 bfd_h_put_32 (abfd, seg->fileoff, raw.fileoff);
1270 bfd_h_put_32 (abfd, seg->filesize, raw.filesize);
1271 bfd_h_put_32 (abfd, seg->maxprot, raw.maxprot);
1272 bfd_h_put_32 (abfd, seg->initprot, raw.initprot);
1273 bfd_h_put_32 (abfd, seg->nsects, raw.nsects);
1274 bfd_h_put_32 (abfd, seg->flags, raw.flags);
c2f09c75 1275
46d1c23b
TG		 1276 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
1277 || bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
c2f09c75 1278 return -1;
1e8a024a 1279
f1bde64c
TG		 1280 for (sec = seg->sect_head; sec != NULL; sec = sec->next)
1281 if (bfd_mach_o_write_section_32 (abfd, sec))
92bc0e80 1282 return -1;
1e8a024a 1283
116c20d2
NC		 1284 return 0;
1285}
1286
1e8a024a 1287static int
ab273af8 1288bfd_mach_o_write_segment_64 (bfd *abfd, bfd_mach_o_load_command *command)
1e8a024a 1289{
46d1c23b 1290 struct mach_o_segment_command_64_external raw;
c2f09c75 1291 bfd_mach_o_segment_command *seg = &command->command.segment;
f1bde64c 1292 bfd_mach_o_section *sec;
c2f09c75
TG		 1293
1294 BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT_64);
1295
f1bde64c
TG		 1296 for (sec = seg->sect_head; sec != NULL; sec = sec->next)
1297 if (!bfd_mach_o_write_relocs (abfd, sec))
92bc0e80 1298 return -1;
c2f09c75 1299
46d1c23b
TG		 1300 memcpy (raw.segname, seg->segname, 16);
1301 bfd_h_put_64 (abfd, seg->vmaddr, raw.vmaddr);
1302 bfd_h_put_64 (abfd, seg->vmsize, raw.vmsize);
1303 bfd_h_put_64 (abfd, seg->fileoff, raw.fileoff);
1304 bfd_h_put_64 (abfd, seg->filesize, raw.filesize);
1305 bfd_h_put_32 (abfd, seg->maxprot, raw.maxprot);
1306 bfd_h_put_32 (abfd, seg->initprot, raw.initprot);
1307 bfd_h_put_32 (abfd, seg->nsects, raw.nsects);
1308 bfd_h_put_32 (abfd, seg->flags, raw.flags);
1309
1310 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
1311 || bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
c2f09c75
TG		 1312 return -1;
1313
f1bde64c
TG		 1314 for (sec = seg->sect_head; sec != NULL; sec = sec->next)
1315 if (bfd_mach_o_write_section_64 (abfd, sec))
92bc0e80 1316 return -1;
c2f09c75 1317
c2f09c75 1318 return 0;
1e8a024a
TG		 1319}
1320
c2f09c75 1321static bfd_boolean
ab273af8 1322bfd_mach_o_write_symtab (bfd *abfd, bfd_mach_o_load_command *command)
116c20d2 1323{
046b007d 1324 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
116c20d2 1325 bfd_mach_o_symtab_command *sym = &command->command.symtab;
116c20d2 1326 unsigned long i;
c2f09c75 1327 unsigned int wide = bfd_mach_o_wide_p (abfd);
046b007d 1328 unsigned int symlen = wide ? BFD_MACH_O_NLIST_64_SIZE : BFD_MACH_O_NLIST_SIZE;
c2f09c75
TG		 1329 struct bfd_strtab_hash *strtab;
1330 asymbol **symbols = bfd_get_outsymbols (abfd);
1331
1332 BFD_ASSERT (command->type == BFD_MACH_O_LC_SYMTAB);
1333
1334 /* Write the symbols first. */
92bc0e80
TG		 1335 mdata->filelen = FILE_ALIGN(mdata->filelen, wide ? 3 : 2);
1336 sym->symoff = mdata->filelen;
c2f09c75
TG		 1337 if (bfd_seek (abfd, sym->symoff, SEEK_SET) != 0)
1338 return FALSE;
1339
1340 sym->nsyms = bfd_get_symcount (abfd);
92bc0e80 1341 mdata->filelen += sym->nsyms * symlen;
c2f09c75
TG		 1342
1343 strtab = _bfd_stringtab_init ();
1344 if (strtab == NULL)
1345 return FALSE;
116c20d2 1346
a4551119
TG		 1347 if (sym->nsyms > 0)
1348 /* Although we don't strictly need to do this, for compatibility with
1349 Darwin system tools, actually output an empty string for the index
1350 0 entry. */
1351 _bfd_stringtab_add (strtab, "", TRUE, FALSE);
1352
116c20d2
NC		 1353 for (i = 0; i < sym->nsyms; i++)
1354 {
91d6fa6a 1355 bfd_size_type str_index;
92bc0e80 1356 bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *)symbols[i];
c2f09c75 1357
7f307238
IS		 1358 /* For a bare indirect symbol, the system tools expect that the symbol
1359 value will be the string table offset for its referenced counterpart.
1360
1361 Normally, indirect syms will not be written this way, but rather as
1362 part of the dysymtab command.
1363
1364 In either case, correct operation depends on the symbol table being
1365 sorted such that the indirect symbols are at the end (since the
1366 string table index is filled in below). */
1367
1368 if (IS_MACHO_INDIRECT (s->n_type))
1369 /* A pointer to the referenced symbol will be stored in the udata
1370 field. Use that to find the string index. */
1371 s->symbol.value =
1372 ((bfd_mach_o_asymbol *)s->symbol.udata.p)->symbol.udata.i;
1373
92bc0e80 1374 if (s->symbol.name == 0 || s->symbol.name[0] == '\0')
7f307238 1375 /* An index of 0 always means the empty string. */
91d6fa6a 1376 str_index = 0;
c2f09c75
TG		 1377 else
1378 {
91d6fa6a 1379 str_index = _bfd_stringtab_add (strtab, s->symbol.name, TRUE, FALSE);
7f307238
IS		 1380 /* Record the string index. This can be looked up by an indirect sym
1381 which retains a pointer to its referenced counterpart, until it is
1382 actually output. */
1383 if (IS_MACHO_INDIRECT (s->n_type))
1384 s->symbol.udata.i = str_index;
1385
91d6fa6a 1386 if (str_index == (bfd_size_type) -1)
c2f09c75
TG		 1387 goto err;
1388 }
46d1c23b 1389
c2f09c75 1390 if (wide)
46d1c23b
TG		 1391 {
1392 struct mach_o_nlist_64_external raw;
1393
1394 bfd_h_put_32 (abfd, str_index, raw.n_strx);
1395 bfd_h_put_8 (abfd, s->n_type, raw.n_type);
1396 bfd_h_put_8 (abfd, s->n_sect, raw.n_sect);
1397 bfd_h_put_16 (abfd, s->n_desc, raw.n_desc);
1398 bfd_h_put_64 (abfd, s->symbol.section->vma + s->symbol.value,
1399 raw.n_value);
1400
1401 if (bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
1402 goto err;
1403 }
c2f09c75 1404 else
46d1c23b
TG		 1405 {
1406 struct mach_o_nlist_external raw;
116c20d2 1407
46d1c23b
TG		 1408 bfd_h_put_32 (abfd, str_index, raw.n_strx);
1409 bfd_h_put_8 (abfd, s->n_type, raw.n_type);
1410 bfd_h_put_8 (abfd, s->n_sect, raw.n_sect);
1411 bfd_h_put_16 (abfd, s->n_desc, raw.n_desc);
1412 bfd_h_put_32 (abfd, s->symbol.section->vma + s->symbol.value,
1413 raw.n_value);
1414
1415 if (bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
1416 goto err;
1417 }
116c20d2 1418 }
c2f09c75 1419 sym->strsize = _bfd_stringtab_size (strtab);
92bc0e80
TG		 1420 sym->stroff = mdata->filelen;
1421 mdata->filelen += sym->strsize;
116c20d2 1422
c2f09c75
TG		 1423 if (_bfd_stringtab_emit (abfd, strtab) != TRUE)
1424 goto err;
1425 _bfd_stringtab_free (strtab);
116c20d2 1426
c2f09c75 1427 /* The command. */
46d1c23b
TG		 1428 {
1429 struct mach_o_symtab_command_external raw;
116c20d2 1430
46d1c23b
TG		 1431 bfd_h_put_32 (abfd, sym->symoff, raw.symoff);
1432 bfd_h_put_32 (abfd, sym->nsyms, raw.nsyms);
1433 bfd_h_put_32 (abfd, sym->stroff, raw.stroff);
1434 bfd_h_put_32 (abfd, sym->strsize, raw.strsize);
1435
1436 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
1437 || bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
1438 return FALSE;
1439 }
116c20d2 1440
c2f09c75 1441 return TRUE;
116c20d2 1442
c2f09c75
TG		 1443 err:
1444 _bfd_stringtab_free (strtab);
1445 return FALSE;
116c20d2
NC		 1446}
1447
7f307238
IS		 1448/* Write a dysymtab command.
1449 TODO: Possibly coalesce writes of smaller objects. */
1450
1451static bfd_boolean
1452bfd_mach_o_write_dysymtab (bfd *abfd, bfd_mach_o_load_command *command)
1453{
1454 bfd_mach_o_dysymtab_command *cmd = &command->command.dysymtab;
1455
1456 BFD_ASSERT (command->type == BFD_MACH_O_LC_DYSYMTAB);
1457
1458 if (cmd->nmodtab != 0)
1459 {
1460 unsigned int i;
1461
1462 if (bfd_seek (abfd, cmd->modtaboff, SEEK_SET) != 0)
1463 return FALSE;
1464
1465 for (i = 0; i < cmd->nmodtab; i++)
1466 {
1467 bfd_mach_o_dylib_module *module = &cmd->dylib_module[i];
1468 unsigned int iinit;
1469 unsigned int ninit;
1470
1471 iinit = module->iinit & 0xffff;
1472 iinit |= ((module->iterm & 0xffff) << 16);
1473
1474 ninit = module->ninit & 0xffff;
1475 ninit |= ((module->nterm & 0xffff) << 16);
1476
1477 if (bfd_mach_o_wide_p (abfd))
1478 {
1479 struct mach_o_dylib_module_64_external w;
1480
1481 bfd_h_put_32 (abfd, module->module_name_idx, &w.module_name);
1482 bfd_h_put_32 (abfd, module->iextdefsym, &w.iextdefsym);
1483 bfd_h_put_32 (abfd, module->nextdefsym, &w.nextdefsym);
1484 bfd_h_put_32 (abfd, module->irefsym, &w.irefsym);
1485 bfd_h_put_32 (abfd, module->nrefsym, &w.nrefsym);
1486 bfd_h_put_32 (abfd, module->ilocalsym, &w.ilocalsym);
1487 bfd_h_put_32 (abfd, module->nlocalsym, &w.nlocalsym);
1488 bfd_h_put_32 (abfd, module->iextrel, &w.iextrel);
1489 bfd_h_put_32 (abfd, module->nextrel, &w.nextrel);
1490 bfd_h_put_32 (abfd, iinit, &w.iinit_iterm);
1491 bfd_h_put_32 (abfd, ninit, &w.ninit_nterm);
1492 bfd_h_put_64 (abfd, module->objc_module_info_addr,
1493 &w.objc_module_info_addr);
1494 bfd_h_put_32 (abfd, module->objc_module_info_size,
1495 &w.objc_module_info_size);
1496
1497 if (bfd_bwrite ((void *) &w, sizeof (w), abfd) != sizeof (w))
1498 return FALSE;
1499 }
1500 else
1501 {
1502 struct mach_o_dylib_module_external n;
1503
1504 bfd_h_put_32 (abfd, module->module_name_idx, &n.module_name);
1505 bfd_h_put_32 (abfd, module->iextdefsym, &n.iextdefsym);
1506 bfd_h_put_32 (abfd, module->nextdefsym, &n.nextdefsym);
1507 bfd_h_put_32 (abfd, module->irefsym, &n.irefsym);
1508 bfd_h_put_32 (abfd, module->nrefsym, &n.nrefsym);
1509 bfd_h_put_32 (abfd, module->ilocalsym, &n.ilocalsym);
1510 bfd_h_put_32 (abfd, module->nlocalsym, &n.nlocalsym);
1511 bfd_h_put_32 (abfd, module->iextrel, &n.iextrel);
1512 bfd_h_put_32 (abfd, module->nextrel, &n.nextrel);
1513 bfd_h_put_32 (abfd, iinit, &n.iinit_iterm);
1514 bfd_h_put_32 (abfd, ninit, &n.ninit_nterm);
1515 bfd_h_put_32 (abfd, module->objc_module_info_addr,
1516 &n.objc_module_info_addr);
1517 bfd_h_put_32 (abfd, module->objc_module_info_size,
1518 &n.objc_module_info_size);
1519
1520 if (bfd_bwrite ((void *) &n, sizeof (n), abfd) != sizeof (n))
1521 return FALSE;
1522 }
1523 }
1524 }
1525
1526 if (cmd->ntoc != 0)
1527 {
1528 unsigned int i;
1529
1530 if (bfd_seek (abfd, cmd->tocoff, SEEK_SET) != 0)
1531 return FALSE;
1532
1533 for (i = 0; i < cmd->ntoc; i++)
1534 {
1535 struct mach_o_dylib_table_of_contents_external raw;
1536 bfd_mach_o_dylib_table_of_content *toc = &cmd->dylib_toc[i];
1537
1538 bfd_h_put_32 (abfd, toc->symbol_index, &raw.symbol_index);
1539 bfd_h_put_32 (abfd, toc->module_index, &raw.module_index);
1540
1541 if (bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
1542 return FALSE;
1543 }
1544 }
1545
1546 if (cmd->nindirectsyms > 0)
1547 {
1548 unsigned int i;
1549
1550 if (bfd_seek (abfd, cmd->indirectsymoff, SEEK_SET) != 0)
1551 return FALSE;
1552
1553 for (i = 0; i < cmd->nindirectsyms; ++i)
1554 {
1555 unsigned char raw[4];
1556
1557 bfd_h_put_32 (abfd, cmd->indirect_syms[i], &raw);
1558 if (bfd_bwrite (raw, sizeof (raw), abfd) != sizeof (raw))
1559 return FALSE;
1560 }
1561 }
1562
1563 if (cmd->nextrefsyms != 0)
1564 {
1565 unsigned int i;
1566
1567 if (bfd_seek (abfd, cmd->extrefsymoff, SEEK_SET) != 0)
1568 return FALSE;
1569
1570 for (i = 0; i < cmd->nextrefsyms; i++)
1571 {
1572 unsigned long v;
1573 unsigned char raw[4];
1574 bfd_mach_o_dylib_reference *ref = &cmd->ext_refs[i];
1575
1576 /* Fields isym and flags are written as bit-fields, thus we need
1577 a specific processing for endianness. */
1578
1579 if (bfd_big_endian (abfd))
1580 {
1581 v = ((ref->isym & 0xffffff) << 8);
1582 v |= ref->flags & 0xff;
1583 }
1584 else
1585 {
1586 v = ref->isym & 0xffffff;
1587 v |= ((ref->flags & 0xff) << 24);
1588 }
1589
1590 bfd_h_put_32 (abfd, v, raw);
1591 if (bfd_bwrite (raw, sizeof (raw), abfd) != sizeof (raw))
1592 return FALSE;
1593 }
1594 }
1595
1596 /* The command. */
1597 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0)
1598 return FALSE;
1599 else
1600 {
1601 struct mach_o_dysymtab_command_external raw;
1602
1603 bfd_h_put_32 (abfd, cmd->ilocalsym, &raw.ilocalsym);
1604 bfd_h_put_32 (abfd, cmd->nlocalsym, &raw.nlocalsym);
1605 bfd_h_put_32 (abfd, cmd->iextdefsym, &raw.iextdefsym);
1606 bfd_h_put_32 (abfd, cmd->nextdefsym, &raw.nextdefsym);
1607 bfd_h_put_32 (abfd, cmd->iundefsym, &raw.iundefsym);
1608 bfd_h_put_32 (abfd, cmd->nundefsym, &raw.nundefsym);
1609 bfd_h_put_32 (abfd, cmd->tocoff, &raw.tocoff);
1610 bfd_h_put_32 (abfd, cmd->ntoc, &raw.ntoc);
1611 bfd_h_put_32 (abfd, cmd->modtaboff, &raw.modtaboff);
1612 bfd_h_put_32 (abfd, cmd->nmodtab, &raw.nmodtab);
1613 bfd_h_put_32 (abfd, cmd->extrefsymoff, &raw.extrefsymoff);
1614 bfd_h_put_32 (abfd, cmd->nextrefsyms, &raw.nextrefsyms);
1615 bfd_h_put_32 (abfd, cmd->indirectsymoff, &raw.indirectsymoff);
1616 bfd_h_put_32 (abfd, cmd->nindirectsyms, &raw.nindirectsyms);
1617 bfd_h_put_32 (abfd, cmd->extreloff, &raw.extreloff);
1618 bfd_h_put_32 (abfd, cmd->nextrel, &raw.nextrel);
1619 bfd_h_put_32 (abfd, cmd->locreloff, &raw.locreloff);
1620 bfd_h_put_32 (abfd, cmd->nlocrel, &raw.nlocrel);
1621
1622 if (bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
1623 return FALSE;
1624 }
1625
1626 return TRUE;
1627}
1628
1629static unsigned
68588f95 1630bfd_mach_o_primary_symbol_sort_key (unsigned type)
7f307238 1631{
68588f95
IS		 1632 unsigned mtyp = type & BFD_MACH_O_N_TYPE;
1633
1634 /* Just leave debug symbols where they are (pretend they are local, and
1635 then they will just be sorted on position). */
1636 if (type & BFD_MACH_O_N_STAB)
1637 return 0;
1638
1639 /* Sort indirects to last. */
1640 if (mtyp == BFD_MACH_O_N_INDR)
7f307238
IS		 1641 return 3;
1642
1643 /* Local (we should never see an undefined local AFAICT). */
68588f95 1644 if (! (type & (BFD_MACH_O_N_EXT | BFD_MACH_O_N_PEXT)))
7f307238
IS		 1645 return 0;
1646
1647 /* Common symbols look like undefined externs. */
68588f95 1648 if (mtyp == BFD_MACH_O_N_UNDF)
7f307238
IS		 1649 return 2;
1650
1651 /* A defined symbol that's not indirect or extern. */
1652 return 1;
1653}
1654
1655static int
1656bfd_mach_o_cf_symbols (const void *a, const void *b)
1657{
1658 bfd_mach_o_asymbol *sa = *(bfd_mach_o_asymbol **) a;
1659 bfd_mach_o_asymbol *sb = *(bfd_mach_o_asymbol **) b;
1660 unsigned int soa, sob;
1661
68588f95
IS		 1662 soa = bfd_mach_o_primary_symbol_sort_key (sa->n_type);
1663 sob = bfd_mach_o_primary_symbol_sort_key (sb->n_type);
7f307238
IS		 1664 if (soa < sob)
1665 return -1;
1666
1667 if (soa > sob)
1668 return 1;
1669
68588f95 1670 /* If it's local or stab, just preserve the input order. */
7f307238
IS		 1671 if (soa == 0)
1672 {
1673 if (sa->symbol.udata.i < sb->symbol.udata.i)
1674 return -1;
1675 if (sa->symbol.udata.i > sb->symbol.udata.i)
1676 return 1;
1677 return 0;
1678 }
1679
1680 /* Unless it's an indirect the second sort key is name. */
1681 if (soa < 3)
1682 return strcmp (sa->symbol.name, sb->symbol.name);
1683
1684 /* Here be indirect symbols, which have different sort rules. */
1685
1686 /* Next sort key for indirect, is the section index. */
1687 if (sa->n_sect < sb->n_sect)
1688 return -1;
1689
1690 if (sa->n_sect > sb->n_sect)
1691 return 1;
1692
1693 /* Last sort key is the order of definition - which should be in line with
1694 the value, since a stub size of 0 is meaninglesss. */
1695
1696 if (sa->symbol.value < sb->symbol.value)
1697 return -1;
1698
1699 if (sa->symbol.value > sb->symbol.value)
1700 return 1;
1701
1702 /* In the final analysis, this is probably an error ... but leave it alone
1703 for now. */
1704 return 0;
1705}
1706
1707/* When this is finished, return the number of non-indirect symbols. */
1708
1709static unsigned int
1710bfd_mach_o_sort_symbol_table (asymbol **symbols, unsigned int nin)
1711{
1712 qsort (symbols, (size_t) nin, sizeof (void *), bfd_mach_o_cf_symbols);
1713
1714 /* Find the last non-indirect symbol.
1715 There must be at least one non-indirect symbol otherwise there's
1716 nothing for the indirect(s) to refer to. */
1717 do
1718 {
1719 bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *)symbols[nin - 1];
1720 if (IS_MACHO_INDIRECT (s->n_type))
1721 nin--;
1722 else
1723 break;
1724 } while (nin - 1 > 0);
1725 return nin;
1726}
1727
1728/* Process the symbols.
1729
1730 This should be OK for single-module files - but it is not likely to work
1731 for multi-module shared libraries.
1732
1733 (a) If the application has not filled in the relevant mach-o fields, make
1734 an estimate.
1735
1736 (b) Order them, like this:
1737 ( i) local.
1738 (unsorted)
1739 ( ii) external defined
1740 (by name)
1741 (iii) external undefined
1742 (by name)
1743 ( iv) common
1744 (by name)
1745 ( v) indirect
1746 (by section)
1747 (by position within section).
1748
1749 (c) Indirect symbols are moved to the end of the list. */
92bc0e80
TG		 1750
1751static bfd_boolean
7f307238 1752bfd_mach_o_mangle_symbols (bfd *abfd, bfd_mach_o_data_struct *mdata)
92bc0e80
TG		 1753{
1754 unsigned long i;
1755 asymbol **symbols = bfd_get_outsymbols (abfd);
1756
7f307238
IS		 1757 if (symbols == NULL || bfd_get_symcount (abfd) == 0)
1758 return TRUE;
1759
92bc0e80
TG		 1760 for (i = 0; i < bfd_get_symcount (abfd); i++)
1761 {
1762 bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *)symbols[i];
1763
1764 if (s->n_type == BFD_MACH_O_N_UNDF && !(s->symbol.flags & BSF_DEBUGGING))
1765 {
1766 /* As genuine Mach-O symbols type shouldn't be N_UNDF (undefined
1767 symbols should be N_UNDEF | N_EXT), we suppose the back-end
1768 values haven't been set. */
1769 if (s->symbol.section == bfd_abs_section_ptr)
1770 s->n_type = BFD_MACH_O_N_ABS;
1771 else if (s->symbol.section == bfd_und_section_ptr)
1772 {
1773 s->n_type = BFD_MACH_O_N_UNDF;
1774 if (s->symbol.flags & BSF_WEAK)
1775 s->n_desc |= BFD_MACH_O_N_WEAK_REF;
7f307238
IS		 1776 /* mach-o automatically makes undefined symbols extern. */
1777 s->n_type |= BFD_MACH_O_N_EXT;
92bc0e80
TG		 1778 }
1779 else if (s->symbol.section == bfd_com_section_ptr)
1780 s->n_type = BFD_MACH_O_N_UNDF | BFD_MACH_O_N_EXT;
1781 else
1782 s->n_type = BFD_MACH_O_N_SECT;
1783
1784 if (s->symbol.flags & BSF_GLOBAL)
1785 s->n_type |= BFD_MACH_O_N_EXT;
1786 }
1787
7f307238 1788 /* Put the section index in, where required. */
68588f95 1789 if ((s->symbol.section != bfd_abs_section_ptr
92bc0e80
TG		 1790 && s->symbol.section != bfd_und_section_ptr
1791 && s->symbol.section != bfd_com_section_ptr)
68588f95
IS		 1792 || ((s->n_type & BFD_MACH_O_N_STAB) != 0
1793 && s->symbol.name == NULL))
1794 s->n_sect = s->symbol.section->target_index;
92bc0e80 1795
7f307238
IS		 1796 /* Unless we're looking at an indirect sym, note the input ordering.
1797 We use this to keep local symbols ordered as per the input. */
f2b324f1 1798 if (! IS_MACHO_INDIRECT (s->n_type))
7f307238
IS		 1799 s->symbol.udata.i = i;
1800 }
1801
1802 /* Sort the symbols and determine how many will remain in the main symbol
1803 table, and how many will be emitted as indirect (assuming that we will
1804 be emitting a dysymtab). Renumber the sorted symbols so that the right
1805 index will be found during indirection. */
1806 i = bfd_mach_o_sort_symbol_table (symbols, bfd_get_symcount (abfd));
1807 if (bfd_mach_o_should_emit_dysymtab ())
1808 {
1809 /* Point at the first indirect symbol. */
1810 if (i < bfd_get_symcount (abfd))
1811 {
1812 mdata->indirect_syms = &symbols[i];
1813 mdata->nindirect = bfd_get_symcount (abfd) - i;
1814 /* This is, essentially, local to the output section of mach-o,
1815 and therefore should be safe. */
1816 abfd->symcount = i;
1817 }
1818
1819 /* Now setup the counts for each type of symbol. */
1820 for (i = 0; i < bfd_get_symcount (abfd); ++i)
1821 {
1822 bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *)symbols[i];
1823 s->symbol.udata.i = i; /* renumber. */
1824 if (s->n_type & (BFD_MACH_O_N_EXT | BFD_MACH_O_N_PEXT))
1825 break;
1826 }
1827 mdata->nlocal = i;
1828 for (; i < bfd_get_symcount (abfd); ++i)
1829 {
1830 bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *)symbols[i];
1831 s->symbol.udata.i = i; /* renumber. */
1832 if ((s->n_type & BFD_MACH_O_N_TYPE) == BFD_MACH_O_N_UNDF)
1833 break;
1834 }
1835 mdata->ndefext = i - mdata->nlocal;
1836 mdata->nundefext = bfd_get_symcount (abfd)
1837 - mdata->ndefext
1838 - mdata->nlocal;
1839 for (; i < bfd_get_symcount (abfd); ++i)
1840 {
1841 bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *)symbols[i];
1842 s->symbol.udata.i = i; /* renumber. */
1843 }
1844 }
1845
1846 return TRUE;
1847}
1848
1849/* We build a flat table of sections, which can be re-ordered if necessary.
1850 Fill in the section number and other mach-o-specific data. */
1851
1852static bfd_boolean
1853bfd_mach_o_mangle_sections (bfd *abfd, bfd_mach_o_data_struct *mdata)
1854{
1855 asection *sec;
1856 unsigned target_index;
1857 unsigned nsect;
1858
1859 nsect = bfd_count_sections (abfd);
1860
1861 /* Don't do it if it's already set - assume the application knows what it's
1862 doing. */
1863 if (mdata->nsects == nsect
1864 && (mdata->nsects == 0 || mdata->sections != NULL))
1865 return TRUE;
1866
1867 mdata->nsects = nsect;
1868 mdata->sections = bfd_alloc (abfd,
1869 mdata->nsects * sizeof (bfd_mach_o_section *));
1870 if (mdata->sections == NULL)
1871 return FALSE;
1872
1873 /* We need to check that this can be done... */
1874 if (nsect > 255)
1875 (*_bfd_error_handler) (_("mach-o: there are too many sections (%d)"
1876 " maximum is 255,\n"), nsect);
1877
1878 /* Create Mach-O sections.
1879 Section type, attribute and align should have been set when the
1880 section was created - either read in or specified. */
1881 target_index = 0;
1882 for (sec = abfd->sections; sec; sec = sec->next)
1883 {
1884 unsigned bfd_align = bfd_get_section_alignment (abfd, sec);
1885 bfd_mach_o_section *msect = bfd_mach_o_get_mach_o_section (sec);
1886
1887 mdata->sections[target_index] = msect;
1888
1889 msect->addr = bfd_get_section_vma (abfd, sec);
1890 msect->size = bfd_get_section_size (sec);
1891
1892 /* Use the largest alignment set, in case it was bumped after the
1893 section was created. */
1894 msect->align = msect->align > bfd_align ? msect->align : bfd_align;
1895
1896 msect->offset = 0;
1897 sec->target_index = ++target_index;
92bc0e80 1898 }
7f307238 1899
92bc0e80
TG		 1900 return TRUE;
1901}
1902
154a1ee5 1903bfd_boolean
116c20d2 1904bfd_mach_o_write_contents (bfd *abfd)
3af9a47b
NC		 1905{
1906 unsigned int i;
046b007d 1907 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3af9a47b 1908
7f307238 1909 /* Make the commands, if not already present. */
92bc0e80
TG		 1910 if (mdata->header.ncmds == 0)
1911 if (!bfd_mach_o_build_commands (abfd))
1912 return FALSE;
1913
154a1ee5 1914 if (!bfd_mach_o_write_header (abfd, &mdata->header))
b34976b6 1915 return FALSE;
3af9a47b
NC		 1916
1917 for (i = 0; i < mdata->header.ncmds; i++)
1918 {
46d1c23b 1919 struct mach_o_load_command_external raw;
3af9a47b
NC		 1920 bfd_mach_o_load_command *cur = &mdata->commands[i];
1921 unsigned long typeflag;
1922
154a1ee5 1923 typeflag = cur->type | (cur->type_required ? BFD_MACH_O_LC_REQ_DYLD : 0);
3af9a47b 1924
46d1c23b
TG		 1925 bfd_h_put_32 (abfd, typeflag, raw.cmd);
1926 bfd_h_put_32 (abfd, cur->len, raw.cmdsize);
3af9a47b 1927
c2f09c75 1928 if (bfd_seek (abfd, cur->offset, SEEK_SET) != 0
46d1c23b 1929 || bfd_bwrite (&raw, BFD_MACH_O_LC_SIZE, abfd) != 8)
b34976b6 1930 return FALSE;
3af9a47b
NC		 1931
1932 switch (cur->type)
1933 {
1934 case BFD_MACH_O_LC_SEGMENT:
ab273af8 1935 if (bfd_mach_o_write_segment_32 (abfd, cur) != 0)
1e8a024a
TG		 1936 return FALSE;
1937 break;
1938 case BFD_MACH_O_LC_SEGMENT_64:
ab273af8 1939 if (bfd_mach_o_write_segment_64 (abfd, cur) != 0)
b34976b6 1940 return FALSE;
3af9a47b
NC		 1941 break;
1942 case BFD_MACH_O_LC_SYMTAB:
ab273af8 1943 if (!bfd_mach_o_write_symtab (abfd, cur))
b34976b6 1944 return FALSE;
3af9a47b 1945 break;
7f307238
IS		 1946 case BFD_MACH_O_LC_DYSYMTAB:
1947 if (!bfd_mach_o_write_dysymtab (abfd, cur))
1948 return FALSE;
1949 break;
3af9a47b
NC		 1950 case BFD_MACH_O_LC_SYMSEG:
1951 break;
1952 case BFD_MACH_O_LC_THREAD:
1953 case BFD_MACH_O_LC_UNIXTHREAD:
ab273af8 1954 if (bfd_mach_o_write_thread (abfd, cur) != 0)
b34976b6 1955 return FALSE;
3af9a47b
NC		 1956 break;
1957 case BFD_MACH_O_LC_LOADFVMLIB:
1958 case BFD_MACH_O_LC_IDFVMLIB:
1959 case BFD_MACH_O_LC_IDENT:
1960 case BFD_MACH_O_LC_FVMFILE:
1961 case BFD_MACH_O_LC_PREPAGE:
3af9a47b
NC		 1962 case BFD_MACH_O_LC_LOAD_DYLIB:
1963 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB:
1964 case BFD_MACH_O_LC_ID_DYLIB:
046b007d 1965 case BFD_MACH_O_LC_REEXPORT_DYLIB:
73017762 1966 case BFD_MACH_O_LC_LOAD_UPWARD_DYLIB:
3af9a47b
NC		 1967 case BFD_MACH_O_LC_LOAD_DYLINKER:
1968 case BFD_MACH_O_LC_ID_DYLINKER:
1969 case BFD_MACH_O_LC_PREBOUND_DYLIB:
1970 case BFD_MACH_O_LC_ROUTINES:
1971 case BFD_MACH_O_LC_SUB_FRAMEWORK:
1972 break;
1973 default:
4a97a0e5
AM		 1974 (*_bfd_error_handler) (_("unable to write unknown load command 0x%lx"),
1975 (unsigned long) cur->type);
b34976b6 1976 return FALSE;
3af9a47b
NC		 1977 }
1978 }
1979
b34976b6 1980 return TRUE;
3af9a47b
NC		 1981}
1982
f1bde64c
TG		 1983static void
1984bfd_mach_o_append_section_to_segment (bfd_mach_o_segment_command *seg,
1985 asection *sec)
1986{
1987 bfd_mach_o_section *s = (bfd_mach_o_section *)sec->used_by_bfd;
1988 if (seg->sect_head == NULL)
1989 seg->sect_head = s;
1990 else
1991 seg->sect_tail->next = s;
1992 seg->sect_tail = s;
1993}
1994
1995/* Create section Mach-O flags from BFD flags. */
1996
1997static void
1998bfd_mach_o_set_section_flags_from_bfd (bfd *abfd ATTRIBUTE_UNUSED, asection *sec)
1999{
2000 flagword bfd_flags;
2001 bfd_mach_o_section *s = bfd_mach_o_get_mach_o_section (sec);
2002
2003 /* Create default flags. */
2004 bfd_flags = bfd_get_section_flags (abfd, sec);
2005 if ((bfd_flags & SEC_CODE) == SEC_CODE)
2006 s->flags = BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS
2007 | BFD_MACH_O_S_ATTR_SOME_INSTRUCTIONS
2008 | BFD_MACH_O_S_REGULAR;
2009 else if ((bfd_flags & (SEC_ALLOC | SEC_LOAD)) == SEC_ALLOC)
2010 s->flags = BFD_MACH_O_S_ZEROFILL;
2011 else if (bfd_flags & SEC_DEBUGGING)
2012 s->flags = BFD_MACH_O_S_REGULAR | BFD_MACH_O_S_ATTR_DEBUG;
2013 else
2014 s->flags = BFD_MACH_O_S_REGULAR;
2015}
2016
7f307238
IS		 2017/* Count the number of sections in the list for the segment named.
2018
2019 The special case of NULL or "" for the segment name is valid for
2020 an MH_OBJECT file and means 'all sections available'.
2021
2022 Requires that the sections table in mdata be filled in.
2023
2024 Returns the number of sections (0 is valid).
2025 Any number > 255 signals an invalid section count, although we will,
2026 perhaps, allow the file to be written (in line with Darwin tools up
2027 to XCode 4).
2028
2029 A section count of (unsigned long) -1 signals a definite error. */
2030
2031static unsigned long
2032bfd_mach_o_count_sections_for_seg (const char *segment,
2033 bfd_mach_o_data_struct *mdata)
2034{
2035 unsigned i,j;
2036 if (mdata == NULL || mdata->sections == NULL)
2037 return (unsigned long) -1;
2038
2039 /* The MH_OBJECT case, all sections are considered; Although nsects is
2040 is an unsigned long, the maximum valid section count is 255 and this
2041 will have been checked already by mangle_sections. */
2042 if (segment == NULL || segment[0] == '\0')
2043 return mdata->nsects;
2044
2045 /* Count the number of sections we see in this segment. */
2046 j = 0;
2047 for (i = 0; i < mdata->nsects; ++i)
2048 {
2049 bfd_mach_o_section *s = mdata->sections[i];
2050 if (strncmp (segment, s->segname, BFD_MACH_O_SEGNAME_SIZE) == 0)
2051 j++;
2052 }
2053 return j;
2054}
2055
2056static bfd_boolean
2057bfd_mach_o_build_seg_command (const char *segment,
2058 bfd_mach_o_data_struct *mdata,
2059 bfd_mach_o_segment_command *seg)
2060{
2061 unsigned i;
2062 int is_mho = (segment == NULL || segment[0] == '\0');
2063
2064 /* Fill segment command. */
2065 if (is_mho)
2066 memset (seg->segname, 0, sizeof (seg->segname));
2067 else
2068 strncpy (seg->segname, segment, sizeof (seg->segname));
2069
2070 /* TODO: fix this up for non-MH_OBJECT cases. */
2071 seg->vmaddr = 0;
2072
2073 seg->fileoff = mdata->filelen;
2074 seg->filesize = 0;
2075 seg->maxprot = BFD_MACH_O_PROT_READ | BFD_MACH_O_PROT_WRITE
2076 | BFD_MACH_O_PROT_EXECUTE;
2077 seg->initprot = seg->maxprot;
2078 seg->flags = 0;
2079 seg->sect_head = NULL;
2080 seg->sect_tail = NULL;
2081
2082 /* Append sections to the segment. */
2083
2084 for (i = 0; i < mdata->nsects; ++i)
2085 {
2086 bfd_mach_o_section *s = mdata->sections[i];
2087 asection *sec = s->bfdsection;
2088
2089 /* If we're not making an MH_OBJECT, check whether this section is from
2090 our segment, and skip if not. Otherwise, just add all sections. */
2091 if (! is_mho
2092 && strncmp (segment, s->segname, BFD_MACH_O_SEGNAME_SIZE) != 0)
2093 continue;
2094
2095 bfd_mach_o_append_section_to_segment (seg, sec);
2096
2097 if (s->size == 0)
2098 s->offset = 0;
2099 else
2100 {
2101 mdata->filelen = FILE_ALIGN (mdata->filelen, s->align);
2102 s->offset = mdata->filelen;
2103 }
2104
2105 sec->filepos = s->offset;
2106
2107 mdata->filelen += s->size;
2108 }
2109
2110 seg->filesize = mdata->filelen - seg->fileoff;
2111 seg->vmsize = seg->filesize;
2112
2113 return TRUE;
2114}
2115
2116static bfd_boolean
2117bfd_mach_o_build_dysymtab_command (bfd *abfd,
2118 bfd_mach_o_data_struct *mdata,
2119 bfd_mach_o_load_command *cmd)
2120{
2121 bfd_mach_o_dysymtab_command *dsym = &cmd->command.dysymtab;
2122
2123 /* TODO:
2124 We are not going to try and fill these in yet and, moreover, we are
2125 going to bail if they are already set. */
2126 if (dsym->nmodtab != 0
2127 || dsym->ntoc != 0
2128 || dsym->nextrefsyms != 0)
2129 {
2130 (*_bfd_error_handler) (_("sorry: modtab, toc and extrefsyms are not yet"
2131 " implemented for dysymtab commands."));
2132 return FALSE;
2133 }
2134
2135 dsym->ilocalsym = 0;
2136 dsym->nlocalsym = mdata->nlocal;
2137 dsym->iextdefsym = dsym->nlocalsym;
2138 dsym->nextdefsym = mdata->ndefext;
2139 dsym->iundefsym = dsym->nextdefsym + dsym->iextdefsym;
2140 dsym->nundefsym = mdata->nundefext;
2141
2142 if (mdata->nindirect > 0)
2143 {
2144 unsigned i, sect;
2145
2146 mdata->filelen = FILE_ALIGN (mdata->filelen, 2);
2147 dsym->indirectsymoff = mdata->filelen;
2148 mdata->filelen += mdata->nindirect * 4;
2149
2150 dsym->indirect_syms = bfd_zalloc (abfd, mdata->nindirect * 4);
2151 if (dsym->indirect_syms == NULL)
2152 return FALSE;
2153 dsym->nindirectsyms = mdata->nindirect;
2154
2155 /* So fill in the indices, and point the section reserved1 fields
2156 at the right one. */
2157 sect = (unsigned) -1;
2158 for (i = 0; i < mdata->nindirect; ++i)
2159 {
2160 bfd_mach_o_asymbol *s =
2161 (bfd_mach_o_asymbol *) mdata->indirect_syms[i];
2162 /* Lookup the index of the referenced symbol. */
2163 dsym->indirect_syms[i] =
2164 ((bfd_mach_o_asymbol *) s->symbol.udata.p)->symbol.udata.i;
2165 if (s->n_sect != sect)
2166 {
2167 /* Mach-o sections are 1-based, but the section table
2168 is 0-based. */
2169 bfd_mach_o_section *sc = mdata->sections[s->n_sect-1];
2170 sc->reserved1 = i;
2171 sect = s->n_sect;
2172 }
2173 }
2174 }
2175
2176 return TRUE;
2177}
2178
2179/* Build Mach-O load commands (currently assuming an MH_OBJECT file).
2180 TODO: Other file formats, rebuilding symtab/dysymtab commands for strip
2181 and copy functionality. */
154a1ee5
TG		 2182
2183bfd_boolean
2184bfd_mach_o_build_commands (bfd *abfd)
2185{
046b007d 2186 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
c2f09c75 2187 unsigned int wide = mach_o_wide_p (&mdata->header);
154a1ee5 2188 bfd_mach_o_segment_command *seg;
c2f09c75
TG		 2189 bfd_mach_o_load_command *cmd;
2190 bfd_mach_o_load_command *symtab_cmd;
7f307238 2191 unsigned symcind;
154a1ee5 2192
7f307238 2193 /* Return now if commands are already present. */
154a1ee5
TG		 2194 if (mdata->header.ncmds)
2195 return FALSE;
2196
7f307238 2197 /* Fill in the file type, if not already set. */
154a1ee5 2198
7f307238 2199 if (mdata->header.filetype == 0)
154a1ee5 2200 {
7f307238
IS		 2201 if (abfd->flags & EXEC_P)
2202 mdata->header.filetype = BFD_MACH_O_MH_EXECUTE;
2203 else if (abfd->flags & DYNAMIC)
2204 mdata->header.filetype = BFD_MACH_O_MH_DYLIB;
2205 else
2206 mdata->header.filetype = BFD_MACH_O_MH_OBJECT;
154a1ee5 2207 }
7f307238
IS		 2208
2209 /* If hasn't already been done, flatten sections list, and sort
2210 if/when required. Must be done before the symbol table is adjusted,
2211 since that depends on properly numbered sections. */
2212 if (mdata->nsects == 0 || mdata->sections == NULL)
2213 if (! bfd_mach_o_mangle_sections (abfd, mdata))
2214 return FALSE;
2215
2216 /* Order the symbol table, fill-in/check mach-o specific fields and
2217 partition out any indirect symbols. */
2218 if (!bfd_mach_o_mangle_symbols (abfd, mdata))
2219 return FALSE;
2220
2221 /* It's valid to have a file with only absolute symbols... */
2222 if (mdata->nsects > 0)
154a1ee5 2223 {
7f307238
IS		 2224 mdata->header.ncmds = 1;
2225 symcind = 1;
154a1ee5 2226 }
7f307238
IS		 2227 else
2228 symcind = 0;
154a1ee5 2229
7f307238
IS		 2230 /* It's OK to have a file with only section statements. */
2231 if (bfd_get_symcount (abfd) > 0)
2232 mdata->header.ncmds += 1;
c2f09c75 2233
7f307238
IS		 2234 /* Very simple version (only really applicable to MH_OBJECTs):
2235 a command (segment) to contain all the sections,
2236 a command for the symbol table
2237 a n (optional) command for the dysymtab.
154a1ee5 2238
7f307238 2239 ??? maybe we should assert that this is an MH_OBJECT? */
c2f09c75 2240
7f307238
IS		 2241 if (bfd_mach_o_should_emit_dysymtab ()
2242 && bfd_get_symcount (abfd) > 0)
2243 mdata->header.ncmds += 1;
f1bde64c 2244
7f307238
IS		 2245 /* A bit weird, but looks like no content;
2246 as -n empty.s -o empty.o */
2247 if (mdata->header.ncmds == 0)
2248 return TRUE;
f1bde64c 2249
7f307238
IS		 2250 mdata->commands = bfd_zalloc (abfd, mdata->header.ncmds
2251 * sizeof (bfd_mach_o_load_command));
2252 if (mdata->commands == NULL)
2253 return FALSE;
2254
2255 if (mdata->nsects > 0)
2256 {
2257 cmd = &mdata->commands[0];
2258 seg = &cmd->command.segment;
2259
2260 /* Count the segctions in the special blank segment used for MH_OBJECT. */
2261 seg->nsects = bfd_mach_o_count_sections_for_seg (NULL, mdata);
2262 if (seg->nsects == (unsigned long) -1)
2263 return FALSE;
2264
2265 /* Init segment command. */
2266 if (wide)
2267 {
2268 cmd->type = BFD_MACH_O_LC_SEGMENT_64;
2269 cmd->offset = BFD_MACH_O_HEADER_64_SIZE;
2270 cmd->len = BFD_MACH_O_LC_SEGMENT_64_SIZE
2271 + BFD_MACH_O_SECTION_64_SIZE * seg->nsects;
2272 }
92bc0e80 2273 else
7f307238
IS		 2274 {
2275 cmd->type = BFD_MACH_O_LC_SEGMENT;
2276 cmd->offset = BFD_MACH_O_HEADER_SIZE;
2277 cmd->len = BFD_MACH_O_LC_SEGMENT_SIZE
2278 + BFD_MACH_O_SECTION_SIZE * seg->nsects;
2279 }
2280 cmd->type_required = FALSE;
2281 mdata->header.sizeofcmds = cmd->len;
2282 mdata->filelen = cmd->offset + cmd->len;
2283 }
f1bde64c 2284
7f307238
IS		 2285 if (bfd_get_symcount (abfd) > 0)
2286 {
2287 /* Init symtab command. */
2288 symtab_cmd = &mdata->commands[symcind];
2289
2290 symtab_cmd->type = BFD_MACH_O_LC_SYMTAB;
2291 if (symcind > 0)
2292 symtab_cmd->offset = mdata->commands[0].offset
2293 + mdata->commands[0].len;
2294 else
2295 symtab_cmd->offset = 0;
2296 symtab_cmd->len = 6 * 4;
2297 symtab_cmd->type_required = FALSE;
2298
2299 mdata->header.sizeofcmds += symtab_cmd->len;
2300 mdata->filelen += symtab_cmd->len;
2301 }
154a1ee5 2302
7f307238
IS		 2303 /* If required, setup symtab command. */
2304 if (bfd_mach_o_should_emit_dysymtab ()
2305 && bfd_get_symcount (abfd) > 0)
2306 {
2307 cmd = &mdata->commands[symcind+1];
2308 cmd->type = BFD_MACH_O_LC_DYSYMTAB;
2309 cmd->offset = symtab_cmd->offset + symtab_cmd->len;
2310 cmd->type_required = FALSE;
2311 cmd->len = 18 * 4 + BFD_MACH_O_LC_SIZE;
2312
2313 mdata->header.sizeofcmds += cmd->len;
2314 mdata->filelen += cmd->len;
154a1ee5 2315 }
154a1ee5 2316
7f307238
IS		 2317 /* So, now we have sized the commands and the filelen set to that.
2318 Now we can build the segment command and set the section file offsets. */
2319 if (mdata->nsects > 0
2320 && ! bfd_mach_o_build_seg_command (NULL, mdata, seg))
2321 return FALSE;
2322
2323 /* If we're doing a dysymtab, cmd points to its load command. */
2324 if (bfd_mach_o_should_emit_dysymtab ()
2325 && bfd_get_symcount (abfd) > 0
2326 && ! bfd_mach_o_build_dysymtab_command (abfd, mdata,
2327 &mdata->commands[symcind+1]))
2328 return FALSE;
2329
2330 /* The symtab command is filled in when the symtab is written. */
154a1ee5
TG		 2331 return TRUE;
2332}
2333
2334/* Set the contents of a section. */
2335
2336bfd_boolean
2337bfd_mach_o_set_section_contents (bfd *abfd,
2338 asection *section,
2339 const void * location,
2340 file_ptr offset,
2341 bfd_size_type count)
2342{
2343 file_ptr pos;
2344
7f307238
IS		 2345 /* Trying to write the first section contents will trigger the creation of
2346 the load commands if they are not already present. */
154a1ee5
TG		 2347 if (! abfd->output_has_begun && ! bfd_mach_o_build_commands (abfd))
2348 return FALSE;
2349
2350 if (count == 0)
2351 return TRUE;
2352
2353 pos = section->filepos + offset;
2354 if (bfd_seek (abfd, pos, SEEK_SET) != 0
2355 || bfd_bwrite (location, count, abfd) != count)
2356 return FALSE;
2357
2358 return TRUE;
2359}
2360
2361int
116c20d2 2362bfd_mach_o_sizeof_headers (bfd *a ATTRIBUTE_UNUSED,
a6b96beb 2363 struct bfd_link_info *info ATTRIBUTE_UNUSED)
3af9a47b
NC		 2364{
2365 return 0;
2366}
2367
2368/* Make an empty symbol. This is required only because
2369 bfd_make_section_anyway wants to create a symbol for the section. */
2370
154a1ee5 2371asymbol *
116c20d2 2372bfd_mach_o_make_empty_symbol (bfd *abfd)
3af9a47b 2373{
d3ce72d0
NC		 2374 asymbol *new_symbol;
2375
2376 new_symbol = bfd_zalloc (abfd, sizeof (bfd_mach_o_asymbol));
2377 if (new_symbol == NULL)
2378 return new_symbol;
2379 new_symbol->the_bfd = abfd;
2380 new_symbol->udata.i = 0;
2381 return new_symbol;
3af9a47b
NC		 2382}
2383
154a1ee5 2384static bfd_boolean
116c20d2 2385bfd_mach_o_read_header (bfd *abfd, bfd_mach_o_header *header)
3af9a47b 2386{
46d1c23b 2387 struct mach_o_header_external raw;
1e8a024a 2388 unsigned int size;
edeb6e24 2389 bfd_vma (*get32) (const void *) = NULL;
3af9a47b 2390
1e8a024a 2391 /* Just read the magic number. */
c2f09c75 2392 if (bfd_seek (abfd, 0, SEEK_SET) != 0
46d1c23b 2393 || bfd_bread (raw.magic, sizeof (raw.magic), abfd) != 4)
154a1ee5 2394 return FALSE;
3af9a47b 2395
46d1c23b 2396 if (bfd_getb32 (raw.magic) == BFD_MACH_O_MH_MAGIC)
3af9a47b
NC		 2397 {
2398 header->byteorder = BFD_ENDIAN_BIG;
154a1ee5 2399 header->magic = BFD_MACH_O_MH_MAGIC;
1e8a024a 2400 header->version = 1;
3af9a47b
NC		 2401 get32 = bfd_getb32;
2402 }
46d1c23b 2403 else if (bfd_getl32 (raw.magic) == BFD_MACH_O_MH_MAGIC)
3af9a47b 2404 {
a95a4550 2405 header->byteorder = BFD_ENDIAN_LITTLE;
154a1ee5 2406 header->magic = BFD_MACH_O_MH_MAGIC;
1e8a024a
TG		 2407 header->version = 1;
2408 get32 = bfd_getl32;
2409 }
46d1c23b 2410 else if (bfd_getb32 (raw.magic) == BFD_MACH_O_MH_MAGIC_64)
1e8a024a
TG		 2411 {
2412 header->byteorder = BFD_ENDIAN_BIG;
154a1ee5 2413 header->magic = BFD_MACH_O_MH_MAGIC_64;
1e8a024a
TG		 2414 header->version = 2;
2415 get32 = bfd_getb32;
2416 }
46d1c23b 2417 else if (bfd_getl32 (raw.magic) == BFD_MACH_O_MH_MAGIC_64)
1e8a024a
TG		 2418 {
2419 header->byteorder = BFD_ENDIAN_LITTLE;
154a1ee5 2420 header->magic = BFD_MACH_O_MH_MAGIC_64;
1e8a024a 2421 header->version = 2;
3af9a47b
NC		 2422 get32 = bfd_getl32;
2423 }
2424 else
2425 {
2426 header->byteorder = BFD_ENDIAN_UNKNOWN;
154a1ee5 2427 return FALSE;
3af9a47b 2428 }
a95a4550 2429
1e8a024a 2430 /* Once the size of the header is known, read the full header. */
c2f09c75 2431 size = mach_o_wide_p (header) ?
154a1ee5 2432 BFD_MACH_O_HEADER_64_SIZE : BFD_MACH_O_HEADER_SIZE;
1e8a024a 2433
c2f09c75 2434 if (bfd_seek (abfd, 0, SEEK_SET) != 0
46d1c23b 2435 || bfd_bread (&raw, size, abfd) != size)
154a1ee5 2436 return FALSE;
1e8a024a 2437
46d1c23b
TG		 2438 header->cputype = (*get32) (raw.cputype);
2439 header->cpusubtype = (*get32) (raw.cpusubtype);
2440 header->filetype = (*get32) (raw.filetype);
2441 header->ncmds = (*get32) (raw.ncmds);
2442 header->sizeofcmds = (*get32) (raw.sizeofcmds);
2443 header->flags = (*get32) (raw.flags);
3af9a47b 2444
c2f09c75 2445 if (mach_o_wide_p (header))
46d1c23b 2446 header->reserved = (*get32) (raw.reserved);
1e8a024a 2447
154a1ee5 2448 return TRUE;
3af9a47b
NC		 2449}
2450
f1bde64c
TG		 2451bfd_boolean
2452bfd_mach_o_new_section_hook (bfd *abfd, asection *sec)
2453{
2454 bfd_mach_o_section *s;
a4551119 2455 unsigned bfdalign = bfd_get_section_alignment (abfd, sec);
f1bde64c
TG		 2456
2457 s = bfd_mach_o_get_mach_o_section (sec);
2458 if (s == NULL)
2459 {
2460 flagword bfd_flags;
a4551119 2461 static const mach_o_section_name_xlat * xlat;
f1bde64c
TG		 2462
2463 s = (bfd_mach_o_section *) bfd_zalloc (abfd, sizeof (*s));
2464 if (s == NULL)
2465 return FALSE;
2466 sec->used_by_bfd = s;
2467 s->bfdsection = sec;
2468
a4551119
TG		 2469 /* Create the Darwin seg/sect name pair from the bfd name.
2470 If this is a canonical name for which a specific paiting exists
2471 there will also be defined flags, type, attribute and alignment
2472 values. */
2473 xlat = bfd_mach_o_convert_section_name_to_mach_o (abfd, sec, s);
2474 if (xlat != NULL)
2475 {
2476 s->flags = xlat->macho_sectype | xlat->macho_secattr;
2477 s->align = xlat->sectalign > bfdalign ? xlat->sectalign
2478 : bfdalign;
2479 bfd_set_section_alignment (abfd, sec, s->align);
2480 bfd_flags = bfd_get_section_flags (abfd, sec);
2481 if (bfd_flags == SEC_NO_FLAGS)
2482 bfd_set_section_flags (abfd, sec, xlat->bfd_flags);
2483 }
f1bde64c 2484 else
a4551119
TG		 2485 /* Create default flags. */
2486 bfd_mach_o_set_section_flags_from_bfd (abfd, sec);
f1bde64c
TG		 2487 }
2488
2489 return _bfd_generic_new_section_hook (abfd, sec);
2490}
2491
2492static void
2493bfd_mach_o_init_section_from_mach_o (bfd *abfd, asection *sec,
2494 unsigned long prot)
3af9a47b 2495{
117ed4f8 2496 flagword flags;
f1bde64c 2497 bfd_mach_o_section *section;
3af9a47b 2498
f1bde64c
TG		 2499 flags = bfd_get_section_flags (abfd, sec);
2500 section = bfd_mach_o_get_mach_o_section (sec);
3af9a47b 2501
a4551119
TG		 2502 /* TODO: see if we should use the xlat system for doing this by
2503 preference and fall back to this for unknown sections. */
2504
8462aec7 2505 if (flags == SEC_NO_FLAGS)
ef17cb22 2506 {
8462aec7
TG		 2507 /* Try to guess flags. */
2508 if (section->flags & BFD_MACH_O_S_ATTR_DEBUG)
2509 flags = SEC_DEBUGGING;
2510 else
2511 {
2512 flags = SEC_ALLOC;
2513 if ((section->flags & BFD_MACH_O_SECTION_TYPE_MASK)
2514 != BFD_MACH_O_S_ZEROFILL)
2515 {
2516 flags |= SEC_LOAD;
2517 if (prot & BFD_MACH_O_PROT_EXECUTE)
2518 flags |= SEC_CODE;
2519 if (prot & BFD_MACH_O_PROT_WRITE)
2520 flags |= SEC_DATA;
2521 else if (prot & BFD_MACH_O_PROT_READ)
2522 flags |= SEC_READONLY;
2523 }
2524 }
ef17cb22 2525 }
15e1c58a
TG		 2526 else
2527 {
8462aec7
TG		 2528 if ((flags & SEC_DEBUGGING) == 0)
2529 flags |= SEC_ALLOC;
15e1c58a 2530 }
8462aec7
TG		 2531
2532 if (section->offset != 0)
2533 flags |= SEC_HAS_CONTENTS;
92bc0e80
TG		 2534 if (section->nreloc != 0)
2535 flags |= SEC_RELOC;
2536
f1bde64c
TG		 2537 bfd_set_section_flags (abfd, sec, flags);
2538
2539 sec->vma = section->addr;
2540 sec->lma = section->addr;
2541 sec->size = section->size;
2542 sec->filepos = section->offset;
2543 sec->alignment_power = section->align;
2544 sec->segment_mark = 0;
2545 sec->reloc_count = section->nreloc;
2546 sec->rel_filepos = section->reloff;
2547}
2548
2549static asection *
2550bfd_mach_o_make_bfd_section (bfd *abfd,
2551 const unsigned char *segname,
2552 const unsigned char *sectname)
2553{
2554 const char *sname;
2555 flagword flags;
a95a4550 2556
f1bde64c
TG		 2557 bfd_mach_o_convert_section_name_to_bfd
2558 (abfd, (const char *)segname, (const char *)sectname, &sname, &flags);
2559 if (sname == NULL)
2560 return NULL;
3af9a47b 2561
f1bde64c 2562 return bfd_make_section_anyway_with_flags (abfd, sname, flags);
3af9a47b
NC		 2563}
2564
f1bde64c 2565static asection *
ab273af8 2566bfd_mach_o_read_section_32 (bfd *abfd,
ab273af8
TG		 2567 unsigned int offset,
2568 unsigned long prot)
3af9a47b 2569{
46d1c23b 2570 struct mach_o_section_32_external raw;
f1bde64c
TG		 2571 asection *sec;
2572 bfd_mach_o_section *section;
3af9a47b 2573
c2f09c75 2574 if (bfd_seek (abfd, offset, SEEK_SET) != 0
46d1c23b 2575 || (bfd_bread (&raw, BFD_MACH_O_SECTION_SIZE, abfd)
c2f09c75 2576 != BFD_MACH_O_SECTION_SIZE))
f1bde64c 2577 return NULL;
a95a4550 2578
5a5cbf72 2579 sec = bfd_mach_o_make_bfd_section (abfd, raw.segname, raw.sectname);
f1bde64c
TG		 2580 if (sec == NULL)
2581 return NULL;
2582
2583 section = bfd_mach_o_get_mach_o_section (sec);
2584 memcpy (section->segname, raw.segname, sizeof (raw.segname));
2585 section->segname[BFD_MACH_O_SEGNAME_SIZE] = 0;
2586 memcpy (section->sectname, raw.sectname, sizeof (raw.sectname));
69499dca 2587 section->sectname[BFD_MACH_O_SECTNAME_SIZE] = 0;
46d1c23b
TG		 2588 section->addr = bfd_h_get_32 (abfd, raw.addr);
2589 section->size = bfd_h_get_32 (abfd, raw.size);
2590 section->offset = bfd_h_get_32 (abfd, raw.offset);
2591 section->align = bfd_h_get_32 (abfd, raw.align);
2592 section->reloff = bfd_h_get_32 (abfd, raw.reloff);
2593 section->nreloc = bfd_h_get_32 (abfd, raw.nreloc);
2594 section->flags = bfd_h_get_32 (abfd, raw.flags);
2595 section->reserved1 = bfd_h_get_32 (abfd, raw.reserved1);
2596 section->reserved2 = bfd_h_get_32 (abfd, raw.reserved2);
1e8a024a 2597 section->reserved3 = 0;
1e8a024a 2598
f1bde64c 2599 bfd_mach_o_init_section_from_mach_o (abfd, sec, prot);
1e8a024a 2600
f1bde64c 2601 return sec;
1e8a024a
TG		 2602}
2603
f1bde64c 2604static asection *
ab273af8 2605bfd_mach_o_read_section_64 (bfd *abfd,
ab273af8
TG		 2606 unsigned int offset,
2607 unsigned long prot)
1e8a024a 2608{
46d1c23b 2609 struct mach_o_section_64_external raw;
f1bde64c
TG		 2610 asection *sec;
2611 bfd_mach_o_section *section;
1e8a024a 2612
c2f09c75 2613 if (bfd_seek (abfd, offset, SEEK_SET) != 0
46d1c23b 2614 || (bfd_bread (&raw, BFD_MACH_O_SECTION_64_SIZE, abfd)
c2f09c75 2615 != BFD_MACH_O_SECTION_64_SIZE))
f1bde64c
TG		 2616 return NULL;
2617
5a5cbf72 2618 sec = bfd_mach_o_make_bfd_section (abfd, raw.segname, raw.sectname);
f1bde64c
TG		 2619 if (sec == NULL)
2620 return NULL;
1e8a024a 2621
f1bde64c
TG		 2622 section = bfd_mach_o_get_mach_o_section (sec);
2623 memcpy (section->segname, raw.segname, sizeof (raw.segname));
2624 section->segname[BFD_MACH_O_SEGNAME_SIZE] = 0;
2625 memcpy (section->sectname, raw.sectname, sizeof (raw.sectname));
69499dca 2626 section->sectname[BFD_MACH_O_SECTNAME_SIZE] = 0;
46d1c23b
TG		 2627 section->addr = bfd_h_get_64 (abfd, raw.addr);
2628 section->size = bfd_h_get_64 (abfd, raw.size);
2629 section->offset = bfd_h_get_32 (abfd, raw.offset);
2630 section->align = bfd_h_get_32 (abfd, raw.align);
2631 section->reloff = bfd_h_get_32 (abfd, raw.reloff);
2632 section->nreloc = bfd_h_get_32 (abfd, raw.nreloc);
2633 section->flags = bfd_h_get_32 (abfd, raw.flags);
2634 section->reserved1 = bfd_h_get_32 (abfd, raw.reserved1);
2635 section->reserved2 = bfd_h_get_32 (abfd, raw.reserved2);
2636 section->reserved3 = bfd_h_get_32 (abfd, raw.reserved3);
3af9a47b 2637
f1bde64c 2638 bfd_mach_o_init_section_from_mach_o (abfd, sec, prot);
3af9a47b 2639
f1bde64c 2640 return sec;
3af9a47b
NC		 2641}
2642
f1bde64c 2643static asection *
ab273af8 2644bfd_mach_o_read_section (bfd *abfd,
ab273af8
TG		 2645 unsigned int offset,
2646 unsigned long prot,
2647 unsigned int wide)
1e8a024a
TG		 2648{
2649 if (wide)
f1bde64c 2650 return bfd_mach_o_read_section_64 (abfd, offset, prot);
1e8a024a 2651 else
f1bde64c 2652 return bfd_mach_o_read_section_32 (abfd, offset, prot);
1e8a024a
TG		 2653}
2654
afbb9e17 2655static bfd_boolean
ab273af8
TG		 2656bfd_mach_o_read_symtab_symbol (bfd *abfd,
2657 bfd_mach_o_symtab_command *sym,
2658 bfd_mach_o_asymbol *s,
2659 unsigned long i)
3af9a47b 2660{
046b007d 2661 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
c2f09c75 2662 unsigned int wide = mach_o_wide_p (&mdata->header);
046b007d
TG		 2663 unsigned int symwidth =
2664 wide ? BFD_MACH_O_NLIST_64_SIZE : BFD_MACH_O_NLIST_SIZE;
92bc0e80 2665 unsigned int symoff = sym->symoff + (i * symwidth);
46d1c23b 2666 struct mach_o_nlist_64_external raw;
3af9a47b
NC		 2667 unsigned char type = -1;
2668 unsigned char section = -1;
2669 short desc = -1;
1e8a024a 2670 symvalue value = -1;
3af9a47b
NC		 2671 unsigned long stroff = -1;
2672 unsigned int symtype = -1;
2673
2674 BFD_ASSERT (sym->strtab != NULL);
2675
c2f09c75 2676 if (bfd_seek (abfd, symoff, SEEK_SET) != 0
46d1c23b 2677 || bfd_bread (&raw, symwidth, abfd) != symwidth)
3af9a47b 2678 {
46d1c23b
TG		 2679 (*_bfd_error_handler)
2680 (_("bfd_mach_o_read_symtab_symbol: unable to read %d bytes at %lu"),
2681 symwidth, (unsigned long) symoff);
afbb9e17 2682 return FALSE;
3af9a47b
NC		 2683 }
2684
46d1c23b
TG		 2685 stroff = bfd_h_get_32 (abfd, raw.n_strx);
2686 type = bfd_h_get_8 (abfd, raw.n_type);
c2f09c75 2687 symtype = type & BFD_MACH_O_N_TYPE;
46d1c23b
TG		 2688 section = bfd_h_get_8 (abfd, raw.n_sect);
2689 desc = bfd_h_get_16 (abfd, raw.n_desc);
1e8a024a 2690 if (wide)
46d1c23b 2691 value = bfd_h_get_64 (abfd, raw.n_value);
1e8a024a 2692 else
46d1c23b 2693 value = bfd_h_get_32 (abfd, raw.n_value);
3af9a47b
NC		 2694
2695 if (stroff >= sym->strsize)
2696 {
46d1c23b
TG		 2697 (*_bfd_error_handler)
2698 (_("bfd_mach_o_read_symtab_symbol: name out of range (%lu >= %lu)"),
2699 (unsigned long) stroff,
2700 (unsigned long) sym->strsize);
afbb9e17 2701 return FALSE;
3af9a47b
NC		 2702 }
2703
92bc0e80
TG		 2704 s->symbol.the_bfd = abfd;
2705 s->symbol.name = sym->strtab + stroff;
2706 s->symbol.value = value;
2707 s->symbol.flags = 0x0;
2708 s->symbol.udata.i = 0;
2709 s->n_type = type;
2710 s->n_sect = section;
2711 s->n_desc = desc;
3af9a47b
NC		 2712
2713 if (type & BFD_MACH_O_N_STAB)
2714 {
92bc0e80
TG		 2715 s->symbol.flags |= BSF_DEBUGGING;
2716 s->symbol.section = bfd_und_section_ptr;
15e1c58a
TG		 2717 switch (type)
2718 {
2719 case N_FUN:
2720 case N_STSYM:
2721 case N_LCSYM:
2722 case N_BNSYM:
2723 case N_SLINE:
2724 case N_ENSYM:
2725 case N_ECOMM:
2726 case N_ECOML:
2727 case N_GSYM:
2728 if ((section > 0) && (section <= mdata->nsects))
2729 {
92bc0e80
TG		 2730 s->symbol.section = mdata->sections[section - 1]->bfdsection;
2731 s->symbol.value =
2732 s->symbol.value - mdata->sections[section - 1]->addr;
15e1c58a
TG		 2733 }
2734 break;
2735 }
3af9a47b
NC		 2736 }
2737 else
2738 {
2739 if (type & BFD_MACH_O_N_PEXT)
92bc0e80 2740 s->symbol.flags |= BSF_GLOBAL;
c2f09c75 2741
3af9a47b 2742 if (type & BFD_MACH_O_N_EXT)
92bc0e80 2743 s->symbol.flags |= BSF_GLOBAL;
15e1c58a
TG		 2744
2745 if (!(type & (BFD_MACH_O_N_PEXT | BFD_MACH_O_N_EXT)))
92bc0e80 2746 s->symbol.flags |= BSF_LOCAL;
3af9a47b
NC		 2747
2748 switch (symtype)
2749 {
2750 case BFD_MACH_O_N_UNDF:
c2f09c75 2751 if (type == (BFD_MACH_O_N_UNDF | BFD_MACH_O_N_EXT)
92bc0e80 2752 && s->symbol.value != 0)
c2f09c75
TG		 2753 {
2754 /* A common symbol. */
92bc0e80
TG		 2755 s->symbol.section = bfd_com_section_ptr;
2756 s->symbol.flags = BSF_NO_FLAGS;
c2f09c75
TG		 2757 }
2758 else
92bc0e80
TG		 2759 {
2760 s->symbol.section = bfd_und_section_ptr;
2761 if (s->n_desc & BFD_MACH_O_N_WEAK_REF)
2762 s->symbol.flags |= BSF_WEAK;
2763 }
3af9a47b
NC		 2764 break;
2765 case BFD_MACH_O_N_PBUD:
92bc0e80 2766 s->symbol.section = bfd_und_section_ptr;
3af9a47b
NC		 2767 break;
2768 case BFD_MACH_O_N_ABS:
92bc0e80 2769 s->symbol.section = bfd_abs_section_ptr;
3af9a47b
NC		 2770 break;
2771 case BFD_MACH_O_N_SECT:
2772 if ((section > 0) && (section <= mdata->nsects))
2773 {
92bc0e80
TG		 2774 s->symbol.section = mdata->sections[section - 1]->bfdsection;
2775 s->symbol.value =
2776 s->symbol.value - mdata->sections[section - 1]->addr;
3af9a47b
NC		 2777 }
2778 else
2779 {
2780 /* Mach-O uses 0 to mean "no section"; not an error. */
2781 if (section != 0)
2782 {
4a97a0e5
AM		 2783 (*_bfd_error_handler) (_("bfd_mach_o_read_symtab_symbol: "
2784 "symbol \"%s\" specified invalid section %d (max %lu): setting to undefined"),
2785 s->symbol.name, section, mdata->nsects);
3af9a47b 2786 }
92bc0e80 2787 s->symbol.section = bfd_und_section_ptr;
3af9a47b
NC		 2788 }
2789 break;
2790 case BFD_MACH_O_N_INDR:
0596a831
TG		 2791 /* FIXME: we don't follow the BFD convention as this indirect symbol
2792 won't be followed by the referenced one. This looks harmless
2793 unless we start using the linker. */
2794 s->symbol.flags |= BSF_INDIRECT;
2795 s->symbol.section = bfd_ind_section_ptr;
2796 s->symbol.value = 0;
3af9a47b
NC		 2797 break;
2798 default:
4a97a0e5
AM		 2799 (*_bfd_error_handler) (_("bfd_mach_o_read_symtab_symbol: "
2800 "symbol \"%s\" specified invalid type field 0x%x: setting to undefined"),
2801 s->symbol.name, symtype);
92bc0e80 2802 s->symbol.section = bfd_und_section_ptr;
3af9a47b
NC		 2803 break;
2804 }
2805 }
2806
afbb9e17 2807 return TRUE;
3af9a47b
NC		 2808}
2809
c5012cd8 2810bfd_boolean
ab273af8 2811bfd_mach_o_read_symtab_strtab (bfd *abfd)
3af9a47b 2812{
046b007d
TG		 2813 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
2814 bfd_mach_o_symtab_command *sym = mdata->symtab;
2815
2816 /* Fail if there is no symtab. */
2817 if (sym == NULL)
afbb9e17 2818 return FALSE;
046b007d
TG		 2819
2820 /* Success if already loaded. */
2821 if (sym->strtab)
afbb9e17 2822 return TRUE;
3af9a47b
NC		 2823
2824 if (abfd->flags & BFD_IN_MEMORY)
2825 {
2826 struct bfd_in_memory *b;
2827
2828 b = (struct bfd_in_memory *) abfd->iostream;
2829
2830 if ((sym->stroff + sym->strsize) > b->size)
2831 {
2832 bfd_set_error (bfd_error_file_truncated);
afbb9e17 2833 return FALSE;
3af9a47b 2834 }
f075ee0c 2835 sym->strtab = (char *) b->buffer + sym->stroff;
3af9a47b 2836 }
046b007d 2837 else
3af9a47b 2838 {
046b007d
TG		 2839 sym->strtab = bfd_alloc (abfd, sym->strsize);
2840 if (sym->strtab == NULL)
afbb9e17 2841 return FALSE;
046b007d
TG		 2842
2843 if (bfd_seek (abfd, sym->stroff, SEEK_SET) != 0
afbb9e17 2844 || bfd_bread (sym->strtab, sym->strsize, abfd) != sym->strsize)
046b007d
TG		 2845 {
2846 bfd_set_error (bfd_error_file_truncated);
afbb9e17 2847 return FALSE;
046b007d 2848 }
3af9a47b
NC		 2849 }
2850
afbb9e17 2851 return TRUE;
3af9a47b
NC		 2852}
2853
c5012cd8 2854bfd_boolean
ab273af8 2855bfd_mach_o_read_symtab_symbols (bfd *abfd)
3af9a47b 2856{
046b007d
TG		 2857 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
2858 bfd_mach_o_symtab_command *sym = mdata->symtab;
3af9a47b 2859 unsigned long i;
3af9a47b 2860
092d27ff
TG		 2861 if (sym == NULL || sym->symbols)
2862 {
2863 /* Return now if there are no symbols or if already loaded. */
afbb9e17 2864 return TRUE;
092d27ff 2865 }
046b007d 2866
92bc0e80 2867 sym->symbols = bfd_alloc (abfd, sym->nsyms * sizeof (bfd_mach_o_asymbol));
3af9a47b
NC		 2868
2869 if (sym->symbols == NULL)
2870 {
4a97a0e5 2871 (*_bfd_error_handler) (_("bfd_mach_o_read_symtab_symbols: unable to allocate memory for symbols"));
afbb9e17 2872 return FALSE;
3af9a47b 2873 }
a95a4550 2874
afbb9e17
TG		 2875 if (!bfd_mach_o_read_symtab_strtab (abfd))
2876 return FALSE;
3af9a47b
NC		 2877
2878 for (i = 0; i < sym->nsyms; i++)
2879 {
afbb9e17
TG		 2880 if (!bfd_mach_o_read_symtab_symbol (abfd, sym, &sym->symbols[i], i))
2881 return FALSE;
3af9a47b 2882 }
a95a4550 2883
afbb9e17 2884 return TRUE;
3af9a47b
NC		 2885}
2886
2887static const char *
116c20d2 2888bfd_mach_o_i386_flavour_string (unsigned int flavour)
3af9a47b
NC		 2889{
2890 switch ((int) flavour)
2891 {
15e1c58a
TG		 2892 case BFD_MACH_O_x86_THREAD_STATE32: return "x86_THREAD_STATE32";
2893 case BFD_MACH_O_x86_FLOAT_STATE32: return "x86_FLOAT_STATE32";
2894 case BFD_MACH_O_x86_EXCEPTION_STATE32: return "x86_EXCEPTION_STATE32";
2895 case BFD_MACH_O_x86_THREAD_STATE64: return "x86_THREAD_STATE64";
2896 case BFD_MACH_O_x86_FLOAT_STATE64: return "x86_FLOAT_STATE64";
2897 case BFD_MACH_O_x86_EXCEPTION_STATE64: return "x86_EXCEPTION_STATE64";
2898 case BFD_MACH_O_x86_THREAD_STATE: return "x86_THREAD_STATE";
2899 case BFD_MACH_O_x86_FLOAT_STATE: return "x86_FLOAT_STATE";
2900 case BFD_MACH_O_x86_EXCEPTION_STATE: return "x86_EXCEPTION_STATE";
2901 case BFD_MACH_O_x86_DEBUG_STATE32: return "x86_DEBUG_STATE32";
2902 case BFD_MACH_O_x86_DEBUG_STATE64: return "x86_DEBUG_STATE64";
2903 case BFD_MACH_O_x86_DEBUG_STATE: return "x86_DEBUG_STATE";
b32e07d7 2904 case BFD_MACH_O_x86_THREAD_STATE_NONE: return "x86_THREAD_STATE_NONE";
3af9a47b
NC		 2905 default: return "UNKNOWN";
2906 }
2907}
2908
2909static const char *
116c20d2 2910bfd_mach_o_ppc_flavour_string (unsigned int flavour)
3af9a47b
NC		 2911{
2912 switch ((int) flavour)
2913 {
b32e07d7
TG		 2914 case BFD_MACH_O_PPC_THREAD_STATE: return "PPC_THREAD_STATE";
2915 case BFD_MACH_O_PPC_FLOAT_STATE: return "PPC_FLOAT_STATE";
2916 case BFD_MACH_O_PPC_EXCEPTION_STATE: return "PPC_EXCEPTION_STATE";
2917 case BFD_MACH_O_PPC_VECTOR_STATE: return "PPC_VECTOR_STATE";
2918 case BFD_MACH_O_PPC_THREAD_STATE64: return "PPC_THREAD_STATE64";
2919 case BFD_MACH_O_PPC_EXCEPTION_STATE64: return "PPC_EXCEPTION_STATE64";
3af9a47b
NC		 2920 default: return "UNKNOWN";
2921 }
2922}
2923
2924static int
ab273af8 2925bfd_mach_o_read_dylinker (bfd *abfd, bfd_mach_o_load_command *command)
3af9a47b
NC		 2926{
2927 bfd_mach_o_dylinker_command *cmd = &command->command.dylinker;
46d1c23b 2928 struct mach_o_str_command_external raw;
3af9a47b 2929 unsigned int nameoff;
3af9a47b
NC		 2930
2931 BFD_ASSERT ((command->type == BFD_MACH_O_LC_ID_DYLINKER)
2932 || (command->type == BFD_MACH_O_LC_LOAD_DYLINKER));
2933
46d1c23b
TG		 2934 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
2935 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3af9a47b
NC		 2936 return -1;
2937
46d1c23b 2938 nameoff = bfd_h_get_32 (abfd, raw.str);
3af9a47b
NC		 2939
2940 cmd->name_offset = command->offset + nameoff;
2941 cmd->name_len = command->len - nameoff;
b32e07d7
TG		 2942 cmd->name_str = bfd_alloc (abfd, cmd->name_len);
2943 if (cmd->name_str == NULL)
3af9a47b 2944 return -1;
b32e07d7
TG		 2945 if (bfd_seek (abfd, cmd->name_offset, SEEK_SET) != 0
2946 || bfd_bread (cmd->name_str, cmd->name_len, abfd) != cmd->name_len)
3af9a47b 2947 return -1;
3af9a47b
NC		 2948 return 0;
2949}
2950
2951static int
ab273af8 2952bfd_mach_o_read_dylib (bfd *abfd, bfd_mach_o_load_command *command)
3af9a47b
NC		 2953{
2954 bfd_mach_o_dylib_command *cmd = &command->command.dylib;
46d1c23b 2955 struct mach_o_dylib_command_external raw;
3af9a47b 2956 unsigned int nameoff;
3af9a47b 2957
046b007d
TG		 2958 switch (command->type)
2959 {
2960 case BFD_MACH_O_LC_LOAD_DYLIB:
046b007d 2961 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB:
046b007d 2962 case BFD_MACH_O_LC_ID_DYLIB:
046b007d 2963 case BFD_MACH_O_LC_REEXPORT_DYLIB:
73017762 2964 case BFD_MACH_O_LC_LOAD_UPWARD_DYLIB:
046b007d
TG		 2965 break;
2966 default:
b32e07d7
TG		 2967 BFD_FAIL ();
2968 return -1;
046b007d 2969 }
3af9a47b 2970
46d1c23b
TG		 2971 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
2972 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3af9a47b
NC		 2973 return -1;
2974
46d1c23b
TG		 2975 nameoff = bfd_h_get_32 (abfd, raw.name);
2976 cmd->timestamp = bfd_h_get_32 (abfd, raw.timestamp);
2977 cmd->current_version = bfd_h_get_32 (abfd, raw.current_version);
2978 cmd->compatibility_version = bfd_h_get_32 (abfd, raw.compatibility_version);
3af9a47b
NC		 2979
2980 cmd->name_offset = command->offset + nameoff;
2981 cmd->name_len = command->len - nameoff;
b32e07d7
TG		 2982 cmd->name_str = bfd_alloc (abfd, cmd->name_len);
2983 if (cmd->name_str == NULL)
3af9a47b 2984 return -1;
b32e07d7
TG		 2985 if (bfd_seek (abfd, cmd->name_offset, SEEK_SET) != 0
2986 || bfd_bread (cmd->name_str, cmd->name_len, abfd) != cmd->name_len)
3af9a47b 2987 return -1;
3af9a47b
NC		 2988 return 0;
2989}
2990
2991static int
ab273af8
TG		 2992bfd_mach_o_read_prebound_dylib (bfd *abfd ATTRIBUTE_UNUSED,
2993 bfd_mach_o_load_command *command ATTRIBUTE_UNUSED)
3af9a47b
NC		 2994{
2995 /* bfd_mach_o_prebound_dylib_command *cmd = &command->command.prebound_dylib; */
2996
2997 BFD_ASSERT (command->type == BFD_MACH_O_LC_PREBOUND_DYLIB);
2998 return 0;
2999}
3000
3001static int
ab273af8 3002bfd_mach_o_read_thread (bfd *abfd, bfd_mach_o_load_command *command)
3af9a47b 3003{
b32e07d7 3004 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3af9a47b 3005 bfd_mach_o_thread_command *cmd = &command->command.thread;
92bc0e80 3006 unsigned int offset;
3af9a47b
NC		 3007 unsigned int nflavours;
3008 unsigned int i;
3009
3010 BFD_ASSERT ((command->type == BFD_MACH_O_LC_THREAD)
3011 || (command->type == BFD_MACH_O_LC_UNIXTHREAD));
3012
b32e07d7 3013 /* Count the number of threads. */
3af9a47b
NC		 3014 offset = 8;
3015 nflavours = 0;
3016 while (offset != command->len)
3017 {
46d1c23b
TG		 3018 struct mach_o_thread_command_external raw;
3019
3af9a47b
NC		 3020 if (offset >= command->len)
3021 return -1;
3022
c2f09c75 3023 if (bfd_seek (abfd, command->offset + offset, SEEK_SET) != 0
46d1c23b 3024 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3af9a47b
NC		 3025 return -1;
3026
46d1c23b 3027 offset += sizeof (raw) + bfd_h_get_32 (abfd, raw.count) * 4;
3af9a47b
NC		 3028 nflavours++;
3029 }
3030
b32e07d7
TG		 3031 /* Allocate threads. */
3032 cmd->flavours = bfd_alloc
3033 (abfd, nflavours * sizeof (bfd_mach_o_thread_flavour));
3af9a47b
NC		 3034 if (cmd->flavours == NULL)
3035 return -1;
3036 cmd->nflavours = nflavours;
3037
3038 offset = 8;
3039 nflavours = 0;
3040 while (offset != command->len)
3041 {
46d1c23b
TG		 3042 struct mach_o_thread_command_external raw;
3043
3af9a47b
NC		 3044 if (offset >= command->len)
3045 return -1;
3046
3047 if (nflavours >= cmd->nflavours)
3048 return -1;
3049
c2f09c75 3050 if (bfd_seek (abfd, command->offset + offset, SEEK_SET) != 0
46d1c23b 3051 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3af9a47b
NC		 3052 return -1;
3053
46d1c23b
TG		 3054 cmd->flavours[nflavours].flavour = bfd_h_get_32 (abfd, raw.flavour);
3055 cmd->flavours[nflavours].offset = command->offset + offset + sizeof (raw);
3056 cmd->flavours[nflavours].size = bfd_h_get_32 (abfd, raw.count) * 4;
3057 offset += cmd->flavours[nflavours].size + sizeof (raw);
3af9a47b
NC		 3058 nflavours++;
3059 }
3060
3061 for (i = 0; i < nflavours; i++)
3062 {
3063 asection *bfdsec;
3064 unsigned int snamelen;
3065 char *sname;
3066 const char *flavourstr;
3067 const char *prefix = "LC_THREAD";
a95a4550
AM		 3068 unsigned int j = 0;
3069
3af9a47b
NC		 3070 switch (mdata->header.cputype)
3071 {
3072 case BFD_MACH_O_CPU_TYPE_POWERPC:
1e8a024a 3073 case BFD_MACH_O_CPU_TYPE_POWERPC_64:
3af9a47b
NC		 3074 flavourstr = bfd_mach_o_ppc_flavour_string (cmd->flavours[i].flavour);
3075 break;
3076 case BFD_MACH_O_CPU_TYPE_I386:
1e8a024a 3077 case BFD_MACH_O_CPU_TYPE_X86_64:
3af9a47b
NC		 3078 flavourstr = bfd_mach_o_i386_flavour_string (cmd->flavours[i].flavour);
3079 break;
3080 default:
3081 flavourstr = "UNKNOWN_ARCHITECTURE";
3082 break;
3083 }
a95a4550 3084
3af9a47b 3085 snamelen = strlen (prefix) + 1 + 20 + 1 + strlen (flavourstr) + 1;
116c20d2 3086 sname = bfd_alloc (abfd, snamelen);
3af9a47b
NC		 3087 if (sname == NULL)
3088 return -1;
3089
3090 for (;;)
3091 {
a95a4550
AM		 3092 sprintf (sname, "%s.%s.%u", prefix, flavourstr, j);
3093 if (bfd_get_section_by_name (abfd, sname) == NULL)
3af9a47b 3094 break;
a95a4550 3095 j++;
3af9a47b
NC		 3096 }
3097
117ed4f8 3098 bfdsec = bfd_make_section_with_flags (abfd, sname, SEC_HAS_CONTENTS);
a95a4550 3099
3af9a47b
NC		 3100 bfdsec->vma = 0;
3101 bfdsec->lma = 0;
eea6121a 3102 bfdsec->size = cmd->flavours[i].size;
3af9a47b
NC		 3103 bfdsec->filepos = cmd->flavours[i].offset;
3104 bfdsec->alignment_power = 0x0;
3af9a47b
NC		 3105
3106 cmd->section = bfdsec;
3107 }
3108
3109 return 0;
3110}
3111
a95a4550 3112static int
ab273af8 3113bfd_mach_o_read_dysymtab (bfd *abfd, bfd_mach_o_load_command *command)
3af9a47b 3114{
046b007d 3115 bfd_mach_o_dysymtab_command *cmd = &command->command.dysymtab;
b32e07d7 3116 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3af9a47b
NC		 3117
3118 BFD_ASSERT (command->type == BFD_MACH_O_LC_DYSYMTAB);
3119
46d1c23b
TG		 3120 {
3121 struct mach_o_dysymtab_command_external raw;
3122
3123 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3124 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3125 return -1;
3af9a47b 3126
46d1c23b
TG		 3127 cmd->ilocalsym = bfd_h_get_32 (abfd, raw.ilocalsym);
3128 cmd->nlocalsym = bfd_h_get_32 (abfd, raw.nlocalsym);
3129 cmd->iextdefsym = bfd_h_get_32 (abfd, raw.iextdefsym);
3130 cmd->nextdefsym = bfd_h_get_32 (abfd, raw.nextdefsym);
3131 cmd->iundefsym = bfd_h_get_32 (abfd, raw.iundefsym);
3132 cmd->nundefsym = bfd_h_get_32 (abfd, raw.nundefsym);
3133 cmd->tocoff = bfd_h_get_32 (abfd, raw.tocoff);
3134 cmd->ntoc = bfd_h_get_32 (abfd, raw.ntoc);
3135 cmd->modtaboff = bfd_h_get_32 (abfd, raw.modtaboff);
3136 cmd->nmodtab = bfd_h_get_32 (abfd, raw.nmodtab);
3137 cmd->extrefsymoff = bfd_h_get_32 (abfd, raw.extrefsymoff);
3138 cmd->nextrefsyms = bfd_h_get_32 (abfd, raw.nextrefsyms);
3139 cmd->indirectsymoff = bfd_h_get_32 (abfd, raw.indirectsymoff);
3140 cmd->nindirectsyms = bfd_h_get_32 (abfd, raw.nindirectsyms);
3141 cmd->extreloff = bfd_h_get_32 (abfd, raw.extreloff);
3142 cmd->nextrel = bfd_h_get_32 (abfd, raw.nextrel);
3143 cmd->locreloff = bfd_h_get_32 (abfd, raw.locreloff);
3144 cmd->nlocrel = bfd_h_get_32 (abfd, raw.nlocrel);
3145 }
046b007d
TG		 3146
3147 if (cmd->nmodtab != 0)
3148 {
046b007d
TG		 3149 unsigned int i;
3150 int wide = bfd_mach_o_wide_p (abfd);
3151 unsigned int module_len = wide ? 56 : 52;
3152
3153 cmd->dylib_module =
3154 bfd_alloc (abfd, cmd->nmodtab * sizeof (bfd_mach_o_dylib_module));
3155 if (cmd->dylib_module == NULL)
3156 return -1;
3157
3158 if (bfd_seek (abfd, cmd->modtaboff, SEEK_SET) != 0)
3159 return -1;
3160
3161 for (i = 0; i < cmd->nmodtab; i++)
3162 {
3163 bfd_mach_o_dylib_module *module = &cmd->dylib_module[i];
3164 unsigned long v;
46d1c23b 3165 unsigned char buf[56];
046b007d 3166
91d6fa6a 3167 if (bfd_bread ((void *) buf, module_len, abfd) != module_len)
046b007d
TG		 3168 return -1;
3169
3170 module->module_name_idx = bfd_h_get_32 (abfd, buf + 0);
3171 module->iextdefsym = bfd_h_get_32 (abfd, buf + 4);
3172 module->nextdefsym = bfd_h_get_32 (abfd, buf + 8);
3173 module->irefsym = bfd_h_get_32 (abfd, buf + 12);
3174 module->nrefsym = bfd_h_get_32 (abfd, buf + 16);
3175 module->ilocalsym = bfd_h_get_32 (abfd, buf + 20);
3176 module->nlocalsym = bfd_h_get_32 (abfd, buf + 24);
3177 module->iextrel = bfd_h_get_32 (abfd, buf + 28);
3178 module->nextrel = bfd_h_get_32 (abfd, buf + 32);
3179 v = bfd_h_get_32 (abfd, buf +36);
3180 module->iinit = v & 0xffff;
3181 module->iterm = (v >> 16) & 0xffff;
3182 v = bfd_h_get_32 (abfd, buf + 40);
3183 module->ninit = v & 0xffff;
3184 module->nterm = (v >> 16) & 0xffff;
3185 if (wide)
3186 {
3187 module->objc_module_info_size = bfd_h_get_32 (abfd, buf + 44);
3188 module->objc_module_info_addr = bfd_h_get_64 (abfd, buf + 48);
3189 }
3190 else
3191 {
3192 module->objc_module_info_addr = bfd_h_get_32 (abfd, buf + 44);
3193 module->objc_module_info_size = bfd_h_get_32 (abfd, buf + 48);
3194 }
3195 }
3196 }
afbb9e17 3197
046b007d
TG		 3198 if (cmd->ntoc != 0)
3199 {
046b007d
TG		 3200 unsigned int i;
3201
3202 cmd->dylib_toc = bfd_alloc
3203 (abfd, cmd->ntoc * sizeof (bfd_mach_o_dylib_table_of_content));
3204 if (cmd->dylib_toc == NULL)
3205 return -1;
3206
3207 if (bfd_seek (abfd, cmd->tocoff, SEEK_SET) != 0)
3208 return -1;
3209
3210 for (i = 0; i < cmd->ntoc; i++)
3211 {
46d1c23b 3212 struct mach_o_dylib_table_of_contents_external raw;
046b007d
TG		 3213 bfd_mach_o_dylib_table_of_content *toc = &cmd->dylib_toc[i];
3214
46d1c23b 3215 if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
046b007d
TG		 3216 return -1;
3217
46d1c23b
TG		 3218 toc->symbol_index = bfd_h_get_32 (abfd, raw.symbol_index);
3219 toc->module_index = bfd_h_get_32 (abfd, raw.module_index);
046b007d
TG		 3220 }
3221 }
3222
3223 if (cmd->nindirectsyms != 0)
3224 {
046b007d
TG		 3225 unsigned int i;
3226
3227 cmd->indirect_syms = bfd_alloc
3228 (abfd, cmd->nindirectsyms * sizeof (unsigned int));
3229 if (cmd->indirect_syms == NULL)
3230 return -1;
3231
3232 if (bfd_seek (abfd, cmd->indirectsymoff, SEEK_SET) != 0)
3233 return -1;
3234
3235 for (i = 0; i < cmd->nindirectsyms; i++)
3236 {
46d1c23b 3237 unsigned char raw[4];
046b007d
TG		 3238 unsigned int *is = &cmd->indirect_syms[i];
3239
46d1c23b 3240 if (bfd_bread (raw, sizeof (raw), abfd) != sizeof (raw))
046b007d
TG		 3241 return -1;
3242
46d1c23b 3243 *is = bfd_h_get_32 (abfd, raw);
046b007d
TG		 3244 }
3245 }
3246
3247 if (cmd->nextrefsyms != 0)
3248 {
046b007d
TG		 3249 unsigned long v;
3250 unsigned int i;
3251
3252 cmd->ext_refs = bfd_alloc
3253 (abfd, cmd->nextrefsyms * sizeof (bfd_mach_o_dylib_reference));
3254 if (cmd->ext_refs == NULL)
3255 return -1;
3256
3257 if (bfd_seek (abfd, cmd->extrefsymoff, SEEK_SET) != 0)
3258 return -1;
3259
3260 for (i = 0; i < cmd->nextrefsyms; i++)
3261 {
46d1c23b 3262 unsigned char raw[4];
046b007d
TG		 3263 bfd_mach_o_dylib_reference *ref = &cmd->ext_refs[i];
3264
46d1c23b 3265 if (bfd_bread (raw, sizeof (raw), abfd) != sizeof (raw))
046b007d
TG		 3266 return -1;
3267
b32e07d7
TG		 3268 /* Fields isym and flags are written as bit-fields, thus we need
3269 a specific processing for endianness. */
46d1c23b 3270 v = bfd_h_get_32 (abfd, raw);
b32e07d7
TG		 3271 if (bfd_big_endian (abfd))
3272 {
3273 ref->isym = (v >> 8) & 0xffffff;
3274 ref->flags = v & 0xff;
3275 }
3276 else
3277 {
3278 ref->isym = v & 0xffffff;
3279 ref->flags = (v >> 24) & 0xff;
3280 }
046b007d
TG		 3281 }
3282 }
3af9a47b 3283
b32e07d7
TG		 3284 if (mdata->dysymtab)
3285 return -1;
3286 mdata->dysymtab = cmd;
3287
3af9a47b
NC		 3288 return 0;
3289}
3290
a95a4550 3291static int
ab273af8 3292bfd_mach_o_read_symtab (bfd *abfd, bfd_mach_o_load_command *command)
3af9a47b 3293{
046b007d
TG		 3294 bfd_mach_o_symtab_command *symtab = &command->command.symtab;
3295 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
46d1c23b 3296 struct mach_o_symtab_command_external raw;
3af9a47b
NC		 3297
3298 BFD_ASSERT (command->type == BFD_MACH_O_LC_SYMTAB);
3299
46d1c23b
TG		 3300 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3301 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3af9a47b 3302 return -1;
a95a4550 3303
46d1c23b
TG		 3304 symtab->symoff = bfd_h_get_32 (abfd, raw.symoff);
3305 symtab->nsyms = bfd_h_get_32 (abfd, raw.nsyms);
3306 symtab->stroff = bfd_h_get_32 (abfd, raw.stroff);
3307 symtab->strsize = bfd_h_get_32 (abfd, raw.strsize);
046b007d
TG		 3308 symtab->symbols = NULL;
3309 symtab->strtab = NULL;
3af9a47b 3310
046b007d 3311 if (symtab->nsyms != 0)
15e1c58a
TG		 3312 abfd->flags |= HAS_SYMS;
3313
046b007d
TG		 3314 if (mdata->symtab)
3315 return -1;
3316 mdata->symtab = symtab;
3af9a47b
NC		 3317 return 0;
3318}
3319
15e1c58a 3320static int
ab273af8 3321bfd_mach_o_read_uuid (bfd *abfd, bfd_mach_o_load_command *command)
15e1c58a
TG		 3322{
3323 bfd_mach_o_uuid_command *cmd = &command->command.uuid;
15e1c58a
TG		 3324
3325 BFD_ASSERT (command->type == BFD_MACH_O_LC_UUID);
3326
46d1c23b
TG		 3327 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3328 || bfd_bread (cmd->uuid, 16, abfd) != 16)
15e1c58a
TG		 3329 return -1;
3330
15e1c58a
TG		 3331 return 0;
3332}
3333
046b007d 3334static int
ab273af8 3335bfd_mach_o_read_linkedit (bfd *abfd, bfd_mach_o_load_command *command)
046b007d
TG		 3336{
3337 bfd_mach_o_linkedit_command *cmd = &command->command.linkedit;
46d1c23b 3338 struct mach_o_linkedit_data_command_external raw;
046b007d 3339
46d1c23b
TG		 3340 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3341 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
046b007d
TG		 3342 return -1;
3343
46d1c23b
TG		 3344 cmd->dataoff = bfd_get_32 (abfd, raw.dataoff);
3345 cmd->datasize = bfd_get_32 (abfd, raw.datasize);
046b007d
TG		 3346 return 0;
3347}
3348
3349static int
ab273af8 3350bfd_mach_o_read_str (bfd *abfd, bfd_mach_o_load_command *command)
046b007d
TG		 3351{
3352 bfd_mach_o_str_command *cmd = &command->command.str;
46d1c23b 3353 struct mach_o_str_command_external raw;
046b007d
TG		 3354 unsigned long off;
3355
46d1c23b
TG		 3356 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3357 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
046b007d
TG		 3358 return -1;
3359
46d1c23b 3360 off = bfd_get_32 (abfd, raw.str);
046b007d
TG		 3361 cmd->stroff = command->offset + off;
3362 cmd->str_len = command->len - off;
3363 cmd->str = bfd_alloc (abfd, cmd->str_len);
3364 if (cmd->str == NULL)
3365 return -1;
3366 if (bfd_seek (abfd, cmd->stroff, SEEK_SET) != 0
91d6fa6a 3367 || bfd_bread ((void *) cmd->str, cmd->str_len, abfd) != cmd->str_len)
046b007d
TG		 3368 return -1;
3369 return 0;
3370}
3371
ad86f1fb 3372static int
ab273af8 3373bfd_mach_o_read_dyld_info (bfd *abfd, bfd_mach_o_load_command *command)
ad86f1fb
TG		 3374{
3375 bfd_mach_o_dyld_info_command *cmd = &command->command.dyld_info;
46d1c23b 3376 struct mach_o_dyld_info_command_external raw;
ad86f1fb 3377
46d1c23b
TG		 3378 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3379 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
ad86f1fb
TG		 3380 return -1;
3381
46d1c23b
TG		 3382 cmd->rebase_off = bfd_get_32 (abfd, raw.rebase_off);
3383 cmd->rebase_size = bfd_get_32 (abfd, raw.rebase_size);
3384 cmd->bind_off = bfd_get_32 (abfd, raw.bind_off);
3385 cmd->bind_size = bfd_get_32 (abfd, raw.bind_size);
3386 cmd->weak_bind_off = bfd_get_32 (abfd, raw.weak_bind_off);
3387 cmd->weak_bind_size = bfd_get_32 (abfd, raw.weak_bind_size);
3388 cmd->lazy_bind_off = bfd_get_32 (abfd, raw.lazy_bind_off);
3389 cmd->lazy_bind_size = bfd_get_32 (abfd, raw.lazy_bind_size);
3390 cmd->export_off = bfd_get_32 (abfd, raw.export_off);
3391 cmd->export_size = bfd_get_32 (abfd, raw.export_size);
ad86f1fb
TG		 3392 return 0;
3393}
3394
edbdea0e
TG		 3395static bfd_boolean
3396bfd_mach_o_read_version_min (bfd *abfd, bfd_mach_o_load_command *command)
3397{
3398 bfd_mach_o_version_min_command *cmd = &command->command.version_min;
3399 struct mach_o_version_min_command_external raw;
3400 unsigned int ver;
3401
3402 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3403 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3404 return FALSE;
3405
3406 ver = bfd_get_32 (abfd, raw.version);
3407 cmd->rel = ver >> 16;
3408 cmd->maj = ver >> 8;
3409 cmd->min = ver;
3410 cmd->reserved = bfd_get_32 (abfd, raw.reserved);
3411 return TRUE;
3412}
3413
fc55a902
TG		 3414static bfd_boolean
3415bfd_mach_o_read_encryption_info (bfd *abfd, bfd_mach_o_load_command *command)
3416{
3417 bfd_mach_o_encryption_info_command *cmd = &command->command.encryption_info;
3418 struct mach_o_encryption_info_command_external raw;
3419
3420 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3421 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3422 return FALSE;
3423
3424 cmd->cryptoff = bfd_get_32 (abfd, raw.cryptoff);
3425 cmd->cryptsize = bfd_get_32 (abfd, raw.cryptsize);
3426 cmd->cryptid = bfd_get_32 (abfd, raw.cryptid);
3427 return TRUE;
3428}
3429
3af9a47b 3430static int
ab273af8
TG		 3431bfd_mach_o_read_segment (bfd *abfd,
3432 bfd_mach_o_load_command *command,
3433 unsigned int wide)
3af9a47b 3434{
3af9a47b
NC		 3435 bfd_mach_o_segment_command *seg = &command->command.segment;
3436 unsigned long i;
a95a4550 3437
1e8a024a
TG		 3438 if (wide)
3439 {
46d1c23b
TG		 3440 struct mach_o_segment_command_64_external raw;
3441
1e8a024a 3442 BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT_64);
3af9a47b 3443
46d1c23b
TG		 3444 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3445 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3446 return -1;
3af9a47b 3447
46d1c23b 3448 memcpy (seg->segname, raw.segname, 16);
15e1c58a 3449 seg->segname[16] = '\0';
1e8a024a 3450
46d1c23b
TG		 3451 seg->vmaddr = bfd_h_get_64 (abfd, raw.vmaddr);
3452 seg->vmsize = bfd_h_get_64 (abfd, raw.vmsize);
3453 seg->fileoff = bfd_h_get_64 (abfd, raw.fileoff);
3454 seg->filesize = bfd_h_get_64 (abfd, raw.filesize);
3455 seg->maxprot = bfd_h_get_32 (abfd, raw.maxprot);
3456 seg->initprot = bfd_h_get_32 (abfd, raw.initprot);
3457 seg->nsects = bfd_h_get_32 (abfd, raw.nsects);
3458 seg->flags = bfd_h_get_32 (abfd, raw.flags);
1e8a024a
TG		 3459 }
3460 else
3461 {
46d1c23b
TG		 3462 struct mach_o_segment_command_32_external raw;
3463
1e8a024a
TG		 3464 BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT);
3465
46d1c23b
TG		 3466 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
3467 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
3468 return -1;
1e8a024a 3469
46d1c23b 3470 memcpy (seg->segname, raw.segname, 16);
15e1c58a 3471 seg->segname[16] = '\0';
1e8a024a 3472
46d1c23b
TG		 3473 seg->vmaddr = bfd_h_get_32 (abfd, raw.vmaddr);
3474 seg->vmsize = bfd_h_get_32 (abfd, raw.vmsize);
3475 seg->fileoff = bfd_h_get_32 (abfd, raw.fileoff);
3476 seg->filesize = bfd_h_get_32 (abfd, raw.filesize);
3477 seg->maxprot = bfd_h_get_32 (abfd, raw.maxprot);
3478 seg->initprot = bfd_h_get_32 (abfd, raw.initprot);
3479 seg->nsects = bfd_h_get_32 (abfd, raw.nsects);
3480 seg->flags = bfd_h_get_32 (abfd, raw.flags);
1e8a024a 3481 }
9d4b6009
TG		 3482 seg->sect_head = NULL;
3483 seg->sect_tail = NULL;
3af9a47b 3484
f1bde64c 3485 for (i = 0; i < seg->nsects; i++)
3af9a47b 3486 {
f1bde64c
TG		 3487 bfd_vma segoff;
3488 asection *sec;
a95a4550 3489
f1bde64c
TG		 3490 if (wide)
3491 segoff = command->offset + BFD_MACH_O_LC_SEGMENT_64_SIZE
3492 + (i * BFD_MACH_O_SECTION_64_SIZE);
3493 else
3494 segoff = command->offset + BFD_MACH_O_LC_SEGMENT_SIZE
3495 + (i * BFD_MACH_O_SECTION_SIZE);
3af9a47b 3496
f1bde64c
TG		 3497 sec = bfd_mach_o_read_section (abfd, segoff, seg->initprot, wide);
3498 if (sec == NULL)
3499 return -1;
3500
3501 bfd_mach_o_append_section_to_segment (seg, sec);
3af9a47b
NC		 3502 }
3503
3504 return 0;
3505}
3506
1e8a024a 3507static int
ab273af8 3508bfd_mach_o_read_segment_32 (bfd *abfd, bfd_mach_o_load_command *command)
1e8a024a 3509{
ab273af8 3510 return bfd_mach_o_read_segment (abfd, command, 0);
1e8a024a
TG		 3511}
3512
3513static int
ab273af8 3514bfd_mach_o_read_segment_64 (bfd *abfd, bfd_mach_o_load_command *command)
1e8a024a 3515{
ab273af8 3516 return bfd_mach_o_read_segment (abfd, command, 1);
1e8a024a
TG		 3517}
3518
3af9a47b 3519static int
ab273af8 3520bfd_mach_o_read_command (bfd *abfd, bfd_mach_o_load_command *command)
3af9a47b 3521{
46d1c23b
TG		 3522 struct mach_o_load_command_external raw;
3523 unsigned int cmd;
3af9a47b 3524
046b007d 3525 /* Read command type and length. */
c2f09c75 3526 if (bfd_seek (abfd, command->offset, SEEK_SET) != 0
46d1c23b 3527 || bfd_bread (&raw, BFD_MACH_O_LC_SIZE, abfd) != BFD_MACH_O_LC_SIZE)
3af9a47b
NC		 3528 return -1;
3529
46d1c23b
TG		 3530 cmd = bfd_h_get_32 (abfd, raw.cmd);
3531 command->type = cmd & ~BFD_MACH_O_LC_REQ_DYLD;
3532 command->type_required = cmd & BFD_MACH_O_LC_REQ_DYLD ? TRUE : FALSE;
3533 command->len = bfd_h_get_32 (abfd, raw.cmdsize);
3af9a47b
NC		 3534
3535 switch (command->type)
3536 {
3537 case BFD_MACH_O_LC_SEGMENT:
ab273af8 3538 if (bfd_mach_o_read_segment_32 (abfd, command) != 0)
1e8a024a
TG		 3539 return -1;
3540 break;
3541 case BFD_MACH_O_LC_SEGMENT_64:
ab273af8 3542 if (bfd_mach_o_read_segment_64 (abfd, command) != 0)
3af9a47b
NC		 3543 return -1;
3544 break;
3545 case BFD_MACH_O_LC_SYMTAB:
ab273af8 3546 if (bfd_mach_o_read_symtab (abfd, command) != 0)
3af9a47b
NC		 3547 return -1;
3548 break;
3549 case BFD_MACH_O_LC_SYMSEG:
3550 break;
3551 case BFD_MACH_O_LC_THREAD:
3552 case BFD_MACH_O_LC_UNIXTHREAD:
ab273af8 3553 if (bfd_mach_o_read_thread (abfd, command) != 0)
3af9a47b
NC		 3554 return -1;
3555 break;
3556 case BFD_MACH_O_LC_LOAD_DYLINKER:
3557 case BFD_MACH_O_LC_ID_DYLINKER:
ab273af8 3558 if (bfd_mach_o_read_dylinker (abfd, command) != 0)
3af9a47b
NC		 3559 return -1;
3560 break;
3561 case BFD_MACH_O_LC_LOAD_DYLIB:
3562 case BFD_MACH_O_LC_ID_DYLIB:
3563 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB:
046b007d 3564 case BFD_MACH_O_LC_REEXPORT_DYLIB:
73017762 3565 case BFD_MACH_O_LC_LOAD_UPWARD_DYLIB:
ab273af8 3566 if (bfd_mach_o_read_dylib (abfd, command) != 0)
3af9a47b
NC		 3567 return -1;
3568 break;
3569 case BFD_MACH_O_LC_PREBOUND_DYLIB:
ab273af8 3570 if (bfd_mach_o_read_prebound_dylib (abfd, command) != 0)
3af9a47b
NC		 3571 return -1;
3572 break;
3573 case BFD_MACH_O_LC_LOADFVMLIB:
3574 case BFD_MACH_O_LC_IDFVMLIB:
3575 case BFD_MACH_O_LC_IDENT:
3576 case BFD_MACH_O_LC_FVMFILE:
3577 case BFD_MACH_O_LC_PREPAGE:
3578 case BFD_MACH_O_LC_ROUTINES:
9b02d212 3579 case BFD_MACH_O_LC_ROUTINES_64:
046b007d 3580 break;
3af9a47b 3581 case BFD_MACH_O_LC_SUB_FRAMEWORK:
046b007d
TG		 3582 case BFD_MACH_O_LC_SUB_UMBRELLA:
3583 case BFD_MACH_O_LC_SUB_LIBRARY:
3584 case BFD_MACH_O_LC_SUB_CLIENT:
0c9b2b4c 3585 case BFD_MACH_O_LC_RPATH:
ab273af8 3586 if (bfd_mach_o_read_str (abfd, command) != 0)
046b007d 3587 return -1;
3af9a47b
NC		 3588 break;
3589 case BFD_MACH_O_LC_DYSYMTAB:
ab273af8 3590 if (bfd_mach_o_read_dysymtab (abfd, command) != 0)
3af9a47b
NC		 3591 return -1;
3592 break;
3af9a47b
NC		 3593 case BFD_MACH_O_LC_TWOLEVEL_HINTS:
3594 case BFD_MACH_O_LC_PREBIND_CKSUM:
3595 break;
15e1c58a 3596 case BFD_MACH_O_LC_UUID:
ab273af8 3597 if (bfd_mach_o_read_uuid (abfd, command) != 0)
15e1c58a
TG		 3598 return -1;
3599 break;
3600 case BFD_MACH_O_LC_CODE_SIGNATURE:
846b9259 3601 case BFD_MACH_O_LC_SEGMENT_SPLIT_INFO:
edbdea0e 3602 case BFD_MACH_O_LC_FUNCTION_STARTS:
ab273af8 3603 if (bfd_mach_o_read_linkedit (abfd, command) != 0)
046b007d 3604 return -1;
15e1c58a 3605 break;
fc55a902
TG		 3606 case BFD_MACH_O_LC_ENCRYPTION_INFO:
3607 if (!bfd_mach_o_read_encryption_info (abfd, command))
3608 return -1;
3609 break;
ad86f1fb 3610 case BFD_MACH_O_LC_DYLD_INFO:
ab273af8 3611 if (bfd_mach_o_read_dyld_info (abfd, command) != 0)
ad86f1fb
TG		 3612 return -1;
3613 break;
edbdea0e
TG		 3614 case BFD_MACH_O_LC_VERSION_MIN_MACOSX:
3615 case BFD_MACH_O_LC_VERSION_MIN_IPHONEOS:
3616 if (!bfd_mach_o_read_version_min (abfd, command))
3617 return -1;
3618 break;
3af9a47b 3619 default:
fc55a902 3620 (*_bfd_error_handler)(_("%B: unknown load command 0x%lx"),
c0d9d051 3621 abfd, (unsigned long) command->type);
3af9a47b
NC		 3622 break;
3623 }
3624
3625 return 0;
3626}
3627
3628static void
116c20d2 3629bfd_mach_o_flatten_sections (bfd *abfd)
3af9a47b 3630{
046b007d 3631 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3af9a47b 3632 long csect = 0;
f1bde64c 3633 unsigned long i;
a95a4550 3634
15e1c58a 3635 /* Count total number of sections. */
3af9a47b
NC		 3636 mdata->nsects = 0;
3637
3638 for (i = 0; i < mdata->header.ncmds; i++)
3639 {
1e8a024a
TG		 3640 if (mdata->commands[i].type == BFD_MACH_O_LC_SEGMENT
3641 || mdata->commands[i].type == BFD_MACH_O_LC_SEGMENT_64)
3af9a47b 3642 {
e84d6fca
AM		 3643 bfd_mach_o_segment_command *seg;
3644
3645 seg = &mdata->commands[i].command.segment;
3af9a47b
NC		 3646 mdata->nsects += seg->nsects;
3647 }
3648 }
3649
15e1c58a 3650 /* Allocate sections array. */
e84d6fca
AM		 3651 mdata->sections = bfd_alloc (abfd,
3652 mdata->nsects * sizeof (bfd_mach_o_section *));
15e1c58a
TG		 3653
3654 /* Fill the array. */
3af9a47b
NC		 3655 csect = 0;
3656
3657 for (i = 0; i < mdata->header.ncmds; i++)
3658 {
1e8a024a
TG		 3659 if (mdata->commands[i].type == BFD_MACH_O_LC_SEGMENT
3660 || mdata->commands[i].type == BFD_MACH_O_LC_SEGMENT_64)
3af9a47b 3661 {
e84d6fca 3662 bfd_mach_o_segment_command *seg;
f1bde64c 3663 bfd_mach_o_section *sec;
3af9a47b 3664
e84d6fca 3665 seg = &mdata->commands[i].command.segment;
3af9a47b
NC		 3666 BFD_ASSERT (csect + seg->nsects <= mdata->nsects);
3667
f1bde64c
TG		 3668 for (sec = seg->sect_head; sec != NULL; sec = sec->next)
3669 mdata->sections[csect++] = sec;
3af9a47b
NC		 3670 }
3671 }
3672}
3673
afbb9e17 3674static bfd_boolean
116c20d2 3675bfd_mach_o_scan_start_address (bfd *abfd)
3af9a47b 3676{
046b007d 3677 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3af9a47b
NC		 3678 bfd_mach_o_thread_command *cmd = NULL;
3679 unsigned long i;
3680
3681 for (i = 0; i < mdata->header.ncmds; i++)
afbb9e17
TG		 3682 if ((mdata->commands[i].type == BFD_MACH_O_LC_THREAD) ||
3683 (mdata->commands[i].type == BFD_MACH_O_LC_UNIXTHREAD))
3684 {
3685 cmd = &mdata->commands[i].command.thread;
3686 break;
3687 }
3af9a47b
NC		 3688
3689 if (cmd == NULL)
afbb9e17 3690 return FALSE;
3af9a47b 3691
afbb9e17 3692 /* FIXME: create a subtarget hook ? */
3af9a47b
NC		 3693 for (i = 0; i < cmd->nflavours; i++)
3694 {
a95a4550 3695 if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_I386)
e84d6fca 3696 && (cmd->flavours[i].flavour
15e1c58a 3697 == (unsigned long) BFD_MACH_O_x86_THREAD_STATE32))
3af9a47b
NC		 3698 {
3699 unsigned char buf[4];
3700
c2f09c75
TG		 3701 if (bfd_seek (abfd, cmd->flavours[i].offset + 40, SEEK_SET) != 0
3702 || bfd_bread (buf, 4, abfd) != 4)
afbb9e17 3703 return FALSE;
3af9a47b
NC		 3704
3705 abfd->start_address = bfd_h_get_32 (abfd, buf);
3706 }
a95a4550 3707 else if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_POWERPC)
3af9a47b
NC		 3708 && (cmd->flavours[i].flavour == BFD_MACH_O_PPC_THREAD_STATE))
3709 {
3710 unsigned char buf[4];
3711
c2f09c75
TG		 3712 if (bfd_seek (abfd, cmd->flavours[i].offset + 0, SEEK_SET) != 0
3713 || bfd_bread (buf, 4, abfd) != 4)
afbb9e17 3714 return FALSE;
3af9a47b
NC		 3715
3716 abfd->start_address = bfd_h_get_32 (abfd, buf);
3717 }
1e8a024a 3718 else if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_POWERPC_64)
b32e07d7 3719 && (cmd->flavours[i].flavour == BFD_MACH_O_PPC_THREAD_STATE64))
1e8a024a
TG		 3720 {
3721 unsigned char buf[8];
3722
c2f09c75
TG		 3723 if (bfd_seek (abfd, cmd->flavours[i].offset + 0, SEEK_SET) != 0
3724 || bfd_bread (buf, 8, abfd) != 8)
afbb9e17 3725 return FALSE;
1e8a024a
TG		 3726
3727 abfd->start_address = bfd_h_get_64 (abfd, buf);
3728 }
3729 else if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_X86_64)
3730 && (cmd->flavours[i].flavour == BFD_MACH_O_x86_THREAD_STATE64))
3731 {
3732 unsigned char buf[8];
3733
c2f09c75
TG		 3734 if (bfd_seek (abfd, cmd->flavours[i].offset + (16 * 8), SEEK_SET) != 0
3735 || bfd_bread (buf, 8, abfd) != 8)
afbb9e17 3736 return FALSE;
1e8a024a
TG		 3737
3738 abfd->start_address = bfd_h_get_64 (abfd, buf);
3739 }
3af9a47b
NC		 3740 }
3741
afbb9e17 3742 return TRUE;
3af9a47b
NC		 3743}
3744
42fa0891
TG		 3745bfd_boolean
3746bfd_mach_o_set_arch_mach (bfd *abfd,
3747 enum bfd_architecture arch,
3748 unsigned long machine)
3749{
3750 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
3751
3752 /* If this isn't the right architecture for this backend, and this
3753 isn't the generic backend, fail. */
3754 if (arch != bed->arch
3755 && arch != bfd_arch_unknown
3756 && bed->arch != bfd_arch_unknown)
3757 return FALSE;
3758
3759 return bfd_default_set_arch_mach (abfd, arch, machine);
3760}
3761
afbb9e17 3762static bfd_boolean
116c20d2
NC		 3763bfd_mach_o_scan (bfd *abfd,
3764 bfd_mach_o_header *header,
3765 bfd_mach_o_data_struct *mdata)
3af9a47b
NC		 3766{
3767 unsigned int i;
3af9a47b
NC		 3768 enum bfd_architecture cputype;
3769 unsigned long cpusubtype;
1e8a024a
TG		 3770 unsigned int hdrsize;
3771
c2f09c75 3772 hdrsize = mach_o_wide_p (header) ?
154a1ee5 3773 BFD_MACH_O_HEADER_64_SIZE : BFD_MACH_O_HEADER_SIZE;
3af9a47b 3774
3af9a47b 3775 mdata->header = *header;
3af9a47b 3776
154a1ee5 3777 abfd->flags = abfd->flags & BFD_IN_MEMORY;
15e1c58a
TG		 3778 switch (header->filetype)
3779 {
3780 case BFD_MACH_O_MH_OBJECT:
3781 abfd->flags |= HAS_RELOC;
3782 break;
3783 case BFD_MACH_O_MH_EXECUTE:
3784 abfd->flags |= EXEC_P;
3785 break;
3786 case BFD_MACH_O_MH_DYLIB:
3787 case BFD_MACH_O_MH_BUNDLE:
3788 abfd->flags |= DYNAMIC;
3789 break;
3790 }
3791
3af9a47b
NC		 3792 abfd->tdata.mach_o_data = mdata;
3793
e84d6fca
AM		 3794 bfd_mach_o_convert_architecture (header->cputype, header->cpusubtype,
3795 &cputype, &cpusubtype);
3af9a47b
NC		 3796 if (cputype == bfd_arch_unknown)
3797 {
afbb9e17
TG		 3798 (*_bfd_error_handler)
3799 (_("bfd_mach_o_scan: unknown architecture 0x%lx/0x%lx"),
3800 header->cputype, header->cpusubtype);
3801 return FALSE;
3af9a47b
NC		 3802 }
3803
3804 bfd_set_arch_mach (abfd, cputype, cpusubtype);
a95a4550 3805
3af9a47b
NC		 3806 if (header->ncmds != 0)
3807 {
046b007d
TG		 3808 mdata->commands = bfd_alloc
3809 (abfd, header->ncmds * sizeof (bfd_mach_o_load_command));
3af9a47b 3810 if (mdata->commands == NULL)
afbb9e17 3811 return FALSE;
a95a4550 3812
3af9a47b
NC		 3813 for (i = 0; i < header->ncmds; i++)
3814 {
3815 bfd_mach_o_load_command *cur = &mdata->commands[i];
3816
3817 if (i == 0)
1e8a024a 3818 cur->offset = hdrsize;
3af9a47b
NC		 3819 else
3820 {
3821 bfd_mach_o_load_command *prev = &mdata->commands[i - 1];
3822 cur->offset = prev->offset + prev->len;
3823 }
3824
ab273af8 3825 if (bfd_mach_o_read_command (abfd, cur) < 0)
afbb9e17 3826 return FALSE;
a95a4550 3827 }
3af9a47b
NC		 3828 }
3829
3830 if (bfd_mach_o_scan_start_address (abfd) < 0)
afbb9e17 3831 return FALSE;
3af9a47b
NC		 3832
3833 bfd_mach_o_flatten_sections (abfd);
afbb9e17 3834 return TRUE;
3af9a47b
NC		 3835}
3836
b34976b6 3837bfd_boolean
154a1ee5 3838bfd_mach_o_mkobject_init (bfd *abfd)
3af9a47b
NC		 3839{
3840 bfd_mach_o_data_struct *mdata = NULL;
3841
116c20d2 3842 mdata = bfd_alloc (abfd, sizeof (bfd_mach_o_data_struct));
3af9a47b 3843 if (mdata == NULL)
b34976b6 3844 return FALSE;
3af9a47b
NC		 3845 abfd->tdata.mach_o_data = mdata;
3846
3847 mdata->header.magic = 0;
3848 mdata->header.cputype = 0;
3849 mdata->header.cpusubtype = 0;
3850 mdata->header.filetype = 0;
3851 mdata->header.ncmds = 0;
3852 mdata->header.sizeofcmds = 0;
3853 mdata->header.flags = 0;
3854 mdata->header.byteorder = BFD_ENDIAN_UNKNOWN;
3855 mdata->commands = NULL;
3af9a47b
NC		 3856 mdata->nsects = 0;
3857 mdata->sections = NULL;
4434114c 3858 mdata->dyn_reloc_cache = NULL;
3af9a47b 3859
b34976b6 3860 return TRUE;
3af9a47b
NC		 3861}
3862
42fa0891
TG		 3863static bfd_boolean
3864bfd_mach_o_gen_mkobject (bfd *abfd)
3865{
3866 bfd_mach_o_data_struct *mdata;
3867
3868 if (!bfd_mach_o_mkobject_init (abfd))
3869 return FALSE;
3870
3871 mdata = bfd_mach_o_get_data (abfd);
3872 mdata->header.magic = BFD_MACH_O_MH_MAGIC;
3873 mdata->header.cputype = 0;
3874 mdata->header.cpusubtype = 0;
3875 mdata->header.byteorder = abfd->xvec->byteorder;
3876 mdata->header.version = 1;
3877
3878 return TRUE;
3879}
3880
3af9a47b 3881const bfd_target *
154a1ee5
TG		 3882bfd_mach_o_header_p (bfd *abfd,
3883 bfd_mach_o_filetype filetype,
3884 bfd_mach_o_cpu_type cputype)
3af9a47b 3885{
e84d6fca 3886 struct bfd_preserve preserve;
3af9a47b
NC		 3887 bfd_mach_o_header header;
3888
e84d6fca 3889 preserve.marker = NULL;
154a1ee5 3890 if (!bfd_mach_o_read_header (abfd, &header))
e84d6fca 3891 goto wrong;
3af9a47b 3892
e84d6fca
AM		 3893 if (! (header.byteorder == BFD_ENDIAN_BIG
3894 || header.byteorder == BFD_ENDIAN_LITTLE))
3af9a47b 3895 {
4a97a0e5
AM		 3896 (*_bfd_error_handler) (_("unknown header byte-order value 0x%lx"),
3897 (unsigned long) header.byteorder);
e84d6fca 3898 goto wrong;
3af9a47b
NC		 3899 }
3900
e84d6fca
AM		 3901 if (! ((header.byteorder == BFD_ENDIAN_BIG
3902 && abfd->xvec->byteorder == BFD_ENDIAN_BIG
3903 && abfd->xvec->header_byteorder == BFD_ENDIAN_BIG)
3904 || (header.byteorder == BFD_ENDIAN_LITTLE
3905 && abfd->xvec->byteorder == BFD_ENDIAN_LITTLE
3906 && abfd->xvec->header_byteorder == BFD_ENDIAN_LITTLE)))
3907 goto wrong;
3af9a47b 3908
154a1ee5
TG		 3909 /* Check cputype and filetype.
3910 In case of wildcard, do not accept magics that are handled by existing
3911 targets. */
3912 if (cputype)
3913 {
3914 if (header.cputype != cputype)
3915 goto wrong;
3916 }
154a1ee5
TG		 3917 if (filetype)
3918 {
3919 if (header.filetype != filetype)
3920 goto wrong;
3921 }
3922 else
3923 {
3924 switch (header.filetype)
3925 {
3926 case BFD_MACH_O_MH_CORE:
3927 /* Handled by core_p */
3928 goto wrong;
3929 default:
3930 break;
3931 }
3932 }
3933
e84d6fca
AM		 3934 preserve.marker = bfd_zalloc (abfd, sizeof (bfd_mach_o_data_struct));
3935 if (preserve.marker == NULL
3936 || !bfd_preserve_save (abfd, &preserve))
3937 goto fail;
3af9a47b 3938
afbb9e17
TG		 3939 if (!bfd_mach_o_scan (abfd, &header,
3940 (bfd_mach_o_data_struct *) preserve.marker))
e84d6fca 3941 goto wrong;
a95a4550 3942
e84d6fca 3943 bfd_preserve_finish (abfd, &preserve);
3af9a47b 3944 return abfd->xvec;
e84d6fca
AM		 3945
3946 wrong:
3947 bfd_set_error (bfd_error_wrong_format);
3948
3949 fail:
3950 if (preserve.marker != NULL)
3951 bfd_preserve_restore (abfd, &preserve);
3952 return NULL;
3af9a47b
NC		 3953}
3954
154a1ee5
TG		 3955static const bfd_target *
3956bfd_mach_o_gen_object_p (bfd *abfd)
3af9a47b 3957{
154a1ee5
TG		 3958 return bfd_mach_o_header_p (abfd, 0, 0);
3959}
e84d6fca 3960
154a1ee5
TG		 3961static const bfd_target *
3962bfd_mach_o_gen_core_p (bfd *abfd)
3963{
3964 return bfd_mach_o_header_p (abfd, BFD_MACH_O_MH_CORE, 0);
3af9a47b
NC		 3965}
3966
3967typedef struct mach_o_fat_archentry
3968{
3969 unsigned long cputype;
3970 unsigned long cpusubtype;
3971 unsigned long offset;
3972 unsigned long size;
3973 unsigned long align;
3af9a47b
NC		 3974} mach_o_fat_archentry;
3975
3976typedef struct mach_o_fat_data_struct
3977{
3978 unsigned long magic;
3979 unsigned long nfat_arch;
3980 mach_o_fat_archentry *archentries;
3981} mach_o_fat_data_struct;
3982
3983const bfd_target *
116c20d2 3984bfd_mach_o_archive_p (bfd *abfd)
3af9a47b 3985{
e84d6fca 3986 mach_o_fat_data_struct *adata = NULL;
46d1c23b 3987 struct mach_o_fat_header_external hdr;
3af9a47b
NC		 3988 unsigned long i;
3989
c2f09c75 3990 if (bfd_seek (abfd, 0, SEEK_SET) != 0
46d1c23b 3991 || bfd_bread (&hdr, sizeof (hdr), abfd) != sizeof (hdr))
e84d6fca 3992 goto error;
3af9a47b 3993
116c20d2 3994 adata = bfd_alloc (abfd, sizeof (mach_o_fat_data_struct));
3af9a47b 3995 if (adata == NULL)
e84d6fca 3996 goto error;
a95a4550 3997
46d1c23b
TG		 3998 adata->magic = bfd_getb32 (hdr.magic);
3999 adata->nfat_arch = bfd_getb32 (hdr.nfat_arch);
3af9a47b 4000 if (adata->magic != 0xcafebabe)
e84d6fca 4001 goto error;
27cc28f9
AS		 4002 /* Avoid matching Java bytecode files, which have the same magic number.
4003 In the Java bytecode file format this field contains the JVM version,
4004 which starts at 43.0. */
4005 if (adata->nfat_arch > 30)
4006 goto error;
3af9a47b 4007
c2f09c75 4008 adata->archentries =
3af9a47b
NC		 4009 bfd_alloc (abfd, adata->nfat_arch * sizeof (mach_o_fat_archentry));
4010 if (adata->archentries == NULL)
e84d6fca 4011 goto error;
3af9a47b
NC		 4012
4013 for (i = 0; i < adata->nfat_arch; i++)
4014 {
46d1c23b
TG		 4015 struct mach_o_fat_arch_external arch;
4016 if (bfd_bread (&arch, sizeof (arch), abfd) != sizeof (arch))
e84d6fca 4017 goto error;
46d1c23b
TG		 4018 adata->archentries[i].cputype = bfd_getb32 (arch.cputype);
4019 adata->archentries[i].cpusubtype = bfd_getb32 (arch.cpusubtype);
4020 adata->archentries[i].offset = bfd_getb32 (arch.offset);
4021 adata->archentries[i].size = bfd_getb32 (arch.size);
4022 adata->archentries[i].align = bfd_getb32 (arch.align);
3af9a47b
NC		 4023 }
4024
4025 abfd->tdata.mach_o_fat_data = adata;
4026 return abfd->xvec;
e84d6fca
AM		 4027
4028 error:
4029 if (adata != NULL)
4030 bfd_release (abfd, adata);
4031 bfd_set_error (bfd_error_wrong_format);
4032 return NULL;
3af9a47b
NC		 4033}
4034
4035bfd *
116c20d2 4036bfd_mach_o_openr_next_archived_file (bfd *archive, bfd *prev)
3af9a47b 4037{
e84d6fca 4038 mach_o_fat_data_struct *adata;
3af9a47b
NC		 4039 mach_o_fat_archentry *entry = NULL;
4040 unsigned long i;
15e1c58a 4041 bfd *nbfd;
15e1c58a
TG		 4042 enum bfd_architecture arch_type;
4043 unsigned long arch_subtype;
3af9a47b 4044
e84d6fca 4045 adata = (mach_o_fat_data_struct *) archive->tdata.mach_o_fat_data;
3af9a47b
NC		 4046 BFD_ASSERT (adata != NULL);
4047
4048 /* Find index of previous entry. */
4049 if (prev == NULL)
4050 i = 0; /* Start at first one. */
4051 else
4052 {
4053 for (i = 0; i < adata->nfat_arch; i++)
4054 {
15e1c58a 4055 if (adata->archentries[i].offset == prev->origin)
3af9a47b
NC		 4056 break;
4057 }
4058
4059 if (i == adata->nfat_arch)
4060 {
4061 /* Not found. */
4062 bfd_set_error (bfd_error_bad_value);
a95a4550 4063 return NULL;
3af9a47b
NC		 4064 }
4065 i++; /* Get next entry. */
4066 }
a95a4550 4067
3af9a47b
NC		 4068 if (i >= adata->nfat_arch)
4069 {
4070 bfd_set_error (bfd_error_no_more_archived_files);
4071 return NULL;
4072 }
4073
4074 entry = &adata->archentries[i];
15e1c58a
TG		 4075 nbfd = _bfd_new_bfd_contained_in (archive);
4076 if (nbfd == NULL)
4077 return NULL;
4078
4079 nbfd->origin = entry->offset;
4080
4081 bfd_mach_o_convert_architecture (entry->cputype, entry->cpusubtype,
4082 &arch_type, &arch_subtype);
846b9259 4083
c0d9d051
TG		 4084 /* Create the member filename. Use ARCH_NAME. */
4085 nbfd->filename = bfd_printable_arch_mach (arch_type, arch_subtype);
15e1c58a 4086 nbfd->iostream = NULL;
846b9259 4087 bfd_set_arch_mach (nbfd, arch_type, arch_subtype);
3af9a47b 4088
15e1c58a 4089 return nbfd;
3af9a47b
NC		 4090}
4091
846b9259
TG		 4092/* If ABFD format is FORMAT and architecture is ARCH, return it.
4093 If ABFD is a fat image containing a member that corresponds to FORMAT
4094 and ARCH, returns it.
4095 In other case, returns NULL.
4096 This function allows transparent uses of fat images. */
4097bfd *
4098bfd_mach_o_fat_extract (bfd *abfd,
4099 bfd_format format,
4100 const bfd_arch_info_type *arch)
4101{
4102 bfd *res;
4103 mach_o_fat_data_struct *adata;
4104 unsigned int i;
4105
4106 if (bfd_check_format (abfd, format))
4107 {
4108 if (bfd_get_arch_info (abfd) == arch)
4109 return abfd;
4110 return NULL;
4111 }
4112 if (!bfd_check_format (abfd, bfd_archive)
4113 || abfd->xvec != &mach_o_fat_vec)
4114 return NULL;
c2f09c75 4115
846b9259
TG		 4116 /* This is a Mach-O fat image. */
4117 adata = (mach_o_fat_data_struct *) abfd->tdata.mach_o_fat_data;
4118 BFD_ASSERT (adata != NULL);
4119
4120 for (i = 0; i < adata->nfat_arch; i++)
4121 {
4122 struct mach_o_fat_archentry *e = &adata->archentries[i];
4123 enum bfd_architecture cpu_type;
4124 unsigned long cpu_subtype;
4125
4126 bfd_mach_o_convert_architecture (e->cputype, e->cpusubtype,
4127 &cpu_type, &cpu_subtype);
4128 if (cpu_type != arch->arch || cpu_subtype != arch->mach)
4129 continue;
4130
4131 /* The architecture is found. */
4132 res = _bfd_new_bfd_contained_in (abfd);
4133 if (res == NULL)
4134 return NULL;
4135
4136 res->origin = e->offset;
4137
c0d9d051 4138 res->filename = bfd_printable_arch_mach (cpu_type, cpu_subtype);
846b9259
TG		 4139 res->iostream = NULL;
4140
4141 if (bfd_check_format (res, format))
4142 {
4143 BFD_ASSERT (bfd_get_arch_info (res) == arch);
4144 return res;
4145 }
4146 bfd_close (res);
4147 return NULL;
4148 }
4149
4150 return NULL;
4151}
4152
3af9a47b 4153int
116c20d2
NC		 4154bfd_mach_o_lookup_command (bfd *abfd,
4155 bfd_mach_o_load_command_type type,
4156 bfd_mach_o_load_command **mcommand)
3af9a47b 4157{
046b007d 4158 struct mach_o_data_struct *md = bfd_mach_o_get_data (abfd);
3af9a47b
NC		 4159 bfd_mach_o_load_command *ncmd = NULL;
4160 unsigned int i, num;
4161
3af9a47b
NC		 4162 BFD_ASSERT (md != NULL);
4163 BFD_ASSERT (mcommand != NULL);
4164
4165 num = 0;
4166 for (i = 0; i < md->header.ncmds; i++)
4167 {
4168 struct bfd_mach_o_load_command *cmd = &md->commands[i];
4169
4170 if (cmd->type != type)
4171 continue;
4172
4173 if (num == 0)
4174 ncmd = cmd;
4175 num++;
4176 }
4177
4178 *mcommand = ncmd;
4179 return num;
4180}
4181
4182unsigned long
116c20d2 4183bfd_mach_o_stack_addr (enum bfd_mach_o_cpu_type type)
3af9a47b
NC		 4184{
4185 switch (type)
4186 {
4187 case BFD_MACH_O_CPU_TYPE_MC680x0:
4188 return 0x04000000;
4189 case BFD_MACH_O_CPU_TYPE_MC88000:
4190 return 0xffffe000;
4191 case BFD_MACH_O_CPU_TYPE_POWERPC:
4192 return 0xc0000000;
4193 case BFD_MACH_O_CPU_TYPE_I386:
4194 return 0xc0000000;
4195 case BFD_MACH_O_CPU_TYPE_SPARC:
4196 return 0xf0000000;
4197 case BFD_MACH_O_CPU_TYPE_I860:
4198 return 0;
4199 case BFD_MACH_O_CPU_TYPE_HPPA:
e84d6fca 4200 return 0xc0000000 - 0x04000000;
3af9a47b
NC		 4201 default:
4202 return 0;
4203 }
4204}
4205
ab76eeaf
IS		 4206/* The following two tables should be kept, as far as possible, in order of
4207 most frequently used entries to optimize their use from gas. */
4208
c5012cd8 4209const bfd_mach_o_xlat_name bfd_mach_o_section_type_name[] =
046b007d
TG		 4210{
4211 { "regular", BFD_MACH_O_S_REGULAR},
ab76eeaf 4212 { "coalesced", BFD_MACH_O_S_COALESCED},
046b007d
TG		 4213 { "zerofill", BFD_MACH_O_S_ZEROFILL},
4214 { "cstring_literals", BFD_MACH_O_S_CSTRING_LITERALS},
4215 { "4byte_literals", BFD_MACH_O_S_4BYTE_LITERALS},
4216 { "8byte_literals", BFD_MACH_O_S_8BYTE_LITERALS},
ab76eeaf 4217 { "16byte_literals", BFD_MACH_O_S_16BYTE_LITERALS},
046b007d 4218 { "literal_pointers", BFD_MACH_O_S_LITERAL_POINTERS},
046b007d
TG		 4219 { "mod_init_func_pointers", BFD_MACH_O_S_MOD_INIT_FUNC_POINTERS},
4220 { "mod_fini_func_pointers", BFD_MACH_O_S_MOD_FINI_FUNC_POINTERS},
046b007d
TG		 4221 { "gb_zerofill", BFD_MACH_O_S_GB_ZEROFILL},
4222 { "interposing", BFD_MACH_O_S_INTERPOSING},
046b007d 4223 { "dtrace_dof", BFD_MACH_O_S_DTRACE_DOF},
ab76eeaf
IS		 4224 { "non_lazy_symbol_pointers", BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS},
4225 { "lazy_symbol_pointers", BFD_MACH_O_S_LAZY_SYMBOL_POINTERS},
a4551119 4226 { "symbol_stubs", BFD_MACH_O_S_SYMBOL_STUBS},
046b007d
TG		 4227 { "lazy_dylib_symbol_pointers", BFD_MACH_O_S_LAZY_DYLIB_SYMBOL_POINTERS},
4228 { NULL, 0}
4229};
4230
c5012cd8 4231const bfd_mach_o_xlat_name bfd_mach_o_section_attribute_name[] =
046b007d 4232{
ab76eeaf
IS		 4233 { "pure_instructions", BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS },
4234 { "some_instructions", BFD_MACH_O_S_ATTR_SOME_INSTRUCTIONS },
046b007d
TG		 4235 { "loc_reloc", BFD_MACH_O_S_ATTR_LOC_RELOC },
4236 { "ext_reloc", BFD_MACH_O_S_ATTR_EXT_RELOC },
046b007d 4237 { "debug", BFD_MACH_O_S_ATTR_DEBUG },
046b007d
TG		 4238 { "live_support", BFD_MACH_O_S_ATTR_LIVE_SUPPORT },
4239 { "no_dead_strip", BFD_MACH_O_S_ATTR_NO_DEAD_STRIP },
4240 { "strip_static_syms", BFD_MACH_O_S_ATTR_STRIP_STATIC_SYMS },
4241 { "no_toc", BFD_MACH_O_S_ATTR_NO_TOC },
a4551119 4242 { "self_modifying_code", BFD_MACH_O_S_SELF_MODIFYING_CODE },
ab76eeaf 4243 { "modifying_code", BFD_MACH_O_S_SELF_MODIFYING_CODE },
046b007d
TG		 4244 { NULL, 0}
4245};
4246
a4551119 4247/* Get the section type from NAME. Return 256 if NAME is unknown. */
53d58d96
TG		 4248
4249unsigned int
ab76eeaf 4250bfd_mach_o_get_section_type_from_name (bfd *abfd, const char *name)
53d58d96 4251{
afbb9e17 4252 const bfd_mach_o_xlat_name *x;
ab76eeaf 4253 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
53d58d96
TG		 4254
4255 for (x = bfd_mach_o_section_type_name; x->name; x++)
4256 if (strcmp (x->name, name) == 0)
ab76eeaf
IS		 4257 {
4258 /* We found it... does the target support it? */
4259 if (bed->bfd_mach_o_section_type_valid_for_target == NULL
4260 || bed->bfd_mach_o_section_type_valid_for_target (x->val))
4261 return x->val; /* OK. */
4262 else
4263 break; /* Not supported. */
4264 }
a4551119
TG		 4265 /* Maximum section ID = 0xff. */
4266 return 256;
53d58d96
TG		 4267}
4268
4269/* Get the section attribute from NAME. Return -1 if NAME is unknown. */
4270
4271unsigned int
4272bfd_mach_o_get_section_attribute_from_name (const char *name)
4273{
afbb9e17 4274 const bfd_mach_o_xlat_name *x;
53d58d96
TG		 4275
4276 for (x = bfd_mach_o_section_attribute_name; x->name; x++)
4277 if (strcmp (x->name, name) == 0)
4278 return x->val;
4279 return (unsigned int)-1;
4280}
4281
3af9a47b 4282int
116c20d2
NC		 4283bfd_mach_o_core_fetch_environment (bfd *abfd,
4284 unsigned char **rbuf,
4285 unsigned int *rlen)
3af9a47b 4286{
046b007d 4287 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3af9a47b
NC		 4288 unsigned long stackaddr = bfd_mach_o_stack_addr (mdata->header.cputype);
4289 unsigned int i = 0;
4290
4291 for (i = 0; i < mdata->header.ncmds; i++)
4292 {
4293 bfd_mach_o_load_command *cur = &mdata->commands[i];
4294 bfd_mach_o_segment_command *seg = NULL;
4295
4296 if (cur->type != BFD_MACH_O_LC_SEGMENT)
4297 continue;
4298
4299 seg = &cur->command.segment;
4300
4301 if ((seg->vmaddr + seg->vmsize) == stackaddr)
4302 {
4303 unsigned long start = seg->fileoff;
4304 unsigned long end = seg->fileoff + seg->filesize;
4305 unsigned char *buf = bfd_malloc (1024);
4306 unsigned long size = 1024;
4307
4308 for (;;)
4309 {
4310 bfd_size_type nread = 0;
4311 unsigned long offset;
4312 int found_nonnull = 0;
4313
4314 if (size > (end - start))
4315 size = (end - start);
4316
515ef31d
NC		 4317 buf = bfd_realloc_or_free (buf, size);
4318 if (buf == NULL)
4319 return -1;
c2f09c75
TG		 4320
4321 if (bfd_seek (abfd, end - size, SEEK_SET) != 0)
4322 {
4323 free (buf);
4324 return -1;
4325 }
4326
3af9a47b 4327 nread = bfd_bread (buf, size, abfd);
a95a4550 4328
3af9a47b 4329 if (nread != size)
515ef31d
NC		 4330 {
4331 free (buf);
4332 return -1;
4333 }
a95a4550 4334
3af9a47b
NC		 4335 for (offset = 4; offset <= size; offset += 4)
4336 {
e84d6fca 4337 unsigned long val;
3af9a47b 4338
e84d6fca 4339 val = *((unsigned long *) (buf + size - offset));
3af9a47b
NC		 4340 if (! found_nonnull)
4341 {
4342 if (val != 0)
4343 found_nonnull = 1;
4344 }
4345 else if (val == 0x0)
4346 {
e84d6fca
AM		 4347 unsigned long bottom;
4348 unsigned long top;
3af9a47b 4349
e84d6fca
AM		 4350 bottom = seg->fileoff + seg->filesize - offset;
4351 top = seg->fileoff + seg->filesize - 4;
3af9a47b
NC		 4352 *rbuf = bfd_malloc (top - bottom);
4353 *rlen = top - bottom;
4354
4355 memcpy (*rbuf, buf + size - *rlen, *rlen);
515ef31d 4356 free (buf);
3af9a47b
NC		 4357 return 0;
4358 }
4359 }
4360
4361 if (size == (end - start))
4362 break;
4363
4364 size *= 2;
4365 }
515ef31d
NC		 4366
4367 free (buf);
3af9a47b
NC		 4368 }
4369 }
4370
4371 return -1;
4372}
4373
4374char *
116c20d2 4375bfd_mach_o_core_file_failing_command (bfd *abfd)
3af9a47b
NC		 4376{
4377 unsigned char *buf = NULL;
4378 unsigned int len = 0;
4379 int ret = -1;
4380
4381 ret = bfd_mach_o_core_fetch_environment (abfd, &buf, &len);
4382 if (ret < 0)
4383 return NULL;
4384
f075ee0c 4385 return (char *) buf;
3af9a47b
NC		 4386}
4387
4388int
116c20d2 4389bfd_mach_o_core_file_failing_signal (bfd *abfd ATTRIBUTE_UNUSED)
3af9a47b
NC		 4390{
4391 return 0;
4392}
4393
2ca7691a
TG		 4394static bfd_mach_o_uuid_command *
4395bfd_mach_o_lookup_uuid_command (bfd *abfd)
4396{
4397 bfd_mach_o_load_command *uuid_cmd;
4398 int ncmd = bfd_mach_o_lookup_command (abfd, BFD_MACH_O_LC_UUID, &uuid_cmd);
4399 if (ncmd != 1)
4400 return FALSE;
4401 return &uuid_cmd->command.uuid;
4402}
4403
4404/* Return true if ABFD is a dSYM file and its UUID matches UUID_CMD. */
4405
4406static bfd_boolean
4407bfd_mach_o_dsym_for_uuid_p (bfd *abfd, const bfd_mach_o_uuid_command *uuid_cmd)
4408{
4409 bfd_mach_o_uuid_command *dsym_uuid_cmd;
4410
4411 BFD_ASSERT (abfd);
4412 BFD_ASSERT (uuid_cmd);
4413
4414 if (!bfd_check_format (abfd, bfd_object))
4415 return FALSE;
4416
4417 if (bfd_get_flavour (abfd) != bfd_target_mach_o_flavour
4418 || bfd_mach_o_get_data (abfd) == NULL
4419 || bfd_mach_o_get_data (abfd)->header.filetype != BFD_MACH_O_MH_DSYM)
4420 return FALSE;
4421
4422 dsym_uuid_cmd = bfd_mach_o_lookup_uuid_command (abfd);
4423 if (dsym_uuid_cmd == NULL)
4424 return FALSE;
4425
4426 if (memcmp (uuid_cmd->uuid, dsym_uuid_cmd->uuid,
4427 sizeof (uuid_cmd->uuid)) != 0)
4428 return FALSE;
4429
4430 return TRUE;
4431}
4432
4433/* Find a BFD in DSYM_FILENAME which matches ARCH and UUID_CMD.
4434 The caller is responsible for closing the returned BFD object and
4435 its my_archive if the returned BFD is in a fat dSYM. */
4436
4437static bfd *
4438bfd_mach_o_find_dsym (const char *dsym_filename,
4439 const bfd_mach_o_uuid_command *uuid_cmd,
4440 const bfd_arch_info_type *arch)
4441{
4442 bfd *base_dsym_bfd, *dsym_bfd;
4443
4444 BFD_ASSERT (uuid_cmd);
4445
4446 base_dsym_bfd = bfd_openr (dsym_filename, NULL);
4447 if (base_dsym_bfd == NULL)
4448 return NULL;
4449
4450 dsym_bfd = bfd_mach_o_fat_extract (base_dsym_bfd, bfd_object, arch);
4451 if (bfd_mach_o_dsym_for_uuid_p (dsym_bfd, uuid_cmd))
4452 return dsym_bfd;
4453
4454 bfd_close (dsym_bfd);
4455 if (base_dsym_bfd != dsym_bfd)
4456 bfd_close (base_dsym_bfd);
4457
4458 return NULL;
4459}
4460
4461/* Return a BFD created from a dSYM file for ABFD.
4462 The caller is responsible for closing the returned BFD object, its
4463 filename, and its my_archive if the returned BFD is in a fat dSYM. */
4464
4465static bfd *
4466bfd_mach_o_follow_dsym (bfd *abfd)
4467{
4468 char *dsym_filename;
4469 bfd_mach_o_uuid_command *uuid_cmd;
4470 bfd *dsym_bfd, *base_bfd = abfd;
4471 const char *base_basename;
4472
4473 if (abfd == NULL || bfd_get_flavour (abfd) != bfd_target_mach_o_flavour)
4474 return NULL;
4475
4476 if (abfd->my_archive)
4477 base_bfd = abfd->my_archive;
4478 /* BFD may have been opened from a stream. */
4479 if (base_bfd->filename == NULL)
4480 {
4481 bfd_set_error (bfd_error_invalid_operation);
4482 return NULL;
4483 }
4484 base_basename = lbasename (base_bfd->filename);
4485
4486 uuid_cmd = bfd_mach_o_lookup_uuid_command (abfd);
4487 if (uuid_cmd == NULL)
4488 return NULL;
4489
4490 /* TODO: We assume the DWARF file has the same as the binary's.
4491 It seems apple's GDB checks all files in the dSYM bundle directory.
4492 http://opensource.apple.com/source/gdb/gdb-1708/src/gdb/macosx/macosx-tdep.c
4493 */
4494 dsym_filename = (char *)bfd_malloc (strlen (base_bfd->filename)
4495 + strlen (dsym_subdir) + 1
4496 + strlen (base_basename) + 1);
4497 sprintf (dsym_filename, "%s%s/%s",
4498 base_bfd->filename, dsym_subdir, base_basename);
4499
4500 dsym_bfd = bfd_mach_o_find_dsym (dsym_filename, uuid_cmd,
4501 bfd_get_arch_info (abfd));
4502 if (dsym_bfd == NULL)
4503 free (dsym_filename);
4504
4505 return dsym_bfd;
4506}
4507
d9071b0c
TG		 4508bfd_boolean
4509bfd_mach_o_find_nearest_line (bfd *abfd,
4510 asection *section,
4511 asymbol **symbols,
4512 bfd_vma offset,
4513 const char **filename_ptr,
4514 const char **functionname_ptr,
4515 unsigned int *line_ptr)
4516{
4517 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
2ca7691a 4518 if (mdata == NULL)
d9071b0c 4519 return FALSE;
2ca7691a
TG		 4520 switch (mdata->header.filetype)
4521 {
4522 case BFD_MACH_O_MH_OBJECT:
4523 break;
4524 case BFD_MACH_O_MH_EXECUTE:
4525 case BFD_MACH_O_MH_DYLIB:
4526 case BFD_MACH_O_MH_BUNDLE:
4527 case BFD_MACH_O_MH_KEXT_BUNDLE:
4528 if (mdata->dwarf2_find_line_info == NULL)
4529 {
4530 mdata->dsym_bfd = bfd_mach_o_follow_dsym (abfd);
4531 /* When we couldn't find dSYM for this binary, we look for
4532 the debug information in the binary itself. In this way,
4533 we won't try finding separated dSYM again because
4534 mdata->dwarf2_find_line_info will be filled. */
4535 if (! mdata->dsym_bfd)
4536 break;
4537 if (! _bfd_dwarf2_slurp_debug_info (abfd, mdata->dsym_bfd,
4538 dwarf_debug_sections, symbols,
4539 &mdata->dwarf2_find_line_info))
4540 return FALSE;
4541 }
4542 break;
4543 default:
4544 return FALSE;
4545 }
d9071b0c
TG		 4546 if (_bfd_dwarf2_find_nearest_line (abfd, dwarf_debug_sections,
4547 section, symbols, offset,
4548 filename_ptr, functionname_ptr,
4549 line_ptr, 0,
4550 &mdata->dwarf2_find_line_info))
4551 return TRUE;
4552 return FALSE;
4553}
4554
4555bfd_boolean
4556bfd_mach_o_close_and_cleanup (bfd *abfd)
4557{
4558 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
4559 if (bfd_get_format (abfd) == bfd_object && mdata != NULL)
4434114c
TG		 4560 {
4561 _bfd_dwarf2_cleanup_debug_info (abfd, &mdata->dwarf2_find_line_info);
4562 bfd_mach_o_free_cached_info (abfd);
2ca7691a
TG		 4563 if (mdata->dsym_bfd != NULL)
4564 {
4565 bfd *fat_bfd = mdata->dsym_bfd->my_archive;
4566 char *dsym_filename = (char *)(fat_bfd
4567 ? fat_bfd->filename
4568 : mdata->dsym_bfd->filename);
4569 bfd_close (mdata->dsym_bfd);
4570 mdata->dsym_bfd = NULL;
4571 if (fat_bfd)
4572 bfd_close (fat_bfd);
4573 free (dsym_filename);
4574 }
4434114c 4575 }
dff55db0 4576
d9071b0c
TG		 4577 return _bfd_generic_close_and_cleanup (abfd);
4578}
4579
dff55db0
TG		 4580bfd_boolean bfd_mach_o_free_cached_info (bfd *abfd)
4581{
4582 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
4583 asection *asect;
4584 free (mdata->dyn_reloc_cache);
4585 mdata->dyn_reloc_cache = NULL;
4586 for (asect = abfd->sections; asect != NULL; asect = asect->next)
4587 {
4588 free (asect->relocation);
4589 asect->relocation = NULL;
4590 }
4591
4592 return TRUE;
4593}
4594
92bc0e80
TG		 4595#define bfd_mach_o_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
4596#define bfd_mach_o_bfd_reloc_name_lookup _bfd_norelocs_bfd_reloc_name_lookup
4597
4598#define bfd_mach_o_swap_reloc_in NULL
4599#define bfd_mach_o_swap_reloc_out NULL
b32e07d7 4600#define bfd_mach_o_print_thread NULL
a4551119 4601#define bfd_mach_o_tgt_seg_table NULL
ab76eeaf 4602#define bfd_mach_o_section_type_valid_for_tgt NULL
92bc0e80 4603
116c20d2
NC		 4604#define TARGET_NAME mach_o_be_vec
4605#define TARGET_STRING "mach-o-be"
42fa0891 4606#define TARGET_ARCHITECTURE bfd_arch_unknown
116c20d2
NC		 4607#define TARGET_BIG_ENDIAN 1
4608#define TARGET_ARCHIVE 0
b93a1992 4609#define TARGET_PRIORITY 1
3af9a47b
NC		 4610#include "mach-o-target.c"
4611
4612#undef TARGET_NAME
4613#undef TARGET_STRING
42fa0891 4614#undef TARGET_ARCHITECTURE
3af9a47b
NC		 4615#undef TARGET_BIG_ENDIAN
4616#undef TARGET_ARCHIVE
b93a1992 4617#undef TARGET_PRIORITY
3af9a47b 4618
116c20d2
NC		 4619#define TARGET_NAME mach_o_le_vec
4620#define TARGET_STRING "mach-o-le"
42fa0891 4621#define TARGET_ARCHITECTURE bfd_arch_unknown
116c20d2
NC		 4622#define TARGET_BIG_ENDIAN 0
4623#define TARGET_ARCHIVE 0
b93a1992 4624#define TARGET_PRIORITY 1
3af9a47b
NC		 4625
4626#include "mach-o-target.c"
4627
4628#undef TARGET_NAME
4629#undef TARGET_STRING
42fa0891 4630#undef TARGET_ARCHITECTURE
3af9a47b
NC		 4631#undef TARGET_BIG_ENDIAN
4632#undef TARGET_ARCHIVE
b93a1992 4633#undef TARGET_PRIORITY
3af9a47b 4634
8f95b6e4
TG		 4635/* Not yet handled: creating an archive. */
4636#define bfd_mach_o_mkarchive _bfd_noarchive_mkarchive
4637
4638/* Not used. */
4639#define bfd_mach_o_read_ar_hdr _bfd_noarchive_read_ar_hdr
4640#define bfd_mach_o_write_ar_hdr _bfd_noarchive_write_ar_hdr
4641#define bfd_mach_o_slurp_armap _bfd_noarchive_slurp_armap
4642#define bfd_mach_o_slurp_extended_name_table _bfd_noarchive_slurp_extended_name_table
4643#define bfd_mach_o_construct_extended_name_table _bfd_noarchive_construct_extended_name_table
4644#define bfd_mach_o_truncate_arname _bfd_noarchive_truncate_arname
4645#define bfd_mach_o_write_armap _bfd_noarchive_write_armap
4646#define bfd_mach_o_get_elt_at_index _bfd_noarchive_get_elt_at_index
4647#define bfd_mach_o_generic_stat_arch_elt _bfd_noarchive_generic_stat_arch_elt
4648#define bfd_mach_o_update_armap_timestamp _bfd_noarchive_update_armap_timestamp
4649
116c20d2
NC		 4650#define TARGET_NAME mach_o_fat_vec
4651#define TARGET_STRING "mach-o-fat"
42fa0891 4652#define TARGET_ARCHITECTURE bfd_arch_unknown
116c20d2
NC		 4653#define TARGET_BIG_ENDIAN 1
4654#define TARGET_ARCHIVE 1
b93a1992 4655#define TARGET_PRIORITY 0
3af9a47b
NC		 4656
4657#include "mach-o-target.c"
4658
4659#undef TARGET_NAME
4660#undef TARGET_STRING
42fa0891 4661#undef TARGET_ARCHITECTURE
3af9a47b
NC		 4662#undef TARGET_BIG_ENDIAN
4663#undef TARGET_ARCHIVE
b93a1992 4664#undef TARGET_PRIORITY
A mirror of the official binutils-gdb repository