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