1 /* Generic BFD library interface and support routines. 2 Copyright (C) 1990-2022 Free Software Foundation, Inc. 3 Written by Cygnus Support. 4 5 This file is part of BFD, the Binary File Descriptor library. 6 7 This program is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 3 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program; if not, write to the Free Software 19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, 20 MA 02110-1301, USA. */ 21 22 /* 23 INODE 24 typedef bfd, Error reporting, BFD front end, BFD front end 25 26 SECTION 27 <<typedef bfd>> 28 29 A BFD has type <<bfd>>; objects of this type are the 30 cornerstone of any application using BFD. Using BFD 31 consists of making references though the BFD and to data in the BFD. 32 33 Here is the structure that defines the type <<bfd>>. It 34 contains the major data about the file and pointers 35 to the rest of the data. 36 37 CODE_FRAGMENT 38 . 39 .enum bfd_direction 40 . { 41 . no_direction = 0, 42 . read_direction = 1, 43 . write_direction = 2, 44 . both_direction = 3 45 . }; 46 . 47 .enum bfd_plugin_format 48 . { 49 . bfd_plugin_unknown = 0, 50 . bfd_plugin_yes = 1, 51 . bfd_plugin_no = 2 52 . }; 53 . 54 .struct bfd_build_id 55 . { 56 . bfd_size_type size; 57 . bfd_byte data[1]; 58 . }; 59 . 60 .struct bfd 61 .{ 62 . {* The filename the application opened the BFD with. *} 63 . const char *filename; 64 . 65 . {* A pointer to the target jump table. *} 66 . const struct bfd_target *xvec; 67 . 68 . {* The IOSTREAM, and corresponding IO vector that provide access 69 . to the file backing the BFD. *} 70 . void *iostream; 71 . const struct bfd_iovec *iovec; 72 . 73 . {* The caching routines use these to maintain a 74 . least-recently-used list of BFDs. *} 75 . struct bfd *lru_prev, *lru_next; 76 . 77 . {* Track current file position (or current buffer offset for 78 . in-memory BFDs). When a file is closed by the caching routines, 79 . BFD retains state information on the file here. *} 80 . ufile_ptr where; 81 . 82 . {* File modified time, if mtime_set is TRUE. *} 83 . long mtime; 84 . 85 . {* A unique identifier of the BFD *} 86 . unsigned int id; 87 . 88 . {* Format_specific flags. *} 89 . flagword flags; 90 . 91 . {* Values that may appear in the flags field of a BFD. These also 92 . appear in the object_flags field of the bfd_target structure, where 93 . they indicate the set of flags used by that backend (not all flags 94 . are meaningful for all object file formats) (FIXME: at the moment, 95 . the object_flags values have mostly just been copied from backend 96 . to another, and are not necessarily correct). *} 97 . 98 .#define BFD_NO_FLAGS 0x0 99 . 100 . {* BFD contains relocation entries. *} 101 .#define HAS_RELOC 0x1 102 . 103 . {* BFD is directly executable. *} 104 .#define EXEC_P 0x2 105 . 106 . {* BFD has line number information (basically used for F_LNNO in a 107 . COFF header). *} 108 .#define HAS_LINENO 0x4 109 . 110 . {* BFD has debugging information. *} 111 .#define HAS_DEBUG 0x08 112 . 113 . {* BFD has symbols. *} 114 .#define HAS_SYMS 0x10 115 . 116 . {* BFD has local symbols (basically used for F_LSYMS in a COFF 117 . header). *} 118 .#define HAS_LOCALS 0x20 119 . 120 . {* BFD is a dynamic object. *} 121 .#define DYNAMIC 0x40 122 . 123 . {* Text section is write protected (if D_PAGED is not set, this is 124 . like an a.out NMAGIC file) (the linker sets this by default, but 125 . clears it for -r or -N). *} 126 .#define WP_TEXT 0x80 127 . 128 . {* BFD is dynamically paged (this is like an a.out ZMAGIC file) (the 129 . linker sets this by default, but clears it for -r or -n or -N). *} 130 .#define D_PAGED 0x100 131 . 132 . {* BFD is relaxable (this means that bfd_relax_section may be able to 133 . do something) (sometimes bfd_relax_section can do something even if 134 . this is not set). *} 135 .#define BFD_IS_RELAXABLE 0x200 136 . 137 . {* This may be set before writing out a BFD to request using a 138 . traditional format. For example, this is used to request that when 139 . writing out an a.out object the symbols not be hashed to eliminate 140 . duplicates. *} 141 .#define BFD_TRADITIONAL_FORMAT 0x400 142 . 143 . {* This flag indicates that the BFD contents are actually cached 144 . in memory. If this is set, iostream points to a bfd_in_memory 145 . struct. *} 146 .#define BFD_IN_MEMORY 0x800 147 . 148 . {* This BFD has been created by the linker and doesn't correspond 149 . to any input file. *} 150 .#define BFD_LINKER_CREATED 0x1000 151 . 152 . {* This may be set before writing out a BFD to request that it 153 . be written using values for UIDs, GIDs, timestamps, etc. that 154 . will be consistent from run to run. *} 155 .#define BFD_DETERMINISTIC_OUTPUT 0x2000 156 . 157 . {* Compress sections in this BFD. *} 158 .#define BFD_COMPRESS 0x4000 159 . 160 . {* Decompress sections in this BFD. *} 161 .#define BFD_DECOMPRESS 0x8000 162 . 163 . {* BFD is a dummy, for plugins. *} 164 .#define BFD_PLUGIN 0x10000 165 . 166 . {* Compress sections in this BFD with SHF_COMPRESSED from gABI. *} 167 .#define BFD_COMPRESS_GABI 0x20000 168 . 169 . {* Convert ELF common symbol type to STT_COMMON or STT_OBJECT in this 170 . BFD. *} 171 .#define BFD_CONVERT_ELF_COMMON 0x40000 172 . 173 . {* Use the ELF STT_COMMON type in this BFD. *} 174 .#define BFD_USE_ELF_STT_COMMON 0x80000 175 . 176 . {* Put pathnames into archives (non-POSIX). *} 177 .#define BFD_ARCHIVE_FULL_PATH 0x100000 178 . 179 . {* Flags bits to be saved in bfd_preserve_save. *} 180 .#define BFD_FLAGS_SAVED \ 181 . (BFD_IN_MEMORY | BFD_COMPRESS | BFD_DECOMPRESS | BFD_LINKER_CREATED \ 182 . | BFD_PLUGIN | BFD_COMPRESS_GABI | BFD_CONVERT_ELF_COMMON \ 183 . | BFD_USE_ELF_STT_COMMON) 184 . 185 . {* Flags bits which are for BFD use only. *} 186 .#define BFD_FLAGS_FOR_BFD_USE_MASK \ 187 . (BFD_IN_MEMORY | BFD_COMPRESS | BFD_DECOMPRESS | BFD_LINKER_CREATED \ 188 . | BFD_PLUGIN | BFD_TRADITIONAL_FORMAT | BFD_DETERMINISTIC_OUTPUT \ 189 . | BFD_COMPRESS_GABI | BFD_CONVERT_ELF_COMMON | BFD_USE_ELF_STT_COMMON) 190 . 191 . {* The format which belongs to the BFD. (object, core, etc.) *} 192 . ENUM_BITFIELD (bfd_format) format : 3; 193 . 194 . {* The direction with which the BFD was opened. *} 195 . ENUM_BITFIELD (bfd_direction) direction : 2; 196 . 197 . {* Is the file descriptor being cached? That is, can it be closed as 198 . needed, and re-opened when accessed later? *} 199 . unsigned int cacheable : 1; 200 . 201 . {* Marks whether there was a default target specified when the 202 . BFD was opened. This is used to select which matching algorithm 203 . to use to choose the back end. *} 204 . unsigned int target_defaulted : 1; 205 . 206 . {* ... and here: (``once'' means at least once). *} 207 . unsigned int opened_once : 1; 208 . 209 . {* Set if we have a locally maintained mtime value, rather than 210 . getting it from the file each time. *} 211 . unsigned int mtime_set : 1; 212 . 213 . {* Flag set if symbols from this BFD should not be exported. *} 214 . unsigned int no_export : 1; 215 . 216 . {* Remember when output has begun, to stop strange things 217 . from happening. *} 218 . unsigned int output_has_begun : 1; 219 . 220 . {* Have archive map. *} 221 . unsigned int has_armap : 1; 222 . 223 . {* Set if this is a thin archive. *} 224 . unsigned int is_thin_archive : 1; 225 . 226 . {* Set if this archive should not cache element positions. *} 227 . unsigned int no_element_cache : 1; 228 . 229 . {* Set if only required symbols should be added in the link hash table for 230 . this object. Used by VMS linkers. *} 231 . unsigned int selective_search : 1; 232 . 233 . {* Set if this is the linker output BFD. *} 234 . unsigned int is_linker_output : 1; 235 . 236 . {* Set if this is the linker input BFD. *} 237 . unsigned int is_linker_input : 1; 238 . 239 . {* If this is an input for a compiler plug-in library. *} 240 . ENUM_BITFIELD (bfd_plugin_format) plugin_format : 2; 241 . 242 . {* Set if this is a plugin output file. *} 243 . unsigned int lto_output : 1; 244 . 245 . {* Set if this is a slim LTO object not loaded with a compiler plugin. *} 246 . unsigned int lto_slim_object : 1; 247 . 248 . {* Do not attempt to modify this file. Set when detecting errors 249 . that BFD is not prepared to handle for objcopy/strip. *} 250 . unsigned int read_only : 1; 251 . 252 . {* Set to dummy BFD created when claimed by a compiler plug-in 253 . library. *} 254 . bfd *plugin_dummy_bfd; 255 . 256 . {* The offset of this bfd in the file, typically 0 if it is not 257 . contained in an archive. *} 258 . ufile_ptr origin; 259 . 260 . {* The origin in the archive of the proxy entry. This will 261 . normally be the same as origin, except for thin archives, 262 . when it will contain the current offset of the proxy in the 263 . thin archive rather than the offset of the bfd in its actual 264 . container. *} 265 . ufile_ptr proxy_origin; 266 . 267 . {* A hash table for section names. *} 268 . struct bfd_hash_table section_htab; 269 . 270 . {* Pointer to linked list of sections. *} 271 . struct bfd_section *sections; 272 . 273 . {* The last section on the section list. *} 274 . struct bfd_section *section_last; 275 . 276 . {* The number of sections. *} 277 . unsigned int section_count; 278 . 279 . {* The archive plugin file descriptor. *} 280 . int archive_plugin_fd; 281 . 282 . {* The number of opens on the archive plugin file descriptor. *} 283 . unsigned int archive_plugin_fd_open_count; 284 . 285 . {* A field used by _bfd_generic_link_add_archive_symbols. This will 286 . be used only for archive elements. *} 287 . int archive_pass; 288 . 289 . {* The total size of memory from bfd_alloc. *} 290 . bfd_size_type alloc_size; 291 . 292 . {* Stuff only useful for object files: 293 . The start address. *} 294 . bfd_vma start_address; 295 . 296 . {* Symbol table for output BFD (with symcount entries). 297 . Also used by the linker to cache input BFD symbols. *} 298 . struct bfd_symbol **outsymbols; 299 . 300 . {* Used for input and output. *} 301 . unsigned int symcount; 302 . 303 . {* Used for slurped dynamic symbol tables. *} 304 . unsigned int dynsymcount; 305 . 306 . {* Pointer to structure which contains architecture information. *} 307 . const struct bfd_arch_info *arch_info; 308 . 309 . {* Cached length of file for bfd_get_size. 0 until bfd_get_size is 310 . called, 1 if stat returns an error or the file size is too large to 311 . return in ufile_ptr. Both 0 and 1 should be treated as "unknown". *} 312 . ufile_ptr size; 313 . 314 . {* Stuff only useful for archives. *} 315 . void *arelt_data; 316 . struct bfd *my_archive; {* The containing archive BFD. *} 317 . struct bfd *archive_next; {* The next BFD in the archive. *} 318 . struct bfd *archive_head; {* The first BFD in the archive. *} 319 . struct bfd *nested_archives; {* List of nested archive in a flattened 320 . thin archive. *} 321 . 322 . union { 323 . {* For input BFDs, a chain of BFDs involved in a link. *} 324 . struct bfd *next; 325 . {* For output BFD, the linker hash table. *} 326 . struct bfd_link_hash_table *hash; 327 . } link; 328 . 329 . {* Used by the back end to hold private data. *} 330 . union 331 . { 332 . struct aout_data_struct *aout_data; 333 . struct artdata *aout_ar_data; 334 . struct coff_tdata *coff_obj_data; 335 . struct pe_tdata *pe_obj_data; 336 . struct xcoff_tdata *xcoff_obj_data; 337 . struct ecoff_tdata *ecoff_obj_data; 338 . struct srec_data_struct *srec_data; 339 . struct verilog_data_struct *verilog_data; 340 . struct ihex_data_struct *ihex_data; 341 . struct tekhex_data_struct *tekhex_data; 342 . struct elf_obj_tdata *elf_obj_data; 343 . struct mmo_data_struct *mmo_data; 344 . struct sun_core_struct *sun_core_data; 345 . struct sco5_core_struct *sco5_core_data; 346 . struct trad_core_struct *trad_core_data; 347 . struct som_data_struct *som_data; 348 . struct hpux_core_struct *hpux_core_data; 349 . struct hppabsd_core_struct *hppabsd_core_data; 350 . struct sgi_core_struct *sgi_core_data; 351 . struct lynx_core_struct *lynx_core_data; 352 . struct osf_core_struct *osf_core_data; 353 . struct cisco_core_struct *cisco_core_data; 354 . struct versados_data_struct *versados_data; 355 . struct netbsd_core_struct *netbsd_core_data; 356 . struct mach_o_data_struct *mach_o_data; 357 . struct mach_o_fat_data_struct *mach_o_fat_data; 358 . struct plugin_data_struct *plugin_data; 359 . struct bfd_pef_data_struct *pef_data; 360 . struct bfd_pef_xlib_data_struct *pef_xlib_data; 361 . struct bfd_sym_data_struct *sym_data; 362 . void *any; 363 . } 364 . tdata; 365 . 366 . {* Used by the application to hold private data. *} 367 . void *usrdata; 368 . 369 . {* Where all the allocated stuff under this BFD goes. This is a 370 . struct objalloc *, but we use void * to avoid requiring the inclusion 371 . of objalloc.h. *} 372 . void *memory; 373 . 374 . {* For input BFDs, the build ID, if the object has one. *} 375 . const struct bfd_build_id *build_id; 376 .}; 377 . 378 .static inline const char * 379 .bfd_get_filename (const bfd *abfd) 380 .{ 381 . return abfd->filename; 382 .} 383 . 384 .static inline bool 385 .bfd_get_cacheable (const bfd *abfd) 386 .{ 387 . return abfd->cacheable; 388 .} 389 . 390 .static inline enum bfd_format 391 .bfd_get_format (const bfd *abfd) 392 .{ 393 . return abfd->format; 394 .} 395 . 396 .static inline flagword 397 .bfd_get_file_flags (const bfd *abfd) 398 .{ 399 . return abfd->flags; 400 .} 401 . 402 .static inline bfd_vma 403 .bfd_get_start_address (const bfd *abfd) 404 .{ 405 . return abfd->start_address; 406 .} 407 . 408 .static inline unsigned int 409 .bfd_get_symcount (const bfd *abfd) 410 .{ 411 . return abfd->symcount; 412 .} 413 . 414 .static inline unsigned int 415 .bfd_get_dynamic_symcount (const bfd *abfd) 416 .{ 417 . return abfd->dynsymcount; 418 .} 419 . 420 .static inline struct bfd_symbol ** 421 .bfd_get_outsymbols (const bfd *abfd) 422 .{ 423 . return abfd->outsymbols; 424 .} 425 . 426 .static inline unsigned int 427 .bfd_count_sections (const bfd *abfd) 428 .{ 429 . return abfd->section_count; 430 .} 431 . 432 .static inline bool 433 .bfd_has_map (const bfd *abfd) 434 .{ 435 . return abfd->has_armap; 436 .} 437 . 438 .static inline bool 439 .bfd_is_thin_archive (const bfd *abfd) 440 .{ 441 . return abfd->is_thin_archive; 442 .} 443 . 444 .static inline void * 445 .bfd_usrdata (const bfd *abfd) 446 .{ 447 . return abfd->usrdata; 448 .} 449 . 450 .{* See note beside bfd_set_section_userdata. *} 451 .static inline bool 452 .bfd_set_cacheable (bfd * abfd, bool val) 453 .{ 454 . abfd->cacheable = val; 455 . return true; 456 .} 457 . 458 .static inline void 459 .bfd_set_thin_archive (bfd *abfd, bool val) 460 .{ 461 . abfd->is_thin_archive = val; 462 .} 463 . 464 .static inline void 465 .bfd_set_usrdata (bfd *abfd, void *val) 466 .{ 467 . abfd->usrdata = val; 468 .} 469 . 470 .static inline asection * 471 .bfd_asymbol_section (const asymbol *sy) 472 .{ 473 . return sy->section; 474 .} 475 . 476 .static inline bfd_vma 477 .bfd_asymbol_value (const asymbol *sy) 478 .{ 479 . return sy->section->vma + sy->value; 480 .} 481 . 482 .static inline const char * 483 .bfd_asymbol_name (const asymbol *sy) 484 .{ 485 . return sy->name; 486 .} 487 . 488 .static inline struct bfd * 489 .bfd_asymbol_bfd (const asymbol *sy) 490 .{ 491 . return sy->the_bfd; 492 .} 493 . 494 .static inline void 495 .bfd_set_asymbol_name (asymbol *sy, const char *name) 496 .{ 497 . sy->name = name; 498 .} 499 . 500 .static inline bfd_size_type 501 .bfd_get_section_limit_octets (const bfd *abfd, const asection *sec) 502 .{ 503 . if (abfd->direction != write_direction && sec->rawsize != 0) 504 . return sec->rawsize; 505 . return sec->size; 506 .} 507 . 508 .{* Find the address one past the end of SEC. *} 509 .static inline bfd_size_type 510 .bfd_get_section_limit (const bfd *abfd, const asection *sec) 511 .{ 512 . return (bfd_get_section_limit_octets (abfd, sec) 513 . / bfd_octets_per_byte (abfd, sec)); 514 .} 515 . 516 .{* Functions to handle insertion and deletion of a bfd's sections. These 517 . only handle the list pointers, ie. do not adjust section_count, 518 . target_index etc. *} 519 .static inline void 520 .bfd_section_list_remove (bfd *abfd, asection *s) 521 .{ 522 . asection *next = s->next; 523 . asection *prev = s->prev; 524 . if (prev) 525 . prev->next = next; 526 . else 527 . abfd->sections = next; 528 . if (next) 529 . next->prev = prev; 530 . else 531 . abfd->section_last = prev; 532 .} 533 . 534 .static inline void 535 .bfd_section_list_append (bfd *abfd, asection *s) 536 .{ 537 . s->next = 0; 538 . if (abfd->section_last) 539 . { 540 . s->prev = abfd->section_last; 541 . abfd->section_last->next = s; 542 . } 543 . else 544 . { 545 . s->prev = 0; 546 . abfd->sections = s; 547 . } 548 . abfd->section_last = s; 549 .} 550 . 551 .static inline void 552 .bfd_section_list_prepend (bfd *abfd, asection *s) 553 .{ 554 . s->prev = 0; 555 . if (abfd->sections) 556 . { 557 . s->next = abfd->sections; 558 . abfd->sections->prev = s; 559 . } 560 . else 561 . { 562 . s->next = 0; 563 . abfd->section_last = s; 564 . } 565 . abfd->sections = s; 566 .} 567 . 568 .static inline void 569 .bfd_section_list_insert_after (bfd *abfd, asection *a, asection *s) 570 .{ 571 . asection *next = a->next; 572 . s->next = next; 573 . s->prev = a; 574 . a->next = s; 575 . if (next) 576 . next->prev = s; 577 . else 578 . abfd->section_last = s; 579 .} 580 . 581 .static inline void 582 .bfd_section_list_insert_before (bfd *abfd, asection *b, asection *s) 583 .{ 584 . asection *prev = b->prev; 585 . s->prev = prev; 586 . s->next = b; 587 . b->prev = s; 588 . if (prev) 589 . prev->next = s; 590 . else 591 . abfd->sections = s; 592 .} 593 . 594 .static inline bool 595 .bfd_section_removed_from_list (const bfd *abfd, const asection *s) 596 .{ 597 . return s->next ? s->next->prev != s : abfd->section_last != s; 598 .} 599 . 600 */ 601 602 #include "sysdep.h" 603 #include <stdarg.h> 604 #include "bfd.h" 605 #include "bfdver.h" 606 #include "libiberty.h" 607 #include "demangle.h" 608 #include "safe-ctype.h" 609 #include "bfdlink.h" 610 #include "libbfd.h" 611 #include "coff/internal.h" 612 #include "coff/sym.h" 613 #include "libcoff.h" 614 #include "libecoff.h" 615 #undef obj_symbols 616 #include "elf-bfd.h" 617 618 #ifndef EXIT_FAILURE 619 #define EXIT_FAILURE 1 620 #endif 621 622 623 /* provide storage for subsystem, stack and heap data which may have been 624 passed in on the command line. Ld puts this data into a bfd_link_info 625 struct which ultimately gets passed in to the bfd. When it arrives, copy 626 it to the following struct so that the data will be available in coffcode.h 627 where it is needed. The typedef's used are defined in bfd.h */ 628 629 /* 630 INODE 631 Error reporting, Miscellaneous, typedef bfd, BFD front end 632 633 SECTION 634 Error reporting 635 636 Most BFD functions return nonzero on success (check their 637 individual documentation for precise semantics). On an error, 638 they call <<bfd_set_error>> to set an error condition that callers 639 can check by calling <<bfd_get_error>>. 640 If that returns <<bfd_error_system_call>>, then check 641 <<errno>>. 642 643 The easiest way to report a BFD error to the user is to 644 use <<bfd_perror>>. 645 646 SUBSECTION 647 Type <<bfd_error_type>> 648 649 The values returned by <<bfd_get_error>> are defined by the 650 enumerated type <<bfd_error_type>>. 651 652 CODE_FRAGMENT 653 . 654 .typedef enum bfd_error 655 .{ 656 . bfd_error_no_error = 0, 657 . bfd_error_system_call, 658 . bfd_error_invalid_target, 659 . bfd_error_wrong_format, 660 . bfd_error_wrong_object_format, 661 . bfd_error_invalid_operation, 662 . bfd_error_no_memory, 663 . bfd_error_no_symbols, 664 . bfd_error_no_armap, 665 . bfd_error_no_more_archived_files, 666 . bfd_error_malformed_archive, 667 . bfd_error_missing_dso, 668 . bfd_error_file_not_recognized, 669 . bfd_error_file_ambiguously_recognized, 670 . bfd_error_no_contents, 671 . bfd_error_nonrepresentable_section, 672 . bfd_error_no_debug_section, 673 . bfd_error_bad_value, 674 . bfd_error_file_truncated, 675 . bfd_error_file_too_big, 676 . bfd_error_sorry, 677 . bfd_error_on_input, 678 . bfd_error_invalid_error_code 679 .} 680 .bfd_error_type; 681 . 682 */ 683 684 static bfd_error_type bfd_error = bfd_error_no_error; 685 static bfd *input_bfd = NULL; 686 static bfd_error_type input_error = bfd_error_no_error; 687 688 const char *const bfd_errmsgs[] = 689 { 690 N_("no error"), 691 N_("system call error"), 692 N_("invalid bfd target"), 693 N_("file in wrong format"), 694 N_("archive object file in wrong format"), 695 N_("invalid operation"), 696 N_("memory exhausted"), 697 N_("no symbols"), 698 N_("archive has no index; run ranlib to add one"), 699 N_("no more archived files"), 700 N_("malformed archive"), 701 N_("DSO missing from command line"), 702 N_("file format not recognized"), 703 N_("file format is ambiguous"), 704 N_("section has no contents"), 705 N_("nonrepresentable section on output"), 706 N_("symbol needs debug section which does not exist"), 707 N_("bad value"), 708 N_("file truncated"), 709 N_("file too big"), 710 N_("sorry, cannot handle this file"), 711 N_("error reading %s: %s"), 712 N_("#<invalid error code>") 713 }; 714 715 /* 716 FUNCTION 717 bfd_get_error 718 719 SYNOPSIS 720 bfd_error_type bfd_get_error (void); 721 722 DESCRIPTION 723 Return the current BFD error condition. 724 */ 725 726 bfd_error_type 727 bfd_get_error (void) 728 { 729 return bfd_error; 730 } 731 732 /* 733 FUNCTION 734 bfd_set_error 735 736 SYNOPSIS 737 void bfd_set_error (bfd_error_type error_tag); 738 739 DESCRIPTION 740 Set the BFD error condition to be @var{error_tag}. 741 742 @var{error_tag} must not be bfd_error_on_input. Use 743 bfd_set_input_error for input errors instead. 744 */ 745 746 void 747 bfd_set_error (bfd_error_type error_tag) 748 { 749 bfd_error = error_tag; 750 if (bfd_error >= bfd_error_on_input) 751 abort (); 752 } 753 754 /* 755 FUNCTION 756 bfd_set_input_error 757 758 SYNOPSIS 759 void bfd_set_input_error (bfd *input, bfd_error_type error_tag); 760 761 DESCRIPTION 762 763 Set the BFD error condition to be bfd_error_on_input. 764 @var{input} is the input bfd where the error occurred, and 765 @var{error_tag} the bfd_error_type error. 766 */ 767 768 void 769 bfd_set_input_error (bfd *input, bfd_error_type error_tag) 770 { 771 /* This is an error that occurred during bfd_close when writing an 772 archive, but on one of the input files. */ 773 bfd_error = bfd_error_on_input; 774 input_bfd = input; 775 input_error = error_tag; 776 if (input_error >= bfd_error_on_input) 777 abort (); 778 } 779 780 /* 781 FUNCTION 782 bfd_errmsg 783 784 SYNOPSIS 785 const char *bfd_errmsg (bfd_error_type error_tag); 786 787 DESCRIPTION 788 Return a string describing the error @var{error_tag}, or 789 the system error if @var{error_tag} is <<bfd_error_system_call>>. 790 */ 791 792 const char * 793 bfd_errmsg (bfd_error_type error_tag) 794 { 795 #ifndef errno 796 extern int errno; 797 #endif 798 if (error_tag == bfd_error_on_input) 799 { 800 char *buf; 801 const char *msg = bfd_errmsg (input_error); 802 803 if (asprintf (&buf, _(bfd_errmsgs [error_tag]), 804 bfd_get_filename (input_bfd), msg) != -1) 805 return buf; 806 807 /* Ick, what to do on out of memory? */ 808 return msg; 809 } 810 811 if (error_tag == bfd_error_system_call) 812 return xstrerror (errno); 813 814 if (error_tag > bfd_error_invalid_error_code) 815 error_tag = bfd_error_invalid_error_code; /* sanity check */ 816 817 return _(bfd_errmsgs [error_tag]); 818 } 819 820 /* 821 FUNCTION 822 bfd_perror 823 824 SYNOPSIS 825 void bfd_perror (const char *message); 826 827 DESCRIPTION 828 Print to the standard error stream a string describing the 829 last BFD error that occurred, or the last system error if 830 the last BFD error was a system call failure. If @var{message} 831 is non-NULL and non-empty, the error string printed is preceded 832 by @var{message}, a colon, and a space. It is followed by a newline. 833 */ 834 835 void 836 bfd_perror (const char *message) 837 { 838 fflush (stdout); 839 if (message == NULL || *message == '\0') 840 fprintf (stderr, "%s\n", bfd_errmsg (bfd_get_error ())); 841 else 842 fprintf (stderr, "%s: %s\n", message, bfd_errmsg (bfd_get_error ())); 843 fflush (stderr); 844 } 845 846 /* 847 SUBSECTION 848 BFD error handler 849 850 Some BFD functions want to print messages describing the 851 problem. They call a BFD error handler function. This 852 function may be overridden by the program. 853 854 The BFD error handler acts like vprintf. 855 856 CODE_FRAGMENT 857 . 858 .typedef void (*bfd_error_handler_type) (const char *, va_list); 859 . 860 */ 861 862 /* The program name used when printing BFD error messages. */ 863 864 static const char *_bfd_error_program_name; 865 866 /* Support for positional parameters. */ 867 868 union _bfd_doprnt_args 869 { 870 int i; 871 long l; 872 long long ll; 873 double d; 874 long double ld; 875 void *p; 876 enum 877 { 878 Bad, 879 Int, 880 Long, 881 LongLong, 882 Double, 883 LongDouble, 884 Ptr 885 } type; 886 }; 887 888 /* This macro and _bfd_doprnt taken from libiberty _doprnt.c, tidied a 889 little and extended to handle '%pA', '%pB' and positional parameters. */ 890 891 #define PRINT_TYPE(TYPE, FIELD) \ 892 do \ 893 { \ 894 TYPE value = (TYPE) args[arg_no].FIELD; \ 895 result = fprintf (stream, specifier, value); \ 896 } while (0) 897 898 static int 899 _bfd_doprnt (FILE *stream, const char *format, union _bfd_doprnt_args *args) 900 { 901 const char *ptr = format; 902 char specifier[128]; 903 int total_printed = 0; 904 unsigned int arg_count = 0; 905 906 while (*ptr != '\0') 907 { 908 int result; 909 910 if (*ptr != '%') 911 { 912 /* While we have regular characters, print them. */ 913 char *end = strchr (ptr, '%'); 914 if (end != NULL) 915 result = fprintf (stream, "%.*s", (int) (end - ptr), ptr); 916 else 917 result = fprintf (stream, "%s", ptr); 918 ptr += result; 919 } 920 else if (ptr[1] == '%') 921 { 922 fputc ('%', stream); 923 result = 1; 924 ptr += 2; 925 } 926 else 927 { 928 /* We have a format specifier! */ 929 char *sptr = specifier; 930 int wide_width = 0, short_width = 0; 931 unsigned int arg_no; 932 933 /* Copy the % and move forward. */ 934 *sptr++ = *ptr++; 935 936 /* Check for a positional parameter. */ 937 arg_no = -1u; 938 if (*ptr != '0' && ISDIGIT (*ptr) && ptr[1] == '$') 939 { 940 arg_no = *ptr - '1'; 941 ptr += 2; 942 } 943 944 /* Move past flags. */ 945 while (strchr ("-+ #0'I", *ptr)) 946 *sptr++ = *ptr++; 947 948 if (*ptr == '*') 949 { 950 int value; 951 unsigned int arg_index; 952 953 ptr++; 954 arg_index = arg_count; 955 if (*ptr != '0' && ISDIGIT (*ptr) && ptr[1] == '$') 956 { 957 arg_index = *ptr - '1'; 958 ptr += 2; 959 } 960 value = abs (args[arg_index].i); 961 arg_count++; 962 sptr += sprintf (sptr, "%d", value); 963 } 964 else 965 /* Handle explicit numeric value. */ 966 while (ISDIGIT (*ptr)) 967 *sptr++ = *ptr++; 968 969 /* Precision. */ 970 if (*ptr == '.') 971 { 972 /* Copy and go past the period. */ 973 *sptr++ = *ptr++; 974 if (*ptr == '*') 975 { 976 int value; 977 unsigned int arg_index; 978 979 ptr++; 980 arg_index = arg_count; 981 if (*ptr != '0' && ISDIGIT (*ptr) && ptr[1] == '$') 982 { 983 arg_index = *ptr - '1'; 984 ptr += 2; 985 } 986 value = abs (args[arg_index].i); 987 arg_count++; 988 sptr += sprintf (sptr, "%d", value); 989 } 990 else 991 /* Handle explicit numeric value. */ 992 while (ISDIGIT (*ptr)) 993 *sptr++ = *ptr++; 994 } 995 while (strchr ("hlL", *ptr)) 996 { 997 switch (*ptr) 998 { 999 case 'h': 1000 short_width = 1; 1001 break; 1002 case 'l': 1003 wide_width++; 1004 break; 1005 case 'L': 1006 wide_width = 2; 1007 break; 1008 default: 1009 abort(); 1010 } 1011 *sptr++ = *ptr++; 1012 } 1013 1014 /* Copy the type specifier, and NULL terminate. */ 1015 *sptr++ = *ptr++; 1016 *sptr = '\0'; 1017 if ((int) arg_no < 0) 1018 arg_no = arg_count; 1019 1020 switch (ptr[-1]) 1021 { 1022 case 'd': 1023 case 'i': 1024 case 'o': 1025 case 'u': 1026 case 'x': 1027 case 'X': 1028 case 'c': 1029 { 1030 /* Short values are promoted to int, so just copy it 1031 as an int and trust the C library printf to cast it 1032 to the right width. */ 1033 if (short_width) 1034 PRINT_TYPE (int, i); 1035 else 1036 { 1037 switch (wide_width) 1038 { 1039 case 0: 1040 PRINT_TYPE (int, i); 1041 break; 1042 case 1: 1043 PRINT_TYPE (long, l); 1044 break; 1045 case 2: 1046 default: 1047 #if defined (__MSVCRT__) 1048 sptr[-3] = 'I'; 1049 sptr[-2] = '6'; 1050 sptr[-1] = '4'; 1051 *sptr++ = ptr[-1]; 1052 *sptr = '\0'; 1053 #endif 1054 PRINT_TYPE (long long, ll); 1055 break; 1056 } 1057 } 1058 } 1059 break; 1060 case 'f': 1061 case 'e': 1062 case 'E': 1063 case 'g': 1064 case 'G': 1065 { 1066 if (wide_width == 0) 1067 PRINT_TYPE (double, d); 1068 else 1069 PRINT_TYPE (long double, ld); 1070 } 1071 break; 1072 case 's': 1073 PRINT_TYPE (char *, p); 1074 break; 1075 case 'p': 1076 if (*ptr == 'A') 1077 { 1078 asection *sec; 1079 bfd *abfd; 1080 const char *group = NULL; 1081 struct coff_comdat_info *ci; 1082 1083 ptr++; 1084 sec = (asection *) args[arg_no].p; 1085 if (sec == NULL) 1086 /* Invoking %pA with a null section pointer is an 1087 internal error. */ 1088 abort (); 1089 abfd = sec->owner; 1090 if (abfd != NULL 1091 && bfd_get_flavour (abfd) == bfd_target_elf_flavour 1092 && elf_next_in_group (sec) != NULL 1093 && (sec->flags & SEC_GROUP) == 0) 1094 group = elf_group_name (sec); 1095 else if (abfd != NULL 1096 && bfd_get_flavour (abfd) == bfd_target_coff_flavour 1097 && (ci = bfd_coff_get_comdat_section (sec->owner, 1098 sec)) != NULL) 1099 group = ci->name; 1100 if (group != NULL) 1101 result = fprintf (stream, "%s[%s]", sec->name, group); 1102 else 1103 result = fprintf (stream, "%s", sec->name); 1104 } 1105 else if (*ptr == 'B') 1106 { 1107 bfd *abfd; 1108 1109 ptr++; 1110 abfd = (bfd *) args[arg_no].p; 1111 if (abfd == NULL) 1112 /* Invoking %pB with a null bfd pointer is an 1113 internal error. */ 1114 abort (); 1115 else if (abfd->my_archive 1116 && !bfd_is_thin_archive (abfd->my_archive)) 1117 result = fprintf (stream, "%s(%s)", 1118 bfd_get_filename (abfd->my_archive), 1119 bfd_get_filename (abfd)); 1120 else 1121 result = fprintf (stream, "%s", bfd_get_filename (abfd)); 1122 } 1123 else 1124 PRINT_TYPE (void *, p); 1125 break; 1126 default: 1127 abort(); 1128 } 1129 arg_count++; 1130 } 1131 if (result == -1) 1132 return -1; 1133 total_printed += result; 1134 } 1135 1136 return total_printed; 1137 } 1138 1139 /* First pass over FORMAT to gather ARGS. Returns number of args. */ 1140 1141 static unsigned int 1142 _bfd_doprnt_scan (const char *format, union _bfd_doprnt_args *args) 1143 { 1144 const char *ptr = format; 1145 unsigned int arg_count = 0; 1146 1147 while (*ptr != '\0') 1148 { 1149 if (*ptr != '%') 1150 { 1151 ptr = strchr (ptr, '%'); 1152 if (ptr == NULL) 1153 break; 1154 } 1155 else if (ptr[1] == '%') 1156 ptr += 2; 1157 else 1158 { 1159 int wide_width = 0, short_width = 0; 1160 unsigned int arg_no; 1161 int arg_type; 1162 1163 ptr++; 1164 1165 /* Check for a positional parameter. */ 1166 arg_no = -1u; 1167 if (*ptr != '0' && ISDIGIT (*ptr) && ptr[1] == '$') 1168 { 1169 arg_no = *ptr - '1'; 1170 ptr += 2; 1171 } 1172 1173 /* Move past flags. */ 1174 while (strchr ("-+ #0'I", *ptr)) 1175 ptr++; 1176 1177 if (*ptr == '*') 1178 { 1179 unsigned int arg_index; 1180 1181 ptr++; 1182 arg_index = arg_count; 1183 if (*ptr != '0' && ISDIGIT (*ptr) && ptr[1] == '$') 1184 { 1185 arg_index = *ptr - '1'; 1186 ptr += 2; 1187 } 1188 if (arg_index >= 9) 1189 abort (); 1190 args[arg_index].type = Int; 1191 arg_count++; 1192 } 1193 else 1194 /* Handle explicit numeric value. */ 1195 while (ISDIGIT (*ptr)) 1196 ptr++; 1197 1198 /* Precision. */ 1199 if (*ptr == '.') 1200 { 1201 ptr++; 1202 if (*ptr == '*') 1203 { 1204 unsigned int arg_index; 1205 1206 ptr++; 1207 arg_index = arg_count; 1208 if (*ptr != '0' && ISDIGIT (*ptr) && ptr[1] == '$') 1209 { 1210 arg_index = *ptr - '1'; 1211 ptr += 2; 1212 } 1213 if (arg_index >= 9) 1214 abort (); 1215 args[arg_index].type = Int; 1216 arg_count++; 1217 } 1218 else 1219 /* Handle explicit numeric value. */ 1220 while (ISDIGIT (*ptr)) 1221 ptr++; 1222 } 1223 while (strchr ("hlL", *ptr)) 1224 { 1225 switch (*ptr) 1226 { 1227 case 'h': 1228 short_width = 1; 1229 break; 1230 case 'l': 1231 wide_width++; 1232 break; 1233 case 'L': 1234 wide_width = 2; 1235 break; 1236 default: 1237 abort(); 1238 } 1239 ptr++; 1240 } 1241 1242 ptr++; 1243 if ((int) arg_no < 0) 1244 arg_no = arg_count; 1245 1246 arg_type = Bad; 1247 switch (ptr[-1]) 1248 { 1249 case 'd': 1250 case 'i': 1251 case 'o': 1252 case 'u': 1253 case 'x': 1254 case 'X': 1255 case 'c': 1256 { 1257 if (short_width) 1258 arg_type = Int; 1259 else 1260 { 1261 switch (wide_width) 1262 { 1263 case 0: 1264 arg_type = Int; 1265 break; 1266 case 1: 1267 arg_type = Long; 1268 break; 1269 case 2: 1270 default: 1271 arg_type = LongLong; 1272 break; 1273 } 1274 } 1275 } 1276 break; 1277 case 'f': 1278 case 'e': 1279 case 'E': 1280 case 'g': 1281 case 'G': 1282 { 1283 if (wide_width == 0) 1284 arg_type = Double; 1285 else 1286 arg_type = LongDouble; 1287 } 1288 break; 1289 case 's': 1290 arg_type = Ptr; 1291 break; 1292 case 'p': 1293 if (*ptr == 'A' || *ptr == 'B') 1294 ptr++; 1295 arg_type = Ptr; 1296 break; 1297 default: 1298 abort(); 1299 } 1300 1301 if (arg_no >= 9) 1302 abort (); 1303 args[arg_no].type = arg_type; 1304 arg_count++; 1305 } 1306 } 1307 1308 return arg_count; 1309 } 1310 1311 static void 1312 error_handler_internal (const char *fmt, va_list ap) 1313 { 1314 unsigned int i, arg_count; 1315 union _bfd_doprnt_args args[9]; 1316 1317 for (i = 0; i < sizeof (args) / sizeof (args[0]); i++) 1318 args[i].type = Bad; 1319 1320 arg_count = _bfd_doprnt_scan (fmt, args); 1321 for (i = 0; i < arg_count; i++) 1322 { 1323 switch (args[i].type) 1324 { 1325 case Int: 1326 args[i].i = va_arg (ap, int); 1327 break; 1328 case Long: 1329 args[i].l = va_arg (ap, long); 1330 break; 1331 case LongLong: 1332 args[i].ll = va_arg (ap, long long); 1333 break; 1334 case Double: 1335 args[i].d = va_arg (ap, double); 1336 break; 1337 case LongDouble: 1338 args[i].ld = va_arg (ap, long double); 1339 break; 1340 case Ptr: 1341 args[i].p = va_arg (ap, void *); 1342 break; 1343 default: 1344 abort (); 1345 } 1346 } 1347 1348 /* PR 4992: Don't interrupt output being sent to stdout. */ 1349 fflush (stdout); 1350 1351 if (_bfd_error_program_name != NULL) 1352 fprintf (stderr, "%s: ", _bfd_error_program_name); 1353 else 1354 fprintf (stderr, "BFD: "); 1355 1356 _bfd_doprnt (stderr, fmt, args); 1357 1358 /* On AIX, putc is implemented as a macro that triggers a -Wunused-value 1359 warning, so use the fputc function to avoid it. */ 1360 fputc ('\n', stderr); 1361 fflush (stderr); 1362 } 1363 1364 /* This is a function pointer to the routine which should handle BFD 1365 error messages. It is called when a BFD routine encounters an 1366 error for which it wants to print a message. Going through a 1367 function pointer permits a program linked against BFD to intercept 1368 the messages and deal with them itself. */ 1369 1370 static bfd_error_handler_type _bfd_error_internal = error_handler_internal; 1371 1372 /* 1373 FUNCTION 1374 _bfd_error_handler 1375 1376 SYNOPSIS 1377 void _bfd_error_handler (const char *fmt, ...) ATTRIBUTE_PRINTF_1; 1378 1379 DESCRIPTION 1380 This is the default routine to handle BFD error messages. 1381 Like fprintf (stderr, ...), but also handles some extra format 1382 specifiers. 1383 1384 %pA section name from section. For group components, prints 1385 group name too. 1386 %pB file name from bfd. For archive components, prints 1387 archive too. 1388 1389 Beware: Only supports a maximum of 9 format arguments. 1390 */ 1391 1392 void 1393 _bfd_error_handler (const char *fmt, ...) 1394 { 1395 va_list ap; 1396 1397 va_start (ap, fmt); 1398 _bfd_error_internal (fmt, ap); 1399 va_end (ap); 1400 } 1401 1402 /* 1403 FUNCTION 1404 bfd_set_error_handler 1405 1406 SYNOPSIS 1407 bfd_error_handler_type bfd_set_error_handler (bfd_error_handler_type); 1408 1409 DESCRIPTION 1410 Set the BFD error handler function. Returns the previous 1411 function. 1412 */ 1413 1414 bfd_error_handler_type 1415 bfd_set_error_handler (bfd_error_handler_type pnew) 1416 { 1417 bfd_error_handler_type pold; 1418 1419 pold = _bfd_error_internal; 1420 _bfd_error_internal = pnew; 1421 return pold; 1422 } 1423 1424 /* 1425 FUNCTION 1426 bfd_set_error_program_name 1427 1428 SYNOPSIS 1429 void bfd_set_error_program_name (const char *); 1430 1431 DESCRIPTION 1432 Set the program name to use when printing a BFD error. This 1433 is printed before the error message followed by a colon and 1434 space. The string must not be changed after it is passed to 1435 this function. 1436 */ 1437 1438 void 1439 bfd_set_error_program_name (const char *name) 1440 { 1441 _bfd_error_program_name = name; 1442 } 1443 1444 /* 1445 SUBSECTION 1446 BFD assert handler 1447 1448 If BFD finds an internal inconsistency, the bfd assert 1449 handler is called with information on the BFD version, BFD 1450 source file and line. If this happens, most programs linked 1451 against BFD are expected to want to exit with an error, or mark 1452 the current BFD operation as failed, so it is recommended to 1453 override the default handler, which just calls 1454 _bfd_error_handler and continues. 1455 1456 CODE_FRAGMENT 1457 . 1458 .typedef void (*bfd_assert_handler_type) (const char *bfd_formatmsg, 1459 . const char *bfd_version, 1460 . const char *bfd_file, 1461 . int bfd_line); 1462 . 1463 */ 1464 1465 /* Note the use of bfd_ prefix on the parameter names above: we want to 1466 show which one is the message and which is the version by naming the 1467 parameters, but avoid polluting the program-using-bfd namespace as 1468 the typedef is visible in the exported headers that the program 1469 includes. Below, it's just for consistency. */ 1470 1471 static void 1472 _bfd_default_assert_handler (const char *bfd_formatmsg, 1473 const char *bfd_version, 1474 const char *bfd_file, 1475 int bfd_line) 1476 1477 { 1478 _bfd_error_handler (bfd_formatmsg, bfd_version, bfd_file, bfd_line); 1479 } 1480 1481 /* Similar to _bfd_error_handler, a program can decide to exit on an 1482 internal BFD error. We use a non-variadic type to simplify passing 1483 on parameters to other functions, e.g. _bfd_error_handler. */ 1484 1485 static bfd_assert_handler_type _bfd_assert_handler = _bfd_default_assert_handler; 1486 1487 /* 1488 FUNCTION 1489 bfd_set_assert_handler 1490 1491 SYNOPSIS 1492 bfd_assert_handler_type bfd_set_assert_handler (bfd_assert_handler_type); 1493 1494 DESCRIPTION 1495 Set the BFD assert handler function. Returns the previous 1496 function. 1497 */ 1498 1499 bfd_assert_handler_type 1500 bfd_set_assert_handler (bfd_assert_handler_type pnew) 1501 { 1502 bfd_assert_handler_type pold; 1503 1504 pold = _bfd_assert_handler; 1505 _bfd_assert_handler = pnew; 1506 return pold; 1507 } 1508 1509 /* 1510 INODE 1511 Miscellaneous, Memory Usage, Error reporting, BFD front end 1512 1513 SECTION 1514 Miscellaneous 1515 1516 SUBSECTION 1517 Miscellaneous functions 1518 */ 1519 1520 /* 1521 FUNCTION 1522 bfd_get_reloc_upper_bound 1523 1524 SYNOPSIS 1525 long bfd_get_reloc_upper_bound (bfd *abfd, asection *sect); 1526 1527 DESCRIPTION 1528 Return the number of bytes required to store the 1529 relocation information associated with section @var{sect} 1530 attached to bfd @var{abfd}. If an error occurs, return -1. 1531 1532 */ 1533 1534 long 1535 bfd_get_reloc_upper_bound (bfd *abfd, sec_ptr asect) 1536 { 1537 if (abfd->format != bfd_object) 1538 { 1539 bfd_set_error (bfd_error_invalid_operation); 1540 return -1; 1541 } 1542 1543 return BFD_SEND (abfd, _get_reloc_upper_bound, (abfd, asect)); 1544 } 1545 1546 /* 1547 FUNCTION 1548 bfd_canonicalize_reloc 1549 1550 SYNOPSIS 1551 long bfd_canonicalize_reloc 1552 (bfd *abfd, asection *sec, arelent **loc, asymbol **syms); 1553 1554 DESCRIPTION 1555 Call the back end associated with the open BFD 1556 @var{abfd} and translate the external form of the relocation 1557 information attached to @var{sec} into the internal canonical 1558 form. Place the table into memory at @var{loc}, which has 1559 been preallocated, usually by a call to 1560 <<bfd_get_reloc_upper_bound>>. Returns the number of relocs, or 1561 -1 on error. 1562 1563 The @var{syms} table is also needed for horrible internal magic 1564 reasons. 1565 1566 */ 1567 long 1568 bfd_canonicalize_reloc (bfd *abfd, 1569 sec_ptr asect, 1570 arelent **location, 1571 asymbol **symbols) 1572 { 1573 if (abfd->format != bfd_object) 1574 { 1575 bfd_set_error (bfd_error_invalid_operation); 1576 return -1; 1577 } 1578 1579 return BFD_SEND (abfd, _bfd_canonicalize_reloc, 1580 (abfd, asect, location, symbols)); 1581 } 1582 1583 /* 1584 FUNCTION 1585 bfd_set_reloc 1586 1587 SYNOPSIS 1588 void bfd_set_reloc 1589 (bfd *abfd, asection *sec, arelent **rel, unsigned int count); 1590 1591 DESCRIPTION 1592 Set the relocation pointer and count within 1593 section @var{sec} to the values @var{rel} and @var{count}. 1594 The argument @var{abfd} is ignored. 1595 1596 .#define bfd_set_reloc(abfd, asect, location, count) \ 1597 . BFD_SEND (abfd, _bfd_set_reloc, (abfd, asect, location, count)) 1598 */ 1599 1600 /* 1601 FUNCTION 1602 bfd_set_file_flags 1603 1604 SYNOPSIS 1605 bool bfd_set_file_flags (bfd *abfd, flagword flags); 1606 1607 DESCRIPTION 1608 Set the flag word in the BFD @var{abfd} to the value @var{flags}. 1609 1610 Possible errors are: 1611 o <<bfd_error_wrong_format>> - The target bfd was not of object format. 1612 o <<bfd_error_invalid_operation>> - The target bfd was open for reading. 1613 o <<bfd_error_invalid_operation>> - 1614 The flag word contained a bit which was not applicable to the 1615 type of file. E.g., an attempt was made to set the <<D_PAGED>> bit 1616 on a BFD format which does not support demand paging. 1617 1618 */ 1619 1620 bool 1621 bfd_set_file_flags (bfd *abfd, flagword flags) 1622 { 1623 if (abfd->format != bfd_object) 1624 { 1625 bfd_set_error (bfd_error_wrong_format); 1626 return false; 1627 } 1628 1629 if (bfd_read_p (abfd)) 1630 { 1631 bfd_set_error (bfd_error_invalid_operation); 1632 return false; 1633 } 1634 1635 abfd->flags = flags; 1636 if ((flags & bfd_applicable_file_flags (abfd)) != flags) 1637 { 1638 bfd_set_error (bfd_error_invalid_operation); 1639 return false; 1640 } 1641 1642 return true; 1643 } 1644 1645 void 1646 bfd_assert (const char *file, int line) 1647 { 1648 /* xgettext:c-format */ 1649 (*_bfd_assert_handler) (_("BFD %s assertion fail %s:%d"), 1650 BFD_VERSION_STRING, file, line); 1651 } 1652 1653 /* A more or less friendly abort message. In libbfd.h abort is 1654 defined to call this function. */ 1655 1656 void 1657 _bfd_abort (const char *file, int line, const char *fn) 1658 { 1659 if (fn != NULL) 1660 _bfd_error_handler 1661 /* xgettext:c-format */ 1662 (_("BFD %s internal error, aborting at %s:%d in %s\n"), 1663 BFD_VERSION_STRING, file, line, fn); 1664 else 1665 _bfd_error_handler 1666 /* xgettext:c-format */ 1667 (_("BFD %s internal error, aborting at %s:%d\n"), 1668 BFD_VERSION_STRING, file, line); 1669 _bfd_error_handler (_("Please report this bug.\n")); 1670 _exit (EXIT_FAILURE); 1671 } 1672 1673 /* 1674 FUNCTION 1675 bfd_get_arch_size 1676 1677 SYNOPSIS 1678 int bfd_get_arch_size (bfd *abfd); 1679 1680 DESCRIPTION 1681 Returns the normalized architecture address size, in bits, as 1682 determined by the object file's format. By normalized, we mean 1683 either 32 or 64. For ELF, this information is included in the 1684 header. Use bfd_arch_bits_per_address for number of bits in 1685 the architecture address. 1686 1687 RETURNS 1688 Returns the arch size in bits if known, <<-1>> otherwise. 1689 */ 1690 1691 int 1692 bfd_get_arch_size (bfd *abfd) 1693 { 1694 if (abfd->xvec->flavour == bfd_target_elf_flavour) 1695 return get_elf_backend_data (abfd)->s->arch_size; 1696 1697 return bfd_arch_bits_per_address (abfd) > 32 ? 64 : 32; 1698 } 1699 1700 /* 1701 FUNCTION 1702 bfd_get_sign_extend_vma 1703 1704 SYNOPSIS 1705 int bfd_get_sign_extend_vma (bfd *abfd); 1706 1707 DESCRIPTION 1708 Indicates if the target architecture "naturally" sign extends 1709 an address. Some architectures implicitly sign extend address 1710 values when they are converted to types larger than the size 1711 of an address. For instance, bfd_get_start_address() will 1712 return an address sign extended to fill a bfd_vma when this is 1713 the case. 1714 1715 RETURNS 1716 Returns <<1>> if the target architecture is known to sign 1717 extend addresses, <<0>> if the target architecture is known to 1718 not sign extend addresses, and <<-1>> otherwise. 1719 */ 1720 1721 int 1722 bfd_get_sign_extend_vma (bfd *abfd) 1723 { 1724 const char *name; 1725 1726 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour) 1727 return get_elf_backend_data (abfd)->sign_extend_vma; 1728 1729 name = bfd_get_target (abfd); 1730 1731 /* Return a proper value for DJGPP & PE COFF. 1732 This function is required for DWARF2 support, but there is 1733 no place to store this information in the COFF back end. 1734 Should enough other COFF targets add support for DWARF2, 1735 a place will have to be found. Until then, this hack will do. */ 1736 if (startswith (name, "coff-go32") 1737 || strcmp (name, "pe-i386") == 0 1738 || strcmp (name, "pei-i386") == 0 1739 || strcmp (name, "pe-x86-64") == 0 1740 || strcmp (name, "pei-x86-64") == 0 1741 || strcmp (name, "pei-aarch64-little") == 0 1742 || strcmp (name, "pe-arm-wince-little") == 0 1743 || strcmp (name, "pei-arm-wince-little") == 0 1744 || strcmp (name, "aixcoff-rs6000") == 0 1745 || strcmp (name, "aix5coff64-rs6000") == 0) 1746 return 1; 1747 1748 if (startswith (name, "mach-o")) 1749 return 0; 1750 1751 bfd_set_error (bfd_error_wrong_format); 1752 return -1; 1753 } 1754 1755 /* 1756 FUNCTION 1757 bfd_set_start_address 1758 1759 SYNOPSIS 1760 bool bfd_set_start_address (bfd *abfd, bfd_vma vma); 1761 1762 DESCRIPTION 1763 Make @var{vma} the entry point of output BFD @var{abfd}. 1764 1765 RETURNS 1766 Returns <<TRUE>> on success, <<FALSE>> otherwise. 1767 */ 1768 1769 bool 1770 bfd_set_start_address (bfd *abfd, bfd_vma vma) 1771 { 1772 abfd->start_address = vma; 1773 return true; 1774 } 1775 1776 /* 1777 FUNCTION 1778 bfd_get_gp_size 1779 1780 SYNOPSIS 1781 unsigned int bfd_get_gp_size (bfd *abfd); 1782 1783 DESCRIPTION 1784 Return the maximum size of objects to be optimized using the GP 1785 register under MIPS ECOFF. This is typically set by the <<-G>> 1786 argument to the compiler, assembler or linker. 1787 */ 1788 1789 unsigned int 1790 bfd_get_gp_size (bfd *abfd) 1791 { 1792 if (abfd->format == bfd_object) 1793 { 1794 if (abfd->xvec->flavour == bfd_target_ecoff_flavour) 1795 return ecoff_data (abfd)->gp_size; 1796 else if (abfd->xvec->flavour == bfd_target_elf_flavour) 1797 return elf_gp_size (abfd); 1798 } 1799 return 0; 1800 } 1801 1802 /* 1803 FUNCTION 1804 bfd_set_gp_size 1805 1806 SYNOPSIS 1807 void bfd_set_gp_size (bfd *abfd, unsigned int i); 1808 1809 DESCRIPTION 1810 Set the maximum size of objects to be optimized using the GP 1811 register under ECOFF or MIPS ELF. This is typically set by 1812 the <<-G>> argument to the compiler, assembler or linker. 1813 */ 1814 1815 void 1816 bfd_set_gp_size (bfd *abfd, unsigned int i) 1817 { 1818 /* Don't try to set GP size on an archive or core file! */ 1819 if (abfd->format != bfd_object) 1820 return; 1821 1822 if (abfd->xvec->flavour == bfd_target_ecoff_flavour) 1823 ecoff_data (abfd)->gp_size = i; 1824 else if (abfd->xvec->flavour == bfd_target_elf_flavour) 1825 elf_gp_size (abfd) = i; 1826 } 1827 1828 /* Get the GP value. This is an internal function used by some of the 1829 relocation special_function routines on targets which support a GP 1830 register. */ 1831 1832 bfd_vma 1833 _bfd_get_gp_value (bfd *abfd) 1834 { 1835 if (! abfd) 1836 return 0; 1837 if (abfd->format != bfd_object) 1838 return 0; 1839 1840 if (abfd->xvec->flavour == bfd_target_ecoff_flavour) 1841 return ecoff_data (abfd)->gp; 1842 else if (abfd->xvec->flavour == bfd_target_elf_flavour) 1843 return elf_gp (abfd); 1844 1845 return 0; 1846 } 1847 1848 /* Set the GP value. */ 1849 1850 void 1851 _bfd_set_gp_value (bfd *abfd, bfd_vma v) 1852 { 1853 if (! abfd) 1854 abort (); 1855 if (abfd->format != bfd_object) 1856 return; 1857 1858 if (abfd->xvec->flavour == bfd_target_ecoff_flavour) 1859 ecoff_data (abfd)->gp = v; 1860 else if (abfd->xvec->flavour == bfd_target_elf_flavour) 1861 elf_gp (abfd) = v; 1862 } 1863 1864 /* 1865 FUNCTION 1866 bfd_set_gp_value 1867 1868 SYNOPSIS 1869 void bfd_set_gp_value (bfd *abfd, bfd_vma v); 1870 1871 DESCRIPTION 1872 Allow external access to the fucntion to set the GP value. 1873 This is specifically added for gdb-compile support. 1874 */ 1875 1876 void 1877 bfd_set_gp_value (bfd *abfd, bfd_vma v) 1878 { 1879 _bfd_set_gp_value (abfd, v); 1880 } 1881 1882 /* 1883 FUNCTION 1884 bfd_scan_vma 1885 1886 SYNOPSIS 1887 bfd_vma bfd_scan_vma (const char *string, const char **end, int base); 1888 1889 DESCRIPTION 1890 Convert, like <<strtoul>>, a numerical expression 1891 @var{string} into a <<bfd_vma>> integer, and return that integer. 1892 (Though without as many bells and whistles as <<strtoul>>.) 1893 The expression is assumed to be unsigned (i.e., positive). 1894 If given a @var{base}, it is used as the base for conversion. 1895 A base of 0 causes the function to interpret the string 1896 in hex if a leading "0x" or "0X" is found, otherwise 1897 in octal if a leading zero is found, otherwise in decimal. 1898 1899 If the value would overflow, the maximum <<bfd_vma>> value is 1900 returned. 1901 */ 1902 1903 bfd_vma 1904 bfd_scan_vma (const char *string, const char **end, int base) 1905 { 1906 bfd_vma value; 1907 bfd_vma cutoff; 1908 unsigned int cutlim; 1909 int overflow; 1910 1911 /* Let the host do it if possible. */ 1912 if (sizeof (bfd_vma) <= sizeof (unsigned long)) 1913 return strtoul (string, (char **) end, base); 1914 1915 if (sizeof (bfd_vma) <= sizeof (unsigned long long)) 1916 return strtoull (string, (char **) end, base); 1917 1918 if (base == 0) 1919 { 1920 if (string[0] == '0') 1921 { 1922 if ((string[1] == 'x') || (string[1] == 'X')) 1923 base = 16; 1924 else 1925 base = 8; 1926 } 1927 } 1928 1929 if ((base < 2) || (base > 36)) 1930 base = 10; 1931 1932 if (base == 16 1933 && string[0] == '0' 1934 && (string[1] == 'x' || string[1] == 'X') 1935 && ISXDIGIT (string[2])) 1936 { 1937 string += 2; 1938 } 1939 1940 cutoff = (~ (bfd_vma) 0) / (bfd_vma) base; 1941 cutlim = (~ (bfd_vma) 0) % (bfd_vma) base; 1942 value = 0; 1943 overflow = 0; 1944 while (1) 1945 { 1946 unsigned int digit; 1947 1948 digit = *string; 1949 if (ISDIGIT (digit)) 1950 digit = digit - '0'; 1951 else if (ISALPHA (digit)) 1952 digit = TOUPPER (digit) - 'A' + 10; 1953 else 1954 break; 1955 if (digit >= (unsigned int) base) 1956 break; 1957 if (value > cutoff || (value == cutoff && digit > cutlim)) 1958 overflow = 1; 1959 value = value * base + digit; 1960 ++string; 1961 } 1962 1963 if (overflow) 1964 value = ~ (bfd_vma) 0; 1965 1966 if (end != NULL) 1967 *end = string; 1968 1969 return value; 1970 } 1971 1972 /* 1973 FUNCTION 1974 bfd_copy_private_header_data 1975 1976 SYNOPSIS 1977 bool bfd_copy_private_header_data (bfd *ibfd, bfd *obfd); 1978 1979 DESCRIPTION 1980 Copy private BFD header information from the BFD @var{ibfd} to the 1981 the BFD @var{obfd}. This copies information that may require 1982 sections to exist, but does not require symbol tables. Return 1983 <<true>> on success, <<false>> on error. 1984 Possible error returns are: 1985 1986 o <<bfd_error_no_memory>> - 1987 Not enough memory exists to create private data for @var{obfd}. 1988 1989 .#define bfd_copy_private_header_data(ibfd, obfd) \ 1990 . BFD_SEND (obfd, _bfd_copy_private_header_data, \ 1991 . (ibfd, obfd)) 1992 1993 */ 1994 1995 /* 1996 FUNCTION 1997 bfd_copy_private_bfd_data 1998 1999 SYNOPSIS 2000 bool bfd_copy_private_bfd_data (bfd *ibfd, bfd *obfd); 2001 2002 DESCRIPTION 2003 Copy private BFD information from the BFD @var{ibfd} to the 2004 the BFD @var{obfd}. Return <<TRUE>> on success, <<FALSE>> on error. 2005 Possible error returns are: 2006 2007 o <<bfd_error_no_memory>> - 2008 Not enough memory exists to create private data for @var{obfd}. 2009 2010 .#define bfd_copy_private_bfd_data(ibfd, obfd) \ 2011 . BFD_SEND (obfd, _bfd_copy_private_bfd_data, \ 2012 . (ibfd, obfd)) 2013 2014 */ 2015 2016 /* 2017 FUNCTION 2018 bfd_set_private_flags 2019 2020 SYNOPSIS 2021 bool bfd_set_private_flags (bfd *abfd, flagword flags); 2022 2023 DESCRIPTION 2024 Set private BFD flag information in the BFD @var{abfd}. 2025 Return <<TRUE>> on success, <<FALSE>> on error. Possible error 2026 returns are: 2027 2028 o <<bfd_error_no_memory>> - 2029 Not enough memory exists to create private data for @var{obfd}. 2030 2031 .#define bfd_set_private_flags(abfd, flags) \ 2032 . BFD_SEND (abfd, _bfd_set_private_flags, (abfd, flags)) 2033 2034 */ 2035 2036 /* 2037 FUNCTION 2038 Other functions 2039 2040 DESCRIPTION 2041 The following functions exist but have not yet been documented. 2042 2043 .#define bfd_sizeof_headers(abfd, info) \ 2044 . BFD_SEND (abfd, _bfd_sizeof_headers, (abfd, info)) 2045 . 2046 .#define bfd_find_nearest_line(abfd, sec, syms, off, file, func, line) \ 2047 . BFD_SEND (abfd, _bfd_find_nearest_line, \ 2048 . (abfd, syms, sec, off, file, func, line, NULL)) 2049 . 2050 .#define bfd_find_nearest_line_discriminator(abfd, sec, syms, off, file, func, \ 2051 . line, disc) \ 2052 . BFD_SEND (abfd, _bfd_find_nearest_line, \ 2053 . (abfd, syms, sec, off, file, func, line, disc)) 2054 . 2055 .#define bfd_find_line(abfd, syms, sym, file, line) \ 2056 . BFD_SEND (abfd, _bfd_find_line, \ 2057 . (abfd, syms, sym, file, line)) 2058 . 2059 .#define bfd_find_inliner_info(abfd, file, func, line) \ 2060 . BFD_SEND (abfd, _bfd_find_inliner_info, \ 2061 . (abfd, file, func, line)) 2062 . 2063 .#define bfd_debug_info_start(abfd) \ 2064 . BFD_SEND (abfd, _bfd_debug_info_start, (abfd)) 2065 . 2066 .#define bfd_debug_info_end(abfd) \ 2067 . BFD_SEND (abfd, _bfd_debug_info_end, (abfd)) 2068 . 2069 .#define bfd_debug_info_accumulate(abfd, section) \ 2070 . BFD_SEND (abfd, _bfd_debug_info_accumulate, (abfd, section)) 2071 . 2072 .#define bfd_stat_arch_elt(abfd, stat) \ 2073 . BFD_SEND (abfd->my_archive ? abfd->my_archive : abfd, \ 2074 . _bfd_stat_arch_elt, (abfd, stat)) 2075 . 2076 .#define bfd_update_armap_timestamp(abfd) \ 2077 . BFD_SEND (abfd, _bfd_update_armap_timestamp, (abfd)) 2078 . 2079 .#define bfd_set_arch_mach(abfd, arch, mach)\ 2080 . BFD_SEND ( abfd, _bfd_set_arch_mach, (abfd, arch, mach)) 2081 . 2082 .#define bfd_relax_section(abfd, section, link_info, again) \ 2083 . BFD_SEND (abfd, _bfd_relax_section, (abfd, section, link_info, again)) 2084 . 2085 .#define bfd_gc_sections(abfd, link_info) \ 2086 . BFD_SEND (abfd, _bfd_gc_sections, (abfd, link_info)) 2087 . 2088 .#define bfd_lookup_section_flags(link_info, flag_info, section) \ 2089 . BFD_SEND (abfd, _bfd_lookup_section_flags, (link_info, flag_info, section)) 2090 . 2091 .#define bfd_merge_sections(abfd, link_info) \ 2092 . BFD_SEND (abfd, _bfd_merge_sections, (abfd, link_info)) 2093 . 2094 .#define bfd_is_group_section(abfd, sec) \ 2095 . BFD_SEND (abfd, _bfd_is_group_section, (abfd, sec)) 2096 . 2097 .#define bfd_group_name(abfd, sec) \ 2098 . BFD_SEND (abfd, _bfd_group_name, (abfd, sec)) 2099 . 2100 .#define bfd_discard_group(abfd, sec) \ 2101 . BFD_SEND (abfd, _bfd_discard_group, (abfd, sec)) 2102 . 2103 .#define bfd_link_hash_table_create(abfd) \ 2104 . BFD_SEND (abfd, _bfd_link_hash_table_create, (abfd)) 2105 . 2106 .#define bfd_link_add_symbols(abfd, info) \ 2107 . BFD_SEND (abfd, _bfd_link_add_symbols, (abfd, info)) 2108 . 2109 .#define bfd_link_just_syms(abfd, sec, info) \ 2110 . BFD_SEND (abfd, _bfd_link_just_syms, (sec, info)) 2111 . 2112 .#define bfd_final_link(abfd, info) \ 2113 . BFD_SEND (abfd, _bfd_final_link, (abfd, info)) 2114 . 2115 .#define bfd_free_cached_info(abfd) \ 2116 . BFD_SEND (abfd, _bfd_free_cached_info, (abfd)) 2117 . 2118 .#define bfd_get_dynamic_symtab_upper_bound(abfd) \ 2119 . BFD_SEND (abfd, _bfd_get_dynamic_symtab_upper_bound, (abfd)) 2120 . 2121 .#define bfd_print_private_bfd_data(abfd, file)\ 2122 . BFD_SEND (abfd, _bfd_print_private_bfd_data, (abfd, file)) 2123 . 2124 .#define bfd_canonicalize_dynamic_symtab(abfd, asymbols) \ 2125 . BFD_SEND (abfd, _bfd_canonicalize_dynamic_symtab, (abfd, asymbols)) 2126 . 2127 .#define bfd_get_synthetic_symtab(abfd, count, syms, dyncount, dynsyms, ret) \ 2128 . BFD_SEND (abfd, _bfd_get_synthetic_symtab, (abfd, count, syms, \ 2129 . dyncount, dynsyms, ret)) 2130 . 2131 .#define bfd_get_dynamic_reloc_upper_bound(abfd) \ 2132 . BFD_SEND (abfd, _bfd_get_dynamic_reloc_upper_bound, (abfd)) 2133 . 2134 .#define bfd_canonicalize_dynamic_reloc(abfd, arels, asyms) \ 2135 . BFD_SEND (abfd, _bfd_canonicalize_dynamic_reloc, (abfd, arels, asyms)) 2136 . 2137 .extern bfd_byte *bfd_get_relocated_section_contents 2138 . (bfd *, struct bfd_link_info *, struct bfd_link_order *, bfd_byte *, 2139 . bool, asymbol **); 2140 . 2141 2142 */ 2143 2144 bfd_byte * 2145 bfd_get_relocated_section_contents (bfd *abfd, 2146 struct bfd_link_info *link_info, 2147 struct bfd_link_order *link_order, 2148 bfd_byte *data, 2149 bool relocatable, 2150 asymbol **symbols) 2151 { 2152 bfd *abfd2; 2153 bfd_byte *(*fn) (bfd *, struct bfd_link_info *, struct bfd_link_order *, 2154 bfd_byte *, bool, asymbol **); 2155 2156 if (link_order->type == bfd_indirect_link_order) 2157 { 2158 abfd2 = link_order->u.indirect.section->owner; 2159 if (abfd2 == NULL) 2160 abfd2 = abfd; 2161 } 2162 else 2163 abfd2 = abfd; 2164 2165 fn = abfd2->xvec->_bfd_get_relocated_section_contents; 2166 2167 return (*fn) (abfd, link_info, link_order, data, relocatable, symbols); 2168 } 2169 2170 /* Record information about an ELF program header. */ 2171 2172 bool 2173 bfd_record_phdr (bfd *abfd, 2174 unsigned long type, 2175 bool flags_valid, 2176 flagword flags, 2177 bool at_valid, 2178 bfd_vma at, /* Bytes. */ 2179 bool includes_filehdr, 2180 bool includes_phdrs, 2181 unsigned int count, 2182 asection **secs) 2183 { 2184 struct elf_segment_map *m, **pm; 2185 size_t amt; 2186 unsigned int opb = bfd_octets_per_byte (abfd, NULL); 2187 2188 if (bfd_get_flavour (abfd) != bfd_target_elf_flavour) 2189 return true; 2190 2191 amt = sizeof (struct elf_segment_map); 2192 amt += ((bfd_size_type) count - 1) * sizeof (asection *); 2193 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt); 2194 if (m == NULL) 2195 return false; 2196 2197 m->p_type = type; 2198 m->p_flags = flags; 2199 m->p_paddr = at * opb; 2200 m->p_flags_valid = flags_valid; 2201 m->p_paddr_valid = at_valid; 2202 m->includes_filehdr = includes_filehdr; 2203 m->includes_phdrs = includes_phdrs; 2204 m->count = count; 2205 if (count > 0) 2206 memcpy (m->sections, secs, count * sizeof (asection *)); 2207 2208 for (pm = &elf_seg_map (abfd); *pm != NULL; pm = &(*pm)->next) 2209 ; 2210 *pm = m; 2211 2212 return true; 2213 } 2214 2215 #ifdef BFD64 2216 /* Return true iff this target is 32-bit. */ 2217 2218 static bool 2219 is32bit (bfd *abfd) 2220 { 2221 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour) 2222 { 2223 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 2224 return bed->s->elfclass == ELFCLASS32; 2225 } 2226 2227 /* For non-ELF targets, use architecture information. */ 2228 return bfd_arch_bits_per_address (abfd) <= 32; 2229 } 2230 #endif 2231 2232 /* bfd_sprintf_vma and bfd_fprintf_vma display an address in the 2233 target's address size. */ 2234 2235 void 2236 bfd_sprintf_vma (bfd *abfd ATTRIBUTE_UNUSED, char *buf, bfd_vma value) 2237 { 2238 #ifdef BFD64 2239 if (is32bit (abfd)) 2240 { 2241 sprintf (buf, "%08lx", (unsigned long) value & 0xffffffff); 2242 return; 2243 } 2244 #endif 2245 sprintf_vma (buf, value); 2246 } 2247 2248 void 2249 bfd_fprintf_vma (bfd *abfd ATTRIBUTE_UNUSED, void *stream, bfd_vma value) 2250 { 2251 #ifdef BFD64 2252 if (is32bit (abfd)) 2253 { 2254 fprintf ((FILE *) stream, "%08lx", (unsigned long) value & 0xffffffff); 2255 return; 2256 } 2257 #endif 2258 fprintf_vma ((FILE *) stream, value); 2259 } 2260 2261 /* 2262 FUNCTION 2263 bfd_alt_mach_code 2264 2265 SYNOPSIS 2266 bool bfd_alt_mach_code (bfd *abfd, int alternative); 2267 2268 DESCRIPTION 2269 2270 When more than one machine code number is available for the 2271 same machine type, this function can be used to switch between 2272 the preferred one (alternative == 0) and any others. Currently, 2273 only ELF supports this feature, with up to two alternate 2274 machine codes. 2275 */ 2276 2277 bool 2278 bfd_alt_mach_code (bfd *abfd, int alternative) 2279 { 2280 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour) 2281 { 2282 int code; 2283 2284 switch (alternative) 2285 { 2286 case 0: 2287 code = get_elf_backend_data (abfd)->elf_machine_code; 2288 break; 2289 2290 case 1: 2291 code = get_elf_backend_data (abfd)->elf_machine_alt1; 2292 if (code == 0) 2293 return false; 2294 break; 2295 2296 case 2: 2297 code = get_elf_backend_data (abfd)->elf_machine_alt2; 2298 if (code == 0) 2299 return false; 2300 break; 2301 2302 default: 2303 return false; 2304 } 2305 2306 elf_elfheader (abfd)->e_machine = code; 2307 2308 return true; 2309 } 2310 2311 return false; 2312 } 2313 2314 /* 2315 FUNCTION 2316 bfd_emul_get_maxpagesize 2317 2318 SYNOPSIS 2319 bfd_vma bfd_emul_get_maxpagesize (const char *); 2320 2321 DESCRIPTION 2322 Returns the maximum page size, in bytes, as determined by 2323 emulation. 2324 2325 RETURNS 2326 Returns the maximum page size in bytes for ELF, 0 otherwise. 2327 */ 2328 2329 bfd_vma 2330 bfd_emul_get_maxpagesize (const char *emul) 2331 { 2332 const bfd_target *target; 2333 2334 target = bfd_find_target (emul, NULL); 2335 if (target != NULL 2336 && target->flavour == bfd_target_elf_flavour) 2337 return xvec_get_elf_backend_data (target)->maxpagesize; 2338 2339 return 0; 2340 } 2341 2342 /* 2343 FUNCTION 2344 bfd_emul_get_commonpagesize 2345 2346 SYNOPSIS 2347 bfd_vma bfd_emul_get_commonpagesize (const char *); 2348 2349 DESCRIPTION 2350 Returns the common page size, in bytes, as determined by 2351 emulation. 2352 2353 RETURNS 2354 Returns the common page size in bytes for ELF, 0 otherwise. 2355 */ 2356 2357 bfd_vma 2358 bfd_emul_get_commonpagesize (const char *emul) 2359 { 2360 const bfd_target *target; 2361 2362 target = bfd_find_target (emul, NULL); 2363 if (target != NULL 2364 && target->flavour == bfd_target_elf_flavour) 2365 { 2366 const struct elf_backend_data *bed; 2367 2368 bed = xvec_get_elf_backend_data (target); 2369 return bed->commonpagesize; 2370 } 2371 return 0; 2372 } 2373 2374 /* 2375 FUNCTION 2376 bfd_demangle 2377 2378 SYNOPSIS 2379 char *bfd_demangle (bfd *, const char *, int); 2380 2381 DESCRIPTION 2382 Wrapper around cplus_demangle. Strips leading underscores and 2383 other such chars that would otherwise confuse the demangler. 2384 If passed a g++ v3 ABI mangled name, returns a buffer allocated 2385 with malloc holding the demangled name. Returns NULL otherwise 2386 and on memory alloc failure. 2387 */ 2388 2389 char * 2390 bfd_demangle (bfd *abfd, const char *name, int options) 2391 { 2392 char *res, *alloc; 2393 const char *pre, *suf; 2394 size_t pre_len; 2395 bool skip_lead; 2396 2397 skip_lead = (abfd != NULL 2398 && *name != '\0' 2399 && bfd_get_symbol_leading_char (abfd) == *name); 2400 if (skip_lead) 2401 ++name; 2402 2403 /* This is a hack for better error reporting on XCOFF, PowerPC64-ELF 2404 or the MS PE format. These formats have a number of leading '.'s 2405 on at least some symbols, so we remove all dots to avoid 2406 confusing the demangler. */ 2407 pre = name; 2408 while (*name == '.' || *name == '$') 2409 ++name; 2410 pre_len = name - pre; 2411 2412 /* Strip off @plt and suchlike too. */ 2413 alloc = NULL; 2414 suf = strchr (name, '@'); 2415 if (suf != NULL) 2416 { 2417 alloc = (char *) bfd_malloc (suf - name + 1); 2418 if (alloc == NULL) 2419 return NULL; 2420 memcpy (alloc, name, suf - name); 2421 alloc[suf - name] = '\0'; 2422 name = alloc; 2423 } 2424 2425 res = cplus_demangle (name, options); 2426 2427 free (alloc); 2428 2429 if (res == NULL) 2430 { 2431 if (skip_lead) 2432 { 2433 size_t len = strlen (pre) + 1; 2434 alloc = (char *) bfd_malloc (len); 2435 if (alloc == NULL) 2436 return NULL; 2437 memcpy (alloc, pre, len); 2438 return alloc; 2439 } 2440 return NULL; 2441 } 2442 2443 /* Put back any prefix or suffix. */ 2444 if (pre_len != 0 || suf != NULL) 2445 { 2446 size_t len; 2447 size_t suf_len; 2448 char *final; 2449 2450 len = strlen (res); 2451 if (suf == NULL) 2452 suf = res + len; 2453 suf_len = strlen (suf) + 1; 2454 final = (char *) bfd_malloc (pre_len + len + suf_len); 2455 if (final != NULL) 2456 { 2457 memcpy (final, pre, pre_len); 2458 memcpy (final + pre_len, res, len); 2459 memcpy (final + pre_len + len, suf, suf_len); 2460 } 2461 free (res); 2462 res = final; 2463 } 2464 2465 return res; 2466 } 2467 2468 /* 2469 FUNCTION 2470 bfd_update_compression_header 2471 2472 SYNOPSIS 2473 void bfd_update_compression_header 2474 (bfd *abfd, bfd_byte *contents, asection *sec); 2475 2476 DESCRIPTION 2477 Set the compression header at CONTENTS of SEC in ABFD and update 2478 elf_section_flags for compression. 2479 */ 2480 2481 void 2482 bfd_update_compression_header (bfd *abfd, bfd_byte *contents, 2483 asection *sec) 2484 { 2485 if ((abfd->flags & BFD_COMPRESS) == 0) 2486 abort (); 2487 2488 switch (bfd_get_flavour (abfd)) 2489 { 2490 case bfd_target_elf_flavour: 2491 if ((abfd->flags & BFD_COMPRESS_GABI) != 0) 2492 { 2493 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 2494 struct bfd_elf_section_data * esd = elf_section_data (sec); 2495 2496 /* Set the SHF_COMPRESSED bit. */ 2497 elf_section_flags (sec) |= SHF_COMPRESSED; 2498 2499 if (bed->s->elfclass == ELFCLASS32) 2500 { 2501 Elf32_External_Chdr *echdr = (Elf32_External_Chdr *) contents; 2502 bfd_put_32 (abfd, ELFCOMPRESS_ZLIB, &echdr->ch_type); 2503 bfd_put_32 (abfd, sec->size, &echdr->ch_size); 2504 bfd_put_32 (abfd, 1u << sec->alignment_power, 2505 &echdr->ch_addralign); 2506 /* bfd_log2 (alignof (Elf32_Chdr)) */ 2507 bfd_set_section_alignment (sec, 2); 2508 esd->this_hdr.sh_addralign = 4; 2509 } 2510 else 2511 { 2512 Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) contents; 2513 bfd_put_32 (abfd, ELFCOMPRESS_ZLIB, &echdr->ch_type); 2514 bfd_put_32 (abfd, 0, &echdr->ch_reserved); 2515 bfd_put_64 (abfd, sec->size, &echdr->ch_size); 2516 bfd_put_64 (abfd, UINT64_C (1) << sec->alignment_power, 2517 &echdr->ch_addralign); 2518 /* bfd_log2 (alignof (Elf64_Chdr)) */ 2519 bfd_set_section_alignment (sec, 3); 2520 esd->this_hdr.sh_addralign = 8; 2521 } 2522 break; 2523 } 2524 2525 /* Clear the SHF_COMPRESSED bit. */ 2526 elf_section_flags (sec) &= ~SHF_COMPRESSED; 2527 /* Fall through. */ 2528 2529 default: 2530 /* Write the zlib header. It should be "ZLIB" followed by 2531 the uncompressed section size, 8 bytes in big-endian 2532 order. */ 2533 memcpy (contents, "ZLIB", 4); 2534 bfd_putb64 (sec->size, contents + 4); 2535 /* No way to keep the original alignment, just use 1 always. */ 2536 bfd_set_section_alignment (sec, 0); 2537 break; 2538 } 2539 } 2540 2541 /* 2542 FUNCTION 2543 bfd_check_compression_header 2544 2545 SYNOPSIS 2546 bool bfd_check_compression_header 2547 (bfd *abfd, bfd_byte *contents, asection *sec, 2548 bfd_size_type *uncompressed_size, 2549 unsigned int *uncompressed_alignment_power); 2550 2551 DESCRIPTION 2552 Check the compression header at CONTENTS of SEC in ABFD and 2553 store the uncompressed size in UNCOMPRESSED_SIZE and the 2554 uncompressed data alignment in UNCOMPRESSED_ALIGNMENT_POWER 2555 if the compression header is valid. 2556 2557 RETURNS 2558 Return TRUE if the compression header is valid. 2559 */ 2560 2561 bool 2562 bfd_check_compression_header (bfd *abfd, bfd_byte *contents, 2563 asection *sec, 2564 bfd_size_type *uncompressed_size, 2565 unsigned int *uncompressed_alignment_power) 2566 { 2567 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour 2568 && (elf_section_flags (sec) & SHF_COMPRESSED) != 0) 2569 { 2570 Elf_Internal_Chdr chdr; 2571 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 2572 if (bed->s->elfclass == ELFCLASS32) 2573 { 2574 Elf32_External_Chdr *echdr = (Elf32_External_Chdr *) contents; 2575 chdr.ch_type = bfd_get_32 (abfd, &echdr->ch_type); 2576 chdr.ch_size = bfd_get_32 (abfd, &echdr->ch_size); 2577 chdr.ch_addralign = bfd_get_32 (abfd, &echdr->ch_addralign); 2578 } 2579 else 2580 { 2581 Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) contents; 2582 chdr.ch_type = bfd_get_32 (abfd, &echdr->ch_type); 2583 chdr.ch_size = bfd_get_64 (abfd, &echdr->ch_size); 2584 chdr.ch_addralign = bfd_get_64 (abfd, &echdr->ch_addralign); 2585 } 2586 if (chdr.ch_type == ELFCOMPRESS_ZLIB 2587 && chdr.ch_addralign == (chdr.ch_addralign & -chdr.ch_addralign)) 2588 { 2589 *uncompressed_size = chdr.ch_size; 2590 *uncompressed_alignment_power = bfd_log2 (chdr.ch_addralign); 2591 return true; 2592 } 2593 } 2594 2595 return false; 2596 } 2597 2598 /* 2599 FUNCTION 2600 bfd_get_compression_header_size 2601 2602 SYNOPSIS 2603 int bfd_get_compression_header_size (bfd *abfd, asection *sec); 2604 2605 DESCRIPTION 2606 Return the size of the compression header of SEC in ABFD. 2607 2608 RETURNS 2609 Return the size of the compression header in bytes. 2610 */ 2611 2612 int 2613 bfd_get_compression_header_size (bfd *abfd, asection *sec) 2614 { 2615 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour) 2616 { 2617 if (sec == NULL) 2618 { 2619 if (!(abfd->flags & BFD_COMPRESS_GABI)) 2620 return 0; 2621 } 2622 else if (!(elf_section_flags (sec) & SHF_COMPRESSED)) 2623 return 0; 2624 2625 if (get_elf_backend_data (abfd)->s->elfclass == ELFCLASS32) 2626 return sizeof (Elf32_External_Chdr); 2627 else 2628 return sizeof (Elf64_External_Chdr); 2629 } 2630 2631 return 0; 2632 } 2633 2634 /* 2635 FUNCTION 2636 bfd_convert_section_size 2637 2638 SYNOPSIS 2639 bfd_size_type bfd_convert_section_size 2640 (bfd *ibfd, asection *isec, bfd *obfd, bfd_size_type size); 2641 2642 DESCRIPTION 2643 Convert the size @var{size} of the section @var{isec} in input 2644 BFD @var{ibfd} to the section size in output BFD @var{obfd}. 2645 */ 2646 2647 bfd_size_type 2648 bfd_convert_section_size (bfd *ibfd, sec_ptr isec, bfd *obfd, 2649 bfd_size_type size) 2650 { 2651 bfd_size_type hdr_size; 2652 2653 /* Do nothing if either input or output aren't ELF. */ 2654 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour 2655 || bfd_get_flavour (obfd) != bfd_target_elf_flavour) 2656 return size; 2657 2658 /* Do nothing if ELF classes of input and output are the same. */ 2659 if (get_elf_backend_data (ibfd)->s->elfclass 2660 == get_elf_backend_data (obfd)->s->elfclass) 2661 return size; 2662 2663 /* Convert GNU property size. */ 2664 if (startswith (isec->name, NOTE_GNU_PROPERTY_SECTION_NAME)) 2665 return _bfd_elf_convert_gnu_property_size (ibfd, obfd); 2666 2667 /* Do nothing if input file will be decompressed. */ 2668 if ((ibfd->flags & BFD_DECOMPRESS)) 2669 return size; 2670 2671 /* Do nothing if the input section isn't a SHF_COMPRESSED section. */ 2672 hdr_size = bfd_get_compression_header_size (ibfd, isec); 2673 if (hdr_size == 0) 2674 return size; 2675 2676 /* Adjust the size of the output SHF_COMPRESSED section. */ 2677 if (hdr_size == sizeof (Elf32_External_Chdr)) 2678 return (size - sizeof (Elf32_External_Chdr) 2679 + sizeof (Elf64_External_Chdr)); 2680 else 2681 return (size - sizeof (Elf64_External_Chdr) 2682 + sizeof (Elf32_External_Chdr)); 2683 } 2684 2685 /* 2686 FUNCTION 2687 bfd_convert_section_contents 2688 2689 SYNOPSIS 2690 bool bfd_convert_section_contents 2691 (bfd *ibfd, asection *isec, bfd *obfd, 2692 bfd_byte **ptr, bfd_size_type *ptr_size); 2693 2694 DESCRIPTION 2695 Convert the contents, stored in @var{*ptr}, of the section 2696 @var{isec} in input BFD @var{ibfd} to output BFD @var{obfd} 2697 if needed. The original buffer pointed to by @var{*ptr} may 2698 be freed and @var{*ptr} is returned with memory malloc'd by this 2699 function, and the new size written to @var{ptr_size}. 2700 */ 2701 2702 bool 2703 bfd_convert_section_contents (bfd *ibfd, sec_ptr isec, bfd *obfd, 2704 bfd_byte **ptr, bfd_size_type *ptr_size) 2705 { 2706 bfd_byte *contents; 2707 bfd_size_type ihdr_size, ohdr_size, size; 2708 Elf_Internal_Chdr chdr; 2709 bool use_memmove; 2710 2711 /* Do nothing if either input or output aren't ELF. */ 2712 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour 2713 || bfd_get_flavour (obfd) != bfd_target_elf_flavour) 2714 return true; 2715 2716 /* Do nothing if ELF classes of input and output are the same. */ 2717 if (get_elf_backend_data (ibfd)->s->elfclass 2718 == get_elf_backend_data (obfd)->s->elfclass) 2719 return true; 2720 2721 /* Convert GNU properties. */ 2722 if (startswith (isec->name, NOTE_GNU_PROPERTY_SECTION_NAME)) 2723 return _bfd_elf_convert_gnu_properties (ibfd, isec, obfd, ptr, 2724 ptr_size); 2725 2726 /* Do nothing if input file will be decompressed. */ 2727 if ((ibfd->flags & BFD_DECOMPRESS)) 2728 return true; 2729 2730 /* Do nothing if the input section isn't a SHF_COMPRESSED section. */ 2731 ihdr_size = bfd_get_compression_header_size (ibfd, isec); 2732 if (ihdr_size == 0) 2733 return true; 2734 2735 /* PR 25221. Check for corrupt input sections. */ 2736 if (ihdr_size > bfd_get_section_limit (ibfd, isec)) 2737 /* FIXME: Issue a warning about a corrupt 2738 compression header size field ? */ 2739 return false; 2740 2741 contents = *ptr; 2742 2743 /* Convert the contents of the input SHF_COMPRESSED section to 2744 output. Get the input compression header and the size of the 2745 output compression header. */ 2746 if (ihdr_size == sizeof (Elf32_External_Chdr)) 2747 { 2748 Elf32_External_Chdr *echdr = (Elf32_External_Chdr *) contents; 2749 chdr.ch_type = bfd_get_32 (ibfd, &echdr->ch_type); 2750 chdr.ch_size = bfd_get_32 (ibfd, &echdr->ch_size); 2751 chdr.ch_addralign = bfd_get_32 (ibfd, &echdr->ch_addralign); 2752 2753 ohdr_size = sizeof (Elf64_External_Chdr); 2754 2755 use_memmove = false; 2756 } 2757 else if (ihdr_size != sizeof (Elf64_External_Chdr)) 2758 { 2759 /* FIXME: Issue a warning about a corrupt 2760 compression header size field ? */ 2761 return false; 2762 } 2763 else 2764 { 2765 Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) contents; 2766 chdr.ch_type = bfd_get_32 (ibfd, &echdr->ch_type); 2767 chdr.ch_size = bfd_get_64 (ibfd, &echdr->ch_size); 2768 chdr.ch_addralign = bfd_get_64 (ibfd, &echdr->ch_addralign); 2769 2770 ohdr_size = sizeof (Elf32_External_Chdr); 2771 use_memmove = true; 2772 } 2773 2774 size = bfd_section_size (isec) - ihdr_size + ohdr_size; 2775 if (!use_memmove) 2776 { 2777 contents = (bfd_byte *) bfd_malloc (size); 2778 if (contents == NULL) 2779 return false; 2780 } 2781 2782 /* Write out the output compression header. */ 2783 if (ohdr_size == sizeof (Elf32_External_Chdr)) 2784 { 2785 Elf32_External_Chdr *echdr = (Elf32_External_Chdr *) contents; 2786 bfd_put_32 (obfd, ELFCOMPRESS_ZLIB, &echdr->ch_type); 2787 bfd_put_32 (obfd, chdr.ch_size, &echdr->ch_size); 2788 bfd_put_32 (obfd, chdr.ch_addralign, &echdr->ch_addralign); 2789 } 2790 else 2791 { 2792 Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) contents; 2793 bfd_put_32 (obfd, ELFCOMPRESS_ZLIB, &echdr->ch_type); 2794 bfd_put_32 (obfd, 0, &echdr->ch_reserved); 2795 bfd_put_64 (obfd, chdr.ch_size, &echdr->ch_size); 2796 bfd_put_64 (obfd, chdr.ch_addralign, &echdr->ch_addralign); 2797 } 2798 2799 /* Copy the compressed contents. */ 2800 if (use_memmove) 2801 memmove (contents + ohdr_size, *ptr + ihdr_size, size - ohdr_size); 2802 else 2803 { 2804 memcpy (contents + ohdr_size, *ptr + ihdr_size, size - ohdr_size); 2805 free (*ptr); 2806 *ptr = contents; 2807 } 2808 2809 *ptr_size = size; 2810 return true; 2811 } 2812 2813 /* Get the linker information. */ 2814 2815 struct bfd_link_info * 2816 _bfd_get_link_info (bfd *abfd) 2817 { 2818 if (bfd_get_flavour (abfd) != bfd_target_elf_flavour) 2819 return NULL; 2820 2821 return elf_link_info (abfd); 2822 } 2823