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