projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
PR24390, Don't decode mtfsb field as a cr field
[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;
650
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;
670
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);
710
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;
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
7a6e0d89
AM		 1420#if GCC_VERSION >= 4003
1421# pragma GCC diagnostic push
1422# pragma GCC diagnostic ignored "-Wtype-limits"
1423#endif
92bc0e80
TG		 1424long
1425bfd_mach_o_get_reloc_upper_bound (bfd *abfd ATTRIBUTE_UNUSED,
07d6d2b8 1426 asection *asect)
92bc0e80 1427{
7a6e0d89
AM		 1428 if (asect->reloc_count >= LONG_MAX / sizeof (arelent *))
1429 {
1430 bfd_set_error (bfd_error_file_too_big);
1431 return -1;
1432 }
1433 return (asect->reloc_count + 1) * sizeof (arelent *);
92bc0e80 1434}
7a6e0d89
AM		 1435#if GCC_VERSION >= 4003
1436# pragma GCC diagnostic pop
1437#endif
92bc0e80 1438
19765f52
IS		 1439/* In addition to the need to byte-swap the symbol number, the bit positions
1440 of the fields in the relocation information vary per target endian-ness. */
1441
bcb51645 1442void
19765f52 1443bfd_mach_o_swap_in_non_scattered_reloc (bfd *abfd, bfd_mach_o_reloc_info *rel,
c6643fcc 1444 unsigned char *fields)
19765f52
IS		 1445{
1446 unsigned char info = fields[3];
1447
1448 if (bfd_big_endian (abfd))
1449 {
1450 rel->r_value = (fields[0] << 16) | (fields[1] << 8) | fields[2];
1451 rel->r_type = (info >> BFD_MACH_O_BE_TYPE_SHIFT) & BFD_MACH_O_TYPE_MASK;
1452 rel->r_pcrel = (info & BFD_MACH_O_BE_PCREL) ? 1 : 0;
68ffbac6 1453 rel->r_length = (info >> BFD_MACH_O_BE_LENGTH_SHIFT)
19765f52
IS		 1454 & BFD_MACH_O_LENGTH_MASK;
1455 rel->r_extern = (info & BFD_MACH_O_BE_EXTERN) ? 1 : 0;
1456 }
1457 else
1458 {
1459 rel->r_value = (fields[2] << 16) | (fields[1] << 8) | fields[0];
1460 rel->r_type = (info >> BFD_MACH_O_LE_TYPE_SHIFT) & BFD_MACH_O_TYPE_MASK;
1461 rel->r_pcrel = (info & BFD_MACH_O_LE_PCREL) ? 1 : 0;
68ffbac6 1462 rel->r_length = (info >> BFD_MACH_O_LE_LENGTH_SHIFT)
19765f52
IS		 1463 & BFD_MACH_O_LENGTH_MASK;
1464 rel->r_extern = (info & BFD_MACH_O_LE_EXTERN) ? 1 : 0;
1465 }
1466}
1467
bcb51645
TG		 1468/* Set syms_ptr_ptr and addend of RES. */
1469
1470bfd_boolean
1471bfd_mach_o_canonicalize_non_scattered_reloc (bfd *abfd,
1472 bfd_mach_o_reloc_info *reloc,
1473 arelent *res, asymbol **syms)
92bc0e80 1474{
046b007d 1475 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
bcb51645 1476 unsigned int num;
b32e07d7
TG		 1477 asymbol **sym;
1478
bcb51645
TG		 1479 /* Non-scattered relocation. */
1480 reloc->r_scattered = 0;
1481 res->addend = 0;
1482
1483 num = reloc->r_value;
1484
1485 if (reloc->r_extern)
1486 {
1487 /* PR 17512: file: 8396-1185-0.004. */
1488 if (num >= (unsigned) bfd_mach_o_count_symbols (abfd))
1489 sym = bfd_und_section_ptr->symbol_ptr_ptr;
1490 else if (syms == NULL)
1491 sym = bfd_und_section_ptr->symbol_ptr_ptr;
1492 else
1493 /* An external symbol number. */
1494 sym = syms + num;
1495 }
1496 else if (num == 0x00ffffff || num == 0)
1497 {
1498 /* The 'symnum' in a non-scattered PAIR is 0x00ffffff. But as this
1499 is generic code, we don't know wether this is really a PAIR.
1500 This value is almost certainly not a valid section number, hence
1501 this specific case to avoid an assertion failure.
1502 Target specific swap_reloc_in routine should adjust that. */
1503 sym = bfd_abs_section_ptr->symbol_ptr_ptr;
1504 }
1505 else
1506 {
1507 /* PR 17512: file: 006-2964-0.004. */
1508 if (num > mdata->nsects)
1509 return FALSE;
1510
1511 /* A section number. */
1512 sym = mdata->sections[num - 1]->bfdsection->symbol_ptr_ptr;
1513 /* For a symbol defined in section S, the addend (stored in the
1514 binary) contains the address of the section. To comply with
1515 bfd convention, subtract the section address.
1516 Use the address from the header, so that the user can modify
07d6d2b8 1517 the vma of the section. */
bcb51645
TG		 1518 res->addend = -mdata->sections[num - 1]->addr;
1519 }
1520
1521 /* Note: Pairs for PPC LO/HI/HA are not scattered, but contain the offset
1522 in the lower 16bits of the address value. So we have to find the
1523 'symbol' from the preceding reloc. We do this even though the
1524 section symbol is probably not needed here, because NULL symbol
1525 values cause an assert in generic BFD code. This must be done in
1526 the PPC swap_reloc_in routine. */
1527 res->sym_ptr_ptr = sym;
1528
1529 return TRUE;
1530}
1531
1532/* Do most of the work for canonicalize_relocs on RAW: create internal
1533 representation RELOC and set most fields of RES using symbol table SYMS.
1534 Each target still has to set the howto of RES and possibly adjust other
1535 fields.
1536 Previously the Mach-O hook point was simply swap_in, but some targets
1537 (like arm64) don't follow the generic rules (symnum is a value for the
1538 non-scattered relocation ADDEND). */
1539
1540bfd_boolean
1541bfd_mach_o_pre_canonicalize_one_reloc (bfd *abfd,
1542 struct mach_o_reloc_info_external *raw,
1543 bfd_mach_o_reloc_info *reloc,
1544 arelent *res, asymbol **syms)
1545{
1546 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
1547 bfd_vma addr;
1548
46d1c23b 1549 addr = bfd_get_32 (abfd, raw->r_address);
19765f52
IS		 1550 res->sym_ptr_ptr = NULL;
1551 res->addend = 0;
f4716ee2 1552
b32e07d7
TG		 1553 if (addr & BFD_MACH_O_SR_SCATTERED)
1554 {
1555 unsigned int j;
19765f52 1556 bfd_vma symnum = bfd_get_32 (abfd, raw->r_symbolnum);
b32e07d7 1557
19765f52 1558 /* Scattered relocation, can't be extern. */
bcb51645
TG		 1559 reloc->r_scattered = 1;
1560 reloc->r_extern = 0;
19765f52
IS		 1561
1562 /* Extract section and offset from r_value (symnum). */
bcb51645 1563 reloc->r_value = symnum;
19765f52
IS		 1564 /* FIXME: This breaks when a symbol in a reloc exactly follows the
1565 end of the data for the section (e.g. in a calculation of section
1566 data length). At present, the symbol will end up associated with
1567 the following section or, if it falls within alignment padding, as
1568 null - which will assert later. */
b32e07d7 1569 for (j = 0; j < mdata->nsects; j++)
07d6d2b8
AM		 1570 {
1571 bfd_mach_o_section *sect = mdata->sections[j];
1572 if (symnum >= sect->addr && symnum < sect->addr + sect->size)
1573 {
1574 res->sym_ptr_ptr = sect->bfdsection->symbol_ptr_ptr;
1575 res->addend = symnum - sect->addr;
1576 break;
1577 }
1578 }
19765f52
IS		 1579
1580 /* Extract the info and address fields from r_address. */
bcb51645
TG		 1581 reloc->r_type = BFD_MACH_O_GET_SR_TYPE (addr);
1582 reloc->r_length = BFD_MACH_O_GET_SR_LENGTH (addr);
1583 reloc->r_pcrel = addr & BFD_MACH_O_SR_PCREL;
1584 reloc->r_address = BFD_MACH_O_GET_SR_TYPE (addr);
19765f52 1585 res->address = BFD_MACH_O_GET_SR_ADDRESS (addr);
b32e07d7
TG		 1586 }
1587 else
1588 {
19765f52 1589 /* Non-scattered relocation. */
bcb51645
TG		 1590 reloc->r_scattered = 0;
1591 reloc->r_address = addr;
1592 res->address = addr;
f4716ee2 1593
19765f52 1594 /* The value and info fields have to be extracted dependent on target
07d6d2b8 1595 endian-ness. */
bcb51645 1596 bfd_mach_o_swap_in_non_scattered_reloc (abfd, reloc, raw->r_symbolnum);
19765f52 1597
bcb51645
TG		 1598 if (!bfd_mach_o_canonicalize_non_scattered_reloc (abfd, reloc,
1599 res, syms))
1600 return FALSE;
b32e07d7 1601 }
f4716ee2
TG		 1602
1603 /* We have set up a reloc with all the information present, so the swapper
1604 can modify address, value and addend fields, if necessary, to convey
1605 information in the generic BFD reloc that is mach-o specific. */
19765f52 1606
bcb51645 1607 return TRUE;
b32e07d7
TG		 1608}
1609
1610static int
1611bfd_mach_o_canonicalize_relocs (bfd *abfd, unsigned long filepos,
07d6d2b8
AM		 1612 unsigned long count,
1613 arelent *res, asymbol **syms)
b32e07d7 1614{
bcb51645 1615 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
92bc0e80 1616 unsigned long i;
46d1c23b 1617 struct mach_o_reloc_info_external *native_relocs;
92bc0e80
TG		 1618 bfd_size_type native_size;
1619
92bc0e80 1620 /* Allocate and read relocs. */
b32e07d7 1621 native_size = count * BFD_MACH_O_RELENT_SIZE;
033539e2 1622
64d29018
NC		 1623 /* PR 17512: file: 09477b57. */
1624 if (native_size < count)
1625 return -1;
1626
46d1c23b
TG		 1627 native_relocs =
1628 (struct mach_o_reloc_info_external *) bfd_malloc (native_size);
92bc0e80
TG		 1629 if (native_relocs == NULL)
1630 return -1;
1631
b32e07d7 1632 if (bfd_seek (abfd, filepos, SEEK_SET) != 0
92bc0e80 1633 || bfd_bread (native_relocs, native_size, abfd) != native_size)
b32e07d7
TG		 1634 goto err;
1635
1636 for (i = 0; i < count; i++)
92bc0e80 1637 {
bcb51645 1638 if (!(*bed->_bfd_mach_o_canonicalize_one_reloc)(abfd, &native_relocs[i],
ca4cf9b9 1639 &res[i], syms, res))
07d6d2b8 1640 goto err;
92bc0e80 1641 }
b32e07d7
TG		 1642 free (native_relocs);
1643 return i;
1644 err:
1645 free (native_relocs);
1646 return -1;
1647}
1648
1649long
1650bfd_mach_o_canonicalize_reloc (bfd *abfd, asection *asect,
07d6d2b8 1651 arelent **rels, asymbol **syms)
b32e07d7
TG		 1652{
1653 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
1654 unsigned long i;
1655 arelent *res;
1656
1657 if (asect->reloc_count == 0)
1658 return 0;
1659
1660 /* No need to go further if we don't know how to read relocs. */
bcb51645 1661 if (bed->_bfd_mach_o_canonicalize_one_reloc == NULL)
b32e07d7 1662 return 0;
92bc0e80 1663
dff55db0 1664 if (asect->relocation == NULL)
92bc0e80 1665 {
64d29018
NC		 1666 if (asect->reloc_count * sizeof (arelent) < asect->reloc_count)
1667 return -1;
dff55db0
TG		 1668 res = bfd_malloc (asect->reloc_count * sizeof (arelent));
1669 if (res == NULL)
07d6d2b8 1670 return -1;
dff55db0
TG		 1671
1672 if (bfd_mach_o_canonicalize_relocs (abfd, asect->rel_filepos,
07d6d2b8
AM		 1673 asect->reloc_count, res, syms) < 0)
1674 {
1675 free (res);
1676 return -1;
1677 }
dff55db0 1678 asect->relocation = res;
92bc0e80
TG		 1679 }
1680
dff55db0 1681 res = asect->relocation;
92bc0e80 1682 for (i = 0; i < asect->reloc_count; i++)
b32e07d7
TG		 1683 rels[i] = &res[i];
1684 rels[i] = NULL;
92bc0e80 1685
b32e07d7
TG		 1686 return i;
1687}
92bc0e80 1688
b32e07d7
TG		 1689long
1690bfd_mach_o_get_dynamic_reloc_upper_bound (bfd *abfd)
1691{
1692 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
92bc0e80 1693
b32e07d7
TG		 1694 if (mdata->dysymtab == NULL)
1695 return 1;
dff55db0 1696 return (mdata->dysymtab->nextrel + mdata->dysymtab->nlocrel + 1)
b32e07d7
TG		 1697 * sizeof (arelent *);
1698}
92bc0e80 1699
b32e07d7
TG		 1700long
1701bfd_mach_o_canonicalize_dynamic_reloc (bfd *abfd, arelent **rels,
07d6d2b8 1702 struct bfd_symbol **syms)
b32e07d7
TG		 1703{
1704 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
1705 bfd_mach_o_dysymtab_command *dysymtab = mdata->dysymtab;
1706 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
1707 unsigned long i;
1708 arelent *res;
1709
1710 if (dysymtab == NULL)
1711 return 0;
1712 if (dysymtab->nextrel == 0 && dysymtab->nlocrel == 0)
1713 return 0;
1714
1715 /* No need to go further if we don't know how to read relocs. */
bcb51645 1716 if (bed->_bfd_mach_o_canonicalize_one_reloc == NULL)
b32e07d7
TG		 1717 return 0;
1718
dff55db0 1719 if (mdata->dyn_reloc_cache == NULL)
b32e07d7 1720 {
64d29018
NC		 1721 if ((dysymtab->nextrel + dysymtab->nlocrel) * sizeof (arelent)
1722 < (dysymtab->nextrel + dysymtab->nlocrel))
1723 return -1;
1724
dff55db0 1725 res = bfd_malloc ((dysymtab->nextrel + dysymtab->nlocrel)
07d6d2b8 1726 * sizeof (arelent));
dff55db0 1727 if (res == NULL)
07d6d2b8 1728 return -1;
b32e07d7 1729
dff55db0 1730 if (bfd_mach_o_canonicalize_relocs (abfd, dysymtab->extreloff,
07d6d2b8
AM		 1731 dysymtab->nextrel, res, syms) < 0)
1732 {
1733 free (res);
1734 return -1;
1735 }
dff55db0
TG		 1736
1737 if (bfd_mach_o_canonicalize_relocs (abfd, dysymtab->locreloff,
07d6d2b8
AM		 1738 dysymtab->nlocrel,
1739 res + dysymtab->nextrel, syms) < 0)
1740 {
1741 free (res);
1742 return -1;
1743 }
dff55db0
TG		 1744
1745 mdata->dyn_reloc_cache = res;
b32e07d7
TG		 1746 }
1747
dff55db0 1748 res = mdata->dyn_reloc_cache;
b32e07d7
TG		 1749 for (i = 0; i < dysymtab->nextrel + dysymtab->nlocrel; i++)
1750 rels[i] = &res[i];
1751 rels[i] = NULL;
92bc0e80
TG		 1752 return i;
1753}
1754
19765f52
IS		 1755/* In addition to the need to byte-swap the symbol number, the bit positions
1756 of the fields in the relocation information vary per target endian-ness. */
1757
1758static void
1759bfd_mach_o_swap_out_non_scattered_reloc (bfd *abfd, unsigned char *fields,
c6643fcc 1760 bfd_mach_o_reloc_info *rel)
19765f52
IS		 1761{
1762 unsigned char info = 0;
1763
1764 BFD_ASSERT (rel->r_type <= 15);
1765 BFD_ASSERT (rel->r_length <= 3);
1766
1767 if (bfd_big_endian (abfd))
1768 {
1769 fields[0] = (rel->r_value >> 16) & 0xff;
1770 fields[1] = (rel->r_value >> 8) & 0xff;
1771 fields[2] = rel->r_value & 0xff;
1772 info |= rel->r_type << BFD_MACH_O_BE_TYPE_SHIFT;
1773 info |= rel->r_pcrel ? BFD_MACH_O_BE_PCREL : 0;
1774 info |= rel->r_length << BFD_MACH_O_BE_LENGTH_SHIFT;
1775 info |= rel->r_extern ? BFD_MACH_O_BE_EXTERN : 0;
1776 }
1777 else
1778 {
1779 fields[2] = (rel->r_value >> 16) & 0xff;
1780 fields[1] = (rel->r_value >> 8) & 0xff;
1781 fields[0] = rel->r_value & 0xff;
1782 info |= rel->r_type << BFD_MACH_O_LE_TYPE_SHIFT;
1783 info |= rel->r_pcrel ? BFD_MACH_O_LE_PCREL : 0;
1784 info |= rel->r_length << BFD_MACH_O_LE_LENGTH_SHIFT;
1785 info |= rel->r_extern ? BFD_MACH_O_LE_EXTERN : 0;
1786 }
1787 fields[3] = info;
1788}
1789
92bc0e80 1790static bfd_boolean
ab273af8 1791bfd_mach_o_write_relocs (bfd *abfd, bfd_mach_o_section *section)
92bc0e80 1792{
92bc0e80
TG		 1793 unsigned int i;
1794 arelent **entries;
1795 asection *sec;
1796 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
1797
1798 sec = section->bfdsection;
1799 if (sec->reloc_count == 0)
1800 return TRUE;
1801
1802 if (bed->_bfd_mach_o_swap_reloc_out == NULL)
1803 return TRUE;
1804
92bc0e80
TG		 1805 if (bfd_seek (abfd, section->reloff, SEEK_SET) != 0)
1806 return FALSE;
1807
1808 /* Convert and write. */
1809 entries = section->bfdsection->orelocation;
1810 for (i = 0; i < section->nreloc; i++)
1811 {
1812 arelent *rel = entries[i];
46d1c23b 1813 struct mach_o_reloc_info_external raw;
92bc0e80
TG		 1814 bfd_mach_o_reloc_info info, *pinfo = &info;
1815
1816 /* Convert relocation to an intermediate representation. */
1817 if (!(*bed->_bfd_mach_o_swap_reloc_out) (rel, pinfo))
07d6d2b8 1818 return FALSE;
92bc0e80
TG		 1819
1820 /* Lower the relocation info. */
1821 if (pinfo->r_scattered)
07d6d2b8
AM		 1822 {
1823 unsigned long v;
1824
1825 v = BFD_MACH_O_SR_SCATTERED
1826 | (pinfo->r_pcrel ? BFD_MACH_O_SR_PCREL : 0)
1827 | BFD_MACH_O_SET_SR_LENGTH (pinfo->r_length)
1828 | BFD_MACH_O_SET_SR_TYPE (pinfo->r_type)
1829 | BFD_MACH_O_SET_SR_ADDRESS (pinfo->r_address);
1830 /* Note: scattered relocs have field in reverse order... */
1831 bfd_put_32 (abfd, v, raw.r_address);
1832 bfd_put_32 (abfd, pinfo->r_value, raw.r_symbolnum);
1833 }
92bc0e80 1834 else
07d6d2b8
AM		 1835 {
1836 bfd_put_32 (abfd, pinfo->r_address, raw.r_address);
1837 bfd_mach_o_swap_out_non_scattered_reloc (abfd, raw.r_symbolnum,
19765f52 1838 pinfo);
07d6d2b8 1839 }
92bc0e80 1840
46d1c23b 1841 if (bfd_bwrite (&raw, BFD_MACH_O_RELENT_SIZE, abfd)
07d6d2b8
AM		 1842 != BFD_MACH_O_RELENT_SIZE)
1843 return FALSE;
92bc0e80
TG		 1844 }
1845 return TRUE;
1846}
1847
452216ab 1848static bfd_boolean
ab273af8 1849bfd_mach_o_write_section_32 (bfd *abfd, bfd_mach_o_section *section)
116c20d2 1850{
46d1c23b
TG		 1851 struct mach_o_section_32_external raw;
1852
1853 memcpy (raw.sectname, section->sectname, 16);
72b5104c 1854 memcpy (raw.segname, section->segname, 16);
46d1c23b
TG		 1855 bfd_h_put_32 (abfd, section->addr, raw.addr);
1856 bfd_h_put_32 (abfd, section->size, raw.size);
1857 bfd_h_put_32 (abfd, section->offset, raw.offset);
1858 bfd_h_put_32 (abfd, section->align, raw.align);
1859 bfd_h_put_32 (abfd, section->reloff, raw.reloff);
1860 bfd_h_put_32 (abfd, section->nreloc, raw.nreloc);
1861 bfd_h_put_32 (abfd, section->flags, raw.flags);
1862 bfd_h_put_32 (abfd, section->reserved1, raw.reserved1);
1863 bfd_h_put_32 (abfd, section->reserved2, raw.reserved2);
1864
1865 if (bfd_bwrite (&raw, BFD_MACH_O_SECTION_SIZE, abfd)
92bc0e80 1866 != BFD_MACH_O_SECTION_SIZE)
452216ab 1867 return FALSE;
116c20d2 1868
452216ab 1869 return TRUE;
116c20d2
NC		 1870}
1871
452216ab 1872static bfd_boolean
ab273af8 1873bfd_mach_o_write_section_64 (bfd *abfd, bfd_mach_o_section *section)
116c20d2 1874{
46d1c23b
TG		 1875 struct mach_o_section_64_external raw;
1876
1877 memcpy (raw.sectname, section->sectname, 16);
1878 memcpy (raw.segname, section->segname, 16);
1879 bfd_h_put_64 (abfd, section->addr, raw.addr);
1880 bfd_h_put_64 (abfd, section->size, raw.size);
1881 bfd_h_put_32 (abfd, section->offset, raw.offset);
1882 bfd_h_put_32 (abfd, section->align, raw.align);
1883 bfd_h_put_32 (abfd, section->reloff, raw.reloff);
1884 bfd_h_put_32 (abfd, section->nreloc, raw.nreloc);
1885 bfd_h_put_32 (abfd, section->flags, raw.flags);
1886 bfd_h_put_32 (abfd, section->reserved1, raw.reserved1);
1887 bfd_h_put_32 (abfd, section->reserved2, raw.reserved2);
1888 bfd_h_put_32 (abfd, section->reserved3, raw.reserved3);
1889
1890 if (bfd_bwrite (&raw, BFD_MACH_O_SECTION_64_SIZE, abfd)
92bc0e80 1891 != BFD_MACH_O_SECTION_64_SIZE)
452216ab 1892 return FALSE;
116c20d2 1893
452216ab 1894 return TRUE;
1e8a024a
TG		 1895}
1896
452216ab 1897static bfd_boolean
ab273af8 1898bfd_mach_o_write_segment_32 (bfd *abfd, bfd_mach_o_load_command *command)
1e8a024a 1899{
46d1c23b 1900 struct mach_o_segment_command_32_external raw;
1e8a024a 1901 bfd_mach_o_segment_command *seg = &command->command.segment;
f1bde64c 1902 bfd_mach_o_section *sec;
1e8a024a 1903
c2f09c75
TG		 1904 BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT);
1905
f1bde64c
TG		 1906 for (sec = seg->sect_head; sec != NULL; sec = sec->next)
1907 if (!bfd_mach_o_write_relocs (abfd, sec))
452216ab 1908 return FALSE;
c2f09c75 1909
46d1c23b
TG		 1910 memcpy (raw.segname, seg->segname, 16);
1911 bfd_h_put_32 (abfd, seg->vmaddr, raw.vmaddr);
1912 bfd_h_put_32 (abfd, seg->vmsize, raw.vmsize);
1913 bfd_h_put_32 (abfd, seg->fileoff, raw.fileoff);
1914 bfd_h_put_32 (abfd, seg->filesize, raw.filesize);
1915 bfd_h_put_32 (abfd, seg->maxprot, raw.maxprot);
1916 bfd_h_put_32 (abfd, seg->initprot, raw.initprot);
1917 bfd_h_put_32 (abfd, seg->nsects, raw.nsects);
1918 bfd_h_put_32 (abfd, seg->flags, raw.flags);
68ffbac6 1919
46d1c23b
TG		 1920 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
1921 || bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
452216ab 1922 return FALSE;
1e8a024a 1923
f1bde64c 1924 for (sec = seg->sect_head; sec != NULL; sec = sec->next)
452216ab
TG		 1925 if (!bfd_mach_o_write_section_32 (abfd, sec))
1926 return FALSE;
1e8a024a 1927
452216ab 1928 return TRUE;
116c20d2
NC		 1929}
1930
452216ab 1931static bfd_boolean
ab273af8 1932bfd_mach_o_write_segment_64 (bfd *abfd, bfd_mach_o_load_command *command)
1e8a024a 1933{
46d1c23b 1934 struct mach_o_segment_command_64_external raw;
c2f09c75 1935 bfd_mach_o_segment_command *seg = &command->command.segment;
f1bde64c 1936 bfd_mach_o_section *sec;
c2f09c75
TG		 1937
1938 BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT_64);
1939
f1bde64c
TG		 1940 for (sec = seg->sect_head; sec != NULL; sec = sec->next)
1941 if (!bfd_mach_o_write_relocs (abfd, sec))
452216ab 1942 return FALSE;
c2f09c75 1943
46d1c23b
TG		 1944 memcpy (raw.segname, seg->segname, 16);
1945 bfd_h_put_64 (abfd, seg->vmaddr, raw.vmaddr);
1946 bfd_h_put_64 (abfd, seg->vmsize, raw.vmsize);
1947 bfd_h_put_64 (abfd, seg->fileoff, raw.fileoff);
1948 bfd_h_put_64 (abfd, seg->filesize, raw.filesize);
1949 bfd_h_put_32 (abfd, seg->maxprot, raw.maxprot);
1950 bfd_h_put_32 (abfd, seg->initprot, raw.initprot);
1951 bfd_h_put_32 (abfd, seg->nsects, raw.nsects);
1952 bfd_h_put_32 (abfd, seg->flags, raw.flags);
1953
1954 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
1955 || bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
452216ab 1956 return FALSE;
c2f09c75 1957
f1bde64c 1958 for (sec = seg->sect_head; sec != NULL; sec = sec->next)
452216ab
TG		 1959 if (!bfd_mach_o_write_section_64 (abfd, sec))
1960 return FALSE;
c2f09c75 1961
452216ab 1962 return TRUE;
1e8a024a
TG		 1963}
1964
c2f09c75 1965static bfd_boolean
c9ffd2ea 1966bfd_mach_o_write_symtab_content (bfd *abfd, bfd_mach_o_symtab_command *sym)
116c20d2 1967{
046b007d 1968 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
116c20d2 1969 unsigned long i;
c2f09c75 1970 unsigned int wide = bfd_mach_o_wide_p (abfd);
c2f09c75
TG		 1971 struct bfd_strtab_hash *strtab;
1972 asymbol **symbols = bfd_get_outsymbols (abfd);
c9ffd2ea 1973 int padlen;
c2f09c75
TG		 1974
1975 /* Write the symbols first. */
1976 if (bfd_seek (abfd, sym->symoff, SEEK_SET) != 0)
1977 return FALSE;
1978
c2f09c75
TG		 1979 strtab = _bfd_stringtab_init ();
1980 if (strtab == NULL)
1981 return FALSE;
116c20d2 1982
a4551119
TG		 1983 if (sym->nsyms > 0)
1984 /* Although we don't strictly need to do this, for compatibility with
1985 Darwin system tools, actually output an empty string for the index
1986 0 entry. */
1987 _bfd_stringtab_add (strtab, "", TRUE, FALSE);
1988
116c20d2
NC		 1989 for (i = 0; i < sym->nsyms; i++)
1990 {
91d6fa6a 1991 bfd_size_type str_index;
92bc0e80 1992 bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *)symbols[i];
68ffbac6 1993
92bc0e80 1994 if (s->symbol.name == 0 || s->symbol.name[0] == '\0')
7f307238 1995 /* An index of 0 always means the empty string. */
07d6d2b8 1996 str_index = 0;
c2f09c75 1997 else
07d6d2b8
AM		 1998 {
1999 str_index = _bfd_stringtab_add (strtab, s->symbol.name, TRUE, FALSE);
7f307238 2000
07d6d2b8
AM		 2001 if (str_index == (bfd_size_type) -1)
2002 goto err;
2003 }
46d1c23b 2004
c2f09c75 2005 if (wide)
07d6d2b8
AM		 2006 {
2007 struct mach_o_nlist_64_external raw;
2008
2009 bfd_h_put_32 (abfd, str_index, raw.n_strx);
2010 bfd_h_put_8 (abfd, s->n_type, raw.n_type);
2011 bfd_h_put_8 (abfd, s->n_sect, raw.n_sect);
2012 bfd_h_put_16 (abfd, s->n_desc, raw.n_desc);
2013 bfd_h_put_64 (abfd, s->symbol.section->vma + s->symbol.value,
2014 raw.n_value);
2015
2016 if (bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
2017 goto err;
2018 }
c2f09c75 2019 else
07d6d2b8
AM		 2020 {
2021 struct mach_o_nlist_external raw;
116c20d2 2022
07d6d2b8
AM		 2023 bfd_h_put_32 (abfd, str_index, raw.n_strx);
2024 bfd_h_put_8 (abfd, s->n_type, raw.n_type);
2025 bfd_h_put_8 (abfd, s->n_sect, raw.n_sect);
2026 bfd_h_put_16 (abfd, s->n_desc, raw.n_desc);
2027 bfd_h_put_32 (abfd, s->symbol.section->vma + s->symbol.value,
2028 raw.n_value);
46d1c23b 2029
07d6d2b8
AM		 2030 if (bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
2031 goto err;
2032 }
116c20d2 2033 }
c2f09c75 2034 sym->strsize = _bfd_stringtab_size (strtab);
92bc0e80
TG		 2035 sym->stroff = mdata->filelen;
2036 mdata->filelen += sym->strsize;
116c20d2 2037
c9ffd2ea 2038 if (bfd_seek (abfd, sym->stroff, SEEK_SET) != 0)
64d29018 2039 goto err;
c9ffd2ea 2040
535b785f 2041 if (!_bfd_stringtab_emit (abfd, strtab))
c2f09c75 2042 goto err;
116c20d2 2043
c9ffd2ea
TG		 2044 /* Pad string table. */
2045 padlen = bfd_mach_o_pad4 (abfd, sym->strsize);
2046 if (padlen < 0)
2047 return FALSE;
2048 mdata->filelen += padlen;
2049 sym->strsize += padlen;
116c20d2 2050
c2f09c75 2051 return TRUE;
116c20d2 2052
c2f09c75
TG		 2053 err:
2054 _bfd_stringtab_free (strtab);
64d29018 2055 sym->strsize = 0;
c2f09c75 2056 return FALSE;
116c20d2
NC		 2057}
2058
c9ffd2ea
TG		 2059static bfd_boolean
2060bfd_mach_o_write_symtab (bfd *abfd, bfd_mach_o_load_command *command)
2061{
2062 bfd_mach_o_symtab_command *sym = &command->command.symtab;
2063 struct mach_o_symtab_command_external raw;
2064
2065 BFD_ASSERT (command->type == BFD_MACH_O_LC_SYMTAB);
2066
2067 /* The command. */
2068 bfd_h_put_32 (abfd, sym->symoff, raw.symoff);
2069 bfd_h_put_32 (abfd, sym->nsyms, raw.nsyms);
2070 bfd_h_put_32 (abfd, sym->stroff, raw.stroff);
2071 bfd_h_put_32 (abfd, sym->strsize, raw.strsize);
2072
2073 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0
2074 || bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
2075 return FALSE;
2076
2077 return TRUE;
2078}
2079
2080/* Count the number of indirect symbols in the image.
2081 Requires that the sections are in their final order. */
2082
2083static unsigned int
2084bfd_mach_o_count_indirect_symbols (bfd *abfd, bfd_mach_o_data_struct *mdata)
2085{
2086 unsigned int i;
2087 unsigned int nisyms = 0;
2088
2089 for (i = 0; i < mdata->nsects; ++i)
2090 {
2091 bfd_mach_o_section *sec = mdata->sections[i];
2092
2093 switch (sec->flags & BFD_MACH_O_SECTION_TYPE_MASK)
2094 {
2095 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS:
2096 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS:
2097 case BFD_MACH_O_S_SYMBOL_STUBS:
2098 nisyms += bfd_mach_o_section_get_nbr_indirect (abfd, sec);
2099 break;
2100 default:
2101 break;
2102 }
2103 }
2104 return nisyms;
2105}
2106
2107/* Create the dysymtab. */
2108
2109static bfd_boolean
2110bfd_mach_o_build_dysymtab (bfd *abfd, bfd_mach_o_dysymtab_command *cmd)
2111{
2112 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
2113
2114 /* TODO:
2115 We are not going to try and fill these in yet and, moreover, we are
2116 going to bail if they are already set. */
2117 if (cmd->nmodtab != 0
2118 || cmd->ntoc != 0
2119 || cmd->nextrefsyms != 0)
2120 {
4eca0228
AM		 2121 _bfd_error_handler (_("sorry: modtab, toc and extrefsyms are not yet"
2122 " implemented for dysymtab commands."));
c9ffd2ea
TG		 2123 return FALSE;
2124 }
2125
2126 cmd->ilocalsym = 0;
2127
2128 if (bfd_get_symcount (abfd) > 0)
2129 {
2130 asymbol **symbols = bfd_get_outsymbols (abfd);
2131 unsigned long i;
2132
2133 /* Count the number of each kind of symbol. */
2134 for (i = 0; i < bfd_get_symcount (abfd); ++i)
2135 {
2136 bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *)symbols[i];
2137 if (s->n_type & (BFD_MACH_O_N_EXT | BFD_MACH_O_N_PEXT))
2138 break;
2139 }
2140 cmd->nlocalsym = i;
2141 cmd->iextdefsym = i;
2142 for (; i < bfd_get_symcount (abfd); ++i)
2143 {
2144 bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *)symbols[i];
2145 if ((s->n_type & BFD_MACH_O_N_TYPE) == BFD_MACH_O_N_UNDF)
2146 break;
2147 }
2148 cmd->nextdefsym = i - cmd->nlocalsym;
2149 cmd->iundefsym = cmd->nextdefsym + cmd->iextdefsym;
2150 cmd->nundefsym = bfd_get_symcount (abfd)
2151 - cmd->nlocalsym
2152 - cmd->nextdefsym;
2153 }
2154 else
2155 {
2156 cmd->nlocalsym = 0;
2157 cmd->iextdefsym = 0;
2158 cmd->nextdefsym = 0;
2159 cmd->iundefsym = 0;
2160 cmd->nundefsym = 0;
2161 }
2162
2163 cmd->nindirectsyms = bfd_mach_o_count_indirect_symbols (abfd, mdata);
2164 if (cmd->nindirectsyms > 0)
2165 {
2166 unsigned i;
2167 unsigned n;
2168
2169 mdata->filelen = FILE_ALIGN (mdata->filelen, 2);
2170 cmd->indirectsymoff = mdata->filelen;
2171 mdata->filelen += cmd->nindirectsyms * 4;
2172
64d29018
NC		 2173 if (cmd->nindirectsyms * 4 < cmd->nindirectsyms)
2174 return FALSE;
c9ffd2ea
TG		 2175 cmd->indirect_syms = bfd_zalloc (abfd, cmd->nindirectsyms * 4);
2176 if (cmd->indirect_syms == NULL)
07d6d2b8 2177 return FALSE;
c9ffd2ea
TG		 2178
2179 n = 0;
2180 for (i = 0; i < mdata->nsects; ++i)
2181 {
2182 bfd_mach_o_section *sec = mdata->sections[i];
2183
2184 switch (sec->flags & BFD_MACH_O_SECTION_TYPE_MASK)
2185 {
2186 case BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS:
2187 case BFD_MACH_O_S_LAZY_SYMBOL_POINTERS:
2188 case BFD_MACH_O_S_SYMBOL_STUBS:
2189 {
2190 unsigned j, num;
2191 bfd_mach_o_asymbol **isyms = sec->indirect_syms;
2192
2193 num = bfd_mach_o_section_get_nbr_indirect (abfd, sec);
2194 if (isyms == NULL || num == 0)
2195 break;
2196 /* Record the starting index in the reserved1 field. */
2197 sec->reserved1 = n;
2198 for (j = 0; j < num; j++, n++)
2199 {
2200 if (isyms[j] == NULL)
07d6d2b8 2201 cmd->indirect_syms[n] = BFD_MACH_O_INDIRECT_SYM_LOCAL;
c9ffd2ea
TG		 2202 else if (isyms[j]->symbol.section == bfd_abs_section_ptr
2203 && ! (isyms[j]->n_type & BFD_MACH_O_N_EXT))
07d6d2b8 2204 cmd->indirect_syms[n] = BFD_MACH_O_INDIRECT_SYM_LOCAL
c9ffd2ea
TG		 2205 | BFD_MACH_O_INDIRECT_SYM_ABS;
2206 else
07d6d2b8 2207 cmd->indirect_syms[n] = isyms[j]->symbol.udata.i;
c9ffd2ea
TG		 2208 }
2209 }
2210 break;
2211 default:
2212 break;
2213 }
2214 }
2215 }
2216
2217 return TRUE;
2218}
2219
7f307238
IS		 2220/* Write a dysymtab command.
2221 TODO: Possibly coalesce writes of smaller objects. */
2222
2223static bfd_boolean
2224bfd_mach_o_write_dysymtab (bfd *abfd, bfd_mach_o_load_command *command)
2225{
2226 bfd_mach_o_dysymtab_command *cmd = &command->command.dysymtab;
2227
2228 BFD_ASSERT (command->type == BFD_MACH_O_LC_DYSYMTAB);
2229
2230 if (cmd->nmodtab != 0)
2231 {
2232 unsigned int i;
2233
2234 if (bfd_seek (abfd, cmd->modtaboff, SEEK_SET) != 0)
2235 return FALSE;
2236
2237 for (i = 0; i < cmd->nmodtab; i++)
2238 {
2239 bfd_mach_o_dylib_module *module = &cmd->dylib_module[i];
2240 unsigned int iinit;
2241 unsigned int ninit;
2242
2243 iinit = module->iinit & 0xffff;
2244 iinit |= ((module->iterm & 0xffff) << 16);
2245
2246 ninit = module->ninit & 0xffff;
2247 ninit |= ((module->nterm & 0xffff) << 16);
2248
2249 if (bfd_mach_o_wide_p (abfd))
2250 {
2251 struct mach_o_dylib_module_64_external w;
2252
2253 bfd_h_put_32 (abfd, module->module_name_idx, &w.module_name);
2254 bfd_h_put_32 (abfd, module->iextdefsym, &w.iextdefsym);
2255 bfd_h_put_32 (abfd, module->nextdefsym, &w.nextdefsym);
2256 bfd_h_put_32 (abfd, module->irefsym, &w.irefsym);
2257 bfd_h_put_32 (abfd, module->nrefsym, &w.nrefsym);
2258 bfd_h_put_32 (abfd, module->ilocalsym, &w.ilocalsym);
2259 bfd_h_put_32 (abfd, module->nlocalsym, &w.nlocalsym);
2260 bfd_h_put_32 (abfd, module->iextrel, &w.iextrel);
2261 bfd_h_put_32 (abfd, module->nextrel, &w.nextrel);
2262 bfd_h_put_32 (abfd, iinit, &w.iinit_iterm);
2263 bfd_h_put_32 (abfd, ninit, &w.ninit_nterm);
2264 bfd_h_put_64 (abfd, module->objc_module_info_addr,
2265 &w.objc_module_info_addr);
2266 bfd_h_put_32 (abfd, module->objc_module_info_size,
2267 &w.objc_module_info_size);
2268
2269 if (bfd_bwrite ((void *) &w, sizeof (w), abfd) != sizeof (w))
2270 return FALSE;
2271 }
2272 else
2273 {
2274 struct mach_o_dylib_module_external n;
2275
2276 bfd_h_put_32 (abfd, module->module_name_idx, &n.module_name);
2277 bfd_h_put_32 (abfd, module->iextdefsym, &n.iextdefsym);
2278 bfd_h_put_32 (abfd, module->nextdefsym, &n.nextdefsym);
2279 bfd_h_put_32 (abfd, module->irefsym, &n.irefsym);
2280 bfd_h_put_32 (abfd, module->nrefsym, &n.nrefsym);
2281 bfd_h_put_32 (abfd, module->ilocalsym, &n.ilocalsym);
2282 bfd_h_put_32 (abfd, module->nlocalsym, &n.nlocalsym);
2283 bfd_h_put_32 (abfd, module->iextrel, &n.iextrel);
2284 bfd_h_put_32 (abfd, module->nextrel, &n.nextrel);
2285 bfd_h_put_32 (abfd, iinit, &n.iinit_iterm);
2286 bfd_h_put_32 (abfd, ninit, &n.ninit_nterm);
2287 bfd_h_put_32 (abfd, module->objc_module_info_addr,
2288 &n.objc_module_info_addr);
2289 bfd_h_put_32 (abfd, module->objc_module_info_size,
2290 &n.objc_module_info_size);
2291
2292 if (bfd_bwrite ((void *) &n, sizeof (n), abfd) != sizeof (n))
2293 return FALSE;
2294 }
2295 }
2296 }
2297
2298 if (cmd->ntoc != 0)
2299 {
2300 unsigned int i;
2301
2302 if (bfd_seek (abfd, cmd->tocoff, SEEK_SET) != 0)
2303 return FALSE;
2304
2305 for (i = 0; i < cmd->ntoc; i++)
2306 {
2307 struct mach_o_dylib_table_of_contents_external raw;
2308 bfd_mach_o_dylib_table_of_content *toc = &cmd->dylib_toc[i];
2309
2310 bfd_h_put_32 (abfd, toc->symbol_index, &raw.symbol_index);
2311 bfd_h_put_32 (abfd, toc->module_index, &raw.module_index);
2312
2313 if (bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
2314 return FALSE;
2315 }
2316 }
68ffbac6 2317
7f307238
IS		 2318 if (cmd->nindirectsyms > 0)
2319 {
2320 unsigned int i;
2321
2322 if (bfd_seek (abfd, cmd->indirectsymoff, SEEK_SET) != 0)
2323 return FALSE;
2324
2325 for (i = 0; i < cmd->nindirectsyms; ++i)
2326 {
2327 unsigned char raw[4];
2328
2329 bfd_h_put_32 (abfd, cmd->indirect_syms[i], &raw);
2330 if (bfd_bwrite (raw, sizeof (raw), abfd) != sizeof (raw))
2331 return FALSE;
68ffbac6 2332 }
7f307238
IS		 2333 }
2334
2335 if (cmd->nextrefsyms != 0)
2336 {
2337 unsigned int i;
2338
2339 if (bfd_seek (abfd, cmd->extrefsymoff, SEEK_SET) != 0)
2340 return FALSE;
2341
2342 for (i = 0; i < cmd->nextrefsyms; i++)
2343 {
2344 unsigned long v;
2345 unsigned char raw[4];
2346 bfd_mach_o_dylib_reference *ref = &cmd->ext_refs[i];
2347
2348 /* Fields isym and flags are written as bit-fields, thus we need
2349 a specific processing for endianness. */
2350
2351 if (bfd_big_endian (abfd))
2352 {
2353 v = ((ref->isym & 0xffffff) << 8);
2354 v |= ref->flags & 0xff;
2355 }
2356 else
2357 {
2358 v = ref->isym & 0xffffff;
2359 v |= ((ref->flags & 0xff) << 24);
2360 }
2361
2362 bfd_h_put_32 (abfd, v, raw);
2363 if (bfd_bwrite (raw, sizeof (raw), abfd) != sizeof (raw))
2364 return FALSE;
2365 }
2366 }
2367
2368 /* The command. */
2369 if (bfd_seek (abfd, command->offset + BFD_MACH_O_LC_SIZE, SEEK_SET) != 0)
2370 return FALSE;
2371 else
2372 {
2373 struct mach_o_dysymtab_command_external raw;
2374
2375 bfd_h_put_32 (abfd, cmd->ilocalsym, &raw.ilocalsym);
2376 bfd_h_put_32 (abfd, cmd->nlocalsym, &raw.nlocalsym);
2377 bfd_h_put_32 (abfd, cmd->iextdefsym, &raw.iextdefsym);
2378 bfd_h_put_32 (abfd, cmd->nextdefsym, &raw.nextdefsym);
2379 bfd_h_put_32 (abfd, cmd->iundefsym, &raw.iundefsym);
2380 bfd_h_put_32 (abfd, cmd->nundefsym, &raw.nundefsym);
2381 bfd_h_put_32 (abfd, cmd->tocoff, &raw.tocoff);
2382 bfd_h_put_32 (abfd, cmd->ntoc, &raw.ntoc);
2383 bfd_h_put_32 (abfd, cmd->modtaboff, &raw.modtaboff);
2384 bfd_h_put_32 (abfd, cmd->nmodtab, &raw.nmodtab);
2385 bfd_h_put_32 (abfd, cmd->extrefsymoff, &raw.extrefsymoff);
2386 bfd_h_put_32 (abfd, cmd->nextrefsyms, &raw.nextrefsyms);
2387 bfd_h_put_32 (abfd, cmd->indirectsymoff, &raw.indirectsymoff);
2388 bfd_h_put_32 (abfd, cmd->nindirectsyms, &raw.nindirectsyms);
2389 bfd_h_put_32 (abfd, cmd->extreloff, &raw.extreloff);
2390 bfd_h_put_32 (abfd, cmd->nextrel, &raw.nextrel);
2391 bfd_h_put_32 (abfd, cmd->locreloff, &raw.locreloff);
2392 bfd_h_put_32 (abfd, cmd->nlocrel, &raw.nlocrel);
2393
2394 if (bfd_bwrite (&raw, sizeof (raw), abfd) != sizeof (raw))
2395 return FALSE;
2396 }
2397
2398 return TRUE;
2399}
2400
2401static unsigned
b22161d6 2402bfd_mach_o_primary_symbol_sort_key (bfd_mach_o_asymbol *s)
7f307238 2403{
b22161d6 2404 unsigned mtyp = s->n_type & BFD_MACH_O_N_TYPE;
68588f95
IS		 2405
2406 /* Just leave debug symbols where they are (pretend they are local, and
2407 then they will just be sorted on position). */
b22161d6 2408 if (s->n_type & BFD_MACH_O_N_STAB)
68588f95
IS		 2409 return 0;
2410
7f307238 2411 /* Local (we should never see an undefined local AFAICT). */
b22161d6 2412 if (! (s->n_type & (BFD_MACH_O_N_EXT | BFD_MACH_O_N_PEXT)))
7f307238
IS		 2413 return 0;
2414
2415 /* Common symbols look like undefined externs. */
68588f95 2416 if (mtyp == BFD_MACH_O_N_UNDF)
7f307238
IS		 2417 return 2;
2418
b22161d6 2419 /* A defined non-local, non-debug symbol. */
7f307238
IS		 2420 return 1;
2421}
2422
2423static int
2424bfd_mach_o_cf_symbols (const void *a, const void *b)
2425{
2426 bfd_mach_o_asymbol *sa = *(bfd_mach_o_asymbol **) a;
2427 bfd_mach_o_asymbol *sb = *(bfd_mach_o_asymbol **) b;
2428 unsigned int soa, sob;
2429
b22161d6
IS		 2430 soa = bfd_mach_o_primary_symbol_sort_key (sa);
2431 sob = bfd_mach_o_primary_symbol_sort_key (sb);
7f307238
IS		 2432 if (soa < sob)
2433 return -1;
2434
2435 if (soa > sob)
2436 return 1;
2437
68588f95 2438 /* If it's local or stab, just preserve the input order. */
7f307238
IS		 2439 if (soa == 0)
2440 {
2441 if (sa->symbol.udata.i < sb->symbol.udata.i)
07d6d2b8 2442 return -1;
7f307238 2443 if (sa->symbol.udata.i > sb->symbol.udata.i)
07d6d2b8 2444 return 1;
b22161d6
IS		 2445
2446 /* This is probably an error. */
7f307238
IS		 2447 return 0;
2448 }
2449
b22161d6
IS		 2450 /* The second sort key is name. */
2451 return strcmp (sa->symbol.name, sb->symbol.name);
7f307238
IS		 2452}
2453
2454/* Process the symbols.
2455
2456 This should be OK for single-module files - but it is not likely to work
2457 for multi-module shared libraries.
2458
2459 (a) If the application has not filled in the relevant mach-o fields, make
2460 an estimate.
2461
2462 (b) Order them, like this:
2463 ( i) local.
2464 (unsorted)
2465 ( ii) external defined
2466 (by name)
b22161d6 2467 (iii) external undefined/common
7f307238
IS		 2468 (by name)
2469 ( iv) common
2470 (by name)
b22161d6 2471*/
92bc0e80
TG		 2472
2473static bfd_boolean
b22161d6 2474bfd_mach_o_mangle_symbols (bfd *abfd)
92bc0e80
TG		 2475{
2476 unsigned long i;
2477 asymbol **symbols = bfd_get_outsymbols (abfd);
2478
7f307238
IS		 2479 if (symbols == NULL || bfd_get_symcount (abfd) == 0)
2480 return TRUE;
2481
92bc0e80
TG		 2482 for (i = 0; i < bfd_get_symcount (abfd); i++)
2483 {
2484 bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *)symbols[i];
2485
b22161d6
IS		 2486 /* We use this value, which is out-of-range as a symbol index, to signal
2487 that the mach-o-specific data are not filled in and need to be created
2488 from the bfd values. It is much preferable for the application to do
2489 this, since more meaningful diagnostics can be made that way. */
2490
2491 if (s->symbol.udata.i == SYM_MACHO_FIELDS_UNSET)
07d6d2b8
AM		 2492 {
2493 /* No symbol information has been set - therefore determine
2494 it from the bfd symbol flags/info. */
2495 if (s->symbol.section == bfd_abs_section_ptr)
2496 s->n_type = BFD_MACH_O_N_ABS;
2497 else if (s->symbol.section == bfd_und_section_ptr)
2498 {
2499 s->n_type = BFD_MACH_O_N_UNDF;
2500 if (s->symbol.flags & BSF_WEAK)
2501 s->n_desc |= BFD_MACH_O_N_WEAK_REF;
2502 /* mach-o automatically makes undefined symbols extern. */
7f307238 2503 s->n_type |= BFD_MACH_O_N_EXT;
b22161d6 2504 s->symbol.flags |= BSF_GLOBAL;
07d6d2b8
AM		 2505 }
2506 else if (s->symbol.section == bfd_com_section_ptr)
b22161d6 2507 {
07d6d2b8
AM		 2508 s->n_type = BFD_MACH_O_N_UNDF | BFD_MACH_O_N_EXT;
2509 s->symbol.flags |= BSF_GLOBAL;
2510 }
2511 else
2512 s->n_type = BFD_MACH_O_N_SECT;
07d6d2b8 2513 }
92bc0e80 2514
ae19acf3 2515 /* Update external symbol bit in case objcopy changed it. */
2516 if (s->symbol.flags & BSF_GLOBAL)
2517 s->n_type |= BFD_MACH_O_N_EXT;
2518 else
2519 s->n_type &= ~BFD_MACH_O_N_EXT;
2520
7f307238 2521 /* Put the section index in, where required. */
68588f95 2522 if ((s->symbol.section != bfd_abs_section_ptr
07d6d2b8
AM		 2523 && s->symbol.section != bfd_und_section_ptr
2524 && s->symbol.section != bfd_com_section_ptr)
2525 || ((s->n_type & BFD_MACH_O_N_STAB) != 0
2526 && s->symbol.name == NULL))
707e555b 2527 s->n_sect = s->symbol.section->output_section->target_index;
92bc0e80 2528
b22161d6
IS		 2529 /* Number to preserve order for local and debug syms. */
2530 s->symbol.udata.i = i;
7f307238
IS		 2531 }
2532
b22161d6
IS		 2533 /* Sort the symbols. */
2534 qsort ((void *) symbols, (size_t) bfd_get_symcount (abfd),
2535 sizeof (asymbol *), bfd_mach_o_cf_symbols);
7f307238 2536
b22161d6
IS		 2537 for (i = 0; i < bfd_get_symcount (abfd); ++i)
2538 {
2539 bfd_mach_o_asymbol *s = (bfd_mach_o_asymbol *)symbols[i];
2540 s->symbol.udata.i = i; /* renumber. */
7f307238
IS		 2541 }
2542
2543 return TRUE;
2544}
2545
2546/* We build a flat table of sections, which can be re-ordered if necessary.
2547 Fill in the section number and other mach-o-specific data. */
2548
2549static bfd_boolean
2550bfd_mach_o_mangle_sections (bfd *abfd, bfd_mach_o_data_struct *mdata)
2551{
2552 asection *sec;
2553 unsigned target_index;
2554 unsigned nsect;
2555
2556 nsect = bfd_count_sections (abfd);
68ffbac6 2557
7f307238
IS		 2558 /* Don't do it if it's already set - assume the application knows what it's
2559 doing. */
2560 if (mdata->nsects == nsect
2561 && (mdata->nsects == 0 || mdata->sections != NULL))
2562 return TRUE;
2563
a1165289
NC		 2564 /* We need to check that this can be done... */
2565 if (nsect > 255)
2566 {
4eca0228
AM		 2567 _bfd_error_handler (_("mach-o: there are too many sections (%u)"
2568 " maximum is 255,\n"), nsect);
a1165289
NC		 2569 return FALSE;
2570 }
2571
7f307238 2572 mdata->nsects = nsect;
64d29018
NC		 2573 mdata->sections = bfd_alloc2 (abfd,
2574 mdata->nsects, sizeof (bfd_mach_o_section *));
7f307238
IS		 2575 if (mdata->sections == NULL)
2576 return FALSE;
2577
7f307238 2578 /* Create Mach-O sections.
68ffbac6 2579 Section type, attribute and align should have been set when the
7f307238
IS		 2580 section was created - either read in or specified. */
2581 target_index = 0;
2582 for (sec = abfd->sections; sec; sec = sec->next)
2583 {
2584 unsigned bfd_align = bfd_get_section_alignment (abfd, sec);
2585 bfd_mach_o_section *msect = bfd_mach_o_get_mach_o_section (sec);
2586
2587 mdata->sections[target_index] = msect;
2588
2589 msect->addr = bfd_get_section_vma (abfd, sec);
2590 msect->size = bfd_get_section_size (sec);
2591
68ffbac6 2592 /* Use the largest alignment set, in case it was bumped after the
7f307238
IS		 2593 section was created. */
2594 msect->align = msect->align > bfd_align ? msect->align : bfd_align;
2595
2596 msect->offset = 0;
2597 sec->target_index = ++target_index;
92bc0e80 2598 }
7f307238 2599
92bc0e80
TG		 2600 return TRUE;
2601}
2602
154a1ee5 2603bfd_boolean
116c20d2 2604bfd_mach_o_write_contents (bfd *abfd)
3af9a47b 2605{
046b007d 2606 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
c9ffd2ea
TG		 2607 bfd_mach_o_load_command *cmd;
2608 bfd_mach_o_symtab_command *symtab = NULL;
2609 bfd_mach_o_dysymtab_command *dysymtab = NULL;
2610 bfd_mach_o_segment_command *linkedit = NULL;
3af9a47b 2611
7f307238 2612 /* Make the commands, if not already present. */
c9ffd2ea
TG		 2613 if (!abfd->output_has_begun && !bfd_mach_o_build_commands (abfd))
2614 return FALSE;
2615 abfd->output_has_begun = TRUE;
92bc0e80 2616
c9ffd2ea 2617 /* Write the header. */
154a1ee5 2618 if (!bfd_mach_o_write_header (abfd, &mdata->header))
b34976b6 2619 return FALSE;
3af9a47b 2620
c9ffd2ea
TG		 2621 /* First pass: allocate the linkedit segment. */
2622 for (cmd = mdata->first_command; cmd != NULL; cmd = cmd->next)
2623 switch (cmd->type)
2624 {
2625 case BFD_MACH_O_LC_SEGMENT_64:
2626 case BFD_MACH_O_LC_SEGMENT:
2627 if (strcmp (cmd->command.segment.segname, "__LINKEDIT") == 0)
2628 linkedit = &cmd->command.segment;
2629 break;
2630 case BFD_MACH_O_LC_SYMTAB:
2631 symtab = &cmd->command.symtab;
2632 break;
2633 case BFD_MACH_O_LC_DYSYMTAB:
2634 dysymtab = &cmd->command.dysymtab;
2635 break;
2636 case BFD_MACH_O_LC_DYLD_INFO:
2637 {
2638 bfd_mach_o_dyld_info_command *di = &cmd->command.dyld_info;
2639
2640 if (di->rebase_size != 0)
2641 {
2642 di->rebase_off = mdata->filelen;
2643 mdata->filelen += di->rebase_size;
2644 }
2645 if (di->bind_size != 0)
2646 {
2647 di->bind_off = mdata->filelen;
2648 mdata->filelen += di->bind_size;
2649 }
2650 if (di->weak_bind_size != 0)
2651 {
2652 di->weak_bind_off = mdata->filelen;
2653 mdata->filelen += di->weak_bind_size;
2654 }
2655 if (di->lazy_bind_size != 0)
2656 {
2657 di->lazy_bind_off = mdata->filelen;
2658 mdata->filelen += di->lazy_bind_size;
2659 }
2660 if (di->export_size != 0)
2661 {
2662 di->export_off = mdata->filelen;
2663 mdata->filelen += di->export_size;
2664 }
2665 }
2666 break;
2667 case BFD_MACH_O_LC_LOAD_DYLIB:
2668 case BFD_MACH_O_LC_LOAD_DYLINKER:
2669 case BFD_MACH_O_LC_MAIN:
2670 /* Nothing to do. */
2671 break;
2672 default:
4eca0228 2673 _bfd_error_handler
d42c267e
AM		 2674 (_("unable to allocate data for load command %#x"),
2675 cmd->type);
c9ffd2ea
TG		 2676 break;
2677 }
2678
2679 /* Specially handle symtab and dysymtab. */
2680
2681 /* Pre-allocate the symbol table (but not the string table). The reason
2682 is that the dysymtab is after the symbol table but before the string
2683 table (required by the native strip tool). */
2684 if (symtab != NULL)
2685 {
2686 unsigned int symlen;
2687 unsigned int wide = bfd_mach_o_wide_p (abfd);
2688
2689 symlen = wide ? BFD_MACH_O_NLIST_64_SIZE : BFD_MACH_O_NLIST_SIZE;
2690
2691 /* Align for symbols. */
2692 mdata->filelen = FILE_ALIGN (mdata->filelen, wide ? 3 : 2);
2693 symtab->symoff = mdata->filelen;
2694
2695 symtab->nsyms = bfd_get_symcount (abfd);
2696 mdata->filelen += symtab->nsyms * symlen;
2697 }
2698
2699 /* Build the dysymtab. */
2700 if (dysymtab != NULL)
2701 if (!bfd_mach_o_build_dysymtab (abfd, dysymtab))
2702 return FALSE;
2703
2704 /* Write symtab and strtab. */
2705 if (symtab != NULL)
2706 if (!bfd_mach_o_write_symtab_content (abfd, symtab))
2707 return FALSE;
2708
2709 /* Adjust linkedit size. */
2710 if (linkedit != NULL)
2711 {
2712 /* bfd_vma pagemask = bfd_mach_o_get_backend_data (abfd)->page_size - 1; */
2713
2714 linkedit->vmsize = mdata->filelen - linkedit->fileoff;
2715 /* linkedit->vmsize = (linkedit->vmsize + pagemask) & ~pagemask; */
2716 linkedit->filesize = mdata->filelen - linkedit->fileoff;
2717
2718 linkedit->initprot = BFD_MACH_O_PROT_READ;
2719 linkedit->maxprot = BFD_MACH_O_PROT_READ | BFD_MACH_O_PROT_WRITE
2720 | BFD_MACH_O_PROT_EXECUTE;
2721 }
2722
2723 /* Second pass: write commands. */
2724 for (cmd = mdata->first_command; cmd != NULL; cmd = cmd->next)
3af9a47b 2725 {
46d1c23b 2726 struct mach_o_load_command_external raw;
3af9a47b
NC		 2727 unsigned long typeflag;
2728
c9ffd2ea 2729 typeflag = cmd->type | (cmd->type_required ? BFD_MACH_O_LC_REQ_DYLD : 0);
3af9a47b 2730
46d1c23b 2731 bfd_h_put_32 (abfd, typeflag, raw.cmd);
c9ffd2ea 2732 bfd_h_put_32 (abfd, cmd->len, raw.cmdsize);
3af9a47b 2733
c9ffd2ea 2734 if (bfd_seek (abfd, cmd->offset, SEEK_SET) != 0
07d6d2b8 2735 || bfd_bwrite (&raw, BFD_MACH_O_LC_SIZE, abfd) != 8)
b34976b6 2736 return FALSE;
3af9a47b 2737
c9ffd2ea 2738 switch (cmd->type)
3af9a47b
NC		 2739 {
2740 case BFD_MACH_O_LC_SEGMENT:
c9ffd2ea 2741 if (!bfd_mach_o_write_segment_32 (abfd, cmd))
1e8a024a
TG		 2742 return FALSE;
2743 break;
2744 case BFD_MACH_O_LC_SEGMENT_64:
c9ffd2ea 2745 if (!bfd_mach_o_write_segment_64 (abfd, cmd))
b34976b6 2746 return FALSE;
3af9a47b
NC		 2747 break;
2748 case BFD_MACH_O_LC_SYMTAB:
c9ffd2ea 2749 if (!bfd_mach_o_write_symtab (abfd, cmd))
b34976b6 2750 return FALSE;
3af9a47b 2751 break;
7f307238 2752 case BFD_MACH_O_LC_DYSYMTAB:
c9ffd2ea 2753 if (!bfd_mach_o_write_dysymtab (abfd, cmd))
7f307238
IS		 2754 return FALSE;
2755 break;
3af9a47b
NC		 2756 case BFD_MACH_O_LC_THREAD:
2757 case BFD_MACH_O_LC_UNIXTHREAD:
c9ffd2ea 2758 if (!bfd_mach_o_write_thread (abfd, cmd))
b34976b6 2759 return FALSE;
3af9a47b 2760 break;
3af9a47b 2761 case BFD_MACH_O_LC_LOAD_DYLIB:
c9ffd2ea
TG		 2762 if (!bfd_mach_o_write_dylib (abfd, cmd))
2763 return FALSE;
2764 break;
3af9a47b 2765 case BFD_MACH_O_LC_LOAD_DYLINKER:
c9ffd2ea
TG		 2766 if (!bfd_mach_o_write_dylinker (abfd, cmd))
2767 return FALSE;
2768 break;
2769 case BFD_MACH_O_LC_MAIN:
2770 if (!bfd_mach_o_write_main (abfd, cmd))
2771 return FALSE;
2772 break;
2773 case BFD_MACH_O_LC_DYLD_INFO:
2774 if (!bfd_mach_o_write_dyld_info (abfd, cmd))
2775 return FALSE;
3af9a47b
NC		 2776 break;
2777 default:
4eca0228 2778 _bfd_error_handler
d42c267e
AM		 2779 (_("unable to write unknown load command %#x"),
2780 cmd->type);
b34976b6 2781 return FALSE;
3af9a47b
NC		 2782 }
2783 }
2784
b34976b6 2785 return TRUE;
3af9a47b
NC		 2786}
2787
f1bde64c
TG		 2788static void
2789bfd_mach_o_append_section_to_segment (bfd_mach_o_segment_command *seg,
07d6d2b8 2790 bfd_mach_o_section *s)
f1bde64c 2791{
f1bde64c
TG		 2792 if (seg->sect_head == NULL)
2793 seg->sect_head = s;
2794 else
2795 seg->sect_tail->next = s;
2796 seg->sect_tail = s;
2797}
2798
2799/* Create section Mach-O flags from BFD flags. */
2800
2801static void
3cc27770
TG		 2802bfd_mach_o_set_section_flags_from_bfd (bfd *abfd ATTRIBUTE_UNUSED,
2803 asection *sec)
f1bde64c
TG		 2804{
2805 flagword bfd_flags;
2806 bfd_mach_o_section *s = bfd_mach_o_get_mach_o_section (sec);
2807
2808 /* Create default flags. */
2809 bfd_flags = bfd_get_section_flags (abfd, sec);
2810 if ((bfd_flags & SEC_CODE) == SEC_CODE)
2811 s->flags = BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS
2812 | BFD_MACH_O_S_ATTR_SOME_INSTRUCTIONS
2813 | BFD_MACH_O_S_REGULAR;
2814 else if ((bfd_flags & (SEC_ALLOC | SEC_LOAD)) == SEC_ALLOC)
2815 s->flags = BFD_MACH_O_S_ZEROFILL;
2816 else if (bfd_flags & SEC_DEBUGGING)
2817 s->flags = BFD_MACH_O_S_REGULAR | BFD_MACH_O_S_ATTR_DEBUG;
2818 else
2819 s->flags = BFD_MACH_O_S_REGULAR;
2820}
2821
7f307238 2822static bfd_boolean
c9ffd2ea 2823bfd_mach_o_build_obj_seg_command (bfd *abfd, bfd_mach_o_segment_command *seg)
7f307238 2824{
c9ffd2ea
TG		 2825 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
2826 unsigned int i, j;
7f307238 2827
7f307238 2828 seg->vmaddr = 0;
7f307238 2829 seg->fileoff = mdata->filelen;
c9ffd2ea
TG		 2830 seg->initprot = BFD_MACH_O_PROT_READ | BFD_MACH_O_PROT_WRITE
2831 | BFD_MACH_O_PROT_EXECUTE;
2832 seg->maxprot = seg->initprot;
7f307238 2833
68ffbac6 2834 /* Append sections to the segment.
09903f4b
IS		 2835
2836 This is a little tedious, we have to honor the need to account zerofill
2837 sections after all the rest. This forces us to do the calculation of
68ffbac6 2838 total vmsize in three passes so that any alignment increments are
09903f4b 2839 properly accounted. */
7f307238
IS		 2840 for (i = 0; i < mdata->nsects; ++i)
2841 {
2842 bfd_mach_o_section *s = mdata->sections[i];
2843 asection *sec = s->bfdsection;
2844
09903f4b
IS		 2845 /* Although we account for zerofill section sizes in vm order, they are
2846 placed in the file in source sequence. */
c9ffd2ea 2847 bfd_mach_o_append_section_to_segment (seg, s);
e5081f2f 2848 s->offset = 0;
68ffbac6 2849
c9ffd2ea
TG		 2850 /* Zerofill sections have zero file size & offset, the only content
2851 written to the file is the symbols. */
e5081f2f 2852 if ((s->flags & BFD_MACH_O_SECTION_TYPE_MASK) == BFD_MACH_O_S_ZEROFILL
07d6d2b8 2853 || ((s->flags & BFD_MACH_O_SECTION_TYPE_MASK)
c9ffd2ea 2854 == BFD_MACH_O_S_GB_ZEROFILL))
07d6d2b8 2855 continue;
e5081f2f 2856
c9ffd2ea
TG		 2857 /* The Darwin system tools (in MH_OBJECT files, at least) always account
2858 sections, even those with zero size. */
e5081f2f 2859 if (s->size > 0)
c9ffd2ea 2860 {
09903f4b
IS		 2861 seg->vmsize = FILE_ALIGN (seg->vmsize, s->align);
2862 seg->vmsize += s->size;
2863
c9ffd2ea
TG		 2864 /* MH_OBJECT files have unaligned content. */
2865 if (1)
2866 {
2867 seg->filesize = FILE_ALIGN (seg->filesize, s->align);
07d6d2b8
AM		 2868 mdata->filelen = FILE_ALIGN (mdata->filelen, s->align);
2869 }
09903f4b
IS		 2870 seg->filesize += s->size;
2871
c9ffd2ea
TG		 2872 /* The system tools write even zero-sized sections with an offset
2873 field set to the current file position. */
07d6d2b8 2874 s->offset = mdata->filelen;
c9ffd2ea 2875 }
7f307238
IS		 2876
2877 sec->filepos = s->offset;
7f307238
IS		 2878 mdata->filelen += s->size;
2879 }
2880
3cc27770 2881 /* Now pass through again, for zerofill, only now we just update the
c9ffd2ea
TG		 2882 vmsize, and then for zerofill_GB. */
2883 for (j = 0; j < 2; j++)
09903f4b 2884 {
c9ffd2ea 2885 unsigned int stype;
68ffbac6 2886
c9ffd2ea
TG		 2887 if (j == 0)
2888 stype = BFD_MACH_O_S_ZEROFILL;
2889 else
2890 stype = BFD_MACH_O_S_GB_ZEROFILL;
09903f4b 2891
c9ffd2ea
TG		 2892 for (i = 0; i < mdata->nsects; ++i)
2893 {
2894 bfd_mach_o_section *s = mdata->sections[i];
2895
2896 if ((s->flags & BFD_MACH_O_SECTION_TYPE_MASK) != stype)
2897 continue;
2898
2899 if (s->size > 0)
2900 {
2901 seg->vmsize = FILE_ALIGN (seg->vmsize, s->align);
2902 seg->vmsize += s->size;
2903 }
09903f4b
IS		 2904 }
2905 }
bb76d940 2906
09903f4b 2907 /* Allocate space for the relocations. */
707e555b 2908 mdata->filelen = FILE_ALIGN (mdata->filelen, 2);
bb76d940
IS		 2909
2910 for (i = 0; i < mdata->nsects; ++i)
2911 {
2912 bfd_mach_o_section *ms = mdata->sections[i];
2913 asection *sec = ms->bfdsection;
68ffbac6 2914
c9ffd2ea
TG		 2915 ms->nreloc = sec->reloc_count;
2916 if (ms->nreloc == 0)
07d6d2b8 2917 {
c9ffd2ea 2918 /* Clear nreloc and reloff if there is no relocs. */
bb76d940
IS		 2919 ms->reloff = 0;
2920 continue;
07d6d2b8 2921 }
bb76d940
IS		 2922 sec->rel_filepos = mdata->filelen;
2923 ms->reloff = sec->rel_filepos;
2924 mdata->filelen += sec->reloc_count * BFD_MACH_O_RELENT_SIZE;
2925 }
7f307238
IS		 2926
2927 return TRUE;
2928}
2929
c9ffd2ea
TG		 2930static bfd_boolean
2931bfd_mach_o_build_exec_seg_command (bfd *abfd, bfd_mach_o_segment_command *seg)
50d10658 2932{
c9ffd2ea 2933 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
50d10658 2934 unsigned int i;
c9ffd2ea
TG		 2935 bfd_vma pagemask = bfd_mach_o_get_backend_data (abfd)->page_size - 1;
2936 bfd_vma vma;
2937 bfd_mach_o_section *s;
2938
2939 seg->vmsize = 0;
50d10658 2940
c9ffd2ea
TG		 2941 seg->fileoff = mdata->filelen;
2942 seg->maxprot = 0;
2943 seg->initprot = 0;
2944 seg->flags = 0;
2945
2946 /* Append sections to the segment. We assume they are properly ordered
2947 by vma (but we check that). */
2948 vma = 0;
50d10658
IS		 2949 for (i = 0; i < mdata->nsects; ++i)
2950 {
c9ffd2ea 2951 s = mdata->sections[i];
50d10658 2952
c9ffd2ea
TG		 2953 /* Consider only sections for this segment. */
2954 if (strcmp (seg->segname, s->segname) != 0)
2955 continue;
50d10658 2956
c9ffd2ea 2957 bfd_mach_o_append_section_to_segment (seg, s);
7f307238 2958
86eafac0
NC		 2959 if (s->addr < vma)
2960 {
4eca0228 2961 _bfd_error_handler
695344c0 2962 /* xgettext:c-format */
2dcf00ce
AM		 2963 (_("section address (%#" PRIx64 ") "
2964 "below start of segment (%#" PRIx64 ")"),
2965 (uint64_t) s->addr, (uint64_t) vma);
86eafac0
NC		 2966 return FALSE;
2967 }
2968
c9ffd2ea 2969 vma = s->addr + s->size;
7f307238
IS		 2970 }
2971
c9ffd2ea
TG		 2972 /* Set segment file offset: make it page aligned. */
2973 vma = seg->sect_head->addr;
2974 seg->vmaddr = vma & ~pagemask;
2975 if ((mdata->filelen & pagemask) > (vma & pagemask))
2976 mdata->filelen += pagemask + 1;
2977 seg->fileoff = mdata->filelen & ~pagemask;
2978 mdata->filelen = seg->fileoff + (vma & pagemask);
7f307238 2979
c9ffd2ea
TG		 2980 /* Set section file offset. */
2981 for (s = seg->sect_head; s != NULL; s = s->next)
7f307238 2982 {
c9ffd2ea
TG		 2983 asection *sec = s->bfdsection;
2984 flagword flags = bfd_get_section_flags (abfd, sec);
b22161d6 2985
c9ffd2ea
TG		 2986 /* Adjust segment size. */
2987 seg->vmsize = FILE_ALIGN (seg->vmsize, s->align);
2988 seg->vmsize += s->size;
2989
2990 /* File offset and length. */
2991 seg->filesize = FILE_ALIGN (seg->filesize, s->align);
2992
2993 if ((s->flags & BFD_MACH_O_SECTION_TYPE_MASK) != BFD_MACH_O_S_ZEROFILL
07d6d2b8 2994 && ((s->flags & BFD_MACH_O_SECTION_TYPE_MASK)
c9ffd2ea 2995 != BFD_MACH_O_S_GB_ZEROFILL))
b22161d6 2996 {
c9ffd2ea
TG		 2997 mdata->filelen = FILE_ALIGN (mdata->filelen, s->align);
2998
2999 s->offset = mdata->filelen;
3000 s->bfdsection->filepos = s->offset;
3001
3002 seg->filesize += s->size;
3003 mdata->filelen += s->size;
b22161d6 3004 }
c9ffd2ea 3005 else
b22161d6 3006 {
c9ffd2ea
TG		 3007 s->offset = 0;
3008 s->bfdsection->filepos = 0;
3009 }
3010
3011 /* Set protection. */
3012 if (flags & SEC_LOAD)
3013 {
3014 if (flags & SEC_CODE)
3015 seg->initprot |= BFD_MACH_O_PROT_READ | BFD_MACH_O_PROT_EXECUTE;
3016 if ((flags & (SEC_DATA | SEC_READONLY)) == SEC_DATA)
3017 seg->initprot |= BFD_MACH_O_PROT_WRITE | BFD_MACH_O_PROT_READ;
b22161d6 3018 }
c9ffd2ea
TG		 3019
3020 /* Relocs shouldn't appear in non-object files. */
3021 if (s->bfdsection->reloc_count != 0)
3022 return FALSE;
b22161d6 3023 }
c9ffd2ea
TG		 3024
3025 /* Set maxprot. */
3026 if (seg->initprot != 0)
3027 seg->maxprot = BFD_MACH_O_PROT_READ | BFD_MACH_O_PROT_WRITE
3028 | BFD_MACH_O_PROT_EXECUTE;
b22161d6 3029 else
c9ffd2ea 3030 seg->maxprot = 0;
b22161d6 3031
c9ffd2ea
TG		 3032 /* Round segment size (and file size). */
3033 seg->vmsize = (seg->vmsize + pagemask) & ~pagemask;
3034 seg->filesize = (seg->filesize + pagemask) & ~pagemask;
3035 mdata->filelen = (mdata->filelen + pagemask) & ~pagemask;
7f307238 3036
c9ffd2ea
TG		 3037 return TRUE;
3038}
68ffbac6 3039
c9ffd2ea
TG		 3040/* Layout the commands: set commands size and offset, set ncmds and sizeofcmds
3041 fields in header. */
68ffbac6 3042
86eafac0 3043static bfd_boolean
c9ffd2ea
TG		 3044bfd_mach_o_layout_commands (bfd_mach_o_data_struct *mdata)
3045{
3046 unsigned wide = mach_o_wide_p (&mdata->header);
3047 unsigned int hdrlen;
3048 ufile_ptr offset;
3049 bfd_mach_o_load_command *cmd;
3050 unsigned int align;
86eafac0 3051 bfd_boolean ret = TRUE;
c9ffd2ea
TG		 3052
3053 hdrlen = wide ? BFD_MACH_O_HEADER_64_SIZE : BFD_MACH_O_HEADER_SIZE;
3054 align = wide ? 8 - 1 : 4 - 1;
3055 offset = hdrlen;
3056 mdata->header.ncmds = 0;
50d10658 3057
c9ffd2ea
TG		 3058 for (cmd = mdata->first_command; cmd; cmd = cmd->next)
3059 {
3060 mdata->header.ncmds++;
3061 cmd->offset = offset;
68ffbac6 3062
c9ffd2ea
TG		 3063 switch (cmd->type)
3064 {
3065 case BFD_MACH_O_LC_SEGMENT_64:
3066 cmd->len = BFD_MACH_O_LC_SEGMENT_64_SIZE
3067 + BFD_MACH_O_SECTION_64_SIZE * cmd->command.segment.nsects;
3068 break;
3069 case BFD_MACH_O_LC_SEGMENT:
3070 cmd->len = BFD_MACH_O_LC_SEGMENT_SIZE
3071 + BFD_MACH_O_SECTION_SIZE * cmd->command.segment.nsects;
3072 break;
3073 case BFD_MACH_O_LC_SYMTAB:
3074 cmd->len = sizeof (struct mach_o_symtab_command_external)
3075 + BFD_MACH_O_LC_SIZE;
3076 break;
3077 case BFD_MACH_O_LC_DYSYMTAB:
3078 cmd->len = sizeof (struct mach_o_dysymtab_command_external)
3079 + BFD_MACH_O_LC_SIZE;
3080 break;
3081 case BFD_MACH_O_LC_LOAD_DYLIB:
3082 cmd->len = sizeof (struct mach_o_dylib_command_external)
3083 + BFD_MACH_O_LC_SIZE;
3084 cmd->command.dylib.name_offset = cmd->len;
3085 cmd->len += strlen (cmd->command.dylib.name_str);
3086 cmd->len = (cmd->len + align) & ~align;
3087 break;
3088 case BFD_MACH_O_LC_LOAD_DYLINKER:
3089 cmd->len = sizeof (struct mach_o_str_command_external)
3090 + BFD_MACH_O_LC_SIZE;
3091 cmd->command.dylinker.name_offset = cmd->len;
3092 cmd->len += strlen (cmd->command.dylinker.name_str);
3093 cmd->len = (cmd->len + align) & ~align;
3094 break;
3095 case BFD_MACH_O_LC_MAIN:
3096 cmd->len = sizeof (struct mach_o_entry_point_command_external)
3097 + BFD_MACH_O_LC_SIZE;
3098 break;
3099 case BFD_MACH_O_LC_DYLD_INFO:
3100 cmd->len = sizeof (struct mach_o_dyld_info_command_external)
3101 + BFD_MACH_O_LC_SIZE;
3102 break;
3103 default:
4eca0228 3104 _bfd_error_handler
d42c267e
AM		 3105 (_("unable to layout unknown load command %#x"),
3106 cmd->type);
86eafac0 3107 ret = FALSE;
c9ffd2ea 3108 break;
7f307238 3109 }
c9ffd2ea
TG		 3110
3111 BFD_ASSERT (cmd->len % (align + 1) == 0);
3112 offset += cmd->len;
7f307238 3113 }
c9ffd2ea
TG		 3114 mdata->header.sizeofcmds = offset - hdrlen;
3115 mdata->filelen = offset;
86eafac0
NC		 3116
3117 return ret;
c9ffd2ea 3118}
7f307238 3119
c9ffd2ea
TG		 3120/* Subroutine of bfd_mach_o_build_commands: set type, name and nsects of a
3121 segment. */
3122
3123static void
3124bfd_mach_o_init_segment (bfd_mach_o_data_struct *mdata,
3125 bfd_mach_o_load_command *cmd,
3126 const char *segname, unsigned int nbr_sect)
3127{
3128 bfd_mach_o_segment_command *seg = &cmd->command.segment;
3129 unsigned wide = mach_o_wide_p (&mdata->header);
3130
3131 /* Init segment command. */
3132 cmd->type = wide ? BFD_MACH_O_LC_SEGMENT_64 : BFD_MACH_O_LC_SEGMENT;
3133 cmd->type_required = FALSE;
3134
3135 strcpy (seg->segname, segname);
3136 seg->nsects = nbr_sect;
3137
3138 seg->vmaddr = 0;
3139 seg->vmsize = 0;
3140
3141 seg->fileoff = 0;
3142 seg->filesize = 0;
3143 seg->maxprot = 0;
3144 seg->initprot = 0;
3145 seg->flags = 0;
3146 seg->sect_head = NULL;
3147 seg->sect_tail = NULL;
7f307238
IS		 3148}
3149
3150/* Build Mach-O load commands (currently assuming an MH_OBJECT file).
3151 TODO: Other file formats, rebuilding symtab/dysymtab commands for strip
3152 and copy functionality. */
154a1ee5
TG		 3153
3154bfd_boolean
3155bfd_mach_o_build_commands (bfd *abfd)
3156{
046b007d 3157 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
bbd56171 3158 unsigned wide = mach_o_wide_p (&mdata->header);
c9ffd2ea
TG		 3159 unsigned int nbr_segcmd = 0;
3160 bfd_mach_o_load_command *commands;
3161 unsigned int nbr_commands;
bbd56171
IS		 3162 int symtab_idx = -1;
3163 int dysymtab_idx = -1;
c9ffd2ea
TG		 3164 int main_idx = -1;
3165 unsigned int i;
154a1ee5 3166
c9ffd2ea
TG		 3167 /* Return now if already built. */
3168 if (mdata->header.ncmds != 0)
3169 return TRUE;
154a1ee5 3170
7f307238 3171 /* Fill in the file type, if not already set. */
7f307238 3172 if (mdata->header.filetype == 0)
154a1ee5 3173 {
7f307238 3174 if (abfd->flags & EXEC_P)
07d6d2b8 3175 mdata->header.filetype = BFD_MACH_O_MH_EXECUTE;
7f307238 3176 else if (abfd->flags & DYNAMIC)
07d6d2b8 3177 mdata->header.filetype = BFD_MACH_O_MH_DYLIB;
7f307238 3178 else
07d6d2b8 3179 mdata->header.filetype = BFD_MACH_O_MH_OBJECT;
154a1ee5 3180 }
7f307238
IS		 3181
3182 /* If hasn't already been done, flatten sections list, and sort
3183 if/when required. Must be done before the symbol table is adjusted,
3184 since that depends on properly numbered sections. */
3185 if (mdata->nsects == 0 || mdata->sections == NULL)
3186 if (! bfd_mach_o_mangle_sections (abfd, mdata))
3187 return FALSE;
3188
3189 /* Order the symbol table, fill-in/check mach-o specific fields and
3190 partition out any indirect symbols. */
b22161d6 3191 if (!bfd_mach_o_mangle_symbols (abfd))
7f307238
IS		 3192 return FALSE;
3193
c9ffd2ea
TG		 3194 /* Segment commands. */
3195 if (mdata->header.filetype == BFD_MACH_O_MH_OBJECT)
3196 {
3197 /* Only one segment for all the sections. But the segment is
3198 optional if there is no sections. */
3199 nbr_segcmd = (mdata->nsects > 0) ? 1 : 0;
3200 }
3201 else
3202 {
3203 bfd_mach_o_section *prev_sect = NULL;
bbd56171 3204
c9ffd2ea
TG		 3205 /* One pagezero segment and one linkedit segment. */
3206 nbr_segcmd = 2;
bbd56171 3207
c9ffd2ea
TG		 3208 /* Create one segment for associated segment name in sections.
3209 Assume that sections with the same segment name are consecutive. */
3210 for (i = 0; i < mdata->nsects; i++)
3211 {
3212 bfd_mach_o_section *this_sect = mdata->sections[i];
bbd56171 3213
c9ffd2ea
TG		 3214 if (prev_sect == NULL
3215 || strcmp (prev_sect->segname, this_sect->segname) != 0)
3216 {
3217 nbr_segcmd++;
3218 prev_sect = this_sect;
3219 }
3220 }
154a1ee5 3221 }
154a1ee5 3222
c9ffd2ea
TG		 3223 nbr_commands = nbr_segcmd;
3224
3225 /* One command for the symbol table (only if there are symbols. */
7f307238 3226 if (bfd_get_symcount (abfd) > 0)
c9ffd2ea 3227 symtab_idx = nbr_commands++;
c2f09c75 3228
bbd56171
IS		 3229 /* FIXME:
3230 This is a rather crude test for whether we should build a dysymtab. */
3231 if (bfd_mach_o_should_emit_dysymtab ()
3232 && bfd_get_symcount (abfd))
3233 {
bbd56171
IS		 3234 /* If there should be a case where a dysymtab could be emitted without
3235 a symtab (seems improbable), this would need amending. */
c9ffd2ea 3236 dysymtab_idx = nbr_commands++;
bbd56171 3237 }
154a1ee5 3238
c9ffd2ea
TG		 3239 /* Add an entry point command. */
3240 if (mdata->header.filetype == BFD_MACH_O_MH_EXECUTE
3241 && bfd_get_start_address (abfd) != 0)
3242 main_idx = nbr_commands++;
c2f09c75 3243
bbd56171 3244 /* Well, we must have a header, at least. */
c9ffd2ea 3245 mdata->filelen = wide ? BFD_MACH_O_HEADER_64_SIZE : BFD_MACH_O_HEADER_SIZE;
f1bde64c 3246
bbd56171 3247 /* A bit unusual, but no content is valid;
7f307238 3248 as -n empty.s -o empty.o */
c9ffd2ea
TG		 3249 if (nbr_commands == 0)
3250 {
3251 /* Layout commands (well none...) and set headers command fields. */
86eafac0 3252 return bfd_mach_o_layout_commands (mdata);
c9ffd2ea 3253 }
f1bde64c 3254
c9ffd2ea
TG		 3255 /* Create commands for segments (and symtabs), prepend them. */
3256 commands = bfd_zalloc (abfd, nbr_commands * sizeof (bfd_mach_o_load_command));
3257 if (commands == NULL)
7f307238 3258 return FALSE;
c9ffd2ea
TG		 3259 for (i = 0; i < nbr_commands - 1; i++)
3260 commands[i].next = &commands[i + 1];
3261 commands[nbr_commands - 1].next = mdata->first_command;
3262 if (mdata->first_command == NULL)
3263 mdata->last_command = &commands[nbr_commands - 1];
3264 mdata->first_command = &commands[0];
3265
3266 if (mdata->header.filetype == BFD_MACH_O_MH_OBJECT && nbr_segcmd != 0)
3267 {
3268 /* For object file, there is only one segment. */
3269 bfd_mach_o_init_segment (mdata, &commands[0], "", mdata->nsects);
3270 }
3271 else if (nbr_segcmd != 0)
68ffbac6 3272 {
c9ffd2ea 3273 bfd_mach_o_load_command *cmd;
7f307238 3274
c9ffd2ea 3275 BFD_ASSERT (nbr_segcmd >= 2);
7f307238 3276
c9ffd2ea
TG		 3277 /* The pagezero. */
3278 cmd = &commands[0];
3279 bfd_mach_o_init_segment (mdata, cmd, "__PAGEZERO", 0);
3280
3281 /* Segments from sections. */
3282 cmd++;
3283 for (i = 0; i < mdata->nsects;)
7f307238 3284 {
c9ffd2ea
TG		 3285 const char *segname = mdata->sections[i]->segname;
3286 unsigned int nbr_sect = 1;
3287
3288 /* Count number of sections for this segment. */
3289 for (i++; i < mdata->nsects; i++)
3290 if (strcmp (mdata->sections[i]->segname, segname) == 0)
3291 nbr_sect++;
3292 else
3293 break;
3294
3295 bfd_mach_o_init_segment (mdata, cmd, segname, nbr_sect);
3296 cmd++;
7f307238 3297 }
bbd56171 3298
c9ffd2ea
TG		 3299 /* The linkedit. */
3300 bfd_mach_o_init_segment (mdata, cmd, "__LINKEDIT", 0);
7f307238 3301 }
f1bde64c 3302
bbd56171 3303 if (symtab_idx >= 0)
7f307238
IS		 3304 {
3305 /* Init symtab command. */
c9ffd2ea 3306 bfd_mach_o_load_command *cmd = &commands[symtab_idx];
68ffbac6 3307
bbd56171 3308 cmd->type = BFD_MACH_O_LC_SYMTAB;
bbd56171 3309 cmd->type_required = FALSE;
7f307238 3310 }
154a1ee5 3311
bbd56171
IS		 3312 /* If required, setup symtab command, see comment above about the quality
3313 of this test. */
3314 if (dysymtab_idx >= 0)
7f307238 3315 {
c9ffd2ea 3316 bfd_mach_o_load_command *cmd = &commands[dysymtab_idx];
bbd56171 3317
7f307238 3318 cmd->type = BFD_MACH_O_LC_DYSYMTAB;
7f307238 3319 cmd->type_required = FALSE;
c9ffd2ea
TG		 3320 }
3321
3322 /* Create the main command. */
3323 if (main_idx >= 0)
3324 {
3325 bfd_mach_o_load_command *cmd = &commands[main_idx];
7f307238 3326
c9ffd2ea
TG		 3327 cmd->type = BFD_MACH_O_LC_MAIN;
3328 cmd->type_required = TRUE;
3329
3330 cmd->command.main.entryoff = 0;
3331 cmd->command.main.stacksize = 0;
154a1ee5 3332 }
154a1ee5 3333
c9ffd2ea 3334 /* Layout commands. */
86eafac0
NC		 3335 if (! bfd_mach_o_layout_commands (mdata))
3336 return FALSE;
c9ffd2ea 3337
7f307238
IS		 3338 /* So, now we have sized the commands and the filelen set to that.
3339 Now we can build the segment command and set the section file offsets. */
c9ffd2ea
TG		 3340 if (mdata->header.filetype == BFD_MACH_O_MH_OBJECT)
3341 {
3342 for (i = 0; i < nbr_segcmd; i++)
3343 if (!bfd_mach_o_build_obj_seg_command
3344 (abfd, &commands[i].command.segment))
3345 return FALSE;
3346 }
3347 else
3348 {
3349 bfd_vma maxvma = 0;
7f307238 3350
c9ffd2ea
TG		 3351 /* Skip pagezero and linkedit segments. */
3352 for (i = 1; i < nbr_segcmd - 1; i++)
3353 {
3354 bfd_mach_o_segment_command *seg = &commands[i].command.segment;
3355
3356 if (!bfd_mach_o_build_exec_seg_command (abfd, seg))
3357 return FALSE;
3358
3359 if (seg->vmaddr + seg->vmsize > maxvma)
3360 maxvma = seg->vmaddr + seg->vmsize;
3361 }
3362
3363 /* Set the size of __PAGEZERO. */
3364 commands[0].command.segment.vmsize =
3365 commands[1].command.segment.vmaddr;
3366
3367 /* Set the vma and fileoff of __LINKEDIT. */
3368 commands[nbr_segcmd - 1].command.segment.vmaddr = maxvma;
3369 commands[nbr_segcmd - 1].command.segment.fileoff = mdata->filelen;
3370
3371 /* Set entry point (once segments have been laid out). */
3372 if (main_idx >= 0)
3373 commands[main_idx].command.main.entryoff =
3374 bfd_get_start_address (abfd) - commands[1].command.segment.vmaddr;
3375 }
7f307238 3376
154a1ee5
TG		 3377 return TRUE;
3378}
3379
3380/* Set the contents of a section. */
3381
3382bfd_boolean
3383bfd_mach_o_set_section_contents (bfd *abfd,
3384 asection *section,
3385 const void * location,
3386 file_ptr offset,
3387 bfd_size_type count)
3388{
3389 file_ptr pos;
3390
7f307238
IS		 3391 /* Trying to write the first section contents will trigger the creation of
3392 the load commands if they are not already present. */
c9ffd2ea 3393 if (!abfd->output_has_begun && !bfd_mach_o_build_commands (abfd))
154a1ee5
TG		 3394 return FALSE;
3395
3396 if (count == 0)
3397 return TRUE;
3398
3399 pos = section->filepos + offset;
3400 if (bfd_seek (abfd, pos, SEEK_SET) != 0
3401 || bfd_bwrite (location, count, abfd) != count)
3402 return FALSE;
3403
3404 return TRUE;
3405}
3406
3407int
116c20d2 3408bfd_mach_o_sizeof_headers (bfd *a ATTRIBUTE_UNUSED,
a6b96beb 3409 struct bfd_link_info *info ATTRIBUTE_UNUSED)
3af9a47b
NC		 3410{
3411 return 0;
3412}
3413
3414/* Make an empty symbol. This is required only because
3415 bfd_make_section_anyway wants to create a symbol for the section. */
3416
154a1ee5 3417asymbol *
116c20d2 3418bfd_mach_o_make_empty_symbol (bfd *abfd)
3af9a47b 3419{
d3ce72d0
NC		 3420 asymbol *new_symbol;
3421
3422 new_symbol = bfd_zalloc (abfd, sizeof (bfd_mach_o_asymbol));
3423 if (new_symbol == NULL)
3424 return new_symbol;
3425 new_symbol->the_bfd = abfd;
b22161d6 3426 new_symbol->udata.i = SYM_MACHO_FIELDS_UNSET;
d3ce72d0 3427 return new_symbol;
3af9a47b
NC		 3428}
3429
154a1ee5 3430static bfd_boolean
47daa70f 3431bfd_mach_o_read_header (bfd *abfd, file_ptr hdr_off, bfd_mach_o_header *header)
3af9a47b 3432{
46d1c23b 3433 struct mach_o_header_external raw;
1e8a024a 3434 unsigned int size;
edeb6e24 3435 bfd_vma (*get32) (const void *) = NULL;
3af9a47b 3436
1e8a024a 3437 /* Just read the magic number. */
47daa70f 3438 if (bfd_seek (abfd, hdr_off, SEEK_SET) != 0
46d1c23b 3439 || bfd_bread (raw.magic, sizeof (raw.magic), abfd) != 4)
154a1ee5 3440 return FALSE;
3af9a47b 3441
46d1c23b 3442 if (bfd_getb32 (raw.magic) == BFD_MACH_O_MH_MAGIC)
3af9a47b
NC		 3443 {
3444 header->byteorder = BFD_ENDIAN_BIG;
154a1ee5 3445 header->magic = BFD_MACH_O_MH_MAGIC;
1e8a024a 3446 header->version = 1;
3af9a47b
NC		 3447 get32 = bfd_getb32;
3448 }
46d1c23b 3449 else if (bfd_getl32 (raw.magic) == BFD_MACH_O_MH_MAGIC)
3af9a47b 3450 {
a95a4550 3451 header->byteorder = BFD_ENDIAN_LITTLE;
154a1ee5 3452 header->magic = BFD_MACH_O_MH_MAGIC;
1e8a024a
TG		 3453 header->version = 1;
3454 get32 = bfd_getl32;
3455 }
46d1c23b 3456 else if (bfd_getb32 (raw.magic) == BFD_MACH_O_MH_MAGIC_64)
1e8a024a
TG		 3457 {
3458 header->byteorder = BFD_ENDIAN_BIG;
154a1ee5 3459 header->magic = BFD_MACH_O_MH_MAGIC_64;
1e8a024a
TG		 3460 header->version = 2;
3461 get32 = bfd_getb32;
3462 }
46d1c23b 3463 else if (bfd_getl32 (raw.magic) == BFD_MACH_O_MH_MAGIC_64)
1e8a024a
TG		 3464 {
3465 header->byteorder = BFD_ENDIAN_LITTLE;
154a1ee5 3466 header->magic = BFD_MACH_O_MH_MAGIC_64;
1e8a024a 3467 header->version = 2;
3af9a47b
NC		 3468 get32 = bfd_getl32;
3469 }
3470 else
3471 {
3472 header->byteorder = BFD_ENDIAN_UNKNOWN;
154a1ee5 3473 return FALSE;
3af9a47b 3474 }
a95a4550 3475
1e8a024a 3476 /* Once the size of the header is known, read the full header. */
c2f09c75 3477 size = mach_o_wide_p (header) ?
154a1ee5 3478 BFD_MACH_O_HEADER_64_SIZE : BFD_MACH_O_HEADER_SIZE;
1e8a024a 3479
47daa70f 3480 if (bfd_seek (abfd, hdr_off, SEEK_SET) != 0
46d1c23b 3481 || bfd_bread (&raw, size, abfd) != size)
154a1ee5 3482 return FALSE;
1e8a024a 3483
46d1c23b
TG		 3484 header->cputype = (*get32) (raw.cputype);
3485 header->cpusubtype = (*get32) (raw.cpusubtype);
3486 header->filetype = (*get32) (raw.filetype);
3487 header->ncmds = (*get32) (raw.ncmds);
3488 header->sizeofcmds = (*get32) (raw.sizeofcmds);
3489 header->flags = (*get32) (raw.flags);
3af9a47b 3490
c2f09c75 3491 if (mach_o_wide_p (header))
46d1c23b 3492 header->reserved = (*get32) (raw.reserved);
facf03f2
TG		 3493 else
3494 header->reserved = 0;
1e8a024a 3495
154a1ee5 3496 return TRUE;
3af9a47b
NC		 3497}
3498
f1bde64c
TG		 3499bfd_boolean
3500bfd_mach_o_new_section_hook (bfd *abfd, asection *sec)
3501{
3502 bfd_mach_o_section *s;
a4551119 3503 unsigned bfdalign = bfd_get_section_alignment (abfd, sec);
f1bde64c
TG		 3504
3505 s = bfd_mach_o_get_mach_o_section (sec);
3506 if (s == NULL)
3507 {
3508 flagword bfd_flags;
a4551119 3509 static const mach_o_section_name_xlat * xlat;
f1bde64c
TG		 3510
3511 s = (bfd_mach_o_section *) bfd_zalloc (abfd, sizeof (*s));
3512 if (s == NULL)
3513 return FALSE;
3514 sec->used_by_bfd = s;
3515 s->bfdsection = sec;
3516
a4551119
TG		 3517 /* Create the Darwin seg/sect name pair from the bfd name.
3518 If this is a canonical name for which a specific paiting exists
3519 there will also be defined flags, type, attribute and alignment
3520 values. */
3521 xlat = bfd_mach_o_convert_section_name_to_mach_o (abfd, sec, s);
3522 if (xlat != NULL)
3523 {
3524 s->flags = xlat->macho_sectype | xlat->macho_secattr;
68ffbac6 3525 s->align = xlat->sectalign > bfdalign ? xlat->sectalign
a4551119 3526 : bfdalign;
a253d456 3527 (void) bfd_set_section_alignment (abfd, sec, s->align);
a4551119
TG		 3528 bfd_flags = bfd_get_section_flags (abfd, sec);
3529 if (bfd_flags == SEC_NO_FLAGS)
3530 bfd_set_section_flags (abfd, sec, xlat->bfd_flags);
3531 }
f1bde64c 3532 else
a4551119
TG		 3533 /* Create default flags. */
3534 bfd_mach_o_set_section_flags_from_bfd (abfd, sec);
f1bde64c
TG		 3535 }
3536
3537 return _bfd_generic_new_section_hook (abfd, sec);
3538}
3539
3540static void
3541bfd_mach_o_init_section_from_mach_o (bfd *abfd, asection *sec,
07d6d2b8 3542 unsigned long prot)
3af9a47b 3543{
117ed4f8 3544 flagword flags;
f1bde64c 3545 bfd_mach_o_section *section;
3af9a47b 3546
f1bde64c
TG		 3547 flags = bfd_get_section_flags (abfd, sec);
3548 section = bfd_mach_o_get_mach_o_section (sec);
3af9a47b 3549
a4551119
TG		 3550 /* TODO: see if we should use the xlat system for doing this by
3551 preference and fall back to this for unknown sections. */
3552
8462aec7 3553 if (flags == SEC_NO_FLAGS)
ef17cb22 3554 {
8462aec7
TG		 3555 /* Try to guess flags. */
3556 if (section->flags & BFD_MACH_O_S_ATTR_DEBUG)
07d6d2b8 3557 flags = SEC_DEBUGGING;
8462aec7 3558 else
07d6d2b8
AM		 3559 {
3560 flags = SEC_ALLOC;
3561 if ((section->flags & BFD_MACH_O_SECTION_TYPE_MASK)
3562 != BFD_MACH_O_S_ZEROFILL)
3563 {
3564 flags |= SEC_LOAD;
3565 if (prot & BFD_MACH_O_PROT_EXECUTE)
3566 flags |= SEC_CODE;
3567 if (prot & BFD_MACH_O_PROT_WRITE)
3568 flags |= SEC_DATA;
3569 else if (prot & BFD_MACH_O_PROT_READ)
3570 flags |= SEC_READONLY;
3571 }
3572 }
ef17cb22 3573 }
15e1c58a
TG		 3574 else
3575 {
8462aec7 3576 if ((flags & SEC_DEBUGGING) == 0)
07d6d2b8 3577 flags |= SEC_ALLOC;
15e1c58a 3578 }
8462aec7
TG		 3579
3580 if (section->offset != 0)
3581 flags |= SEC_HAS_CONTENTS;
92bc0e80
TG		 3582 if (section->nreloc != 0)
3583 flags |= SEC_RELOC;
3584
f1bde64c
TG		 3585 bfd_set_section_flags (abfd, sec, flags);
3586
3587 sec->vma = section->addr;
3588 sec->lma = section->addr;
3589 sec->size = section->size;
3590 sec->filepos = section->offset;
3591 sec->alignment_power = section->align;
3592 sec->segment_mark = 0;
3593 sec->reloc_count = section->nreloc;
3594 sec->rel_filepos = section->reloff;
3595}
3596
3597static asection *
3598bfd_mach_o_make_bfd_section (bfd *abfd,
07d6d2b8
AM		 3599 const unsigned char *segname,
3600 const unsigned char *sectname)
f1bde64c
TG		 3601{
3602 const char *sname;
3603 flagword flags;
a95a4550 3604
f1bde64c
TG		 3605 bfd_mach_o_convert_section_name_to_bfd
3606 (abfd, (const char *)segname, (const char *)sectname, &sname, &flags);
3607 if (sname == NULL)
3608 return NULL;
3af9a47b 3609
f1bde64c 3610 return bfd_make_section_anyway_with_flags (abfd, sname, flags);
3af9a47b
NC		 3611}
3612
f1bde64c 3613static asection *
47daa70f 3614bfd_mach_o_read_section_32 (bfd *abfd, unsigned long prot)
3af9a47b 3615{
46d1c23b 3616 struct mach_o_section_32_external raw;
f1bde64c
TG		 3617 asection *sec;
3618 bfd_mach_o_section *section;
3af9a47b 3619
47daa70f
TG		 3620 if (bfd_bread (&raw, BFD_MACH_O_SECTION_SIZE, abfd)
3621 != BFD_MACH_O_SECTION_SIZE)
f1bde64c 3622 return NULL;
a95a4550 3623
5a5cbf72 3624 sec = bfd_mach_o_make_bfd_section (abfd, raw.segname, raw.sectname);
f1bde64c
TG		 3625 if (sec == NULL)
3626 return NULL;
3627
3628 section = bfd_mach_o_get_mach_o_section (sec);
3629 memcpy (section->segname, raw.segname, sizeof (raw.segname));
3630 section->segname[BFD_MACH_O_SEGNAME_SIZE] = 0;
3631 memcpy (section->sectname, raw.sectname, sizeof (raw.sectname));
69499dca 3632 section->sectname[BFD_MACH_O_SECTNAME_SIZE] = 0;
46d1c23b
TG		 3633 section->addr = bfd_h_get_32 (abfd, raw.addr);
3634 section->size = bfd_h_get_32 (abfd, raw.size);
3635 section->offset = bfd_h_get_32 (abfd, raw.offset);
3636 section->align = bfd_h_get_32 (abfd, raw.align);
c86934ce
NC		 3637 /* PR 17512: file: 0017eb76. */
3638 if (section->align > 64)
3639 {
4eca0228 3640 _bfd_error_handler
d42c267e 3641 (_("bfd_mach_o_read_section_32: overlarge alignment value: %#lx, "
4eca0228 3642 "using 32 instead"), section->align);
c86934ce
NC		 3643 section->align = 32;
3644 }
46d1c23b
TG		 3645 section->reloff = bfd_h_get_32 (abfd, raw.reloff);
3646 section->nreloc = bfd_h_get_32 (abfd, raw.nreloc);
3647 section->flags = bfd_h_get_32 (abfd, raw.flags);
3648 section->reserved1 = bfd_h_get_32 (abfd, raw.reserved1);
3649 section->reserved2 = bfd_h_get_32 (abfd, raw.reserved2);
1e8a024a 3650 section->reserved3 = 0;
1e8a024a 3651
f1bde64c 3652 bfd_mach_o_init_section_from_mach_o (abfd, sec, prot);
1e8a024a 3653
f1bde64c 3654 return sec;
1e8a024a
TG		 3655}
3656
f1bde64c 3657static asection *
47daa70f 3658bfd_mach_o_read_section_64 (bfd *abfd, unsigned long prot)
1e8a024a 3659{
46d1c23b 3660 struct mach_o_section_64_external raw;
f1bde64c
TG		 3661 asection *sec;
3662 bfd_mach_o_section *section;
1e8a024a 3663
47daa70f
TG		 3664 if (bfd_bread (&raw, BFD_MACH_O_SECTION_64_SIZE, abfd)
3665 != BFD_MACH_O_SECTION_64_SIZE)
f1bde64c
TG		 3666 return NULL;
3667
5a5cbf72 3668 sec = bfd_mach_o_make_bfd_section (abfd, raw.segname, raw.sectname);
f1bde64c
TG		 3669 if (sec == NULL)
3670 return NULL;
1e8a024a 3671
f1bde64c
TG		 3672 section = bfd_mach_o_get_mach_o_section (sec);
3673 memcpy (section->segname, raw.segname, sizeof (raw.segname));
3674 section->segname[BFD_MACH_O_SEGNAME_SIZE] = 0;
3675 memcpy (section->sectname, raw.sectname, sizeof (raw.sectname));
69499dca 3676 section->sectname[BFD_MACH_O_SECTNAME_SIZE] = 0;
46d1c23b
TG		 3677 section->addr = bfd_h_get_64 (abfd, raw.addr);
3678 section->size = bfd_h_get_64 (abfd, raw.size);
3679 section->offset = bfd_h_get_32 (abfd, raw.offset);
3680 section->align = bfd_h_get_32 (abfd, raw.align);
c86934ce
NC		 3681 if (section->align > 64)
3682 {
4eca0228 3683 _bfd_error_handler
d42c267e 3684 (_("bfd_mach_o_read_section_64: overlarge alignment value: %#lx, "
4eca0228 3685 "using 32 instead"), section->align);
c86934ce
NC		 3686 section->align = 32;
3687 }
46d1c23b
TG		 3688 section->reloff = bfd_h_get_32 (abfd, raw.reloff);
3689 section->nreloc = bfd_h_get_32 (abfd, raw.nreloc);
3690 section->flags = bfd_h_get_32 (abfd, raw.flags);
3691 section->reserved1 = bfd_h_get_32 (abfd, raw.reserved1);
3692 section->reserved2 = bfd_h_get_32 (abfd, raw.reserved2);
3693 section->reserved3 = bfd_h_get_32 (abfd, raw.reserved3);
3af9a47b 3694
f1bde64c 3695 bfd_mach_o_init_section_from_mach_o (abfd, sec, prot);
3af9a47b 3696
f1bde64c 3697 return sec;
3af9a47b
NC		 3698}
3699
f1bde64c 3700static asection *
47daa70f 3701bfd_mach_o_read_section (bfd *abfd, unsigned long prot, unsigned int wide)
1e8a024a
TG		 3702{
3703 if (wide)
47daa70f 3704 return bfd_mach_o_read_section_64 (abfd, prot);
1e8a024a 3705 else
47daa70f 3706 return bfd_mach_o_read_section_32 (abfd, prot);
1e8a024a
TG		 3707}
3708
afbb9e17 3709static bfd_boolean
ab273af8 3710bfd_mach_o_read_symtab_symbol (bfd *abfd,
07d6d2b8
AM		 3711 bfd_mach_o_symtab_command *sym,
3712 bfd_mach_o_asymbol *s,
3713 unsigned long i)
3af9a47b 3714{
046b007d 3715 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
c2f09c75 3716 unsigned int wide = mach_o_wide_p (&mdata->header);
046b007d
TG		 3717 unsigned int symwidth =
3718 wide ? BFD_MACH_O_NLIST_64_SIZE : BFD_MACH_O_NLIST_SIZE;
92bc0e80 3719 unsigned int symoff = sym->symoff + (i * symwidth);
46d1c23b 3720 struct mach_o_nlist_64_external raw;
3af9a47b
NC		 3721 unsigned char type = -1;
3722 unsigned char section = -1;
3723 short desc = -1;
1e8a024a 3724 symvalue value = -1;
3af9a47b
NC		 3725 unsigned long stroff = -1;
3726 unsigned int symtype = -1;
3727
3728 BFD_ASSERT (sym->strtab != NULL);
3729
c2f09c75 3730 if (bfd_seek (abfd, symoff, SEEK_SET) != 0
46d1c23b 3731 || bfd_bread (&raw, symwidth, abfd) != symwidth)
3af9a47b 3732 {
4eca0228 3733 _bfd_error_handler
695344c0 3734 /* xgettext:c-format */
07d6d2b8
AM		 3735 (_("bfd_mach_o_read_symtab_symbol: unable to read %d bytes at %u"),
3736 symwidth, symoff);
afbb9e17 3737 return FALSE;
3af9a47b
NC		 3738 }
3739
46d1c23b
TG		 3740 stroff = bfd_h_get_32 (abfd, raw.n_strx);
3741 type = bfd_h_get_8 (abfd, raw.n_type);
c2f09c75 3742 symtype = type & BFD_MACH_O_N_TYPE;
46d1c23b
TG		 3743 section = bfd_h_get_8 (abfd, raw.n_sect);
3744 desc = bfd_h_get_16 (abfd, raw.n_desc);
1e8a024a 3745 if (wide)
46d1c23b 3746 value = bfd_h_get_64 (abfd, raw.n_value);
1e8a024a 3747 else
46d1c23b 3748 value = bfd_h_get_32 (abfd, raw.n_value);
3af9a47b
NC		 3749
3750 if (stroff >= sym->strsize)
3751 {
4eca0228 3752 _bfd_error_handler
695344c0 3753 /* xgettext:c-format */
07d6d2b8
AM		 3754 (_("bfd_mach_o_read_symtab_symbol: name out of range (%lu >= %u)"),
3755 stroff,
3756 sym->strsize);
afbb9e17 3757 return FALSE;
3af9a47b
NC		 3758 }
3759
92bc0e80
TG		 3760 s->symbol.the_bfd = abfd;
3761 s->symbol.name = sym->strtab + stroff;
3762 s->symbol.value = value;
3763 s->symbol.flags = 0x0;
b22161d6 3764 s->symbol.udata.i = i;
92bc0e80
TG		 3765 s->n_type = type;
3766 s->n_sect = section;
3767 s->n_desc = desc;
3af9a47b
NC		 3768
3769 if (type & BFD_MACH_O_N_STAB)
3770 {
92bc0e80
TG		 3771 s->symbol.flags |= BSF_DEBUGGING;
3772 s->symbol.section = bfd_und_section_ptr;
15e1c58a
TG		 3773 switch (type)
3774 {
3775 case N_FUN:
3776 case N_STSYM:
3777 case N_LCSYM:
3778 case N_BNSYM:
3779 case N_SLINE:
3780 case N_ENSYM:
3781 case N_ECOMM:
3782 case N_ECOML:
3783 case N_GSYM:
3784 if ((section > 0) && (section <= mdata->nsects))
3785 {
92bc0e80
TG		 3786 s->symbol.section = mdata->sections[section - 1]->bfdsection;
3787 s->symbol.value =
07d6d2b8 3788 s->symbol.value - mdata->sections[section - 1]->addr;
15e1c58a
TG		 3789 }
3790 break;
3791 }
3af9a47b
NC		 3792 }
3793 else
3794 {
b22161d6 3795 if (type & (BFD_MACH_O_N_PEXT | BFD_MACH_O_N_EXT))
92bc0e80 3796 s->symbol.flags |= BSF_GLOBAL;
b22161d6 3797 else
92bc0e80 3798 s->symbol.flags |= BSF_LOCAL;
3af9a47b
NC		 3799
3800 switch (symtype)
3801 {
3802 case BFD_MACH_O_N_UNDF:
07d6d2b8
AM		 3803 if (type == (BFD_MACH_O_N_UNDF | BFD_MACH_O_N_EXT)
3804 && s->symbol.value != 0)
3805 {
3806 /* A common symbol. */
3807 s->symbol.section = bfd_com_section_ptr;
3808 s->symbol.flags = BSF_NO_FLAGS;
3809 }
3810 else
3811 {
3812 s->symbol.section = bfd_und_section_ptr;
3813 if (s->n_desc & BFD_MACH_O_N_WEAK_REF)
3814 s->symbol.flags |= BSF_WEAK;
3815 }
3af9a47b
NC		 3816 break;
3817 case BFD_MACH_O_N_PBUD:
92bc0e80 3818 s->symbol.section = bfd_und_section_ptr;
3af9a47b
NC		 3819 break;
3820 case BFD_MACH_O_N_ABS:
92bc0e80 3821 s->symbol.section = bfd_abs_section_ptr;
3af9a47b
NC		 3822 break;
3823 case BFD_MACH_O_N_SECT:
3824 if ((section > 0) && (section <= mdata->nsects))
3825 {
92bc0e80
TG		 3826 s->symbol.section = mdata->sections[section - 1]->bfdsection;
3827 s->symbol.value =
07d6d2b8 3828 s->symbol.value - mdata->sections[section - 1]->addr;
3af9a47b
NC		 3829 }
3830 else
3831 {
3832 /* Mach-O uses 0 to mean "no section"; not an error. */
3833 if (section != 0)
3834 {
4eca0228 3835 _bfd_error_handler
695344c0 3836 /* xgettext:c-format */
4eca0228
AM		 3837 (_("bfd_mach_o_read_symtab_symbol: "
3838 "symbol \"%s\" specified invalid section %d (max %lu): "
3839 "setting to undefined"),
3840 s->symbol.name, section, mdata->nsects);
3af9a47b 3841 }
92bc0e80 3842 s->symbol.section = bfd_und_section_ptr;
3af9a47b
NC		 3843 }
3844 break;
3845 case BFD_MACH_O_N_INDR:
0596a831
TG		 3846 /* FIXME: we don't follow the BFD convention as this indirect symbol
3847 won't be followed by the referenced one. This looks harmless
3848 unless we start using the linker. */
3849 s->symbol.flags |= BSF_INDIRECT;
3850 s->symbol.section = bfd_ind_section_ptr;
3851 s->symbol.value = 0;
3af9a47b
NC		 3852 break;
3853 default:
4eca0228 3854 _bfd_error_handler
695344c0 3855 /* xgettext:c-format */
4eca0228
AM		 3856 (_("bfd_mach_o_read_symtab_symbol: "
3857 "symbol \"%s\" specified invalid type field 0x%x: "
3858 "setting to undefined"), s->symbol.name, symtype);
92bc0e80 3859 s->symbol.section = bfd_und_section_ptr;
3af9a47b
NC		 3860 break;
3861 }
3862 }
3863
afbb9e17 3864 return TRUE;
3af9a47b
NC		 3865}
3866
c5012cd8 3867bfd_boolean
ab273af8 3868bfd_mach_o_read_symtab_strtab (bfd *abfd)
3af9a47b 3869{
046b007d
TG		 3870 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3871 bfd_mach_o_symtab_command *sym = mdata->symtab;
3872
3873 /* Fail if there is no symtab. */
3874 if (sym == NULL)
afbb9e17 3875 return FALSE;
046b007d
TG		 3876
3877 /* Success if already loaded. */
3878 if (sym->strtab)
afbb9e17 3879 return TRUE;
3af9a47b
NC		 3880
3881 if (abfd->flags & BFD_IN_MEMORY)
3882 {
3883 struct bfd_in_memory *b;
3884
3885 b = (struct bfd_in_memory *) abfd->iostream;
3886
3887 if ((sym->stroff + sym->strsize) > b->size)
3888 {
3889 bfd_set_error (bfd_error_file_truncated);
afbb9e17 3890 return FALSE;
3af9a47b 3891 }
f075ee0c 3892 sym->strtab = (char *) b->buffer + sym->stroff;
3af9a47b 3893 }
046b007d 3894 else
3af9a47b 3895 {
8bdf0be1
NC		 3896 /* See PR 21840 for a reproducer. */
3897 if ((sym->strsize + 1) == 0)
3898 return FALSE;
e7287c7f 3899 sym->strtab = bfd_alloc (abfd, sym->strsize + 1);
046b007d 3900 if (sym->strtab == NULL)
07d6d2b8 3901 return FALSE;
046b007d
TG		 3902
3903 if (bfd_seek (abfd, sym->stroff, SEEK_SET) != 0
07d6d2b8
AM		 3904 || bfd_bread (sym->strtab, sym->strsize, abfd) != sym->strsize)
3905 {
a1165289
NC		 3906 /* PR 17512: file: 10888-1609-0.004. */
3907 bfd_release (abfd, sym->strtab);
3908 sym->strtab = NULL;
07d6d2b8
AM		 3909 bfd_set_error (bfd_error_file_truncated);
3910 return FALSE;
3911 }
e7287c7f
NC		 3912 /* Zero terminate the string table. */
3913 sym->strtab[sym->strsize] = 0;
3af9a47b
NC		 3914 }
3915
afbb9e17 3916 return TRUE;
3af9a47b
NC		 3917}
3918
c5012cd8 3919bfd_boolean
ab273af8 3920bfd_mach_o_read_symtab_symbols (bfd *abfd)
3af9a47b 3921{
046b007d
TG		 3922 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3923 bfd_mach_o_symtab_command *sym = mdata->symtab;
3af9a47b 3924 unsigned long i;
3af9a47b 3925
092d27ff 3926 if (sym == NULL || sym->symbols)
0a9d414a
NC		 3927 /* Return now if there are no symbols or if already loaded. */
3928 return TRUE;
046b007d 3929
64d29018 3930 sym->symbols = bfd_alloc2 (abfd, sym->nsyms, sizeof (bfd_mach_o_asymbol));
3af9a47b
NC		 3931 if (sym->symbols == NULL)
3932 {
4eca0228
AM		 3933 _bfd_error_handler (_("bfd_mach_o_read_symtab_symbols: "
3934 "unable to allocate memory for symbols"));
64d29018 3935 sym->nsyms = 0;
afbb9e17 3936 return FALSE;
3af9a47b 3937 }
a95a4550 3938
afbb9e17 3939 if (!bfd_mach_o_read_symtab_strtab (abfd))
64d29018 3940 goto fail;
3af9a47b
NC		 3941
3942 for (i = 0; i < sym->nsyms; i++)
64d29018
NC		 3943 if (!bfd_mach_o_read_symtab_symbol (abfd, sym, &sym->symbols[i], i))
3944 goto fail;
a95a4550 3945
afbb9e17 3946 return TRUE;
64d29018
NC		 3947
3948 fail:
3949 bfd_release (abfd, sym->symbols);
3950 sym->symbols = NULL;
3951 sym->nsyms = 0;
3952 return FALSE;
3af9a47b
NC		 3953}
3954
3955static const char *
116c20d2 3956bfd_mach_o_i386_flavour_string (unsigned int flavour)
3af9a47b
NC		 3957{
3958 switch ((int) flavour)
3959 {
15e1c58a
TG		 3960 case BFD_MACH_O_x86_THREAD_STATE32: return "x86_THREAD_STATE32";
3961 case BFD_MACH_O_x86_FLOAT_STATE32: return "x86_FLOAT_STATE32";
3962 case BFD_MACH_O_x86_EXCEPTION_STATE32: return "x86_EXCEPTION_STATE32";
3963 case BFD_MACH_O_x86_THREAD_STATE64: return "x86_THREAD_STATE64";
3964 case BFD_MACH_O_x86_FLOAT_STATE64: return "x86_FLOAT_STATE64";
3965 case BFD_MACH_O_x86_EXCEPTION_STATE64: return "x86_EXCEPTION_STATE64";
3966 case BFD_MACH_O_x86_THREAD_STATE: return "x86_THREAD_STATE";
3967 case BFD_MACH_O_x86_FLOAT_STATE: return "x86_FLOAT_STATE";
3968 case BFD_MACH_O_x86_EXCEPTION_STATE: return "x86_EXCEPTION_STATE";
3969 case BFD_MACH_O_x86_DEBUG_STATE32: return "x86_DEBUG_STATE32";
3970 case BFD_MACH_O_x86_DEBUG_STATE64: return "x86_DEBUG_STATE64";
3971 case BFD_MACH_O_x86_DEBUG_STATE: return "x86_DEBUG_STATE";
b32e07d7 3972 case BFD_MACH_O_x86_THREAD_STATE_NONE: return "x86_THREAD_STATE_NONE";
3af9a47b
NC		 3973 default: return "UNKNOWN";
3974 }
3975}
3976
3977static const char *
116c20d2 3978bfd_mach_o_ppc_flavour_string (unsigned int flavour)
3af9a47b
NC		 3979{
3980 switch ((int) flavour)
3981 {
b32e07d7
TG		 3982 case BFD_MACH_O_PPC_THREAD_STATE: return "PPC_THREAD_STATE";
3983 case BFD_MACH_O_PPC_FLOAT_STATE: return "PPC_FLOAT_STATE";
3984 case BFD_MACH_O_PPC_EXCEPTION_STATE: return "PPC_EXCEPTION_STATE";
3985 case BFD_MACH_O_PPC_VECTOR_STATE: return "PPC_VECTOR_STATE";
3986 case BFD_MACH_O_PPC_THREAD_STATE64: return "PPC_THREAD_STATE64";
3987 case BFD_MACH_O_PPC_EXCEPTION_STATE64: return "PPC_EXCEPTION_STATE64";
3af9a47b
NC		 3988 default: return "UNKNOWN";
3989 }
3990}
3991
452216ab 3992static bfd_boolean
ab273af8 3993bfd_mach_o_read_dylinker (bfd *abfd, bfd_mach_o_load_command *command)
3af9a47b
NC		 3994{
3995 bfd_mach_o_dylinker_command *cmd = &command->command.dylinker;
46d1c23b 3996 struct mach_o_str_command_external raw;
3af9a47b 3997 unsigned int nameoff;
4525c51a 3998 unsigned int namelen;
3af9a47b 3999
47daa70f 4000 if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
452216ab 4001 return FALSE;
3af9a47b 4002
46d1c23b 4003 nameoff = bfd_h_get_32 (abfd, raw.str);
3af9a47b 4004
4525c51a
TG		 4005 cmd->name_offset = nameoff;
4006 namelen = command->len - nameoff;
4007 nameoff += command->offset;
4008 cmd->name_str = bfd_alloc (abfd, namelen);
b32e07d7 4009 if (cmd->name_str == NULL)
452216ab 4010 return FALSE;
4525c51a
TG		 4011 if (bfd_seek (abfd, nameoff, SEEK_SET) != 0
4012 || bfd_bread (cmd->name_str, namelen, abfd) != namelen)
452216ab
TG		 4013 return FALSE;
4014 return TRUE;
3af9a47b
NC		 4015}
4016
452216ab 4017static bfd_boolean
ab273af8 4018bfd_mach_o_read_dylib (bfd *abfd, bfd_mach_o_load_command *command)
3af9a47b 4019{
47daa70f 4020 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3af9a47b 4021 bfd_mach_o_dylib_command *cmd = &command->command.dylib;
46d1c23b 4022 struct mach_o_dylib_command_external raw;
3af9a47b 4023 unsigned int nameoff;
4525c51a 4024 unsigned int namelen;
3af9a47b 4025
046b007d
TG		 4026 switch (command->type)
4027 {
4028 case BFD_MACH_O_LC_LOAD_DYLIB:
fbe383b9 4029 case BFD_MACH_O_LC_LAZY_LOAD_DYLIB:
046b007d 4030 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB:
046b007d 4031 case BFD_MACH_O_LC_ID_DYLIB:
046b007d 4032 case BFD_MACH_O_LC_REEXPORT_DYLIB:
73017762 4033 case BFD_MACH_O_LC_LOAD_UPWARD_DYLIB:
046b007d
TG		 4034 break;
4035 default:
b32e07d7 4036 BFD_FAIL ();
452216ab 4037 return FALSE;
046b007d 4038 }
3af9a47b 4039
47daa70f 4040 if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
452216ab 4041 return FALSE;
3af9a47b 4042
46d1c23b
TG		 4043 nameoff = bfd_h_get_32 (abfd, raw.name);
4044 cmd->timestamp = bfd_h_get_32 (abfd, raw.timestamp);
4045 cmd->current_version = bfd_h_get_32 (abfd, raw.current_version);
4046 cmd->compatibility_version = bfd_h_get_32 (abfd, raw.compatibility_version);
3af9a47b
NC		 4047
4048 cmd->name_offset = command->offset + nameoff;
4525c51a
TG		 4049 namelen = command->len - nameoff;
4050 cmd->name_str = bfd_alloc (abfd, namelen);
b32e07d7 4051 if (cmd->name_str == NULL)
452216ab 4052 return FALSE;
47daa70f 4053 if (bfd_seek (abfd, mdata->hdr_offset + cmd->name_offset, SEEK_SET) != 0
4525c51a 4054 || bfd_bread (cmd->name_str, namelen, abfd) != namelen)
452216ab
TG		 4055 return FALSE;
4056 return TRUE;
3af9a47b
NC		 4057}
4058
452216ab 4059static bfd_boolean
7a79c514 4060bfd_mach_o_read_prebound_dylib (bfd *abfd,
07d6d2b8 4061 bfd_mach_o_load_command *command)
3af9a47b 4062{
7a79c514
TG		 4063 bfd_mach_o_prebound_dylib_command *cmd = &command->command.prebound_dylib;
4064 struct mach_o_prebound_dylib_command_external raw;
4065 unsigned int nameoff;
4066 unsigned int modoff;
4067 unsigned int str_len;
4068 unsigned char *str;
4069
47daa70f 4070 if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
452216ab 4071 return FALSE;
7a79c514
TG		 4072
4073 nameoff = bfd_h_get_32 (abfd, raw.name);
4074 modoff = bfd_h_get_32 (abfd, raw.linked_modules);
4075 if (nameoff > command->len || modoff > command->len)
452216ab 4076 return FALSE;
7a79c514
TG		 4077
4078 str_len = command->len - sizeof (raw);
4079 str = bfd_alloc (abfd, str_len);
4080 if (str == NULL)
452216ab 4081 return FALSE;
7a79c514 4082 if (bfd_bread (str, str_len, abfd) != str_len)
452216ab 4083 return FALSE;
7a79c514
TG		 4084
4085 cmd->name_offset = command->offset + nameoff;
4086 cmd->nmodules = bfd_h_get_32 (abfd, raw.nmodules);
4087 cmd->linked_modules_offset = command->offset + modoff;
4088
4089 cmd->name_str = (char *)str + nameoff - (sizeof (raw) + BFD_MACH_O_LC_SIZE);
4090 cmd->linked_modules = str + modoff - (sizeof (raw) + BFD_MACH_O_LC_SIZE);
452216ab 4091 return TRUE;
7a79c514
TG		 4092}
4093
452216ab 4094static bfd_boolean
7a79c514
TG		 4095bfd_mach_o_read_prebind_cksum (bfd *abfd,
4096 bfd_mach_o_load_command *command)
4097{
4098 bfd_mach_o_prebind_cksum_command *cmd = &command->command.prebind_cksum;
4099 struct mach_o_prebind_cksum_command_external raw;
3af9a47b 4100
47daa70f 4101 if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
452216ab 4102 return FALSE;
7a79c514
TG		 4103
4104 cmd->cksum = bfd_get_32 (abfd, raw.cksum);
452216ab 4105 return TRUE;
7a79c514
TG		 4106}
4107
452216ab 4108static bfd_boolean
7a79c514
TG		 4109bfd_mach_o_read_twolevel_hints (bfd *abfd,
4110 bfd_mach_o_load_command *command)
4111{
4112 bfd_mach_o_twolevel_hints_command *cmd = &command->command.twolevel_hints;
4113 struct mach_o_twolevel_hints_command_external raw;
4114
47daa70f 4115 if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
452216ab 4116 return FALSE;
7a79c514
TG		 4117
4118 cmd->offset = bfd_get_32 (abfd, raw.offset);
4119 cmd->nhints = bfd_get_32 (abfd, raw.nhints);
452216ab 4120 return TRUE;
3af9a47b
NC		 4121}
4122
452216ab 4123static bfd_boolean
9f4a5bd1
TG		 4124bfd_mach_o_read_fvmlib (bfd *abfd, bfd_mach_o_load_command *command)
4125{
4126 bfd_mach_o_fvmlib_command *fvm = &command->command.fvmlib;
4127 struct mach_o_fvmlib_command_external raw;
4128 unsigned int nameoff;
4525c51a 4129 unsigned int namelen;
9f4a5bd1 4130
47daa70f 4131 if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
452216ab 4132 return FALSE;
9f4a5bd1
TG		 4133
4134 nameoff = bfd_h_get_32 (abfd, raw.name);
4135 fvm->minor_version = bfd_h_get_32 (abfd, raw.minor_version);
4136 fvm->header_addr = bfd_h_get_32 (abfd, raw.header_addr);
4137
4138 fvm->name_offset = command->offset + nameoff;
4525c51a
TG		 4139 namelen = command->len - nameoff;
4140 fvm->name_str = bfd_alloc (abfd, namelen);
9f4a5bd1 4141 if (fvm->name_str == NULL)
452216ab 4142 return FALSE;
9f4a5bd1 4143 if (bfd_seek (abfd, fvm->name_offset, SEEK_SET) != 0
4525c51a 4144 || bfd_bread (fvm->name_str, namelen, abfd) != namelen)
452216ab
TG		 4145 return FALSE;
4146 return TRUE;
9f4a5bd1
TG		 4147}
4148
452216ab 4149static bfd_boolean
ab273af8 4150bfd_mach_o_read_thread (bfd *abfd, bfd_mach_o_load_command *command)
3af9a47b 4151{
b32e07d7 4152 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3af9a47b 4153 bfd_mach_o_thread_command *cmd = &command->command.thread;
92bc0e80 4154 unsigned int offset;
3af9a47b
NC		 4155 unsigned int nflavours;
4156 unsigned int i;
4157
4158 BFD_ASSERT ((command->type == BFD_MACH_O_LC_THREAD)
4159 || (command->type == BFD_MACH_O_LC_UNIXTHREAD));
4160
b32e07d7 4161 /* Count the number of threads. */
3af9a47b
NC		 4162 offset = 8;
4163 nflavours = 0;
4164 while (offset != command->len)
4165 {
46d1c23b
TG		 4166 struct mach_o_thread_command_external raw;
4167
3af9a47b 4168 if (offset >= command->len)
452216ab 4169 return FALSE;
3af9a47b 4170
c2f09c75 4171 if (bfd_seek (abfd, command->offset + offset, SEEK_SET) != 0
07d6d2b8 4172 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
452216ab 4173 return FALSE;
3af9a47b 4174
46d1c23b 4175 offset += sizeof (raw) + bfd_h_get_32 (abfd, raw.count) * 4;
3af9a47b
NC		 4176 nflavours++;
4177 }
4178
b32e07d7 4179 /* Allocate threads. */
64d29018
NC		 4180 cmd->flavours = bfd_alloc2
4181 (abfd, nflavours, sizeof (bfd_mach_o_thread_flavour));
3af9a47b 4182 if (cmd->flavours == NULL)
452216ab 4183 return FALSE;
3af9a47b
NC		 4184 cmd->nflavours = nflavours;
4185
4186 offset = 8;
4187 nflavours = 0;
4188 while (offset != command->len)
4189 {
46d1c23b
TG		 4190 struct mach_o_thread_command_external raw;
4191
3af9a47b 4192 if (offset >= command->len)
452216ab 4193 return FALSE;
3af9a47b
NC		 4194
4195 if (nflavours >= cmd->nflavours)
452216ab 4196 return FALSE;
3af9a47b 4197
c2f09c75 4198 if (bfd_seek (abfd, command->offset + offset, SEEK_SET) != 0
07d6d2b8 4199 || bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
452216ab 4200 return FALSE;
3af9a47b 4201
46d1c23b
TG		 4202 cmd->flavours[nflavours].flavour = bfd_h_get_32 (abfd, raw.flavour);
4203 cmd->flavours[nflavours].offset = command->offset + offset + sizeof (raw);
4204 cmd->flavours[nflavours].size = bfd_h_get_32 (abfd, raw.count) * 4;
4205 offset += cmd->flavours[nflavours].size + sizeof (raw);
3af9a47b
NC		 4206 nflavours++;
4207 }
4208
4209 for (i = 0; i < nflavours; i++)
4210 {
4211 asection *bfdsec;
4212 unsigned int snamelen;
4213 char *sname;
4214 const char *flavourstr;
4215 const char *prefix = "LC_THREAD";
a95a4550
AM		 4216 unsigned int j = 0;
4217
3af9a47b
NC		 4218 switch (mdata->header.cputype)
4219 {
4220 case BFD_MACH_O_CPU_TYPE_POWERPC:
1e8a024a 4221 case BFD_MACH_O_CPU_TYPE_POWERPC_64:
707e555b
TG		 4222 flavourstr =
4223 bfd_mach_o_ppc_flavour_string (cmd->flavours[i].flavour);
3af9a47b
NC		 4224 break;
4225 case BFD_MACH_O_CPU_TYPE_I386:
1e8a024a 4226 case BFD_MACH_O_CPU_TYPE_X86_64:
707e555b
TG		 4227 flavourstr =
4228 bfd_mach_o_i386_flavour_string (cmd->flavours[i].flavour);
3af9a47b
NC		 4229 break;
4230 default:
4231 flavourstr = "UNKNOWN_ARCHITECTURE";
4232 break;
4233 }
a95a4550 4234
3af9a47b 4235 snamelen = strlen (prefix) + 1 + 20 + 1 + strlen (flavourstr) + 1;
116c20d2 4236 sname = bfd_alloc (abfd, snamelen);
3af9a47b 4237 if (sname == NULL)
452216ab 4238 return FALSE;
3af9a47b
NC		 4239
4240 for (;;)
4241 {
a95a4550
AM		 4242 sprintf (sname, "%s.%s.%u", prefix, flavourstr, j);
4243 if (bfd_get_section_by_name (abfd, sname) == NULL)
3af9a47b 4244 break;
a95a4550 4245 j++;
3af9a47b
NC		 4246 }
4247
117ed4f8 4248 bfdsec = bfd_make_section_with_flags (abfd, sname, SEC_HAS_CONTENTS);
a95a4550 4249
3af9a47b
NC		 4250 bfdsec->vma = 0;
4251 bfdsec->lma = 0;
eea6121a 4252 bfdsec->size = cmd->flavours[i].size;
3af9a47b
NC		 4253 bfdsec->filepos = cmd->flavours[i].offset;
4254 bfdsec->alignment_power = 0x0;
3af9a47b
NC		 4255
4256 cmd->section = bfdsec;
4257 }
4258
452216ab 4259 return TRUE;
3af9a47b
NC		 4260}
4261
452216ab 4262static bfd_boolean
ab273af8 4263bfd_mach_o_read_dysymtab (bfd *abfd, bfd_mach_o_load_command *command)
3af9a47b 4264{
046b007d 4265 bfd_mach_o_dysymtab_command *cmd = &command->command.dysymtab;
b32e07d7 4266 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3af9a47b
NC		 4267
4268 BFD_ASSERT (command->type == BFD_MACH_O_LC_DYSYMTAB);
4269
46d1c23b
TG		 4270 {
4271 struct mach_o_dysymtab_command_external raw;
4272
47daa70f 4273 if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
452216ab 4274 return FALSE;
3af9a47b 4275
46d1c23b
TG		 4276 cmd->ilocalsym = bfd_h_get_32 (abfd, raw.ilocalsym);
4277 cmd->nlocalsym = bfd_h_get_32 (abfd, raw.nlocalsym);
4278 cmd->iextdefsym = bfd_h_get_32 (abfd, raw.iextdefsym);
4279 cmd->nextdefsym = bfd_h_get_32 (abfd, raw.nextdefsym);
4280 cmd->iundefsym = bfd_h_get_32 (abfd, raw.iundefsym);
4281 cmd->nundefsym = bfd_h_get_32 (abfd, raw.nundefsym);
4282 cmd->tocoff = bfd_h_get_32 (abfd, raw.tocoff);
4283 cmd->ntoc = bfd_h_get_32 (abfd, raw.ntoc);
4284 cmd->modtaboff = bfd_h_get_32 (abfd, raw.modtaboff);
4285 cmd->nmodtab = bfd_h_get_32 (abfd, raw.nmodtab);
4286 cmd->extrefsymoff = bfd_h_get_32 (abfd, raw.extrefsymoff);
4287 cmd->nextrefsyms = bfd_h_get_32 (abfd, raw.nextrefsyms);
4288 cmd->indirectsymoff = bfd_h_get_32 (abfd, raw.indirectsymoff);
4289 cmd->nindirectsyms = bfd_h_get_32 (abfd, raw.nindirectsyms);
4290 cmd->extreloff = bfd_h_get_32 (abfd, raw.extreloff);
4291 cmd->nextrel = bfd_h_get_32 (abfd, raw.nextrel);
4292 cmd->locreloff = bfd_h_get_32 (abfd, raw.locreloff);
4293 cmd->nlocrel = bfd_h_get_32 (abfd, raw.nlocrel);
4294 }
046b007d
TG		 4295
4296 if (cmd->nmodtab != 0)
4297 {
046b007d
TG		 4298 unsigned int i;
4299 int wide = bfd_mach_o_wide_p (abfd);
4300 unsigned int module_len = wide ? 56 : 52;
4301
4302 cmd->dylib_module =
07d6d2b8 4303 bfd_alloc2 (abfd, cmd->nmodtab, sizeof (bfd_mach_o_dylib_module));
046b007d 4304 if (cmd->dylib_module == NULL)
07d6d2b8 4305 return FALSE;
046b007d
TG		 4306
4307 if (bfd_seek (abfd, cmd->modtaboff, SEEK_SET) != 0)
07d6d2b8 4308 return FALSE;
046b007d
TG		 4309
4310 for (i = 0; i < cmd->nmodtab; i++)
07d6d2b8
AM		 4311 {
4312 bfd_mach_o_dylib_module *module = &cmd->dylib_module[i];
4313 unsigned long v;
4314 unsigned char buf[56];
4315
4316 if (bfd_bread ((void *) buf, module_len, abfd) != module_len)
4317 return FALSE;
4318
4319 module->module_name_idx = bfd_h_get_32 (abfd, buf + 0);
4320 module->iextdefsym = bfd_h_get_32 (abfd, buf + 4);
4321 module->nextdefsym = bfd_h_get_32 (abfd, buf + 8);
4322 module->irefsym = bfd_h_get_32 (abfd, buf + 12);
4323 module->nrefsym = bfd_h_get_32 (abfd, buf + 16);
4324 module->ilocalsym = bfd_h_get_32 (abfd, buf + 20);
4325 module->nlocalsym = bfd_h_get_32 (abfd, buf + 24);
4326 module->iextrel = bfd_h_get_32 (abfd, buf + 28);
4327 module->nextrel = bfd_h_get_32 (abfd, buf + 32);
4328 v = bfd_h_get_32 (abfd, buf +36);
4329 module->iinit = v & 0xffff;
4330 module->iterm = (v >> 16) & 0xffff;
4331 v = bfd_h_get_32 (abfd, buf + 40);
4332 module->ninit = v & 0xffff;
4333 module->nterm = (v >> 16) & 0xffff;
4334 if (wide)
4335 {
4336 module->objc_module_info_size = bfd_h_get_32 (abfd, buf + 44);
4337 module->objc_module_info_addr = bfd_h_get_64 (abfd, buf + 48);
4338 }
4339 else
4340 {
4341 module->objc_module_info_addr = bfd_h_get_32 (abfd, buf + 44);
4342 module->objc_module_info_size = bfd_h_get_32 (abfd, buf + 48);
4343 }
4344 }
046b007d 4345 }
afbb9e17 4346
046b007d
TG		 4347 if (cmd->ntoc != 0)
4348 {
64d29018 4349 unsigned long i;
046b007d 4350
64d29018 4351 cmd->dylib_toc = bfd_alloc2
07d6d2b8 4352 (abfd, cmd->ntoc, sizeof (bfd_mach_o_dylib_table_of_content));
046b007d 4353 if (cmd->dylib_toc == NULL)
07d6d2b8 4354 return FALSE;
046b007d
TG		 4355
4356 if (bfd_seek (abfd, cmd->tocoff, SEEK_SET) != 0)
07d6d2b8 4357 return FALSE;
046b007d
TG		 4358
4359 for (i = 0; i < cmd->ntoc; i++)
07d6d2b8
AM		 4360 {
4361 struct mach_o_dylib_table_of_contents_external raw;
4362 bfd_mach_o_dylib_table_of_content *toc = &cmd->dylib_toc[i];
046b007d 4363
07d6d2b8
AM		 4364 if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
4365 return FALSE;
046b007d 4366
07d6d2b8
AM		 4367 toc->symbol_index = bfd_h_get_32 (abfd, raw.symbol_index);
4368 toc->module_index = bfd_h_get_32 (abfd, raw.module_index);
4369 }
046b007d
TG		 4370 }
4371
4372 if (cmd->nindirectsyms != 0)
4373 {
046b007d
TG		 4374 unsigned int i;
4375
64d29018 4376 cmd->indirect_syms = bfd_alloc2
07d6d2b8 4377 (abfd, cmd->nindirectsyms, sizeof (unsigned int));
046b007d 4378 if (cmd->indirect_syms == NULL)
07d6d2b8 4379 return FALSE;
046b007d
TG		 4380
4381 if (bfd_seek (abfd, cmd->indirectsymoff, SEEK_SET) != 0)
07d6d2b8 4382 return FALSE;
046b007d
TG		 4383
4384 for (i = 0; i < cmd->nindirectsyms; i++)
07d6d2b8
AM		 4385 {
4386 unsigned char raw[4];
4387 unsigned int *is = &cmd->indirect_syms[i];
046b007d 4388
07d6d2b8
AM		 4389 if (bfd_bread (raw, sizeof (raw), abfd) != sizeof (raw))
4390 return FALSE;
046b007d 4391
07d6d2b8
AM		 4392 *is = bfd_h_get_32 (abfd, raw);
4393 }
046b007d
TG		 4394 }
4395
4396 if (cmd->nextrefsyms != 0)
4397 {
046b007d
TG		 4398 unsigned long v;
4399 unsigned int i;
4400
64d29018 4401 cmd->ext_refs = bfd_alloc2
07d6d2b8 4402 (abfd, cmd->nextrefsyms, sizeof (bfd_mach_o_dylib_reference));
046b007d 4403 if (cmd->ext_refs == NULL)
07d6d2b8 4404 return FALSE;
046b007d
TG		 4405
4406 if (bfd_seek (abfd, cmd->extrefsymoff, SEEK_SET) != 0)
07d6d2b8 4407 return FALSE;
046b007d
TG		 4408
4409 for (i = 0; i < cmd->nextrefsyms; i++)
07d6d2b8
AM		 4410 {
4411 unsigned char raw[4];
4412 bfd_mach_o_dylib_reference *ref = &cmd->ext_refs[i];
4413
4414 if (bfd_bread (raw, sizeof (raw), abfd) != sizeof (raw))
4415 return FALSE;
4416
4417 /* Fields isym and flags are written as bit-fields, thus we need
4418 a specific processing for endianness. */
4419 v = bfd_h_get_32 (abfd, raw);
4420 if (bfd_big_endian (abfd))
4421 {
4422 ref->isym = (v >> 8) & 0xffffff;
4423 ref->flags = v & 0xff;
4424 }
4425 else
4426 {
4427 ref->isym = v & 0xffffff;
4428 ref->flags = (v >> 24) & 0xff;
4429 }
4430 }
046b007d 4431 }
3af9a47b 4432
b32e07d7 4433 if (mdata->dysymtab)
452216ab 4434 return FALSE;
b32e07d7
TG		 4435 mdata->dysymtab = cmd;
4436
452216ab 4437 return TRUE;
3af9a47b
NC		 4438}
4439
452216ab 4440static bfd_boolean
ab273af8 4441bfd_mach_o_read_symtab (bfd *abfd, bfd_mach_o_load_command *command)
3af9a47b 4442{
046b007d
TG		 4443 bfd_mach_o_symtab_command *symtab = &command->command.symtab;
4444 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
46d1c23b 4445 struct mach_o_symtab_command_external raw;
3af9a47b
NC		 4446
4447 BFD_ASSERT (command->type == BFD_MACH_O_LC_SYMTAB);
4448
47daa70f 4449 if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
452216ab 4450 return FALSE;
a95a4550 4451
46d1c23b
TG		 4452 symtab->symoff = bfd_h_get_32 (abfd, raw.symoff);
4453 symtab->nsyms = bfd_h_get_32 (abfd, raw.nsyms);
4454 symtab->stroff = bfd_h_get_32 (abfd, raw.stroff);
4455 symtab->strsize = bfd_h_get_32 (abfd, raw.strsize);
046b007d
TG		 4456 symtab->symbols = NULL;
4457 symtab->strtab = NULL;
3af9a47b 4458
046b007d 4459 if (symtab->nsyms != 0)
15e1c58a
TG		 4460 abfd->flags |= HAS_SYMS;
4461
046b007d 4462 if (mdata->symtab)
452216ab 4463 return FALSE;
046b007d 4464 mdata->symtab = symtab;
452216ab 4465 return TRUE;
3af9a47b
NC		 4466}
4467
452216ab 4468static bfd_boolean
ab273af8 4469bfd_mach_o_read_uuid (bfd *abfd, bfd_mach_o_load_command *command)
15e1c58a
TG		 4470{
4471 bfd_mach_o_uuid_command *cmd = &command->command.uuid;
15e1c58a
TG		 4472
4473 BFD_ASSERT (command->type == BFD_MACH_O_LC_UUID);
4474
47daa70f 4475 if (bfd_bread (cmd->uuid, 16, abfd) != 16)
452216ab 4476 return FALSE;
15e1c58a 4477
452216ab 4478 return TRUE;
15e1c58a
TG		 4479}
4480
452216ab 4481static bfd_boolean
ab273af8 4482bfd_mach_o_read_linkedit (bfd *abfd, bfd_mach_o_load_command *command)
046b007d
TG		 4483{
4484 bfd_mach_o_linkedit_command *cmd = &command->command.linkedit;
46d1c23b 4485 struct mach_o_linkedit_data_command_external raw;
046b007d 4486
47daa70f 4487 if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
452216ab 4488 return FALSE;
046b007d 4489
46d1c23b
TG		 4490 cmd->dataoff = bfd_get_32 (abfd, raw.dataoff);
4491 cmd->datasize = bfd_get_32 (abfd, raw.datasize);
452216ab 4492 return TRUE;
046b007d
TG		 4493}
4494
452216ab 4495static bfd_boolean
ab273af8 4496bfd_mach_o_read_str (bfd *abfd, bfd_mach_o_load_command *command)
046b007d
TG		 4497{
4498 bfd_mach_o_str_command *cmd = &command->command.str;
46d1c23b 4499 struct mach_o_str_command_external raw;
046b007d
TG		 4500 unsigned long off;
4501
47daa70f 4502 if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
452216ab 4503 return FALSE;
046b007d 4504
46d1c23b 4505 off = bfd_get_32 (abfd, raw.str);
046b007d
TG		 4506 cmd->stroff = command->offset + off;
4507 cmd->str_len = command->len - off;
4508 cmd->str = bfd_alloc (abfd, cmd->str_len);
4509 if (cmd->str == NULL)
452216ab 4510 return FALSE;
046b007d 4511 if (bfd_seek (abfd, cmd->stroff, SEEK_SET) != 0
91d6fa6a 4512 || bfd_bread ((void *) cmd->str, cmd->str_len, abfd) != cmd->str_len)
452216ab
TG		 4513 return FALSE;
4514 return TRUE;
046b007d
TG		 4515}
4516
c9ffd2ea
TG		 4517static unsigned char *
4518bfd_mach_o_alloc_and_read (bfd *abfd, unsigned int off, unsigned int size)
4519{
4520 unsigned char *buf;
4521
4522 buf = bfd_alloc (abfd, size);
4523 if (buf == NULL)
4524 return NULL;
4525 if (bfd_seek (abfd, off, SEEK_SET) != 0
4526 || bfd_bread (buf, size, abfd) != size)
4527 return NULL;
4528 return buf;
4529}
4530
4531static bfd_boolean
4532bfd_mach_o_read_dyld_content (bfd *abfd, bfd_mach_o_dyld_info_command *cmd)
4533{
4534 /* Read rebase content. */
4535 if (cmd->rebase_content == NULL && cmd->rebase_size != 0)
4536 {
4537 cmd->rebase_content =
4538 bfd_mach_o_alloc_and_read (abfd, cmd->rebase_off, cmd->rebase_size);
4539 if (cmd->rebase_content == NULL)
4540 return FALSE;
4541 }
4542
4543 /* Read bind content. */
4544 if (cmd->bind_content == NULL && cmd->bind_size != 0)
4545 {
4546 cmd->bind_content =
4547 bfd_mach_o_alloc_and_read (abfd, cmd->bind_off, cmd->bind_size);
4548 if (cmd->bind_content == NULL)
4549 return FALSE;
4550 }
4551
4552 /* Read weak bind content. */
4553 if (cmd->weak_bind_content == NULL && cmd->weak_bind_size != 0)
4554 {
4555 cmd->weak_bind_content = bfd_mach_o_alloc_and_read
4556 (abfd, cmd->weak_bind_off, cmd->weak_bind_size);
4557 if (cmd->weak_bind_content == NULL)
4558 return FALSE;
4559 }
4560
4561 /* Read lazy bind content. */
4562 if (cmd->lazy_bind_content == NULL && cmd->lazy_bind_size != 0)
4563 {
4564 cmd->lazy_bind_content = bfd_mach_o_alloc_and_read
4565 (abfd, cmd->lazy_bind_off, cmd->lazy_bind_size);
4566 if (cmd->lazy_bind_content == NULL)
4567 return FALSE;
4568 }
4569
4570 /* Read export content. */
4571 if (cmd->export_content == NULL && cmd->export_size != 0)
4572 {
4573 cmd->export_content = bfd_mach_o_alloc_and_read
4574 (abfd, cmd->export_off, cmd->export_size);
4575 if (cmd->export_content == NULL)
4576 return FALSE;
4577 }
4578
4579 return TRUE;
4580}
4581
452216ab 4582static bfd_boolean
ab273af8 4583bfd_mach_o_read_dyld_info (bfd *abfd, bfd_mach_o_load_command *command)
ad86f1fb
TG		 4584{
4585 bfd_mach_o_dyld_info_command *cmd = &command->command.dyld_info;
46d1c23b 4586 struct mach_o_dyld_info_command_external raw;
ad86f1fb 4587
47daa70f 4588 if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
452216ab 4589 return FALSE;
ad86f1fb 4590
46d1c23b
TG		 4591 cmd->rebase_off = bfd_get_32 (abfd, raw.rebase_off);
4592 cmd->rebase_size = bfd_get_32 (abfd, raw.rebase_size);
c9ffd2ea 4593 cmd->rebase_content = NULL;
46d1c23b
TG		 4594 cmd->bind_off = bfd_get_32 (abfd, raw.bind_off);
4595 cmd->bind_size = bfd_get_32 (abfd, raw.bind_size);
c9ffd2ea 4596 cmd->bind_content = NULL;
46d1c23b
TG		 4597 cmd->weak_bind_off = bfd_get_32 (abfd, raw.weak_bind_off);
4598 cmd->weak_bind_size = bfd_get_32 (abfd, raw.weak_bind_size);
c9ffd2ea 4599 cmd->weak_bind_content = NULL;
46d1c23b
TG		 4600 cmd->lazy_bind_off = bfd_get_32 (abfd, raw.lazy_bind_off);
4601 cmd->lazy_bind_size = bfd_get_32 (abfd, raw.lazy_bind_size);
c9ffd2ea 4602 cmd->lazy_bind_content = NULL;
46d1c23b
TG		 4603 cmd->export_off = bfd_get_32 (abfd, raw.export_off);
4604 cmd->export_size = bfd_get_32 (abfd, raw.export_size);
c9ffd2ea 4605 cmd->export_content = NULL;
452216ab 4606 return TRUE;
ad86f1fb
TG		 4607}
4608
edbdea0e
TG		 4609static bfd_boolean
4610bfd_mach_o_read_version_min (bfd *abfd, bfd_mach_o_load_command *command)
4611{
4612 bfd_mach_o_version_min_command *cmd = &command->command.version_min;
4613 struct mach_o_version_min_command_external raw;
edbdea0e 4614
47daa70f 4615 if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
edbdea0e
TG		 4616 return FALSE;
4617
fc7b364a
RB		 4618 cmd->version = bfd_get_32 (abfd, raw.version);
4619 cmd->sdk = bfd_get_32 (abfd, raw.sdk);
edbdea0e
TG		 4620 return TRUE;
4621}
4622
fc55a902
TG		 4623static bfd_boolean
4624bfd_mach_o_read_encryption_info (bfd *abfd, bfd_mach_o_load_command *command)
4625{
4626 bfd_mach_o_encryption_info_command *cmd = &command->command.encryption_info;
4627 struct mach_o_encryption_info_command_external raw;
4628
47daa70f
TG		 4629 if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
4630 return FALSE;
4631
4632 cmd->cryptoff = bfd_get_32 (abfd, raw.cryptoff);
4633 cmd->cryptsize = bfd_get_32 (abfd, raw.cryptsize);
4634 cmd->cryptid = bfd_get_32 (abfd, raw.cryptid);
4635 return TRUE;
4636}
4637
4638static bfd_boolean
4639bfd_mach_o_read_encryption_info_64 (bfd *abfd, bfd_mach_o_load_command *command)
4640{
4641 bfd_mach_o_encryption_info_command *cmd = &command->command.encryption_info;
4642 struct mach_o_encryption_info_64_command_external raw;
4643
4644 if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
fc55a902
TG		 4645 return FALSE;
4646
4647 cmd->cryptoff = bfd_get_32 (abfd, raw.cryptoff);
4648 cmd->cryptsize = bfd_get_32 (abfd, raw.cryptsize);
4649 cmd->cryptid = bfd_get_32 (abfd, raw.cryptid);
4650 return TRUE;
4651}
4652
1778ad74
TG		 4653static bfd_boolean
4654bfd_mach_o_read_main (bfd *abfd, bfd_mach_o_load_command *command)
4655{
4656 bfd_mach_o_main_command *cmd = &command->command.main;
4657 struct mach_o_entry_point_command_external raw;
4658
47daa70f 4659 if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
1778ad74
TG		 4660 return FALSE;
4661
4662 cmd->entryoff = bfd_get_64 (abfd, raw.entryoff);
4663 cmd->stacksize = bfd_get_64 (abfd, raw.stacksize);
4664 return TRUE;
4665}
4666
4667static bfd_boolean
4668bfd_mach_o_read_source_version (bfd *abfd, bfd_mach_o_load_command *command)
4669{
4670 bfd_mach_o_source_version_command *cmd = &command->command.source_version;
4671 struct mach_o_source_version_command_external raw;
4672 bfd_uint64_t ver;
4673
47daa70f 4674 if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
1778ad74
TG		 4675 return FALSE;
4676
4677 ver = bfd_get_64 (abfd, raw.version);
4678 /* Note: we use a serie of shift to avoid shift > 32 (for which gcc
4679 generates warnings) in case of the host doesn't support 64 bit
4680 integers. */
4681 cmd->e = ver & 0x3ff;
4682 ver >>= 10;
4683 cmd->d = ver & 0x3ff;
4684 ver >>= 10;
4685 cmd->c = ver & 0x3ff;
4686 ver >>= 10;
4687 cmd->b = ver & 0x3ff;
4688 ver >>= 10;
4689 cmd->a = ver & 0xffffff;
4690 return TRUE;
4691}
4692
fc7b364a
RB		 4693static bfd_boolean
4694bfd_mach_o_read_note (bfd *abfd, bfd_mach_o_load_command *command)
4695{
4696 bfd_mach_o_note_command *cmd = &command->command.note;
4697 struct mach_o_note_command_external raw;
4698
4699 if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
4700 return FALSE;
4701
4702 memcpy (cmd->data_owner, raw.data_owner, 16);
4703 cmd->offset = bfd_get_64 (abfd, raw.offset);
4704 cmd->size = bfd_get_64 (abfd, raw.size);
4705 return TRUE;
4706}
4707
4708static bfd_boolean
4709bfd_mach_o_read_build_version (bfd *abfd, bfd_mach_o_load_command *command)
4710{
4711 bfd_mach_o_build_version_command *cmd = &command->command.build_version;
4712 struct mach_o_build_version_command_external raw;
4713
4714 if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
4715 return FALSE;
4716
4717 cmd->platform = bfd_get_32 (abfd, raw.platform);
4718 cmd->minos = bfd_get_32 (abfd, raw.minos);
4719 cmd->sdk = bfd_get_32 (abfd, raw.sdk);
4720 cmd->ntools = bfd_get_32 (abfd, raw.ntools);
4721 return TRUE;
4722}
4723
452216ab 4724static bfd_boolean
ab273af8 4725bfd_mach_o_read_segment (bfd *abfd,
07d6d2b8
AM		 4726 bfd_mach_o_load_command *command,
4727 unsigned int wide)
3af9a47b 4728{
3af9a47b
NC		 4729 bfd_mach_o_segment_command *seg = &command->command.segment;
4730 unsigned long i;
a95a4550 4731
1e8a024a
TG		 4732 if (wide)
4733 {
46d1c23b
TG		 4734 struct mach_o_segment_command_64_external raw;
4735
1e8a024a 4736 BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT_64);
3af9a47b 4737
47daa70f 4738 if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
07d6d2b8 4739 return FALSE;
3af9a47b 4740
46d1c23b 4741 memcpy (seg->segname, raw.segname, 16);
15e1c58a 4742 seg->segname[16] = '\0';
1e8a024a 4743
46d1c23b
TG		 4744 seg->vmaddr = bfd_h_get_64 (abfd, raw.vmaddr);
4745 seg->vmsize = bfd_h_get_64 (abfd, raw.vmsize);
4746 seg->fileoff = bfd_h_get_64 (abfd, raw.fileoff);
4747 seg->filesize = bfd_h_get_64 (abfd, raw.filesize);
4748 seg->maxprot = bfd_h_get_32 (abfd, raw.maxprot);
4749 seg->initprot = bfd_h_get_32 (abfd, raw.initprot);
4750 seg->nsects = bfd_h_get_32 (abfd, raw.nsects);
4751 seg->flags = bfd_h_get_32 (abfd, raw.flags);
1e8a024a
TG		 4752 }
4753 else
4754 {
46d1c23b
TG		 4755 struct mach_o_segment_command_32_external raw;
4756
1e8a024a
TG		 4757 BFD_ASSERT (command->type == BFD_MACH_O_LC_SEGMENT);
4758
47daa70f 4759 if (bfd_bread (&raw, sizeof (raw), abfd) != sizeof (raw))
07d6d2b8 4760 return FALSE;
1e8a024a 4761
46d1c23b 4762 memcpy (seg->segname, raw.segname, 16);
15e1c58a 4763 seg->segname[16] = '\0';
1e8a024a 4764
46d1c23b
TG		 4765 seg->vmaddr = bfd_h_get_32 (abfd, raw.vmaddr);
4766 seg->vmsize = bfd_h_get_32 (abfd, raw.vmsize);
4767 seg->fileoff = bfd_h_get_32 (abfd, raw.fileoff);
4768 seg->filesize = bfd_h_get_32 (abfd, raw.filesize);
4769 seg->maxprot = bfd_h_get_32 (abfd, raw.maxprot);
4770 seg->initprot = bfd_h_get_32 (abfd, raw.initprot);
4771 seg->nsects = bfd_h_get_32 (abfd, raw.nsects);
4772 seg->flags = bfd_h_get_32 (abfd, raw.flags);
1e8a024a 4773 }
9d4b6009
TG		 4774 seg->sect_head = NULL;
4775 seg->sect_tail = NULL;
3af9a47b 4776
f1bde64c 4777 for (i = 0; i < seg->nsects; i++)
3af9a47b 4778 {
f1bde64c 4779 asection *sec;
a95a4550 4780
47daa70f 4781 sec = bfd_mach_o_read_section (abfd, seg->initprot, wide);
f1bde64c 4782 if (sec == NULL)
07d6d2b8 4783 return FALSE;
f1bde64c 4784
c9ffd2ea
TG		 4785 bfd_mach_o_append_section_to_segment
4786 (seg, bfd_mach_o_get_mach_o_section (sec));
3af9a47b
NC		 4787 }
4788
452216ab 4789 return TRUE;
3af9a47b
NC		 4790}
4791
452216ab 4792static bfd_boolean
ab273af8 4793bfd_mach_o_read_segment_32 (bfd *abfd, bfd_mach_o_load_command *command)
1e8a024a 4794{
ab273af8 4795 return bfd_mach_o_read_segment (abfd, command, 0);
1e8a024a
TG		 4796}
4797
452216ab 4798static bfd_boolean
ab273af8 4799bfd_mach_o_read_segment_64 (bfd *abfd, bfd_mach_o_load_command *command)
1e8a024a 4800{
ab273af8 4801 return bfd_mach_o_read_segment (abfd, command, 1);
1e8a024a
TG		 4802}
4803
452216ab 4804static bfd_boolean
ab273af8 4805bfd_mach_o_read_command (bfd *abfd, bfd_mach_o_load_command *command)
3af9a47b 4806{
47daa70f 4807 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
46d1c23b
TG		 4808 struct mach_o_load_command_external raw;
4809 unsigned int cmd;
3af9a47b 4810
046b007d 4811 /* Read command type and length. */
47daa70f 4812 if (bfd_seek (abfd, mdata->hdr_offset + command->offset, SEEK_SET) != 0
46d1c23b 4813 || bfd_bread (&raw, BFD_MACH_O_LC_SIZE, abfd) != BFD_MACH_O_LC_SIZE)
452216ab 4814 return FALSE;
3af9a47b 4815
46d1c23b
TG		 4816 cmd = bfd_h_get_32 (abfd, raw.cmd);
4817 command->type = cmd & ~BFD_MACH_O_LC_REQ_DYLD;
4818 command->type_required = cmd & BFD_MACH_O_LC_REQ_DYLD ? TRUE : FALSE;
4819 command->len = bfd_h_get_32 (abfd, raw.cmdsize);
3af9a47b
NC		 4820
4821 switch (command->type)
4822 {
4823 case BFD_MACH_O_LC_SEGMENT:
452216ab
TG		 4824 if (!bfd_mach_o_read_segment_32 (abfd, command))
4825 return FALSE;
1e8a024a
TG		 4826 break;
4827 case BFD_MACH_O_LC_SEGMENT_64:
452216ab
TG		 4828 if (!bfd_mach_o_read_segment_64 (abfd, command))
4829 return FALSE;
3af9a47b
NC		 4830 break;
4831 case BFD_MACH_O_LC_SYMTAB:
452216ab
TG		 4832 if (!bfd_mach_o_read_symtab (abfd, command))
4833 return FALSE;
3af9a47b
NC		 4834 break;
4835 case BFD_MACH_O_LC_SYMSEG:
4836 break;
4837 case BFD_MACH_O_LC_THREAD:
4838 case BFD_MACH_O_LC_UNIXTHREAD:
452216ab
TG		 4839 if (!bfd_mach_o_read_thread (abfd, command))
4840 return FALSE;
3af9a47b
NC		 4841 break;
4842 case BFD_MACH_O_LC_LOAD_DYLINKER:
4843 case BFD_MACH_O_LC_ID_DYLINKER:
10be66a4 4844 case BFD_MACH_O_LC_DYLD_ENVIRONMENT:
452216ab
TG		 4845 if (!bfd_mach_o_read_dylinker (abfd, command))
4846 return FALSE;
3af9a47b
NC		 4847 break;
4848 case BFD_MACH_O_LC_LOAD_DYLIB:
fbe383b9 4849 case BFD_MACH_O_LC_LAZY_LOAD_DYLIB:
3af9a47b
NC		 4850 case BFD_MACH_O_LC_ID_DYLIB:
4851 case BFD_MACH_O_LC_LOAD_WEAK_DYLIB:
046b007d 4852 case BFD_MACH_O_LC_REEXPORT_DYLIB:
73017762 4853 case BFD_MACH_O_LC_LOAD_UPWARD_DYLIB:
452216ab
TG		 4854 if (!bfd_mach_o_read_dylib (abfd, command))
4855 return FALSE;
3af9a47b
NC		 4856 break;
4857 case BFD_MACH_O_LC_PREBOUND_DYLIB:
452216ab
TG		 4858 if (!bfd_mach_o_read_prebound_dylib (abfd, command))
4859 return FALSE;
3af9a47b
NC		 4860 break;
4861 case BFD_MACH_O_LC_LOADFVMLIB:
4862 case BFD_MACH_O_LC_IDFVMLIB:
452216ab
TG		 4863 if (!bfd_mach_o_read_fvmlib (abfd, command))
4864 return FALSE;
9f4a5bd1 4865 break;
3af9a47b
NC		 4866 case BFD_MACH_O_LC_IDENT:
4867 case BFD_MACH_O_LC_FVMFILE:
4868 case BFD_MACH_O_LC_PREPAGE:
4869 case BFD_MACH_O_LC_ROUTINES:
9b02d212 4870 case BFD_MACH_O_LC_ROUTINES_64:
046b007d 4871 break;
3af9a47b 4872 case BFD_MACH_O_LC_SUB_FRAMEWORK:
046b007d
TG		 4873 case BFD_MACH_O_LC_SUB_UMBRELLA:
4874 case BFD_MACH_O_LC_SUB_LIBRARY:
4875 case BFD_MACH_O_LC_SUB_CLIENT:
0c9b2b4c 4876 case BFD_MACH_O_LC_RPATH:
452216ab 4877 if (!bfd_mach_o_read_str (abfd, command))
07d6d2b8 4878 return FALSE;
3af9a47b
NC		 4879 break;
4880 case BFD_MACH_O_LC_DYSYMTAB:
452216ab
TG		 4881 if (!bfd_mach_o_read_dysymtab (abfd, command))
4882 return FALSE;
3af9a47b 4883 break;
3af9a47b 4884 case BFD_MACH_O_LC_PREBIND_CKSUM:
452216ab
TG		 4885 if (!bfd_mach_o_read_prebind_cksum (abfd, command))
4886 return FALSE;
7a79c514
TG		 4887 break;
4888 case BFD_MACH_O_LC_TWOLEVEL_HINTS:
452216ab
TG		 4889 if (!bfd_mach_o_read_twolevel_hints (abfd, command))
4890 return FALSE;
3af9a47b 4891 break;
15e1c58a 4892 case BFD_MACH_O_LC_UUID:
452216ab
TG		 4893 if (!bfd_mach_o_read_uuid (abfd, command))
4894 return FALSE;
15e1c58a
TG		 4895 break;
4896 case BFD_MACH_O_LC_CODE_SIGNATURE:
846b9259 4897 case BFD_MACH_O_LC_SEGMENT_SPLIT_INFO:
edbdea0e 4898 case BFD_MACH_O_LC_FUNCTION_STARTS:
1778ad74
TG		 4899 case BFD_MACH_O_LC_DATA_IN_CODE:
4900 case BFD_MACH_O_LC_DYLIB_CODE_SIGN_DRS:
47daa70f 4901 case BFD_MACH_O_LC_LINKER_OPTIMIZATION_HINT:
452216ab
TG		 4902 if (!bfd_mach_o_read_linkedit (abfd, command))
4903 return FALSE;
15e1c58a 4904 break;
fc55a902
TG		 4905 case BFD_MACH_O_LC_ENCRYPTION_INFO:
4906 if (!bfd_mach_o_read_encryption_info (abfd, command))
452216ab 4907 return FALSE;
fc55a902 4908 break;
47daa70f
TG		 4909 case BFD_MACH_O_LC_ENCRYPTION_INFO_64:
4910 if (!bfd_mach_o_read_encryption_info_64 (abfd, command))
4911 return FALSE;
4912 break;
ad86f1fb 4913 case BFD_MACH_O_LC_DYLD_INFO:
452216ab
TG		 4914 if (!bfd_mach_o_read_dyld_info (abfd, command))
4915 return FALSE;
ad86f1fb 4916 break;
edbdea0e
TG		 4917 case BFD_MACH_O_LC_VERSION_MIN_MACOSX:
4918 case BFD_MACH_O_LC_VERSION_MIN_IPHONEOS:
47daa70f 4919 case BFD_MACH_O_LC_VERSION_MIN_WATCHOS:
fc7b364a 4920 case BFD_MACH_O_LC_VERSION_MIN_TVOS:
edbdea0e 4921 if (!bfd_mach_o_read_version_min (abfd, command))
452216ab 4922 return FALSE;
edbdea0e 4923 break;
1778ad74
TG		 4924 case BFD_MACH_O_LC_MAIN:
4925 if (!bfd_mach_o_read_main (abfd, command))
452216ab 4926 return FALSE;
1778ad74
TG		 4927 break;
4928 case BFD_MACH_O_LC_SOURCE_VERSION:
4929 if (!bfd_mach_o_read_source_version (abfd, command))
452216ab 4930 return FALSE;
1778ad74 4931 break;
ddea148b 4932 case BFD_MACH_O_LC_LINKER_OPTIONS:
fc7b364a
RB		 4933 break;
4934 case BFD_MACH_O_LC_NOTE:
4935 if (!bfd_mach_o_read_note (abfd, command))
4936 return FALSE;
4937 break;
ddea148b 4938 case BFD_MACH_O_LC_BUILD_VERSION:
fc7b364a
RB		 4939 if (!bfd_mach_o_read_build_version (abfd, command))
4940 return FALSE;
ddea148b 4941 break;
3af9a47b 4942 default:
86eafac0 4943 command->len = 0;
871b3ab2 4944 _bfd_error_handler (_("%pB: unknown load command %#x"),
d42c267e 4945 abfd, command->type);
86eafac0 4946 return FALSE;
3af9a47b
NC		 4947 }
4948
452216ab 4949 return TRUE;
3af9a47b
NC		 4950}
4951
4952static void
116c20d2 4953bfd_mach_o_flatten_sections (bfd *abfd)
3af9a47b 4954{
046b007d 4955 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
c9ffd2ea 4956 bfd_mach_o_load_command *cmd;
3af9a47b 4957 long csect = 0;
a95a4550 4958
15e1c58a 4959 /* Count total number of sections. */
3af9a47b
NC		 4960 mdata->nsects = 0;
4961
c9ffd2ea 4962 for (cmd = mdata->first_command; cmd != NULL; cmd = cmd->next)
3af9a47b 4963 {
c9ffd2ea
TG		 4964 if (cmd->type == BFD_MACH_O_LC_SEGMENT
4965 || cmd->type == BFD_MACH_O_LC_SEGMENT_64)
3af9a47b 4966 {
c9ffd2ea 4967 bfd_mach_o_segment_command *seg = &cmd->command.segment;
e84d6fca 4968
3af9a47b
NC		 4969 mdata->nsects += seg->nsects;
4970 }
4971 }
4972
15e1c58a 4973 /* Allocate sections array. */
64d29018
NC		 4974 mdata->sections = bfd_alloc2 (abfd,
4975 mdata->nsects, sizeof (bfd_mach_o_section *));
15e1c58a
TG		 4976
4977 /* Fill the array. */
3af9a47b
NC		 4978 csect = 0;
4979
c9ffd2ea 4980 for (cmd = mdata->first_command; cmd != NULL; cmd = cmd->next)
3af9a47b 4981 {
c9ffd2ea
TG		 4982 if (cmd->type == BFD_MACH_O_LC_SEGMENT
4983 || cmd->type == BFD_MACH_O_LC_SEGMENT_64)
3af9a47b 4984 {
c9ffd2ea 4985 bfd_mach_o_segment_command *seg = &cmd->command.segment;
07d6d2b8 4986 bfd_mach_o_section *sec;
3af9a47b
NC		 4987
4988 BFD_ASSERT (csect + seg->nsects <= mdata->nsects);
4989
07d6d2b8 4990 for (sec = seg->sect_head; sec != NULL; sec = sec->next)
f1bde64c 4991 mdata->sections[csect++] = sec;
3af9a47b
NC		 4992 }
4993 }
4994}
4995
afbb9e17 4996static bfd_boolean
116c20d2 4997bfd_mach_o_scan_start_address (bfd *abfd)
3af9a47b 4998{
046b007d 4999 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
c9ffd2ea
TG		 5000 bfd_mach_o_thread_command *thr = NULL;
5001 bfd_mach_o_load_command *cmd;
3af9a47b
NC		 5002 unsigned long i;
5003
c9ffd2ea
TG		 5004 for (cmd = mdata->first_command; cmd != NULL; cmd = cmd->next)
5005 if (cmd->type == BFD_MACH_O_LC_THREAD
5006 || cmd->type == BFD_MACH_O_LC_UNIXTHREAD)
afbb9e17 5007 {
07d6d2b8
AM		 5008 thr = &cmd->command.thread;
5009 break;
afbb9e17 5010 }
c9ffd2ea 5011 else if (cmd->type == BFD_MACH_O_LC_MAIN && mdata->nsects > 1)
c0fd7846 5012 {
c9ffd2ea 5013 bfd_mach_o_main_command *main_cmd = &cmd->command.main;
c0fd7846 5014 bfd_mach_o_section *text_sect = mdata->sections[0];
c9ffd2ea 5015
c0fd7846
TG		 5016 if (text_sect)
5017 {
5018 abfd->start_address = main_cmd->entryoff
5019 + (text_sect->addr - text_sect->offset);
5020 return TRUE;
5021 }
5022 }
3af9a47b 5023
5ee43bc4 5024 /* An object file has no start address, so do not fail if not found. */
c9ffd2ea 5025 if (thr == NULL)
5ee43bc4 5026 return TRUE;
3af9a47b 5027
afbb9e17 5028 /* FIXME: create a subtarget hook ? */
c9ffd2ea 5029 for (i = 0; i < thr->nflavours; i++)
3af9a47b 5030 {
a95a4550 5031 if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_I386)
c9ffd2ea 5032 && (thr->flavours[i].flavour == BFD_MACH_O_x86_THREAD_STATE32))
3af9a47b
NC		 5033 {
5034 unsigned char buf[4];
5035
c9ffd2ea 5036 if (bfd_seek (abfd, thr->flavours[i].offset + 40, SEEK_SET) != 0
07d6d2b8 5037 || bfd_bread (buf, 4, abfd) != 4)
afbb9e17 5038 return FALSE;
3af9a47b
NC		 5039
5040 abfd->start_address = bfd_h_get_32 (abfd, buf);
5041 }
a95a4550 5042 else if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_POWERPC)
c9ffd2ea 5043 && (thr->flavours[i].flavour == BFD_MACH_O_PPC_THREAD_STATE))
3af9a47b
NC		 5044 {
5045 unsigned char buf[4];
5046
c9ffd2ea 5047 if (bfd_seek (abfd, thr->flavours[i].offset + 0, SEEK_SET) != 0
07d6d2b8 5048 || bfd_bread (buf, 4, abfd) != 4)
afbb9e17 5049 return FALSE;
3af9a47b
NC		 5050
5051 abfd->start_address = bfd_h_get_32 (abfd, buf);
5052 }
1e8a024a 5053 else if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_POWERPC_64)
07d6d2b8
AM		 5054 && (thr->flavours[i].flavour == BFD_MACH_O_PPC_THREAD_STATE64))
5055 {
5056 unsigned char buf[8];
1e8a024a 5057
07d6d2b8
AM		 5058 if (bfd_seek (abfd, thr->flavours[i].offset + 0, SEEK_SET) != 0
5059 || bfd_bread (buf, 8, abfd) != 8)
5060 return FALSE;
1e8a024a 5061
07d6d2b8
AM		 5062 abfd->start_address = bfd_h_get_64 (abfd, buf);
5063 }
1e8a024a 5064 else if ((mdata->header.cputype == BFD_MACH_O_CPU_TYPE_X86_64)
07d6d2b8
AM		 5065 && (thr->flavours[i].flavour == BFD_MACH_O_x86_THREAD_STATE64))
5066 {
5067 unsigned char buf[8];
1e8a024a 5068
07d6d2b8
AM		 5069 if (bfd_seek (abfd, thr->flavours[i].offset + (16 * 8), SEEK_SET) != 0
5070 || bfd_bread (buf, 8, abfd) != 8)
5071 return FALSE;
1e8a024a 5072
07d6d2b8
AM		 5073 abfd->start_address = bfd_h_get_64 (abfd, buf);
5074 }
3af9a47b
NC		 5075 }
5076
afbb9e17 5077 return TRUE;
3af9a47b
NC		 5078}
5079
42fa0891
TG		 5080bfd_boolean
5081bfd_mach_o_set_arch_mach (bfd *abfd,
07d6d2b8
AM		 5082 enum bfd_architecture arch,
5083 unsigned long machine)
42fa0891
TG		 5084{
5085 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
5086
5087 /* If this isn't the right architecture for this backend, and this
5088 isn't the generic backend, fail. */
5089 if (arch != bed->arch
5090 && arch != bfd_arch_unknown
5091 && bed->arch != bfd_arch_unknown)
5092 return FALSE;
5093
5094 return bfd_default_set_arch_mach (abfd, arch, machine);
5095}
5096
afbb9e17 5097static bfd_boolean
116c20d2
NC		 5098bfd_mach_o_scan (bfd *abfd,
5099 bfd_mach_o_header *header,
5100 bfd_mach_o_data_struct *mdata)
3af9a47b
NC		 5101{
5102 unsigned int i;
3af9a47b
NC		 5103 enum bfd_architecture cputype;
5104 unsigned long cpusubtype;
1e8a024a
TG		 5105 unsigned int hdrsize;
5106
c2f09c75 5107 hdrsize = mach_o_wide_p (header) ?
154a1ee5 5108 BFD_MACH_O_HEADER_64_SIZE : BFD_MACH_O_HEADER_SIZE;
3af9a47b 5109
3af9a47b 5110 mdata->header = *header;
3af9a47b 5111
154a1ee5 5112 abfd->flags = abfd->flags & BFD_IN_MEMORY;
15e1c58a
TG		 5113 switch (header->filetype)
5114 {
5115 case BFD_MACH_O_MH_OBJECT:
5116 abfd->flags |= HAS_RELOC;
5117 break;
5118 case BFD_MACH_O_MH_EXECUTE:
5119 abfd->flags |= EXEC_P;
5120 break;
5121 case BFD_MACH_O_MH_DYLIB:
5122 case BFD_MACH_O_MH_BUNDLE:
5123 abfd->flags |= DYNAMIC;
5124 break;
5125 }
5126
3af9a47b
NC		 5127 abfd->tdata.mach_o_data = mdata;
5128
e84d6fca
AM		 5129 bfd_mach_o_convert_architecture (header->cputype, header->cpusubtype,
5130 &cputype, &cpusubtype);
3af9a47b
NC		 5131 if (cputype == bfd_arch_unknown)
5132 {
4eca0228 5133 _bfd_error_handler
695344c0 5134 /* xgettext:c-format */
07d6d2b8
AM		 5135 (_("bfd_mach_o_scan: unknown architecture 0x%lx/0x%lx"),
5136 header->cputype, header->cpusubtype);
afbb9e17 5137 return FALSE;
3af9a47b
NC		 5138 }
5139
5140 bfd_set_arch_mach (abfd, cputype, cpusubtype);
a95a4550 5141
3af9a47b
NC		 5142 if (header->ncmds != 0)
5143 {
c9ffd2ea
TG		 5144 bfd_mach_o_load_command *cmd;
5145
5146 mdata->first_command = NULL;
5147 mdata->last_command = NULL;
64d29018
NC		 5148
5149 cmd = bfd_alloc2 (abfd, header->ncmds, sizeof (bfd_mach_o_load_command));
c9ffd2ea 5150 if (cmd == NULL)
afbb9e17 5151 return FALSE;
a95a4550 5152
3af9a47b
NC		 5153 for (i = 0; i < header->ncmds; i++)
5154 {
c9ffd2ea
TG		 5155 bfd_mach_o_load_command *cur = &cmd[i];
5156
5157 bfd_mach_o_append_command (abfd, cur);
3af9a47b
NC		 5158
5159 if (i == 0)
1e8a024a 5160 cur->offset = hdrsize;
3af9a47b
NC		 5161 else
5162 {
c9ffd2ea 5163 bfd_mach_o_load_command *prev = &cmd[i - 1];
3af9a47b
NC		 5164 cur->offset = prev->offset + prev->len;
5165 }
5166
452216ab 5167 if (!bfd_mach_o_read_command (abfd, cur))
afbb9e17 5168 return FALSE;
a95a4550 5169 }
3af9a47b
NC		 5170 }
5171
c0fd7846
TG		 5172 /* Sections should be flatten before scanning start address. */
5173 bfd_mach_o_flatten_sections (abfd);
5174 if (!bfd_mach_o_scan_start_address (abfd))
afbb9e17 5175 return FALSE;
3af9a47b 5176
afbb9e17 5177 return TRUE;
3af9a47b
NC		 5178}
5179
b34976b6 5180bfd_boolean
154a1ee5 5181bfd_mach_o_mkobject_init (bfd *abfd)
3af9a47b
NC		 5182{
5183 bfd_mach_o_data_struct *mdata = NULL;
5184
b30a5d18 5185 mdata = bfd_zalloc (abfd, sizeof (bfd_mach_o_data_struct));
3af9a47b 5186 if (mdata == NULL)
b34976b6 5187 return FALSE;
3af9a47b
NC		 5188 abfd->tdata.mach_o_data = mdata;
5189
5190 mdata->header.magic = 0;
5191 mdata->header.cputype = 0;
5192 mdata->header.cpusubtype = 0;
5193 mdata->header.filetype = 0;
5194 mdata->header.ncmds = 0;
5195 mdata->header.sizeofcmds = 0;
5196 mdata->header.flags = 0;
5197 mdata->header.byteorder = BFD_ENDIAN_UNKNOWN;
c9ffd2ea
TG		 5198 mdata->first_command = NULL;
5199 mdata->last_command = NULL;
3af9a47b
NC		 5200 mdata->nsects = 0;
5201 mdata->sections = NULL;
4434114c 5202 mdata->dyn_reloc_cache = NULL;
3af9a47b 5203
b34976b6 5204 return TRUE;
3af9a47b
NC		 5205}
5206
42fa0891
TG		 5207static bfd_boolean
5208bfd_mach_o_gen_mkobject (bfd *abfd)
5209{
5210 bfd_mach_o_data_struct *mdata;
5211
5212 if (!bfd_mach_o_mkobject_init (abfd))
5213 return FALSE;
5214
5215 mdata = bfd_mach_o_get_data (abfd);
5216 mdata->header.magic = BFD_MACH_O_MH_MAGIC;
5217 mdata->header.cputype = 0;
5218 mdata->header.cpusubtype = 0;
5219 mdata->header.byteorder = abfd->xvec->byteorder;
5220 mdata->header.version = 1;
5221
5222 return TRUE;
5223}
5224
3af9a47b 5225const bfd_target *
154a1ee5 5226bfd_mach_o_header_p (bfd *abfd,
47daa70f 5227 file_ptr hdr_off,
07d6d2b8
AM		 5228 bfd_mach_o_filetype filetype,
5229 bfd_mach_o_cpu_type cputype)
3af9a47b
NC		 5230{
5231 bfd_mach_o_header header;
c9ba0c87 5232 bfd_mach_o_data_struct *mdata;
3af9a47b 5233
47daa70f 5234 if (!bfd_mach_o_read_header (abfd, hdr_off, &header))
e84d6fca 5235 goto wrong;
3af9a47b 5236
e84d6fca
AM		 5237 if (! (header.byteorder == BFD_ENDIAN_BIG
5238 || header.byteorder == BFD_ENDIAN_LITTLE))
3af9a47b 5239 {
d42c267e
AM		 5240 _bfd_error_handler (_("unknown header byte-order value %#x"),
5241 header.byteorder);
e84d6fca 5242 goto wrong;
3af9a47b
NC		 5243 }
5244
e84d6fca
AM		 5245 if (! ((header.byteorder == BFD_ENDIAN_BIG
5246 && abfd->xvec->byteorder == BFD_ENDIAN_BIG
5247 && abfd->xvec->header_byteorder == BFD_ENDIAN_BIG)
5248 || (header.byteorder == BFD_ENDIAN_LITTLE
5249 && abfd->xvec->byteorder == BFD_ENDIAN_LITTLE
5250 && abfd->xvec->header_byteorder == BFD_ENDIAN_LITTLE)))
5251 goto wrong;
3af9a47b 5252
154a1ee5
TG		 5253 /* Check cputype and filetype.
5254 In case of wildcard, do not accept magics that are handled by existing
5255 targets. */
5256 if (cputype)
5257 {
5258 if (header.cputype != cputype)
07d6d2b8 5259 goto wrong;
154a1ee5 5260 }
26954155
TG		 5261 else
5262 {
5263#ifndef BFD64
5264 /* Do not recognize 64 architectures if not configured for 64bit targets.
5265 This could happen only for generic targets. */
5266 if (mach_o_wide_p (&header))
5267 goto wrong;
5268#endif
5269 }
b22161d6 5270
154a1ee5
TG		 5271 if (filetype)
5272 {
5273 if (header.filetype != filetype)
07d6d2b8 5274 goto wrong;
154a1ee5
TG		 5275 }
5276 else
5277 {
5278 switch (header.filetype)
07d6d2b8
AM		 5279 {
5280 case BFD_MACH_O_MH_CORE:
5281 /* Handled by core_p */
5282 goto wrong;
5283 default:
5284 break;
5285 }
154a1ee5
TG		 5286 }
5287
c9ba0c87
AM		 5288 mdata = (bfd_mach_o_data_struct *) bfd_zalloc (abfd, sizeof (*mdata));
5289 if (mdata == NULL)
e84d6fca 5290 goto fail;
47daa70f 5291 mdata->hdr_offset = hdr_off;
3af9a47b 5292
c9ba0c87 5293 if (!bfd_mach_o_scan (abfd, &header, mdata))
e84d6fca 5294 goto wrong;
a95a4550 5295
3af9a47b 5296 return abfd->xvec;
e84d6fca
AM		 5297
5298 wrong:
5299 bfd_set_error (bfd_error_wrong_format);
5300
5301 fail:
e84d6fca 5302 return NULL;
3af9a47b
NC		 5303}
5304
154a1ee5
TG		 5305static const bfd_target *
5306bfd_mach_o_gen_object_p (bfd *abfd)
3af9a47b 5307{
47daa70f 5308 return bfd_mach_o_header_p (abfd, 0, 0, 0);
154a1ee5 5309}
e84d6fca 5310
154a1ee5
TG		 5311static const bfd_target *
5312bfd_mach_o_gen_core_p (bfd *abfd)
5313{
47daa70f 5314 return bfd_mach_o_header_p (abfd, 0, BFD_MACH_O_MH_CORE, 0);
3af9a47b
NC		 5315}
5316
3cc27770
TG		 5317/* Return the base address of ABFD, ie the address at which the image is
5318 mapped. The possible initial pagezero is ignored. */
5319
5320bfd_vma
5321bfd_mach_o_get_base_address (bfd *abfd)
5322{
5323 bfd_mach_o_data_struct *mdata;
c9ffd2ea 5324 bfd_mach_o_load_command *cmd;
3cc27770
TG		 5325
5326 /* Check for Mach-O. */
5327 if (!bfd_mach_o_valid (abfd))
5328 return 0;
5329 mdata = bfd_mach_o_get_data (abfd);
5330
c9ffd2ea 5331 for (cmd = mdata->first_command; cmd != NULL; cmd = cmd->next)
3cc27770 5332 {
3cc27770
TG		 5333 if ((cmd->type == BFD_MACH_O_LC_SEGMENT
5334 || cmd->type == BFD_MACH_O_LC_SEGMENT_64))
5335 {
5336 struct bfd_mach_o_segment_command *segcmd = &cmd->command.segment;
5337
5338 if (segcmd->initprot != 0)
5339 return segcmd->vmaddr;
5340 }
5341 }
5342 return 0;
5343}
5344
3af9a47b
NC		 5345typedef struct mach_o_fat_archentry
5346{
5347 unsigned long cputype;
5348 unsigned long cpusubtype;
5349 unsigned long offset;
5350 unsigned long size;
5351 unsigned long align;
3af9a47b
NC		 5352} mach_o_fat_archentry;
5353
5354typedef struct mach_o_fat_data_struct
5355{
5356 unsigned long magic;
5357 unsigned long nfat_arch;
5358 mach_o_fat_archentry *archentries;
5359} mach_o_fat_data_struct;
5360
5361const bfd_target *
47daa70f 5362bfd_mach_o_fat_archive_p (bfd *abfd)
3af9a47b 5363{
e84d6fca 5364 mach_o_fat_data_struct *adata = NULL;
46d1c23b 5365 struct mach_o_fat_header_external hdr;
3af9a47b
NC		 5366 unsigned long i;
5367
c2f09c75 5368 if (bfd_seek (abfd, 0, SEEK_SET) != 0
46d1c23b 5369 || bfd_bread (&hdr, sizeof (hdr), abfd) != sizeof (hdr))
e84d6fca 5370 goto error;
3af9a47b 5371
116c20d2 5372 adata = bfd_alloc (abfd, sizeof (mach_o_fat_data_struct));
3af9a47b 5373 if (adata == NULL)
e84d6fca 5374 goto error;
a95a4550 5375
46d1c23b
TG		 5376 adata->magic = bfd_getb32 (hdr.magic);
5377 adata->nfat_arch = bfd_getb32 (hdr.nfat_arch);
3af9a47b 5378 if (adata->magic != 0xcafebabe)
e84d6fca 5379 goto error;
27cc28f9
AS		 5380 /* Avoid matching Java bytecode files, which have the same magic number.
5381 In the Java bytecode file format this field contains the JVM version,
5382 which starts at 43.0. */
5383 if (adata->nfat_arch > 30)
5384 goto error;
3af9a47b 5385
c2f09c75 5386 adata->archentries =
64d29018 5387 bfd_alloc2 (abfd, adata->nfat_arch, sizeof (mach_o_fat_archentry));
3af9a47b 5388 if (adata->archentries == NULL)
e84d6fca 5389 goto error;
3af9a47b
NC		 5390
5391 for (i = 0; i < adata->nfat_arch; i++)
5392 {
46d1c23b
TG		 5393 struct mach_o_fat_arch_external arch;
5394 if (bfd_bread (&arch, sizeof (arch), abfd) != sizeof (arch))
e84d6fca 5395 goto error;
46d1c23b
TG		 5396 adata->archentries[i].cputype = bfd_getb32 (arch.cputype);
5397 adata->archentries[i].cpusubtype = bfd_getb32 (arch.cpusubtype);
5398 adata->archentries[i].offset = bfd_getb32 (arch.offset);
5399 adata->archentries[i].size = bfd_getb32 (arch.size);
5400 adata->archentries[i].align = bfd_getb32 (arch.align);
3af9a47b
NC		 5401 }
5402
5403 abfd->tdata.mach_o_fat_data = adata;
64d29018 5404
3af9a47b 5405 return abfd->xvec;
e84d6fca
AM		 5406
5407 error:
5408 if (adata != NULL)
5409 bfd_release (abfd, adata);
5410 bfd_set_error (bfd_error_wrong_format);
5411 return NULL;
3af9a47b
NC		 5412}
5413
a4e241ca
TG		 5414/* Set the filename for a fat binary member ABFD, whose bfd architecture is
5415 ARCH_TYPE/ARCH_SUBTYPE and corresponding entry in header is ENTRY.
5416 Set arelt_data and origin fields too. */
5417
5418static void
5419bfd_mach_o_fat_member_init (bfd *abfd,
07d6d2b8
AM		 5420 enum bfd_architecture arch_type,
5421 unsigned long arch_subtype,
5422 mach_o_fat_archentry *entry)
a4e241ca
TG		 5423{
5424 struct areltdata *areltdata;
5425 /* Create the member filename. Use ARCH_NAME. */
5426 const bfd_arch_info_type *ap = bfd_lookup_arch (arch_type, arch_subtype);
5427
5428 if (ap)
5429 {
5430 /* Use the architecture name if known. */
1be5090b 5431 abfd->filename = xstrdup (ap->printable_name);
a4e241ca
TG		 5432 }
5433 else
5434 {
5435 /* Forge a uniq id. */
5436 const size_t namelen = 2 + 8 + 1 + 2 + 8 + 1;
1be5090b 5437 char *name = xmalloc (namelen);
a4e241ca 5438 snprintf (name, namelen, "0x%lx-0x%lx",
07d6d2b8 5439 entry->cputype, entry->cpusubtype);
a4e241ca
TG		 5440 abfd->filename = name;
5441 }
5442
06e7acd7 5443 areltdata = bfd_zmalloc (sizeof (struct areltdata));
a4e241ca
TG		 5444 areltdata->parsed_size = entry->size;
5445 abfd->arelt_data = areltdata;
5446 abfd->iostream = NULL;
5447 abfd->origin = entry->offset;
5448}
5449
3af9a47b 5450bfd *
47daa70f 5451bfd_mach_o_fat_openr_next_archived_file (bfd *archive, bfd *prev)
3af9a47b 5452{
e84d6fca 5453 mach_o_fat_data_struct *adata;
3af9a47b
NC		 5454 mach_o_fat_archentry *entry = NULL;
5455 unsigned long i;
15e1c58a 5456 bfd *nbfd;
15e1c58a
TG		 5457 enum bfd_architecture arch_type;
5458 unsigned long arch_subtype;
3af9a47b 5459
e84d6fca 5460 adata = (mach_o_fat_data_struct *) archive->tdata.mach_o_fat_data;
3af9a47b
NC		 5461 BFD_ASSERT (adata != NULL);
5462
5463 /* Find index of previous entry. */
5464 if (prev == NULL)
a4e241ca
TG		 5465 {
5466 /* Start at first one. */
5467 i = 0;
5468 }
3af9a47b
NC		 5469 else
5470 {
a4e241ca 5471 /* Find index of PREV. */
3af9a47b
NC		 5472 for (i = 0; i < adata->nfat_arch; i++)
5473 {
15e1c58a 5474 if (adata->archentries[i].offset == prev->origin)
3af9a47b
NC		 5475 break;
5476 }
5477
5478 if (i == adata->nfat_arch)
5479 {
5480 /* Not found. */
5481 bfd_set_error (bfd_error_bad_value);
a95a4550 5482 return NULL;
3af9a47b 5483 }
a4e241ca
TG		 5484
5485 /* Get next entry. */
5486 i++;
5487 }
a95a4550 5488
3af9a47b
NC		 5489 if (i >= adata->nfat_arch)
5490 {
5491 bfd_set_error (bfd_error_no_more_archived_files);
5492 return NULL;
5493 }
5494
5495 entry = &adata->archentries[i];
15e1c58a
TG		 5496 nbfd = _bfd_new_bfd_contained_in (archive);
5497 if (nbfd == NULL)
5498 return NULL;
5499
15e1c58a
TG		 5500 bfd_mach_o_convert_architecture (entry->cputype, entry->cpusubtype,
5501 &arch_type, &arch_subtype);
846b9259 5502
a4e241ca
TG		 5503 bfd_mach_o_fat_member_init (nbfd, arch_type, arch_subtype, entry);
5504
846b9259 5505 bfd_set_arch_mach (nbfd, arch_type, arch_subtype);
3af9a47b 5506
15e1c58a 5507 return nbfd;
3af9a47b
NC		 5508}
5509
15bbba8d
TG		 5510/* Analogous to stat call. */
5511
5512static int
5513bfd_mach_o_fat_stat_arch_elt (bfd *abfd, struct stat *buf)
5514{
5515 if (abfd->arelt_data == NULL)
5516 {
5517 bfd_set_error (bfd_error_invalid_operation);
5518 return -1;
5519 }
5520
5521 buf->st_mtime = 0;
5522 buf->st_uid = 0;
5523 buf->st_gid = 0;
5524 buf->st_mode = 0644;
5525 buf->st_size = arelt_size (abfd);
5526
5527 return 0;
5528}
5529
846b9259
TG		 5530/* If ABFD format is FORMAT and architecture is ARCH, return it.
5531 If ABFD is a fat image containing a member that corresponds to FORMAT
5532 and ARCH, returns it.
5533 In other case, returns NULL.
5534 This function allows transparent uses of fat images. */
a4e241ca 5535
846b9259
TG		 5536bfd *
5537bfd_mach_o_fat_extract (bfd *abfd,
5538 bfd_format format,
5539 const bfd_arch_info_type *arch)
5540{
5541 bfd *res;
5542 mach_o_fat_data_struct *adata;
5543 unsigned int i;
5544
5545 if (bfd_check_format (abfd, format))
5546 {
5547 if (bfd_get_arch_info (abfd) == arch)
5548 return abfd;
5549 return NULL;
5550 }
5551 if (!bfd_check_format (abfd, bfd_archive)
5552 || abfd->xvec != &mach_o_fat_vec)
5553 return NULL;
c2f09c75 5554
846b9259
TG		 5555 /* This is a Mach-O fat image. */
5556 adata = (mach_o_fat_data_struct *) abfd->tdata.mach_o_fat_data;
5557 BFD_ASSERT (adata != NULL);
5558
5559 for (i = 0; i < adata->nfat_arch; i++)
5560 {
5561 struct mach_o_fat_archentry *e = &adata->archentries[i];
5562 enum bfd_architecture cpu_type;
5563 unsigned long cpu_subtype;
5564
5565 bfd_mach_o_convert_architecture (e->cputype, e->cpusubtype,
5566 &cpu_type, &cpu_subtype);
5567 if (cpu_type != arch->arch || cpu_subtype != arch->mach)
5568 continue;
5569
5570 /* The architecture is found. */
5571 res = _bfd_new_bfd_contained_in (abfd);
5572 if (res == NULL)
5573 return NULL;
5574
a4e241ca 5575 bfd_mach_o_fat_member_init (res, cpu_type, cpu_subtype, e);
846b9259
TG		 5576
5577 if (bfd_check_format (res, format))
5578 {
5579 BFD_ASSERT (bfd_get_arch_info (res) == arch);
5580 return res;
5581 }
5582 bfd_close (res);
5583 return NULL;
5584 }
5585
5586 return NULL;
5587}
5588
eac61af6
TT		 5589static bfd_boolean
5590bfd_mach_o_fat_close_and_cleanup (bfd *abfd)
5591{
5592 _bfd_unlink_from_archive_parent (abfd);
5593 return TRUE;
5594}
5595
3af9a47b 5596int
116c20d2
NC		 5597bfd_mach_o_lookup_command (bfd *abfd,
5598 bfd_mach_o_load_command_type type,
5599 bfd_mach_o_load_command **mcommand)
3af9a47b 5600{
c9ffd2ea
TG		 5601 struct mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
5602 struct bfd_mach_o_load_command *cmd;
5603 unsigned int num;
3af9a47b 5604
c9ffd2ea 5605 BFD_ASSERT (mdata != NULL);
3af9a47b
NC		 5606 BFD_ASSERT (mcommand != NULL);
5607
5608 num = 0;
c9ffd2ea 5609 for (cmd = mdata->first_command; cmd != NULL; cmd = cmd->next)
3af9a47b 5610 {
3af9a47b
NC		 5611 if (cmd->type != type)
5612 continue;
5613
5614 if (num == 0)
c9ffd2ea 5615 *mcommand = cmd;
3af9a47b
NC		 5616 num++;
5617 }
5618
3af9a47b
NC		 5619 return num;
5620}
5621
5622unsigned long
116c20d2 5623bfd_mach_o_stack_addr (enum bfd_mach_o_cpu_type type)
3af9a47b
NC		 5624{
5625 switch (type)
5626 {
5627 case BFD_MACH_O_CPU_TYPE_MC680x0:
5628 return 0x04000000;
3af9a47b
NC		 5629 case BFD_MACH_O_CPU_TYPE_POWERPC:
5630 return 0xc0000000;
5631 case BFD_MACH_O_CPU_TYPE_I386:
5632 return 0xc0000000;
5633 case BFD_MACH_O_CPU_TYPE_SPARC:
5634 return 0xf0000000;
3af9a47b 5635 case BFD_MACH_O_CPU_TYPE_HPPA:
e84d6fca 5636 return 0xc0000000 - 0x04000000;
3af9a47b
NC		 5637 default:
5638 return 0;
5639 }
5640}
5641
ab76eeaf
IS		 5642/* The following two tables should be kept, as far as possible, in order of
5643 most frequently used entries to optimize their use from gas. */
5644
c5012cd8 5645const bfd_mach_o_xlat_name bfd_mach_o_section_type_name[] =
046b007d
TG		 5646{
5647 { "regular", BFD_MACH_O_S_REGULAR},
ab76eeaf 5648 { "coalesced", BFD_MACH_O_S_COALESCED},
046b007d
TG		 5649 { "zerofill", BFD_MACH_O_S_ZEROFILL},
5650 { "cstring_literals", BFD_MACH_O_S_CSTRING_LITERALS},
5651 { "4byte_literals", BFD_MACH_O_S_4BYTE_LITERALS},
5652 { "8byte_literals", BFD_MACH_O_S_8BYTE_LITERALS},
ab76eeaf 5653 { "16byte_literals", BFD_MACH_O_S_16BYTE_LITERALS},
046b007d 5654 { "literal_pointers", BFD_MACH_O_S_LITERAL_POINTERS},
046b007d
TG		 5655 { "mod_init_func_pointers", BFD_MACH_O_S_MOD_INIT_FUNC_POINTERS},
5656 { "mod_fini_func_pointers", BFD_MACH_O_S_MOD_FINI_FUNC_POINTERS},
046b007d
TG		 5657 { "gb_zerofill", BFD_MACH_O_S_GB_ZEROFILL},
5658 { "interposing", BFD_MACH_O_S_INTERPOSING},
046b007d 5659 { "dtrace_dof", BFD_MACH_O_S_DTRACE_DOF},
ab76eeaf
IS		 5660 { "non_lazy_symbol_pointers", BFD_MACH_O_S_NON_LAZY_SYMBOL_POINTERS},
5661 { "lazy_symbol_pointers", BFD_MACH_O_S_LAZY_SYMBOL_POINTERS},
a4551119 5662 { "symbol_stubs", BFD_MACH_O_S_SYMBOL_STUBS},
046b007d
TG		 5663 { "lazy_dylib_symbol_pointers", BFD_MACH_O_S_LAZY_DYLIB_SYMBOL_POINTERS},
5664 { NULL, 0}
5665};
5666
c5012cd8 5667const bfd_mach_o_xlat_name bfd_mach_o_section_attribute_name[] =
046b007d 5668{
ab76eeaf
IS		 5669 { "pure_instructions", BFD_MACH_O_S_ATTR_PURE_INSTRUCTIONS },
5670 { "some_instructions", BFD_MACH_O_S_ATTR_SOME_INSTRUCTIONS },
046b007d
TG		 5671 { "loc_reloc", BFD_MACH_O_S_ATTR_LOC_RELOC },
5672 { "ext_reloc", BFD_MACH_O_S_ATTR_EXT_RELOC },
046b007d 5673 { "debug", BFD_MACH_O_S_ATTR_DEBUG },
046b007d
TG		 5674 { "live_support", BFD_MACH_O_S_ATTR_LIVE_SUPPORT },
5675 { "no_dead_strip", BFD_MACH_O_S_ATTR_NO_DEAD_STRIP },
5676 { "strip_static_syms", BFD_MACH_O_S_ATTR_STRIP_STATIC_SYMS },
5677 { "no_toc", BFD_MACH_O_S_ATTR_NO_TOC },
a4551119 5678 { "self_modifying_code", BFD_MACH_O_S_SELF_MODIFYING_CODE },
ab76eeaf 5679 { "modifying_code", BFD_MACH_O_S_SELF_MODIFYING_CODE },
046b007d
TG		 5680 { NULL, 0}
5681};
5682
a4551119 5683/* Get the section type from NAME. Return 256 if NAME is unknown. */
53d58d96
TG		 5684
5685unsigned int
ab76eeaf 5686bfd_mach_o_get_section_type_from_name (bfd *abfd, const char *name)
53d58d96 5687{
afbb9e17 5688 const bfd_mach_o_xlat_name *x;
ab76eeaf 5689 bfd_mach_o_backend_data *bed = bfd_mach_o_get_backend_data (abfd);
53d58d96
TG		 5690
5691 for (x = bfd_mach_o_section_type_name; x->name; x++)
5692 if (strcmp (x->name, name) == 0)
ab76eeaf
IS		 5693 {
5694 /* We found it... does the target support it? */
5695 if (bed->bfd_mach_o_section_type_valid_for_target == NULL
5696 || bed->bfd_mach_o_section_type_valid_for_target (x->val))
5697 return x->val; /* OK. */
5698 else
5699 break; /* Not supported. */
5700 }
a4551119
TG		 5701 /* Maximum section ID = 0xff. */
5702 return 256;
53d58d96
TG		 5703}
5704
5705/* Get the section attribute from NAME. Return -1 if NAME is unknown. */
5706
5707unsigned int
5708bfd_mach_o_get_section_attribute_from_name (const char *name)
5709{
afbb9e17 5710 const bfd_mach_o_xlat_name *x;
53d58d96
TG		 5711
5712 for (x = bfd_mach_o_section_attribute_name; x->name; x++)
5713 if (strcmp (x->name, name) == 0)
5714 return x->val;
5715 return (unsigned int)-1;
5716}
5717
3af9a47b 5718int
116c20d2
NC		 5719bfd_mach_o_core_fetch_environment (bfd *abfd,
5720 unsigned char **rbuf,
5721 unsigned int *rlen)
3af9a47b 5722{
046b007d 5723 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
3af9a47b 5724 unsigned long stackaddr = bfd_mach_o_stack_addr (mdata->header.cputype);
c9ffd2ea 5725 bfd_mach_o_load_command *cmd;
3af9a47b 5726
c9ffd2ea 5727 for (cmd = mdata->first_command; cmd != NULL; cmd = cmd->next)
3af9a47b 5728 {
c9ffd2ea 5729 bfd_mach_o_segment_command *seg;
3af9a47b 5730
c9ffd2ea 5731 if (cmd->type != BFD_MACH_O_LC_SEGMENT)
3af9a47b
NC		 5732 continue;
5733
c9ffd2ea 5734 seg = &cmd->command.segment;
3af9a47b
NC		 5735
5736 if ((seg->vmaddr + seg->vmsize) == stackaddr)
5737 {
5738 unsigned long start = seg->fileoff;
5739 unsigned long end = seg->fileoff + seg->filesize;
5740 unsigned char *buf = bfd_malloc (1024);
5741 unsigned long size = 1024;
5742
5743 for (;;)
5744 {
5745 bfd_size_type nread = 0;
5746 unsigned long offset;
5747 int found_nonnull = 0;
5748
5749 if (size > (end - start))
5750 size = (end - start);
5751
515ef31d
NC		 5752 buf = bfd_realloc_or_free (buf, size);
5753 if (buf == NULL)
5754 return -1;
c2f09c75
TG		 5755
5756 if (bfd_seek (abfd, end - size, SEEK_SET) != 0)
07d6d2b8
AM		 5757 {
5758 free (buf);
5759 return -1;
5760 }
c2f09c75 5761
3af9a47b 5762 nread = bfd_bread (buf, size, abfd);
a95a4550 5763
3af9a47b 5764 if (nread != size)
515ef31d
NC		 5765 {
5766 free (buf);
5767 return -1;
5768 }
a95a4550 5769
3af9a47b
NC		 5770 for (offset = 4; offset <= size; offset += 4)
5771 {
e84d6fca 5772 unsigned long val;
3af9a47b 5773
e84d6fca 5774 val = *((unsigned long *) (buf + size - offset));
3af9a47b
NC		 5775 if (! found_nonnull)
5776 {
5777 if (val != 0)
5778 found_nonnull = 1;
5779 }
5780 else if (val == 0x0)
5781 {
e84d6fca
AM		 5782 unsigned long bottom;
5783 unsigned long top;
3af9a47b 5784
e84d6fca
AM		 5785 bottom = seg->fileoff + seg->filesize - offset;
5786 top = seg->fileoff + seg->filesize - 4;
3af9a47b
NC		 5787 *rbuf = bfd_malloc (top - bottom);
5788 *rlen = top - bottom;
5789
5790 memcpy (*rbuf, buf + size - *rlen, *rlen);
515ef31d 5791 free (buf);
3af9a47b
NC		 5792 return 0;
5793 }
5794 }
5795
5796 if (size == (end - start))
5797 break;
5798
5799 size *= 2;
5800 }
515ef31d
NC		 5801
5802 free (buf);
3af9a47b
NC		 5803 }
5804 }
5805
5806 return -1;
5807}
5808
5809char *
116c20d2 5810bfd_mach_o_core_file_failing_command (bfd *abfd)
3af9a47b
NC		 5811{
5812 unsigned char *buf = NULL;
5813 unsigned int len = 0;
452216ab 5814 int ret;
3af9a47b
NC		 5815
5816 ret = bfd_mach_o_core_fetch_environment (abfd, &buf, &len);
5817 if (ret < 0)
5818 return NULL;
5819
f075ee0c 5820 return (char *) buf;
3af9a47b
NC		 5821}
5822
5823int
116c20d2 5824bfd_mach_o_core_file_failing_signal (bfd *abfd ATTRIBUTE_UNUSED)
3af9a47b
NC		 5825{
5826 return 0;
5827}
5828
2ca7691a
TG		 5829static bfd_mach_o_uuid_command *
5830bfd_mach_o_lookup_uuid_command (bfd *abfd)
5831{
09fe2662 5832 bfd_mach_o_load_command *uuid_cmd = NULL;
2ca7691a 5833 int ncmd = bfd_mach_o_lookup_command (abfd, BFD_MACH_O_LC_UUID, &uuid_cmd);
09fe2662 5834 if (ncmd != 1 || uuid_cmd == NULL)
2ca7691a
TG		 5835 return FALSE;
5836 return &uuid_cmd->command.uuid;
5837}
5838
5839/* Return true if ABFD is a dSYM file and its UUID matches UUID_CMD. */
5840
5841static bfd_boolean
5842bfd_mach_o_dsym_for_uuid_p (bfd *abfd, const bfd_mach_o_uuid_command *uuid_cmd)
5843{
5844 bfd_mach_o_uuid_command *dsym_uuid_cmd;
5845
5846 BFD_ASSERT (abfd);
5847 BFD_ASSERT (uuid_cmd);
5848
5849 if (!bfd_check_format (abfd, bfd_object))
5850 return FALSE;
5851
5852 if (bfd_get_flavour (abfd) != bfd_target_mach_o_flavour
5853 || bfd_mach_o_get_data (abfd) == NULL
5854 || bfd_mach_o_get_data (abfd)->header.filetype != BFD_MACH_O_MH_DSYM)
5855 return FALSE;
5856
5857 dsym_uuid_cmd = bfd_mach_o_lookup_uuid_command (abfd);
5858 if (dsym_uuid_cmd == NULL)
5859 return FALSE;
5860
5861 if (memcmp (uuid_cmd->uuid, dsym_uuid_cmd->uuid,
07d6d2b8 5862 sizeof (uuid_cmd->uuid)) != 0)
2ca7691a
TG		 5863 return FALSE;
5864
5865 return TRUE;
5866}
5867
5868/* Find a BFD in DSYM_FILENAME which matches ARCH and UUID_CMD.
5869 The caller is responsible for closing the returned BFD object and
5870 its my_archive if the returned BFD is in a fat dSYM. */
5871
5872static bfd *
5873bfd_mach_o_find_dsym (const char *dsym_filename,
07d6d2b8
AM		 5874 const bfd_mach_o_uuid_command *uuid_cmd,
5875 const bfd_arch_info_type *arch)
2ca7691a
TG		 5876{
5877 bfd *base_dsym_bfd, *dsym_bfd;
5878
5879 BFD_ASSERT (uuid_cmd);
5880
5881 base_dsym_bfd = bfd_openr (dsym_filename, NULL);
5882 if (base_dsym_bfd == NULL)
5883 return NULL;
5884
5885 dsym_bfd = bfd_mach_o_fat_extract (base_dsym_bfd, bfd_object, arch);
5886 if (bfd_mach_o_dsym_for_uuid_p (dsym_bfd, uuid_cmd))
5887 return dsym_bfd;
5888
5889 bfd_close (dsym_bfd);
5890 if (base_dsym_bfd != dsym_bfd)
5891 bfd_close (base_dsym_bfd);
5892
5893 return NULL;
5894}
5895
5896/* Return a BFD created from a dSYM file for ABFD.
5897 The caller is responsible for closing the returned BFD object, its
5898 filename, and its my_archive if the returned BFD is in a fat dSYM. */
5899
5900static bfd *
5901bfd_mach_o_follow_dsym (bfd *abfd)
5902{
5903 char *dsym_filename;
5904 bfd_mach_o_uuid_command *uuid_cmd;
5905 bfd *dsym_bfd, *base_bfd = abfd;
5906 const char *base_basename;
5907
5908 if (abfd == NULL || bfd_get_flavour (abfd) != bfd_target_mach_o_flavour)
5909 return NULL;
5910
b0cffb47 5911 if (abfd->my_archive && !bfd_is_thin_archive (abfd->my_archive))
2ca7691a
TG		 5912 base_bfd = abfd->my_archive;
5913 /* BFD may have been opened from a stream. */
5914 if (base_bfd->filename == NULL)
5915 {
5916 bfd_set_error (bfd_error_invalid_operation);
5917 return NULL;
5918 }
5919 base_basename = lbasename (base_bfd->filename);
5920
5921 uuid_cmd = bfd_mach_o_lookup_uuid_command (abfd);
5922 if (uuid_cmd == NULL)
5923 return NULL;
5924
5925 /* TODO: We assume the DWARF file has the same as the binary's.
5926 It seems apple's GDB checks all files in the dSYM bundle directory.
5927 http://opensource.apple.com/source/gdb/gdb-1708/src/gdb/macosx/macosx-tdep.c
5928 */
5929 dsym_filename = (char *)bfd_malloc (strlen (base_bfd->filename)
07d6d2b8
AM		 5930 + strlen (dsym_subdir) + 1
5931 + strlen (base_basename) + 1);
2ca7691a 5932 sprintf (dsym_filename, "%s%s/%s",
07d6d2b8 5933 base_bfd->filename, dsym_subdir, base_basename);
2ca7691a
TG		 5934
5935 dsym_bfd = bfd_mach_o_find_dsym (dsym_filename, uuid_cmd,
07d6d2b8 5936 bfd_get_arch_info (abfd));
2ca7691a
TG		 5937 if (dsym_bfd == NULL)
5938 free (dsym_filename);
5939
5940 return dsym_bfd;
5941}
5942
d9071b0c
TG		 5943bfd_boolean
5944bfd_mach_o_find_nearest_line (bfd *abfd,
d9071b0c 5945 asymbol **symbols,
fb167eb2 5946 asection *section,
d9071b0c
TG		 5947 bfd_vma offset,
5948 const char **filename_ptr,
5949 const char **functionname_ptr,
fb167eb2
AM		 5950 unsigned int *line_ptr,
5951 unsigned int *discriminator_ptr)
d9071b0c
TG		 5952{
5953 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
2ca7691a 5954 if (mdata == NULL)
d9071b0c 5955 return FALSE;
2ca7691a
TG		 5956 switch (mdata->header.filetype)
5957 {
5958 case BFD_MACH_O_MH_OBJECT:
5959 break;
5960 case BFD_MACH_O_MH_EXECUTE:
5961 case BFD_MACH_O_MH_DYLIB:
5962 case BFD_MACH_O_MH_BUNDLE:
5963 case BFD_MACH_O_MH_KEXT_BUNDLE:
5964 if (mdata->dwarf2_find_line_info == NULL)
07d6d2b8
AM		 5965 {
5966 mdata->dsym_bfd = bfd_mach_o_follow_dsym (abfd);
5967 /* When we couldn't find dSYM for this binary, we look for
5968 the debug information in the binary itself. In this way,
5969 we won't try finding separated dSYM again because
5970 mdata->dwarf2_find_line_info will be filled. */
5971 if (! mdata->dsym_bfd)
5972 break;
5973 if (! _bfd_dwarf2_slurp_debug_info (abfd, mdata->dsym_bfd,
5974 dwarf_debug_sections, symbols,
5975 &mdata->dwarf2_find_line_info,
93ee1e36 5976 FALSE))
07d6d2b8
AM		 5977 return FALSE;
5978 }
2ca7691a
TG		 5979 break;
5980 default:
5981 return FALSE;
5982 }
fb167eb2
AM		 5983 return _bfd_dwarf2_find_nearest_line (abfd, symbols, NULL, section, offset,
5984 filename_ptr, functionname_ptr,
5985 line_ptr, discriminator_ptr,
5986 dwarf_debug_sections, 0,
5987 &mdata->dwarf2_find_line_info);
d9071b0c
TG		 5988}
5989
5990bfd_boolean
5991bfd_mach_o_close_and_cleanup (bfd *abfd)
5992{
5993 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
5994 if (bfd_get_format (abfd) == bfd_object && mdata != NULL)
4434114c
TG		 5995 {
5996 _bfd_dwarf2_cleanup_debug_info (abfd, &mdata->dwarf2_find_line_info);
5997 bfd_mach_o_free_cached_info (abfd);
2ca7691a 5998 if (mdata->dsym_bfd != NULL)
07d6d2b8
AM		 5999 {
6000 bfd *fat_bfd = mdata->dsym_bfd->my_archive;
cf466c2a
NC		 6001#if 0
6002 /* FIXME: PR 19435: This calculation to find the memory allocated by
6003 bfd_mach_o_follow_dsym for the filename does not always end up
6004 selecting the correct pointer. Unfortunately this problem is
6005 very hard to reproduce on a non Mach-O native system, so until it
6006 can be traced and fixed on such a system, this code will remain
6007 commented out. This does mean that there will be a memory leak,
6008 but it is small, and happens when we are closing down, so it
c244074c 6009 should not matter too much. */
07d6d2b8
AM		 6010 char *dsym_filename = (char *)(fat_bfd
6011 ? fat_bfd->filename
6012 : mdata->dsym_bfd->filename);
cf466c2a 6013#endif
07d6d2b8
AM		 6014 bfd_close (mdata->dsym_bfd);
6015 mdata->dsym_bfd = NULL;
6016 if (fat_bfd)
6017 bfd_close (fat_bfd);
cf466c2a 6018#if 0
07d6d2b8 6019 free (dsym_filename);
cf466c2a 6020#endif
07d6d2b8 6021 }
4434114c 6022 }
dff55db0 6023
d9071b0c
TG		 6024 return _bfd_generic_close_and_cleanup (abfd);
6025}
6026
c6643fcc
NC		 6027bfd_boolean
6028bfd_mach_o_free_cached_info (bfd *abfd)
dff55db0
TG		 6029{
6030 bfd_mach_o_data_struct *mdata = bfd_mach_o_get_data (abfd);
6031 asection *asect;
6032 free (mdata->dyn_reloc_cache);
6033 mdata->dyn_reloc_cache = NULL;
6034 for (asect = abfd->sections; asect != NULL; asect = asect->next)
6035 {
6036 free (asect->relocation);
6037 asect->relocation = NULL;
6038 }
6039
6040 return TRUE;
6041}
6042
68ffbac6 6043#define bfd_mach_o_bfd_reloc_type_lookup _bfd_norelocs_bfd_reloc_type_lookup
92bc0e80
TG		 6044#define bfd_mach_o_bfd_reloc_name_lookup _bfd_norelocs_bfd_reloc_name_lookup
6045
bcb51645 6046#define bfd_mach_o_canonicalize_one_reloc NULL
92bc0e80 6047#define bfd_mach_o_swap_reloc_out NULL
b32e07d7 6048#define bfd_mach_o_print_thread NULL
a4551119 6049#define bfd_mach_o_tgt_seg_table NULL
ab76eeaf 6050#define bfd_mach_o_section_type_valid_for_tgt NULL
92bc0e80 6051
07d6d2b8
AM		 6052#define TARGET_NAME mach_o_be_vec
6053#define TARGET_STRING "mach-o-be"
42fa0891 6054#define TARGET_ARCHITECTURE bfd_arch_unknown
4384b284 6055#define TARGET_PAGESIZE 1
07d6d2b8
AM		 6056#define TARGET_BIG_ENDIAN 1
6057#define TARGET_ARCHIVE 0
b93a1992 6058#define TARGET_PRIORITY 1
3af9a47b
NC		 6059#include "mach-o-target.c"
6060
6061#undef TARGET_NAME
6062#undef TARGET_STRING
42fa0891 6063#undef TARGET_ARCHITECTURE
4384b284 6064#undef TARGET_PAGESIZE
3af9a47b
NC		 6065#undef TARGET_BIG_ENDIAN
6066#undef TARGET_ARCHIVE
b93a1992 6067#undef TARGET_PRIORITY
3af9a47b 6068
07d6d2b8
AM		 6069#define TARGET_NAME mach_o_le_vec
6070#define TARGET_STRING "mach-o-le"
42fa0891 6071#define TARGET_ARCHITECTURE bfd_arch_unknown
4384b284 6072#define TARGET_PAGESIZE 1
07d6d2b8
AM		 6073#define TARGET_BIG_ENDIAN 0
6074#define TARGET_ARCHIVE 0
b93a1992 6075#define TARGET_PRIORITY 1
3af9a47b
NC		 6076
6077#include "mach-o-target.c"
6078
6079#undef TARGET_NAME
6080#undef TARGET_STRING
42fa0891 6081#undef TARGET_ARCHITECTURE
4384b284 6082#undef TARGET_PAGESIZE
3af9a47b
NC		 6083#undef TARGET_BIG_ENDIAN
6084#undef TARGET_ARCHIVE
b93a1992 6085#undef TARGET_PRIORITY
3af9a47b 6086
8f95b6e4 6087/* Not yet handled: creating an archive. */
07d6d2b8 6088#define bfd_mach_o_mkarchive _bfd_noarchive_mkarchive
8f95b6e4 6089
eac61af6 6090#define bfd_mach_o_close_and_cleanup bfd_mach_o_fat_close_and_cleanup
47daa70f 6091
8f95b6e4 6092/* Not used. */
07d6d2b8 6093#define bfd_mach_o_generic_stat_arch_elt bfd_mach_o_fat_stat_arch_elt
47daa70f
TG		 6094#define bfd_mach_o_openr_next_archived_file bfd_mach_o_fat_openr_next_archived_file
6095#define bfd_mach_o_archive_p bfd_mach_o_fat_archive_p
8f95b6e4 6096
07d6d2b8
AM		 6097#define TARGET_NAME mach_o_fat_vec
6098#define TARGET_STRING "mach-o-fat"
42fa0891 6099#define TARGET_ARCHITECTURE bfd_arch_unknown
4384b284 6100#define TARGET_PAGESIZE 1
07d6d2b8
AM		 6101#define TARGET_BIG_ENDIAN 1
6102#define TARGET_ARCHIVE 1
b93a1992 6103#define TARGET_PRIORITY 0
3af9a47b
NC		 6104
6105#include "mach-o-target.c"
6106
6107#undef TARGET_NAME
6108#undef TARGET_STRING
42fa0891 6109#undef TARGET_ARCHITECTURE
4384b284 6110#undef TARGET_PAGESIZE
3af9a47b
NC		 6111#undef TARGET_BIG_ENDIAN
6112#undef TARGET_ARCHIVE
b93a1992 6113#undef TARGET_PRIORITY
GDB Binutils - Deliverables
This page took 1.609614 seconds and 4 git commands to generate.