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