1 /* Generic BFD library interface and support routines. 2 Copyright (C) 1990-2014 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 .struct bfd 48 .{ 49 . {* The filename the application opened the BFD with. *} 50 . const char *filename; 51 . 52 . {* A pointer to the target jump table. *} 53 . const struct bfd_target *xvec; 54 . 55 . {* The IOSTREAM, and corresponding IO vector that provide access 56 . to the file backing the BFD. *} 57 . void *iostream; 58 . const struct bfd_iovec *iovec; 59 . 60 . {* The caching routines use these to maintain a 61 . least-recently-used list of BFDs. *} 62 . struct bfd *lru_prev, *lru_next; 63 . 64 . {* When a file is closed by the caching routines, BFD retains 65 . state information on the file here... *} 66 . ufile_ptr where; 67 . 68 . {* File modified time, if mtime_set is TRUE. *} 69 . long mtime; 70 . 71 . {* A unique identifier of the BFD *} 72 . unsigned int id; 73 . 74 . {* The format which belongs to the BFD. (object, core, etc.) *} 75 . ENUM_BITFIELD (bfd_format) format : 3; 76 . 77 . {* The direction with which the BFD was opened. *} 78 . ENUM_BITFIELD (bfd_direction) direction : 2; 79 . 80 . {* Format_specific flags. *} 81 . flagword flags : 17; 82 . 83 . {* Values that may appear in the flags field of a BFD. These also 84 . appear in the object_flags field of the bfd_target structure, where 85 . they indicate the set of flags used by that backend (not all flags 86 . are meaningful for all object file formats) (FIXME: at the moment, 87 . the object_flags values have mostly just been copied from backend 88 . to another, and are not necessarily correct). *} 89 . 90 .#define BFD_NO_FLAGS 0x00 91 . 92 . {* BFD contains relocation entries. *} 93 .#define HAS_RELOC 0x01 94 . 95 . {* BFD is directly executable. *} 96 .#define EXEC_P 0x02 97 . 98 . {* BFD has line number information (basically used for F_LNNO in a 99 . COFF header). *} 100 .#define HAS_LINENO 0x04 101 . 102 . {* BFD has debugging information. *} 103 .#define HAS_DEBUG 0x08 104 . 105 . {* BFD has symbols. *} 106 .#define HAS_SYMS 0x10 107 . 108 . {* BFD has local symbols (basically used for F_LSYMS in a COFF 109 . header). *} 110 .#define HAS_LOCALS 0x20 111 . 112 . {* BFD is a dynamic object. *} 113 .#define DYNAMIC 0x40 114 . 115 . {* Text section is write protected (if D_PAGED is not set, this is 116 . like an a.out NMAGIC file) (the linker sets this by default, but 117 . clears it for -r or -N). *} 118 .#define WP_TEXT 0x80 119 . 120 . {* BFD is dynamically paged (this is like an a.out ZMAGIC file) (the 121 . linker sets this by default, but clears it for -r or -n or -N). *} 122 .#define D_PAGED 0x100 123 . 124 . {* BFD is relaxable (this means that bfd_relax_section may be able to 125 . do something) (sometimes bfd_relax_section can do something even if 126 . this is not set). *} 127 .#define BFD_IS_RELAXABLE 0x200 128 . 129 . {* This may be set before writing out a BFD to request using a 130 . traditional format. For example, this is used to request that when 131 . writing out an a.out object the symbols not be hashed to eliminate 132 . duplicates. *} 133 .#define BFD_TRADITIONAL_FORMAT 0x400 134 . 135 . {* This flag indicates that the BFD contents are actually cached 136 . in memory. If this is set, iostream points to a bfd_in_memory 137 . struct. *} 138 .#define BFD_IN_MEMORY 0x800 139 . 140 . {* This BFD has been created by the linker and doesn't correspond 141 . to any input file. *} 142 .#define BFD_LINKER_CREATED 0x1000 143 . 144 . {* This may be set before writing out a BFD to request that it 145 . be written using values for UIDs, GIDs, timestamps, etc. that 146 . will be consistent from run to run. *} 147 .#define BFD_DETERMINISTIC_OUTPUT 0x2000 148 . 149 . {* Compress sections in this BFD. *} 150 .#define BFD_COMPRESS 0x4000 151 . 152 . {* Decompress sections in this BFD. *} 153 .#define BFD_DECOMPRESS 0x8000 154 . 155 . {* BFD is a dummy, for plugins. *} 156 .#define BFD_PLUGIN 0x10000 157 . 158 . {* Flags bits to be saved in bfd_preserve_save. *} 159 .#define BFD_FLAGS_SAVED \ 160 . (BFD_IN_MEMORY | BFD_COMPRESS | BFD_DECOMPRESS | BFD_PLUGIN) 161 . 162 . {* Flags bits which are for BFD use only. *} 163 .#define BFD_FLAGS_FOR_BFD_USE_MASK \ 164 . (BFD_IN_MEMORY | BFD_COMPRESS | BFD_DECOMPRESS | BFD_LINKER_CREATED \ 165 . | BFD_PLUGIN | BFD_TRADITIONAL_FORMAT | BFD_DETERMINISTIC_OUTPUT) 166 . 167 . {* Is the file descriptor being cached? That is, can it be closed as 168 . needed, and re-opened when accessed later? *} 169 . unsigned int cacheable : 1; 170 . 171 . {* Marks whether there was a default target specified when the 172 . BFD was opened. This is used to select which matching algorithm 173 . to use to choose the back end. *} 174 . unsigned int target_defaulted : 1; 175 . 176 . {* ... and here: (``once'' means at least once). *} 177 . unsigned int opened_once : 1; 178 . 179 . {* Set if we have a locally maintained mtime value, rather than 180 . getting it from the file each time. *} 181 . unsigned int mtime_set : 1; 182 . 183 . {* Flag set if symbols from this BFD should not be exported. *} 184 . unsigned int no_export : 1; 185 . 186 . {* Remember when output has begun, to stop strange things 187 . from happening. *} 188 . unsigned int output_has_begun : 1; 189 . 190 . {* Have archive map. *} 191 . unsigned int has_armap : 1; 192 . 193 . {* Set if this is a thin archive. *} 194 . unsigned int is_thin_archive : 1; 195 . 196 . {* Set if only required symbols should be added in the link hash table for 197 . this object. Used by VMS linkers. *} 198 . unsigned int selective_search : 1; 199 . 200 . {* Set if this is the linker output BFD. *} 201 . unsigned int is_linker_output : 1; 202 . 203 . {* Currently my_archive is tested before adding origin to 204 . anything. I believe that this can become always an add of 205 . origin, with origin set to 0 for non archive files. *} 206 . ufile_ptr origin; 207 . 208 . {* The origin in the archive of the proxy entry. This will 209 . normally be the same as origin, except for thin archives, 210 . when it will contain the current offset of the proxy in the 211 . thin archive rather than the offset of the bfd in its actual 212 . container. *} 213 . ufile_ptr proxy_origin; 214 . 215 . {* A hash table for section names. *} 216 . struct bfd_hash_table section_htab; 217 . 218 . {* Pointer to linked list of sections. *} 219 . struct bfd_section *sections; 220 . 221 . {* The last section on the section list. *} 222 . struct bfd_section *section_last; 223 . 224 . {* The number of sections. *} 225 . unsigned int section_count; 226 . 227 . {* A field used by _bfd_generic_link_add_archive_symbols. This will 228 . be used only for archive elements. *} 229 . int archive_pass; 230 . 231 . {* Stuff only useful for object files: 232 . The start address. *} 233 . bfd_vma start_address; 234 . 235 . {* Symbol table for output BFD (with symcount entries). 236 . Also used by the linker to cache input BFD symbols. *} 237 . struct bfd_symbol **outsymbols; 238 . 239 . {* Used for input and output. *} 240 . unsigned int symcount; 241 . 242 . {* Used for slurped dynamic symbol tables. *} 243 . unsigned int dynsymcount; 244 . 245 . {* Pointer to structure which contains architecture information. *} 246 . const struct bfd_arch_info *arch_info; 247 . 248 . {* Stuff only useful for archives. *} 249 . void *arelt_data; 250 . struct bfd *my_archive; {* The containing archive BFD. *} 251 . struct bfd *archive_next; {* The next BFD in the archive. *} 252 . struct bfd *archive_head; {* The first BFD in the archive. *} 253 . struct bfd *nested_archives; {* List of nested archive in a flattened 254 . thin archive. *} 255 . 256 . union { 257 . {* For input BFDs, a chain of BFDs involved in a link. *} 258 . struct bfd *next; 259 . {* For output BFD, the linker hash table. *} 260 . struct bfd_link_hash_table *hash; 261 . } link; 262 . 263 . {* Used by the back end to hold private data. *} 264 . union 265 . { 266 . struct aout_data_struct *aout_data; 267 . struct artdata *aout_ar_data; 268 . struct _oasys_data *oasys_obj_data; 269 . struct _oasys_ar_data *oasys_ar_data; 270 . struct coff_tdata *coff_obj_data; 271 . struct pe_tdata *pe_obj_data; 272 . struct xcoff_tdata *xcoff_obj_data; 273 . struct ecoff_tdata *ecoff_obj_data; 274 . struct ieee_data_struct *ieee_data; 275 . struct ieee_ar_data_struct *ieee_ar_data; 276 . struct srec_data_struct *srec_data; 277 . struct verilog_data_struct *verilog_data; 278 . struct ihex_data_struct *ihex_data; 279 . struct tekhex_data_struct *tekhex_data; 280 . struct elf_obj_tdata *elf_obj_data; 281 . struct nlm_obj_tdata *nlm_obj_data; 282 . struct bout_data_struct *bout_data; 283 . struct mmo_data_struct *mmo_data; 284 . struct sun_core_struct *sun_core_data; 285 . struct sco5_core_struct *sco5_core_data; 286 . struct trad_core_struct *trad_core_data; 287 . struct som_data_struct *som_data; 288 . struct hpux_core_struct *hpux_core_data; 289 . struct hppabsd_core_struct *hppabsd_core_data; 290 . struct sgi_core_struct *sgi_core_data; 291 . struct lynx_core_struct *lynx_core_data; 292 . struct osf_core_struct *osf_core_data; 293 . struct cisco_core_struct *cisco_core_data; 294 . struct versados_data_struct *versados_data; 295 . struct netbsd_core_struct *netbsd_core_data; 296 . struct mach_o_data_struct *mach_o_data; 297 . struct mach_o_fat_data_struct *mach_o_fat_data; 298 . struct plugin_data_struct *plugin_data; 299 . struct bfd_pef_data_struct *pef_data; 300 . struct bfd_pef_xlib_data_struct *pef_xlib_data; 301 . struct bfd_sym_data_struct *sym_data; 302 . void *any; 303 . } 304 . tdata; 305 . 306 . {* Used by the application to hold private data. *} 307 . void *usrdata; 308 . 309 . {* Where all the allocated stuff under this BFD goes. This is a 310 . struct objalloc *, but we use void * to avoid requiring the inclusion 311 . of objalloc.h. *} 312 . void *memory; 313 .}; 314 . 315 .{* See note beside bfd_set_section_userdata. *} 316 .static inline bfd_boolean 317 .bfd_set_cacheable (bfd * abfd, bfd_boolean val) 318 .{ 319 . abfd->cacheable = val; 320 . return TRUE; 321 .} 322 . 323 */ 324 325 #include "sysdep.h" 326 #include <stdarg.h> 327 #include "bfd.h" 328 #include "bfdver.h" 329 #include "libiberty.h" 330 #include "demangle.h" 331 #include "safe-ctype.h" 332 #include "bfdlink.h" 333 #include "libbfd.h" 334 #include "coff/internal.h" 335 #include "coff/sym.h" 336 #include "libcoff.h" 337 #include "libecoff.h" 338 #undef obj_symbols 339 #include "elf-bfd.h" 340 341 #ifndef EXIT_FAILURE 342 #define EXIT_FAILURE 1 343 #endif 344 345 346 /* provide storage for subsystem, stack and heap data which may have been 348 passed in on the command line. Ld puts this data into a bfd_link_info 349 struct which ultimately gets passed in to the bfd. When it arrives, copy 350 it to the following struct so that the data will be available in coffcode.h 351 where it is needed. The typedef's used are defined in bfd.h */ 352 353 /* 355 INODE 356 Error reporting, Miscellaneous, typedef bfd, BFD front end 357 358 SECTION 359 Error reporting 360 361 Most BFD functions return nonzero on success (check their 362 individual documentation for precise semantics). On an error, 363 they call <<bfd_set_error>> to set an error condition that callers 364 can check by calling <<bfd_get_error>>. 365 If that returns <<bfd_error_system_call>>, then check 366 <<errno>>. 367 368 The easiest way to report a BFD error to the user is to 369 use <<bfd_perror>>. 370 371 SUBSECTION 372 Type <<bfd_error_type>> 373 374 The values returned by <<bfd_get_error>> are defined by the 375 enumerated type <<bfd_error_type>>. 376 377 CODE_FRAGMENT 378 . 379 .typedef enum bfd_error 380 .{ 381 . bfd_error_no_error = 0, 382 . bfd_error_system_call, 383 . bfd_error_invalid_target, 384 . bfd_error_wrong_format, 385 . bfd_error_wrong_object_format, 386 . bfd_error_invalid_operation, 387 . bfd_error_no_memory, 388 . bfd_error_no_symbols, 389 . bfd_error_no_armap, 390 . bfd_error_no_more_archived_files, 391 . bfd_error_malformed_archive, 392 . bfd_error_missing_dso, 393 . bfd_error_file_not_recognized, 394 . bfd_error_file_ambiguously_recognized, 395 . bfd_error_no_contents, 396 . bfd_error_nonrepresentable_section, 397 . bfd_error_no_debug_section, 398 . bfd_error_bad_value, 399 . bfd_error_file_truncated, 400 . bfd_error_file_too_big, 401 . bfd_error_on_input, 402 . bfd_error_invalid_error_code 403 .} 404 .bfd_error_type; 405 . 406 */ 407 408 static bfd_error_type bfd_error = bfd_error_no_error; 409 static bfd *input_bfd = NULL; 410 static bfd_error_type input_error = bfd_error_no_error; 411 412 const char *const bfd_errmsgs[] = 413 { 414 N_("No error"), 415 N_("System call error"), 416 N_("Invalid bfd target"), 417 N_("File in wrong format"), 418 N_("Archive object file in wrong format"), 419 N_("Invalid operation"), 420 N_("Memory exhausted"), 421 N_("No symbols"), 422 N_("Archive has no index; run ranlib to add one"), 423 N_("No more archived files"), 424 N_("Malformed archive"), 425 N_("DSO missing from command line"), 426 N_("File format not recognized"), 427 N_("File format is ambiguous"), 428 N_("Section has no contents"), 429 N_("Nonrepresentable section on output"), 430 N_("Symbol needs debug section which does not exist"), 431 N_("Bad value"), 432 N_("File truncated"), 433 N_("File too big"), 434 N_("Error reading %s: %s"), 435 N_("#<Invalid error code>") 436 }; 437 438 /* 439 FUNCTION 440 bfd_get_error 441 442 SYNOPSIS 443 bfd_error_type bfd_get_error (void); 444 445 DESCRIPTION 446 Return the current BFD error condition. 447 */ 448 449 bfd_error_type 450 bfd_get_error (void) 451 { 452 return bfd_error; 453 } 454 455 /* 456 FUNCTION 457 bfd_set_error 458 459 SYNOPSIS 460 void bfd_set_error (bfd_error_type error_tag, ...); 461 462 DESCRIPTION 463 Set the BFD error condition to be @var{error_tag}. 464 If @var{error_tag} is bfd_error_on_input, then this function 465 takes two more parameters, the input bfd where the error 466 occurred, and the bfd_error_type error. 467 */ 468 469 void 470 bfd_set_error (bfd_error_type error_tag, ...) 471 { 472 bfd_error = error_tag; 473 if (error_tag == bfd_error_on_input) 474 { 475 /* This is an error that occurred during bfd_close when 476 writing an archive, but on one of the input files. */ 477 va_list ap; 478 479 va_start (ap, error_tag); 480 input_bfd = va_arg (ap, bfd *); 481 input_error = (bfd_error_type) va_arg (ap, int); 482 if (input_error >= bfd_error_on_input) 483 abort (); 484 va_end (ap); 485 } 486 } 487 488 /* 489 FUNCTION 490 bfd_errmsg 491 492 SYNOPSIS 493 const char *bfd_errmsg (bfd_error_type error_tag); 494 495 DESCRIPTION 496 Return a string describing the error @var{error_tag}, or 497 the system error if @var{error_tag} is <<bfd_error_system_call>>. 498 */ 499 500 const char * 501 bfd_errmsg (bfd_error_type error_tag) 502 { 503 #ifndef errno 504 extern int errno; 505 #endif 506 if (error_tag == bfd_error_on_input) 507 { 508 char *buf; 509 const char *msg = bfd_errmsg (input_error); 510 511 if (asprintf (&buf, _(bfd_errmsgs [error_tag]), input_bfd->filename, msg) 512 != -1) 513 return buf; 514 515 /* Ick, what to do on out of memory? */ 516 return msg; 517 } 518 519 if (error_tag == bfd_error_system_call) 520 return xstrerror (errno); 521 522 if (error_tag > bfd_error_invalid_error_code) 523 error_tag = bfd_error_invalid_error_code; /* sanity check */ 524 525 return _(bfd_errmsgs [error_tag]); 526 } 527 528 /* 529 FUNCTION 530 bfd_perror 531 532 SYNOPSIS 533 void bfd_perror (const char *message); 534 535 DESCRIPTION 536 Print to the standard error stream a string describing the 537 last BFD error that occurred, or the last system error if 538 the last BFD error was a system call failure. If @var{message} 539 is non-NULL and non-empty, the error string printed is preceded 540 by @var{message}, a colon, and a space. It is followed by a newline. 541 */ 542 543 void 544 bfd_perror (const char *message) 545 { 546 fflush (stdout); 547 if (message == NULL || *message == '\0') 548 fprintf (stderr, "%s\n", bfd_errmsg (bfd_get_error ())); 549 else 550 fprintf (stderr, "%s: %s\n", message, bfd_errmsg (bfd_get_error ())); 551 fflush (stderr); 552 } 553 554 /* 555 SUBSECTION 556 BFD error handler 557 558 Some BFD functions want to print messages describing the 559 problem. They call a BFD error handler function. This 560 function may be overridden by the program. 561 562 The BFD error handler acts like printf. 563 564 CODE_FRAGMENT 565 . 566 .typedef void (*bfd_error_handler_type) (const char *, ...); 567 . 568 */ 569 570 /* The program name used when printing BFD error messages. */ 571 572 static const char *_bfd_error_program_name; 573 574 /* This is the default routine to handle BFD error messages. 575 Like fprintf (stderr, ...), but also handles some extra format specifiers. 576 577 %A section name from section. For group components, print group name too. 578 %B file name from bfd. For archive components, prints archive too. 579 580 Note - because these two extra format specifiers require special handling 581 they are scanned for and processed in this function, before calling 582 vfprintf. This means that the *arguments* for these format specifiers 583 must be the first ones in the variable argument list, regardless of where 584 the specifiers appear in the format string. Thus for example calling 585 this function with a format string of: 586 587 "blah %s blah %A blah %d blah %B" 588 589 would involve passing the arguments as: 590 591 "blah %s blah %A blah %d blah %B", 592 asection_for_the_%A, 593 bfd_for_the_%B, 594 string_for_the_%s, 595 integer_for_the_%d); 596 */ 597 598 void 599 _bfd_default_error_handler (const char *fmt, ...) 600 { 601 va_list ap; 602 char *bufp; 603 const char *new_fmt, *p; 604 size_t avail = 1000; 605 char buf[1000]; 606 607 /* PR 4992: Don't interrupt output being sent to stdout. */ 608 fflush (stdout); 609 610 if (_bfd_error_program_name != NULL) 611 fprintf (stderr, "%s: ", _bfd_error_program_name); 612 else 613 fprintf (stderr, "BFD: "); 614 615 va_start (ap, fmt); 616 new_fmt = fmt; 617 bufp = buf; 618 619 /* Reserve enough space for the existing format string. */ 620 avail -= strlen (fmt) + 1; 621 if (avail > 1000) 622 _exit (EXIT_FAILURE); 623 624 p = fmt; 625 while (1) 626 { 627 char *q; 628 size_t len, extra, trim; 629 630 p = strchr (p, '%'); 631 if (p == NULL || p[1] == '\0') 632 { 633 if (new_fmt == buf) 634 { 635 len = strlen (fmt); 636 memcpy (bufp, fmt, len + 1); 637 } 638 break; 639 } 640 641 if (p[1] == 'A' || p[1] == 'B') 642 { 643 len = p - fmt; 644 memcpy (bufp, fmt, len); 645 bufp += len; 646 fmt = p + 2; 647 new_fmt = buf; 648 649 /* If we run out of space, tough, you lose your ridiculously 650 long file or section name. It's not safe to try to alloc 651 memory here; We might be printing an out of memory message. */ 652 if (avail == 0) 653 { 654 *bufp++ = '*'; 655 *bufp++ = '*'; 656 *bufp = '\0'; 657 } 658 else 659 { 660 if (p[1] == 'B') 661 { 662 bfd *abfd = va_arg (ap, bfd *); 663 664 if (abfd == NULL) 665 /* Invoking %B with a null bfd pointer is an internal error. */ 666 abort (); 667 else if (abfd->my_archive) 668 snprintf (bufp, avail, "%s(%s)", 669 abfd->my_archive->filename, abfd->filename); 670 else 671 snprintf (bufp, avail, "%s", abfd->filename); 672 } 673 else 674 { 675 asection *sec = va_arg (ap, asection *); 676 bfd *abfd; 677 const char *group = NULL; 678 struct coff_comdat_info *ci; 679 680 if (sec == NULL) 681 /* Invoking %A with a null section pointer is an internal error. */ 682 abort (); 683 abfd = sec->owner; 684 if (abfd != NULL 685 && bfd_get_flavour (abfd) == bfd_target_elf_flavour 686 && elf_next_in_group (sec) != NULL 687 && (sec->flags & SEC_GROUP) == 0) 688 group = elf_group_name (sec); 689 else if (abfd != NULL 690 && bfd_get_flavour (abfd) == bfd_target_coff_flavour 691 && (ci = bfd_coff_get_comdat_section (sec->owner, 692 sec)) != NULL) 693 group = ci->name; 694 if (group != NULL) 695 snprintf (bufp, avail, "%s[%s]", sec->name, group); 696 else 697 snprintf (bufp, avail, "%s", sec->name); 698 } 699 len = strlen (bufp); 700 avail = avail - len + 2; 701 702 /* We need to replace any '%' we printed by "%%". 703 First count how many. */ 704 q = bufp; 705 bufp += len; 706 extra = 0; 707 while ((q = strchr (q, '%')) != NULL) 708 { 709 ++q; 710 ++extra; 711 } 712 713 /* If there isn't room, trim off the end of the string. */ 714 q = bufp; 715 bufp += extra; 716 if (extra > avail) 717 { 718 trim = extra - avail; 719 bufp -= trim; 720 do 721 { 722 if (*--q == '%') 723 --extra; 724 } 725 while (--trim != 0); 726 *q = '\0'; 727 avail = extra; 728 } 729 avail -= extra; 730 731 /* Now double all '%' chars, shuffling the string as we go. */ 732 while (extra != 0) 733 { 734 while ((q[extra] = *q) != '%') 735 --q; 736 q[--extra] = '%'; 737 --q; 738 } 739 } 740 } 741 p = p + 2; 742 } 743 744 vfprintf (stderr, new_fmt, ap); 745 va_end (ap); 746 747 /* On AIX, putc is implemented as a macro that triggers a -Wunused-value 748 warning, so use the fputc function to avoid it. */ 749 fputc ('\n', stderr); 750 fflush (stderr); 751 } 752 753 /* This is a function pointer to the routine which should handle BFD 754 error messages. It is called when a BFD routine encounters an 755 error for which it wants to print a message. Going through a 756 function pointer permits a program linked against BFD to intercept 757 the messages and deal with them itself. */ 758 759 bfd_error_handler_type _bfd_error_handler = _bfd_default_error_handler; 760 761 /* 762 FUNCTION 763 bfd_set_error_handler 764 765 SYNOPSIS 766 bfd_error_handler_type bfd_set_error_handler (bfd_error_handler_type); 767 768 DESCRIPTION 769 Set the BFD error handler function. Returns the previous 770 function. 771 */ 772 773 bfd_error_handler_type 774 bfd_set_error_handler (bfd_error_handler_type pnew) 775 { 776 bfd_error_handler_type pold; 777 778 pold = _bfd_error_handler; 779 _bfd_error_handler = pnew; 780 return pold; 781 } 782 783 /* 784 FUNCTION 785 bfd_set_error_program_name 786 787 SYNOPSIS 788 void bfd_set_error_program_name (const char *); 789 790 DESCRIPTION 791 Set the program name to use when printing a BFD error. This 792 is printed before the error message followed by a colon and 793 space. The string must not be changed after it is passed to 794 this function. 795 */ 796 797 void 798 bfd_set_error_program_name (const char *name) 799 { 800 _bfd_error_program_name = name; 801 } 802 803 /* 804 FUNCTION 805 bfd_get_error_handler 806 807 SYNOPSIS 808 bfd_error_handler_type bfd_get_error_handler (void); 809 810 DESCRIPTION 811 Return the BFD error handler function. 812 */ 813 814 bfd_error_handler_type 815 bfd_get_error_handler (void) 816 { 817 return _bfd_error_handler; 818 } 819 820 /* 821 SUBSECTION 822 BFD assert handler 823 824 If BFD finds an internal inconsistency, the bfd assert 825 handler is called with information on the BFD version, BFD 826 source file and line. If this happens, most programs linked 827 against BFD are expected to want to exit with an error, or mark 828 the current BFD operation as failed, so it is recommended to 829 override the default handler, which just calls 830 _bfd_error_handler and continues. 831 832 CODE_FRAGMENT 833 . 834 .typedef void (*bfd_assert_handler_type) (const char *bfd_formatmsg, 835 . const char *bfd_version, 836 . const char *bfd_file, 837 . int bfd_line); 838 . 839 */ 840 841 /* Note the use of bfd_ prefix on the parameter names above: we want to 842 show which one is the message and which is the version by naming the 843 parameters, but avoid polluting the program-using-bfd namespace as 844 the typedef is visible in the exported headers that the program 845 includes. Below, it's just for consistency. */ 846 847 static void 848 _bfd_default_assert_handler (const char *bfd_formatmsg, 849 const char *bfd_version, 850 const char *bfd_file, 851 int bfd_line) 852 853 { 854 (*_bfd_error_handler) (bfd_formatmsg, bfd_version, bfd_file, bfd_line); 855 } 856 857 /* Similar to _bfd_error_handler, a program can decide to exit on an 858 internal BFD error. We use a non-variadic type to simplify passing 859 on parameters to other functions, e.g. _bfd_error_handler. */ 860 861 bfd_assert_handler_type _bfd_assert_handler = _bfd_default_assert_handler; 862 863 /* 864 FUNCTION 865 bfd_set_assert_handler 866 867 SYNOPSIS 868 bfd_assert_handler_type bfd_set_assert_handler (bfd_assert_handler_type); 869 870 DESCRIPTION 871 Set the BFD assert handler function. Returns the previous 872 function. 873 */ 874 875 bfd_assert_handler_type 876 bfd_set_assert_handler (bfd_assert_handler_type pnew) 877 { 878 bfd_assert_handler_type pold; 879 880 pold = _bfd_assert_handler; 881 _bfd_assert_handler = pnew; 882 return pold; 883 } 884 885 /* 886 FUNCTION 887 bfd_get_assert_handler 888 889 SYNOPSIS 890 bfd_assert_handler_type bfd_get_assert_handler (void); 891 892 DESCRIPTION 893 Return the BFD assert handler function. 894 */ 895 896 bfd_assert_handler_type 897 bfd_get_assert_handler (void) 898 { 899 return _bfd_assert_handler; 900 } 901 902 /* 904 INODE 905 Miscellaneous, Memory Usage, Error reporting, BFD front end 906 907 SECTION 908 Miscellaneous 909 910 SUBSECTION 911 Miscellaneous functions 912 */ 913 914 /* 915 FUNCTION 916 bfd_get_reloc_upper_bound 917 918 SYNOPSIS 919 long bfd_get_reloc_upper_bound (bfd *abfd, asection *sect); 920 921 DESCRIPTION 922 Return the number of bytes required to store the 923 relocation information associated with section @var{sect} 924 attached to bfd @var{abfd}. If an error occurs, return -1. 925 926 */ 927 928 long 929 bfd_get_reloc_upper_bound (bfd *abfd, sec_ptr asect) 930 { 931 if (abfd->format != bfd_object) 932 { 933 bfd_set_error (bfd_error_invalid_operation); 934 return -1; 935 } 936 937 return BFD_SEND (abfd, _get_reloc_upper_bound, (abfd, asect)); 938 } 939 940 /* 941 FUNCTION 942 bfd_canonicalize_reloc 943 944 SYNOPSIS 945 long bfd_canonicalize_reloc 946 (bfd *abfd, asection *sec, arelent **loc, asymbol **syms); 947 948 DESCRIPTION 949 Call the back end associated with the open BFD 950 @var{abfd} and translate the external form of the relocation 951 information attached to @var{sec} into the internal canonical 952 form. Place the table into memory at @var{loc}, which has 953 been preallocated, usually by a call to 954 <<bfd_get_reloc_upper_bound>>. Returns the number of relocs, or 955 -1 on error. 956 957 The @var{syms} table is also needed for horrible internal magic 958 reasons. 959 960 */ 961 long 962 bfd_canonicalize_reloc (bfd *abfd, 963 sec_ptr asect, 964 arelent **location, 965 asymbol **symbols) 966 { 967 if (abfd->format != bfd_object) 968 { 969 bfd_set_error (bfd_error_invalid_operation); 970 return -1; 971 } 972 973 return BFD_SEND (abfd, _bfd_canonicalize_reloc, 974 (abfd, asect, location, symbols)); 975 } 976 977 /* 978 FUNCTION 979 bfd_set_reloc 980 981 SYNOPSIS 982 void bfd_set_reloc 983 (bfd *abfd, asection *sec, arelent **rel, unsigned int count); 984 985 DESCRIPTION 986 Set the relocation pointer and count within 987 section @var{sec} to the values @var{rel} and @var{count}. 988 The argument @var{abfd} is ignored. 989 990 */ 991 992 void 993 bfd_set_reloc (bfd *ignore_abfd ATTRIBUTE_UNUSED, 994 sec_ptr asect, 995 arelent **location, 996 unsigned int count) 997 { 998 asect->orelocation = location; 999 asect->reloc_count = count; 1000 } 1001 1002 /* 1003 FUNCTION 1004 bfd_set_file_flags 1005 1006 SYNOPSIS 1007 bfd_boolean bfd_set_file_flags (bfd *abfd, flagword flags); 1008 1009 DESCRIPTION 1010 Set the flag word in the BFD @var{abfd} to the value @var{flags}. 1011 1012 Possible errors are: 1013 o <<bfd_error_wrong_format>> - The target bfd was not of object format. 1014 o <<bfd_error_invalid_operation>> - The target bfd was open for reading. 1015 o <<bfd_error_invalid_operation>> - 1016 The flag word contained a bit which was not applicable to the 1017 type of file. E.g., an attempt was made to set the <<D_PAGED>> bit 1018 on a BFD format which does not support demand paging. 1019 1020 */ 1021 1022 bfd_boolean 1023 bfd_set_file_flags (bfd *abfd, flagword flags) 1024 { 1025 if (abfd->format != bfd_object) 1026 { 1027 bfd_set_error (bfd_error_wrong_format); 1028 return FALSE; 1029 } 1030 1031 if (bfd_read_p (abfd)) 1032 { 1033 bfd_set_error (bfd_error_invalid_operation); 1034 return FALSE; 1035 } 1036 1037 bfd_get_file_flags (abfd) = flags; 1038 if ((flags & bfd_applicable_file_flags (abfd)) != flags) 1039 { 1040 bfd_set_error (bfd_error_invalid_operation); 1041 return FALSE; 1042 } 1043 1044 return TRUE; 1045 } 1046 1047 void 1048 bfd_assert (const char *file, int line) 1049 { 1050 (*_bfd_assert_handler) (_("BFD %s assertion fail %s:%d"), 1051 BFD_VERSION_STRING, file, line); 1052 } 1053 1054 /* A more or less friendly abort message. In libbfd.h abort is 1055 defined to call this function. */ 1056 1057 void 1058 _bfd_abort (const char *file, int line, const char *fn) 1059 { 1060 if (fn != NULL) 1061 (*_bfd_error_handler) 1062 (_("BFD %s internal error, aborting at %s line %d in %s\n"), 1063 BFD_VERSION_STRING, file, line, fn); 1064 else 1065 (*_bfd_error_handler) 1066 (_("BFD %s internal error, aborting at %s line %d\n"), 1067 BFD_VERSION_STRING, file, line); 1068 (*_bfd_error_handler) (_("Please report this bug.\n")); 1069 _exit (EXIT_FAILURE); 1070 } 1071 1072 /* 1073 FUNCTION 1074 bfd_get_arch_size 1075 1076 SYNOPSIS 1077 int bfd_get_arch_size (bfd *abfd); 1078 1079 DESCRIPTION 1080 Returns the normalized architecture address size, in bits, as 1081 determined by the object file's format. By normalized, we mean 1082 either 32 or 64. For ELF, this information is included in the 1083 header. Use bfd_arch_bits_per_address for number of bits in 1084 the architecture address. 1085 1086 RETURNS 1087 Returns the arch size in bits if known, <<-1>> otherwise. 1088 */ 1089 1090 int 1091 bfd_get_arch_size (bfd *abfd) 1092 { 1093 if (abfd->xvec->flavour == bfd_target_elf_flavour) 1094 return get_elf_backend_data (abfd)->s->arch_size; 1095 1096 return bfd_arch_bits_per_address (abfd) > 32 ? 64 : 32; 1097 } 1098 1099 /* 1100 FUNCTION 1101 bfd_get_sign_extend_vma 1102 1103 SYNOPSIS 1104 int bfd_get_sign_extend_vma (bfd *abfd); 1105 1106 DESCRIPTION 1107 Indicates if the target architecture "naturally" sign extends 1108 an address. Some architectures implicitly sign extend address 1109 values when they are converted to types larger than the size 1110 of an address. For instance, bfd_get_start_address() will 1111 return an address sign extended to fill a bfd_vma when this is 1112 the case. 1113 1114 RETURNS 1115 Returns <<1>> if the target architecture is known to sign 1116 extend addresses, <<0>> if the target architecture is known to 1117 not sign extend addresses, and <<-1>> otherwise. 1118 */ 1119 1120 int 1121 bfd_get_sign_extend_vma (bfd *abfd) 1122 { 1123 char *name; 1124 1125 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour) 1126 return get_elf_backend_data (abfd)->sign_extend_vma; 1127 1128 name = bfd_get_target (abfd); 1129 1130 /* Return a proper value for DJGPP & PE COFF. 1131 This function is required for DWARF2 support, but there is 1132 no place to store this information in the COFF back end. 1133 Should enough other COFF targets add support for DWARF2, 1134 a place will have to be found. Until then, this hack will do. */ 1135 if (CONST_STRNEQ (name, "coff-go32") 1136 || strcmp (name, "pe-i386") == 0 1137 || strcmp (name, "pei-i386") == 0 1138 || strcmp (name, "pe-x86-64") == 0 1139 || strcmp (name, "pei-x86-64") == 0 1140 || strcmp (name, "pe-arm-wince-little") == 0 1141 || strcmp (name, "pei-arm-wince-little") == 0 1142 || strcmp (name, "aixcoff-rs6000") == 0) 1143 return 1; 1144 1145 if (CONST_STRNEQ (name, "mach-o")) 1146 return 0; 1147 1148 bfd_set_error (bfd_error_wrong_format); 1149 return -1; 1150 } 1151 1152 /* 1153 FUNCTION 1154 bfd_set_start_address 1155 1156 SYNOPSIS 1157 bfd_boolean bfd_set_start_address (bfd *abfd, bfd_vma vma); 1158 1159 DESCRIPTION 1160 Make @var{vma} the entry point of output BFD @var{abfd}. 1161 1162 RETURNS 1163 Returns <<TRUE>> on success, <<FALSE>> otherwise. 1164 */ 1165 1166 bfd_boolean 1167 bfd_set_start_address (bfd *abfd, bfd_vma vma) 1168 { 1169 abfd->start_address = vma; 1170 return TRUE; 1171 } 1172 1173 /* 1174 FUNCTION 1175 bfd_get_gp_size 1176 1177 SYNOPSIS 1178 unsigned int bfd_get_gp_size (bfd *abfd); 1179 1180 DESCRIPTION 1181 Return the maximum size of objects to be optimized using the GP 1182 register under MIPS ECOFF. This is typically set by the <<-G>> 1183 argument to the compiler, assembler or linker. 1184 */ 1185 1186 unsigned int 1187 bfd_get_gp_size (bfd *abfd) 1188 { 1189 if (abfd->format == bfd_object) 1190 { 1191 if (abfd->xvec->flavour == bfd_target_ecoff_flavour) 1192 return ecoff_data (abfd)->gp_size; 1193 else if (abfd->xvec->flavour == bfd_target_elf_flavour) 1194 return elf_gp_size (abfd); 1195 } 1196 return 0; 1197 } 1198 1199 /* 1200 FUNCTION 1201 bfd_set_gp_size 1202 1203 SYNOPSIS 1204 void bfd_set_gp_size (bfd *abfd, unsigned int i); 1205 1206 DESCRIPTION 1207 Set the maximum size of objects to be optimized using the GP 1208 register under ECOFF or MIPS ELF. This is typically set by 1209 the <<-G>> argument to the compiler, assembler or linker. 1210 */ 1211 1212 void 1213 bfd_set_gp_size (bfd *abfd, unsigned int i) 1214 { 1215 /* Don't try to set GP size on an archive or core file! */ 1216 if (abfd->format != bfd_object) 1217 return; 1218 1219 if (abfd->xvec->flavour == bfd_target_ecoff_flavour) 1220 ecoff_data (abfd)->gp_size = i; 1221 else if (abfd->xvec->flavour == bfd_target_elf_flavour) 1222 elf_gp_size (abfd) = i; 1223 } 1224 1225 /* Get the GP value. This is an internal function used by some of the 1226 relocation special_function routines on targets which support a GP 1227 register. */ 1228 1229 bfd_vma 1230 _bfd_get_gp_value (bfd *abfd) 1231 { 1232 if (! abfd) 1233 return 0; 1234 if (abfd->format != bfd_object) 1235 return 0; 1236 1237 if (abfd->xvec->flavour == bfd_target_ecoff_flavour) 1238 return ecoff_data (abfd)->gp; 1239 else if (abfd->xvec->flavour == bfd_target_elf_flavour) 1240 return elf_gp (abfd); 1241 1242 return 0; 1243 } 1244 1245 /* Set the GP value. */ 1246 1247 void 1248 _bfd_set_gp_value (bfd *abfd, bfd_vma v) 1249 { 1250 if (! abfd) 1251 abort (); 1252 if (abfd->format != bfd_object) 1253 return; 1254 1255 if (abfd->xvec->flavour == bfd_target_ecoff_flavour) 1256 ecoff_data (abfd)->gp = v; 1257 else if (abfd->xvec->flavour == bfd_target_elf_flavour) 1258 elf_gp (abfd) = v; 1259 } 1260 1261 /* 1262 FUNCTION 1263 bfd_scan_vma 1264 1265 SYNOPSIS 1266 bfd_vma bfd_scan_vma (const char *string, const char **end, int base); 1267 1268 DESCRIPTION 1269 Convert, like <<strtoul>>, a numerical expression 1270 @var{string} into a <<bfd_vma>> integer, and return that integer. 1271 (Though without as many bells and whistles as <<strtoul>>.) 1272 The expression is assumed to be unsigned (i.e., positive). 1273 If given a @var{base}, it is used as the base for conversion. 1274 A base of 0 causes the function to interpret the string 1275 in hex if a leading "0x" or "0X" is found, otherwise 1276 in octal if a leading zero is found, otherwise in decimal. 1277 1278 If the value would overflow, the maximum <<bfd_vma>> value is 1279 returned. 1280 */ 1281 1282 bfd_vma 1283 bfd_scan_vma (const char *string, const char **end, int base) 1284 { 1285 bfd_vma value; 1286 bfd_vma cutoff; 1287 unsigned int cutlim; 1288 int overflow; 1289 1290 /* Let the host do it if possible. */ 1291 if (sizeof (bfd_vma) <= sizeof (unsigned long)) 1292 return strtoul (string, (char **) end, base); 1293 1294 #ifdef HAVE_STRTOULL 1295 if (sizeof (bfd_vma) <= sizeof (unsigned long long)) 1296 return strtoull (string, (char **) end, base); 1297 #endif 1298 1299 if (base == 0) 1300 { 1301 if (string[0] == '0') 1302 { 1303 if ((string[1] == 'x') || (string[1] == 'X')) 1304 base = 16; 1305 else 1306 base = 8; 1307 } 1308 } 1309 1310 if ((base < 2) || (base > 36)) 1311 base = 10; 1312 1313 if (base == 16 1314 && string[0] == '0' 1315 && (string[1] == 'x' || string[1] == 'X') 1316 && ISXDIGIT (string[2])) 1317 { 1318 string += 2; 1319 } 1320 1321 cutoff = (~ (bfd_vma) 0) / (bfd_vma) base; 1322 cutlim = (~ (bfd_vma) 0) % (bfd_vma) base; 1323 value = 0; 1324 overflow = 0; 1325 while (1) 1326 { 1327 unsigned int digit; 1328 1329 digit = *string; 1330 if (ISDIGIT (digit)) 1331 digit = digit - '0'; 1332 else if (ISALPHA (digit)) 1333 digit = TOUPPER (digit) - 'A' + 10; 1334 else 1335 break; 1336 if (digit >= (unsigned int) base) 1337 break; 1338 if (value > cutoff || (value == cutoff && digit > cutlim)) 1339 overflow = 1; 1340 value = value * base + digit; 1341 ++string; 1342 } 1343 1344 if (overflow) 1345 value = ~ (bfd_vma) 0; 1346 1347 if (end != NULL) 1348 *end = string; 1349 1350 return value; 1351 } 1352 1353 /* 1354 FUNCTION 1355 bfd_copy_private_header_data 1356 1357 SYNOPSIS 1358 bfd_boolean bfd_copy_private_header_data (bfd *ibfd, bfd *obfd); 1359 1360 DESCRIPTION 1361 Copy private BFD header information from the BFD @var{ibfd} to the 1362 the BFD @var{obfd}. This copies information that may require 1363 sections to exist, but does not require symbol tables. Return 1364 <<true>> on success, <<false>> on error. 1365 Possible error returns are: 1366 1367 o <<bfd_error_no_memory>> - 1368 Not enough memory exists to create private data for @var{obfd}. 1369 1370 .#define bfd_copy_private_header_data(ibfd, obfd) \ 1371 . BFD_SEND (obfd, _bfd_copy_private_header_data, \ 1372 . (ibfd, obfd)) 1373 1374 */ 1375 1376 /* 1377 FUNCTION 1378 bfd_copy_private_bfd_data 1379 1380 SYNOPSIS 1381 bfd_boolean bfd_copy_private_bfd_data (bfd *ibfd, bfd *obfd); 1382 1383 DESCRIPTION 1384 Copy private BFD information from the BFD @var{ibfd} to the 1385 the BFD @var{obfd}. Return <<TRUE>> on success, <<FALSE>> on error. 1386 Possible error returns are: 1387 1388 o <<bfd_error_no_memory>> - 1389 Not enough memory exists to create private data for @var{obfd}. 1390 1391 .#define bfd_copy_private_bfd_data(ibfd, obfd) \ 1392 . BFD_SEND (obfd, _bfd_copy_private_bfd_data, \ 1393 . (ibfd, obfd)) 1394 1395 */ 1396 1397 /* 1398 FUNCTION 1399 bfd_merge_private_bfd_data 1400 1401 SYNOPSIS 1402 bfd_boolean bfd_merge_private_bfd_data (bfd *ibfd, bfd *obfd); 1403 1404 DESCRIPTION 1405 Merge private BFD information from the BFD @var{ibfd} to the 1406 the output file BFD @var{obfd} when linking. Return <<TRUE>> 1407 on success, <<FALSE>> on error. Possible error returns are: 1408 1409 o <<bfd_error_no_memory>> - 1410 Not enough memory exists to create private data for @var{obfd}. 1411 1412 .#define bfd_merge_private_bfd_data(ibfd, obfd) \ 1413 . BFD_SEND (obfd, _bfd_merge_private_bfd_data, \ 1414 . (ibfd, obfd)) 1415 1416 */ 1417 1418 /* 1419 FUNCTION 1420 bfd_set_private_flags 1421 1422 SYNOPSIS 1423 bfd_boolean bfd_set_private_flags (bfd *abfd, flagword flags); 1424 1425 DESCRIPTION 1426 Set private BFD flag information in the BFD @var{abfd}. 1427 Return <<TRUE>> on success, <<FALSE>> on error. Possible error 1428 returns are: 1429 1430 o <<bfd_error_no_memory>> - 1431 Not enough memory exists to create private data for @var{obfd}. 1432 1433 .#define bfd_set_private_flags(abfd, flags) \ 1434 . BFD_SEND (abfd, _bfd_set_private_flags, (abfd, flags)) 1435 1436 */ 1437 1438 /* 1439 FUNCTION 1440 Other functions 1441 1442 DESCRIPTION 1443 The following functions exist but have not yet been documented. 1444 1445 .#define bfd_sizeof_headers(abfd, info) \ 1446 . BFD_SEND (abfd, _bfd_sizeof_headers, (abfd, info)) 1447 . 1448 .#define bfd_find_nearest_line(abfd, sec, syms, off, file, func, line) \ 1449 . BFD_SEND (abfd, _bfd_find_nearest_line, \ 1450 . (abfd, syms, sec, off, file, func, line, NULL)) 1451 . 1452 .#define bfd_find_nearest_line_discriminator(abfd, sec, syms, off, file, func, \ 1453 . line, disc) \ 1454 . BFD_SEND (abfd, _bfd_find_nearest_line, \ 1455 . (abfd, syms, sec, off, file, func, line, disc)) 1456 . 1457 .#define bfd_find_line(abfd, syms, sym, file, line) \ 1458 . BFD_SEND (abfd, _bfd_find_line, \ 1459 . (abfd, syms, sym, file, line)) 1460 . 1461 .#define bfd_find_inliner_info(abfd, file, func, line) \ 1462 . BFD_SEND (abfd, _bfd_find_inliner_info, \ 1463 . (abfd, file, func, line)) 1464 . 1465 .#define bfd_debug_info_start(abfd) \ 1466 . BFD_SEND (abfd, _bfd_debug_info_start, (abfd)) 1467 . 1468 .#define bfd_debug_info_end(abfd) \ 1469 . BFD_SEND (abfd, _bfd_debug_info_end, (abfd)) 1470 . 1471 .#define bfd_debug_info_accumulate(abfd, section) \ 1472 . BFD_SEND (abfd, _bfd_debug_info_accumulate, (abfd, section)) 1473 . 1474 .#define bfd_stat_arch_elt(abfd, stat) \ 1475 . BFD_SEND (abfd, _bfd_stat_arch_elt,(abfd, stat)) 1476 . 1477 .#define bfd_update_armap_timestamp(abfd) \ 1478 . BFD_SEND (abfd, _bfd_update_armap_timestamp, (abfd)) 1479 . 1480 .#define bfd_set_arch_mach(abfd, arch, mach)\ 1481 . BFD_SEND ( abfd, _bfd_set_arch_mach, (abfd, arch, mach)) 1482 . 1483 .#define bfd_relax_section(abfd, section, link_info, again) \ 1484 . BFD_SEND (abfd, _bfd_relax_section, (abfd, section, link_info, again)) 1485 . 1486 .#define bfd_gc_sections(abfd, link_info) \ 1487 . BFD_SEND (abfd, _bfd_gc_sections, (abfd, link_info)) 1488 . 1489 .#define bfd_lookup_section_flags(link_info, flag_info, section) \ 1490 . BFD_SEND (abfd, _bfd_lookup_section_flags, (link_info, flag_info, section)) 1491 . 1492 .#define bfd_merge_sections(abfd, link_info) \ 1493 . BFD_SEND (abfd, _bfd_merge_sections, (abfd, link_info)) 1494 . 1495 .#define bfd_is_group_section(abfd, sec) \ 1496 . BFD_SEND (abfd, _bfd_is_group_section, (abfd, sec)) 1497 . 1498 .#define bfd_discard_group(abfd, sec) \ 1499 . BFD_SEND (abfd, _bfd_discard_group, (abfd, sec)) 1500 . 1501 .#define bfd_link_hash_table_create(abfd) \ 1502 . BFD_SEND (abfd, _bfd_link_hash_table_create, (abfd)) 1503 . 1504 .#define bfd_link_add_symbols(abfd, info) \ 1505 . BFD_SEND (abfd, _bfd_link_add_symbols, (abfd, info)) 1506 . 1507 .#define bfd_link_just_syms(abfd, sec, info) \ 1508 . BFD_SEND (abfd, _bfd_link_just_syms, (sec, info)) 1509 . 1510 .#define bfd_final_link(abfd, info) \ 1511 . BFD_SEND (abfd, _bfd_final_link, (abfd, info)) 1512 . 1513 .#define bfd_free_cached_info(abfd) \ 1514 . BFD_SEND (abfd, _bfd_free_cached_info, (abfd)) 1515 . 1516 .#define bfd_get_dynamic_symtab_upper_bound(abfd) \ 1517 . BFD_SEND (abfd, _bfd_get_dynamic_symtab_upper_bound, (abfd)) 1518 . 1519 .#define bfd_print_private_bfd_data(abfd, file)\ 1520 . BFD_SEND (abfd, _bfd_print_private_bfd_data, (abfd, file)) 1521 . 1522 .#define bfd_canonicalize_dynamic_symtab(abfd, asymbols) \ 1523 . BFD_SEND (abfd, _bfd_canonicalize_dynamic_symtab, (abfd, asymbols)) 1524 . 1525 .#define bfd_get_synthetic_symtab(abfd, count, syms, dyncount, dynsyms, ret) \ 1526 . BFD_SEND (abfd, _bfd_get_synthetic_symtab, (abfd, count, syms, \ 1527 . dyncount, dynsyms, ret)) 1528 . 1529 .#define bfd_get_dynamic_reloc_upper_bound(abfd) \ 1530 . BFD_SEND (abfd, _bfd_get_dynamic_reloc_upper_bound, (abfd)) 1531 . 1532 .#define bfd_canonicalize_dynamic_reloc(abfd, arels, asyms) \ 1533 . BFD_SEND (abfd, _bfd_canonicalize_dynamic_reloc, (abfd, arels, asyms)) 1534 . 1535 .extern bfd_byte *bfd_get_relocated_section_contents 1536 . (bfd *, struct bfd_link_info *, struct bfd_link_order *, bfd_byte *, 1537 . bfd_boolean, asymbol **); 1538 . 1539 1540 */ 1541 1542 bfd_byte * 1543 bfd_get_relocated_section_contents (bfd *abfd, 1544 struct bfd_link_info *link_info, 1545 struct bfd_link_order *link_order, 1546 bfd_byte *data, 1547 bfd_boolean relocatable, 1548 asymbol **symbols) 1549 { 1550 bfd *abfd2; 1551 bfd_byte *(*fn) (bfd *, struct bfd_link_info *, struct bfd_link_order *, 1552 bfd_byte *, bfd_boolean, asymbol **); 1553 1554 if (link_order->type == bfd_indirect_link_order) 1555 { 1556 abfd2 = link_order->u.indirect.section->owner; 1557 if (abfd2 == NULL) 1558 abfd2 = abfd; 1559 } 1560 else 1561 abfd2 = abfd; 1562 1563 fn = abfd2->xvec->_bfd_get_relocated_section_contents; 1564 1565 return (*fn) (abfd, link_info, link_order, data, relocatable, symbols); 1566 } 1567 1568 /* Record information about an ELF program header. */ 1569 1570 bfd_boolean 1571 bfd_record_phdr (bfd *abfd, 1572 unsigned long type, 1573 bfd_boolean flags_valid, 1574 flagword flags, 1575 bfd_boolean at_valid, 1576 bfd_vma at, 1577 bfd_boolean includes_filehdr, 1578 bfd_boolean includes_phdrs, 1579 unsigned int count, 1580 asection **secs) 1581 { 1582 struct elf_segment_map *m, **pm; 1583 bfd_size_type amt; 1584 1585 if (bfd_get_flavour (abfd) != bfd_target_elf_flavour) 1586 return TRUE; 1587 1588 amt = sizeof (struct elf_segment_map); 1589 amt += ((bfd_size_type) count - 1) * sizeof (asection *); 1590 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt); 1591 if (m == NULL) 1592 return FALSE; 1593 1594 m->p_type = type; 1595 m->p_flags = flags; 1596 m->p_paddr = at; 1597 m->p_flags_valid = flags_valid; 1598 m->p_paddr_valid = at_valid; 1599 m->includes_filehdr = includes_filehdr; 1600 m->includes_phdrs = includes_phdrs; 1601 m->count = count; 1602 if (count > 0) 1603 memcpy (m->sections, secs, count * sizeof (asection *)); 1604 1605 for (pm = &elf_seg_map (abfd); *pm != NULL; pm = &(*pm)->next) 1606 ; 1607 *pm = m; 1608 1609 return TRUE; 1610 } 1611 1612 #ifdef BFD64 1613 /* Return true iff this target is 32-bit. */ 1614 1615 static bfd_boolean 1616 is32bit (bfd *abfd) 1617 { 1618 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour) 1619 { 1620 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 1621 return bed->s->elfclass == ELFCLASS32; 1622 } 1623 1624 /* For non-ELF targets, use architecture information. */ 1625 return bfd_arch_bits_per_address (abfd) <= 32; 1626 } 1627 #endif 1628 1629 /* bfd_sprintf_vma and bfd_fprintf_vma display an address in the 1630 target's address size. */ 1631 1632 void 1633 bfd_sprintf_vma (bfd *abfd ATTRIBUTE_UNUSED, char *buf, bfd_vma value) 1634 { 1635 #ifdef BFD64 1636 if (is32bit (abfd)) 1637 { 1638 sprintf (buf, "%08lx", (unsigned long) value & 0xffffffff); 1639 return; 1640 } 1641 #endif 1642 sprintf_vma (buf, value); 1643 } 1644 1645 void 1646 bfd_fprintf_vma (bfd *abfd ATTRIBUTE_UNUSED, void *stream, bfd_vma value) 1647 { 1648 #ifdef BFD64 1649 if (is32bit (abfd)) 1650 { 1651 fprintf ((FILE *) stream, "%08lx", (unsigned long) value & 0xffffffff); 1652 return; 1653 } 1654 #endif 1655 fprintf_vma ((FILE *) stream, value); 1656 } 1657 1658 /* 1659 FUNCTION 1660 bfd_alt_mach_code 1661 1662 SYNOPSIS 1663 bfd_boolean bfd_alt_mach_code (bfd *abfd, int alternative); 1664 1665 DESCRIPTION 1666 1667 When more than one machine code number is available for the 1668 same machine type, this function can be used to switch between 1669 the preferred one (alternative == 0) and any others. Currently, 1670 only ELF supports this feature, with up to two alternate 1671 machine codes. 1672 */ 1673 1674 bfd_boolean 1675 bfd_alt_mach_code (bfd *abfd, int alternative) 1676 { 1677 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour) 1678 { 1679 int code; 1680 1681 switch (alternative) 1682 { 1683 case 0: 1684 code = get_elf_backend_data (abfd)->elf_machine_code; 1685 break; 1686 1687 case 1: 1688 code = get_elf_backend_data (abfd)->elf_machine_alt1; 1689 if (code == 0) 1690 return FALSE; 1691 break; 1692 1693 case 2: 1694 code = get_elf_backend_data (abfd)->elf_machine_alt2; 1695 if (code == 0) 1696 return FALSE; 1697 break; 1698 1699 default: 1700 return FALSE; 1701 } 1702 1703 elf_elfheader (abfd)->e_machine = code; 1704 1705 return TRUE; 1706 } 1707 1708 return FALSE; 1709 } 1710 1711 /* 1712 FUNCTION 1713 bfd_emul_get_maxpagesize 1714 1715 SYNOPSIS 1716 bfd_vma bfd_emul_get_maxpagesize (const char *); 1717 1718 DESCRIPTION 1719 Returns the maximum page size, in bytes, as determined by 1720 emulation. 1721 1722 RETURNS 1723 Returns the maximum page size in bytes for ELF, 0 otherwise. 1724 */ 1725 1726 bfd_vma 1727 bfd_emul_get_maxpagesize (const char *emul) 1728 { 1729 const bfd_target *target; 1730 1731 target = bfd_find_target (emul, NULL); 1732 if (target != NULL 1733 && target->flavour == bfd_target_elf_flavour) 1734 return xvec_get_elf_backend_data (target)->maxpagesize; 1735 1736 return 0; 1737 } 1738 1739 static void 1740 bfd_elf_set_pagesize (const bfd_target *target, bfd_vma size, 1741 int offset, const bfd_target *orig_target) 1742 { 1743 if (target->flavour == bfd_target_elf_flavour) 1744 { 1745 const struct elf_backend_data *bed; 1746 1747 bed = xvec_get_elf_backend_data (target); 1748 *((bfd_vma *) ((char *) bed + offset)) = size; 1749 } 1750 1751 if (target->alternative_target 1752 && target->alternative_target != orig_target) 1753 bfd_elf_set_pagesize (target->alternative_target, size, offset, 1754 orig_target); 1755 } 1756 1757 /* 1758 FUNCTION 1759 bfd_emul_set_maxpagesize 1760 1761 SYNOPSIS 1762 void bfd_emul_set_maxpagesize (const char *, bfd_vma); 1763 1764 DESCRIPTION 1765 For ELF, set the maximum page size for the emulation. It is 1766 a no-op for other formats. 1767 1768 */ 1769 1770 void 1771 bfd_emul_set_maxpagesize (const char *emul, bfd_vma size) 1772 { 1773 const bfd_target *target; 1774 1775 target = bfd_find_target (emul, NULL); 1776 if (target) 1777 bfd_elf_set_pagesize (target, size, 1778 offsetof (struct elf_backend_data, 1779 maxpagesize), target); 1780 } 1781 1782 /* 1783 FUNCTION 1784 bfd_emul_get_commonpagesize 1785 1786 SYNOPSIS 1787 bfd_vma bfd_emul_get_commonpagesize (const char *); 1788 1789 DESCRIPTION 1790 Returns the common page size, in bytes, as determined by 1791 emulation. 1792 1793 RETURNS 1794 Returns the common page size in bytes for ELF, 0 otherwise. 1795 */ 1796 1797 bfd_vma 1798 bfd_emul_get_commonpagesize (const char *emul) 1799 { 1800 const bfd_target *target; 1801 1802 target = bfd_find_target (emul, NULL); 1803 if (target != NULL 1804 && target->flavour == bfd_target_elf_flavour) 1805 return xvec_get_elf_backend_data (target)->commonpagesize; 1806 1807 return 0; 1808 } 1809 1810 /* 1811 FUNCTION 1812 bfd_emul_set_commonpagesize 1813 1814 SYNOPSIS 1815 void bfd_emul_set_commonpagesize (const char *, bfd_vma); 1816 1817 DESCRIPTION 1818 For ELF, set the common page size for the emulation. It is 1819 a no-op for other formats. 1820 1821 */ 1822 1823 void 1824 bfd_emul_set_commonpagesize (const char *emul, bfd_vma size) 1825 { 1826 const bfd_target *target; 1827 1828 target = bfd_find_target (emul, NULL); 1829 if (target) 1830 bfd_elf_set_pagesize (target, size, 1831 offsetof (struct elf_backend_data, 1832 commonpagesize), target); 1833 } 1834 1835 /* 1836 FUNCTION 1837 bfd_demangle 1838 1839 SYNOPSIS 1840 char *bfd_demangle (bfd *, const char *, int); 1841 1842 DESCRIPTION 1843 Wrapper around cplus_demangle. Strips leading underscores and 1844 other such chars that would otherwise confuse the demangler. 1845 If passed a g++ v3 ABI mangled name, returns a buffer allocated 1846 with malloc holding the demangled name. Returns NULL otherwise 1847 and on memory alloc failure. 1848 */ 1849 1850 char * 1851 bfd_demangle (bfd *abfd, const char *name, int options) 1852 { 1853 char *res, *alloc; 1854 const char *pre, *suf; 1855 size_t pre_len; 1856 bfd_boolean skip_lead; 1857 1858 skip_lead = (abfd != NULL 1859 && *name != '\0' 1860 && bfd_get_symbol_leading_char (abfd) == *name); 1861 if (skip_lead) 1862 ++name; 1863 1864 /* This is a hack for better error reporting on XCOFF, PowerPC64-ELF 1865 or the MS PE format. These formats have a number of leading '.'s 1866 on at least some symbols, so we remove all dots to avoid 1867 confusing the demangler. */ 1868 pre = name; 1869 while (*name == '.' || *name == '$') 1870 ++name; 1871 pre_len = name - pre; 1872 1873 /* Strip off @plt and suchlike too. */ 1874 alloc = NULL; 1875 suf = strchr (name, '@'); 1876 if (suf != NULL) 1877 { 1878 alloc = (char *) bfd_malloc (suf - name + 1); 1879 if (alloc == NULL) 1880 return NULL; 1881 memcpy (alloc, name, suf - name); 1882 alloc[suf - name] = '\0'; 1883 name = alloc; 1884 } 1885 1886 res = cplus_demangle (name, options); 1887 1888 if (alloc != NULL) 1889 free (alloc); 1890 1891 if (res == NULL) 1892 { 1893 if (skip_lead) 1894 { 1895 size_t len = strlen (pre) + 1; 1896 alloc = (char *) bfd_malloc (len); 1897 if (alloc == NULL) 1898 return NULL; 1899 memcpy (alloc, pre, len); 1900 return alloc; 1901 } 1902 return NULL; 1903 } 1904 1905 /* Put back any prefix or suffix. */ 1906 if (pre_len != 0 || suf != NULL) 1907 { 1908 size_t len; 1909 size_t suf_len; 1910 char *final; 1911 1912 len = strlen (res); 1913 if (suf == NULL) 1914 suf = res + len; 1915 suf_len = strlen (suf) + 1; 1916 final = (char *) bfd_malloc (pre_len + len + suf_len); 1917 if (final != NULL) 1918 { 1919 memcpy (final, pre, pre_len); 1920 memcpy (final + pre_len, res, len); 1921 memcpy (final + pre_len + len, suf, suf_len); 1922 } 1923 free (res); 1924 res = final; 1925 } 1926 1927 return res; 1928 } 1929
