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