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