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