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