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