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