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