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