projects / deliverable / binutils-gdb.git / blob
? search:


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