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