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