1/* Generic BFD library interface and support routines. 2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 3 2000, 2001, 2002, 2003, 2004, 2005, 2006 4 Free Software Foundation, Inc. 5 Written by Cygnus Support. 6 7 This file is part of BFD, the Binary File Descriptor library. 8 9 This program is free software; you can redistribute it and/or modify 10 it under the terms of the GNU General Public License as published by 11 the Free Software Foundation; either version 2 of the License, or 12 (at your option) any later version. 13 14 This program is distributed in the hope that it will be useful, 15 but WITHOUT ANY WARRANTY; without even the implied warranty of 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 GNU General Public License for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with this program; if not, write to the Free Software 21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */ 22 23/* 24SECTION 25 <<typedef bfd>> 26 27 A BFD has type <<bfd>>; objects of this type are the 28 cornerstone of any application using BFD. Using BFD 29 consists of making references though the BFD and to data in the BFD. 30 31 Here is the structure that defines the type <<bfd>>. It 32 contains the major data about the file and pointers 33 to the rest of the data. 34 35CODE_FRAGMENT 36. 37.struct bfd 38.{ 39. {* A unique identifier of the BFD *} 40. unsigned int id; 41. 42. {* The filename the application opened the BFD with. *} 43. const char *filename; 44. 45. {* A pointer to the target jump table. *} 46. const struct bfd_target *xvec; 47. 48. {* The IOSTREAM, and corresponding IO vector that provide access 49. to the file backing the BFD. *} 50. void *iostream; 51. const struct bfd_iovec *iovec; 52. 53. {* Is the file descriptor being cached? That is, can it be closed as 54. needed, and re-opened when accessed later? *} 55. bfd_boolean cacheable; 56. 57. {* Marks whether there was a default target specified when the 58. BFD was opened. This is used to select which matching algorithm 59. to use to choose the back end. *} 60. bfd_boolean target_defaulted; 61. 62. {* The caching routines use these to maintain a 63. least-recently-used list of BFDs. *} 64. struct bfd *lru_prev, *lru_next; 65. 66. {* When a file is closed by the caching routines, BFD retains 67. state information on the file here... *} 68. ufile_ptr where; 69. 70. {* ... and here: (``once'' means at least once). *} 71. bfd_boolean opened_once; 72. 73. {* Set if we have a locally maintained mtime value, rather than 74. getting it from the file each time. *} 75. bfd_boolean mtime_set; 76. 77. {* File modified time, if mtime_set is TRUE. *} 78. long mtime; 79. 80. {* Reserved for an unimplemented file locking extension. *} 81. int ifd; 82. 83. {* The format which belongs to the BFD. (object, core, etc.) *} 84. bfd_format format; 85. 86. {* The direction with which the BFD was opened. *} 87. enum bfd_direction 88. { 89. no_direction = 0, 90. read_direction = 1, 91. write_direction = 2, 92. both_direction = 3 93. } 94. direction; 95. 96. {* Format_specific flags. *} 97. flagword flags; 98. 99. {* Currently my_archive is tested before adding origin to 100. anything. I believe that this can become always an add of 101. origin, with origin set to 0 for non archive files. *} 102. ufile_ptr origin; 103. 104. {* Remember when output has begun, to stop strange things 105. from happening. *} 106. bfd_boolean output_has_begun; 107. 108. {* A hash table for section names. *} 109. struct bfd_hash_table section_htab; 110. 111. {* Pointer to linked list of sections. *} 112. struct bfd_section *sections; 113. 114. {* The last section on the section list. *} 115. struct bfd_section *section_last; 116. 117. {* The number of sections. *} 118. unsigned int section_count; 119. 120. {* Stuff only useful for object files: 121. The start address. *} 122. bfd_vma start_address; 123. 124. {* Used for input and output. *} 125. unsigned int symcount; 126. 127. {* Symbol table for output BFD (with symcount entries). *} 128. struct bfd_symbol **outsymbols; 129. 130. {* Used for slurped dynamic symbol tables. *} 131. unsigned int dynsymcount; 132. 133. {* Pointer to structure which contains architecture information. *} 134. const struct bfd_arch_info *arch_info; 135. 136. {* Flag set if symbols from this BFD should not be exported. *} 137. bfd_boolean no_export; 138. 139. {* Stuff only useful for archives. *} 140. void *arelt_data; 141. struct bfd *my_archive; {* The containing archive BFD. *} 142. struct bfd *next; {* The next BFD in the archive. *} 143. struct bfd *archive_head; {* The first BFD in the archive. *} 144. bfd_boolean has_armap; 145. 146. {* A chain of BFD structures involved in a link. *} 147. struct bfd *link_next; 148. 149. {* A field used by _bfd_generic_link_add_archive_symbols. This will 150. be used only for archive elements. *} 151. int archive_pass; 152. 153. {* Used by the back end to hold private data. *} 154. union 155. { 156. struct aout_data_struct *aout_data; 157. struct artdata *aout_ar_data; 158. struct _oasys_data *oasys_obj_data; 159. struct _oasys_ar_data *oasys_ar_data; 160. struct coff_tdata *coff_obj_data; 161. struct pe_tdata *pe_obj_data; 162. struct xcoff_tdata *xcoff_obj_data; 163. struct ecoff_tdata *ecoff_obj_data; 164. struct ieee_data_struct *ieee_data; 165. struct ieee_ar_data_struct *ieee_ar_data; 166. struct srec_data_struct *srec_data; 167. struct ihex_data_struct *ihex_data; 168. struct tekhex_data_struct *tekhex_data; 169. struct elf_obj_tdata *elf_obj_data; 170. struct nlm_obj_tdata *nlm_obj_data; 171. struct bout_data_struct *bout_data; 172. struct mmo_data_struct *mmo_data; 173. struct sun_core_struct *sun_core_data; 174. struct sco5_core_struct *sco5_core_data; 175. struct trad_core_struct *trad_core_data; 176. struct som_data_struct *som_data; 177. struct hpux_core_struct *hpux_core_data; 178. struct hppabsd_core_struct *hppabsd_core_data; 179. struct sgi_core_struct *sgi_core_data; 180. struct lynx_core_struct *lynx_core_data; 181. struct osf_core_struct *osf_core_data; 182. struct cisco_core_struct *cisco_core_data; 183. struct versados_data_struct *versados_data; 184. struct netbsd_core_struct *netbsd_core_data; 185. struct mach_o_data_struct *mach_o_data; 186. struct mach_o_fat_data_struct *mach_o_fat_data; 187. struct bfd_pef_data_struct *pef_data; 188. struct bfd_pef_xlib_data_struct *pef_xlib_data; 189. struct bfd_sym_data_struct *sym_data; 190. void *any; 191. } 192. tdata; 193. 194. {* Used by the application to hold private data. *} 195. void *usrdata; 196. 197. {* Where all the allocated stuff under this BFD goes. This is a 198. struct objalloc *, but we use void * to avoid requiring the inclusion 199. of objalloc.h. *} 200. void *memory; 201.}; 202. 203*/ 204 205#include "bfd.h" 206#include "bfdver.h" 207#include "sysdep.h" 208#include <stdarg.h> 209#include "libiberty.h" 210#include "safe-ctype.h" 211#include "bfdlink.h" 212#include "libbfd.h" 213#include "coff/internal.h" 214#include "coff/sym.h" 215#include "libcoff.h" 216#include "libecoff.h" 217#undef obj_symbols 218#include "elf-bfd.h" 219 220#ifndef EXIT_FAILURE 221#define EXIT_FAILURE 1 222#endif 223 224 225/* provide storage for subsystem, stack and heap data which may have been 226 passed in on the command line. Ld puts this data into a bfd_link_info 227 struct which ultimately gets passed in to the bfd. When it arrives, copy 228 it to the following struct so that the data will be available in coffcode.h 229 where it is needed. The typedef's used are defined in bfd.h */ 230 231/* 232SECTION 233 Error reporting 234 235 Most BFD functions return nonzero on success (check their 236 individual documentation for precise semantics). On an error, 237 they call <<bfd_set_error>> to set an error condition that callers 238 can check by calling <<bfd_get_error>>. 239 If that returns <<bfd_error_system_call>>, then check 240 <<errno>>. 241 242 The easiest way to report a BFD error to the user is to 243 use <<bfd_perror>>. 244 245SUBSECTION 246 Type <<bfd_error_type>> 247 248 The values returned by <<bfd_get_error>> are defined by the 249 enumerated type <<bfd_error_type>>. 250 251CODE_FRAGMENT 252. 253.typedef enum bfd_error 254.{ 255. bfd_error_no_error = 0, 256. bfd_error_system_call, 257. bfd_error_invalid_target, 258. bfd_error_wrong_format, 259. bfd_error_wrong_object_format, 260. bfd_error_invalid_operation, 261. bfd_error_no_memory, 262. bfd_error_no_symbols, 263. bfd_error_no_armap, 264. bfd_error_no_more_archived_files, 265. bfd_error_malformed_archive, 266. bfd_error_file_not_recognized, 267. bfd_error_file_ambiguously_recognized, 268. bfd_error_no_contents, 269. bfd_error_nonrepresentable_section, 270. bfd_error_no_debug_section, 271. bfd_error_bad_value, 272. bfd_error_file_truncated, 273. bfd_error_file_too_big, 274. bfd_error_invalid_error_code 275.} 276.bfd_error_type; 277. 278*/ 279 280static bfd_error_type bfd_error = bfd_error_no_error; 281 282const char *const bfd_errmsgs[] = 283{ 284 N_("No error"), 285 N_("System call error"), 286 N_("Invalid bfd target"), 287 N_("File in wrong format"), 288 N_("Archive object file in wrong format"), 289 N_("Invalid operation"), 290 N_("Memory exhausted"), 291 N_("No symbols"), 292 N_("Archive has no index; run ranlib to add one"), 293 N_("No more archived files"), 294 N_("Malformed archive"), 295 N_("File format not recognized"), 296 N_("File format is ambiguous"), 297 N_("Section has no contents"), 298 N_("Nonrepresentable section on output"), 299 N_("Symbol needs debug section which does not exist"), 300 N_("Bad value"), 301 N_("File truncated"), 302 N_("File too big"), 303 N_("#<Invalid error code>") 304}; 305 306/* 307FUNCTION 308 bfd_get_error 309 310SYNOPSIS 311 bfd_error_type bfd_get_error (void); 312 313DESCRIPTION 314 Return the current BFD error condition. 315*/ 316 317bfd_error_type 318bfd_get_error (void) 319{ 320 return bfd_error; 321} 322 323/* 324FUNCTION 325 bfd_set_error 326 327SYNOPSIS 328 void bfd_set_error (bfd_error_type error_tag); 329 330DESCRIPTION 331 Set the BFD error condition to be @var{error_tag}. 332*/ 333 334void 335bfd_set_error (bfd_error_type error_tag) 336{ 337 bfd_error = error_tag; 338} 339 340/* 341FUNCTION 342 bfd_errmsg 343 344SYNOPSIS 345 const char *bfd_errmsg (bfd_error_type error_tag); 346 347DESCRIPTION 348 Return a string describing the error @var{error_tag}, or 349 the system error if @var{error_tag} is <<bfd_error_system_call>>. 350*/ 351 352const char * 353bfd_errmsg (bfd_error_type error_tag) 354{ 355#ifndef errno 356 extern int errno; 357#endif 358 if (error_tag == bfd_error_system_call) 359 return xstrerror (errno); 360 361 if (error_tag > bfd_error_invalid_error_code) 362 error_tag = bfd_error_invalid_error_code; /* sanity check */ 363 364 return _(bfd_errmsgs [error_tag]); 365} 366 367/* 368FUNCTION 369 bfd_perror 370 371SYNOPSIS 372 void bfd_perror (const char *message); 373 374DESCRIPTION 375 Print to the standard error stream a string describing the 376 last BFD error that occurred, or the last system error if 377 the last BFD error was a system call failure. If @var{message} 378 is non-NULL and non-empty, the error string printed is preceded 379 by @var{message}, a colon, and a space. It is followed by a newline. 380*/ 381 382void 383bfd_perror (const char *message) 384{ 385 if (bfd_get_error () == bfd_error_system_call) 386 /* Must be a system error then. */ 387 perror ((char *) message); 388 else 389 { 390 if (message == NULL || *message == '\0') 391 fprintf (stderr, "%s\n", bfd_errmsg (bfd_get_error ())); 392 else 393 fprintf (stderr, "%s: %s\n", message, bfd_errmsg (bfd_get_error ())); 394 } 395} 396 397/* 398SUBSECTION 399 BFD error handler 400 401 Some BFD functions want to print messages describing the 402 problem. They call a BFD error handler function. This 403 function may be overridden by the program. 404 405 The BFD error handler acts like printf. 406 407CODE_FRAGMENT 408. 409.typedef void (*bfd_error_handler_type) (const char *, ...); 410. 411*/ 412 413/* The program name used when printing BFD error messages. */ 414 415static const char *_bfd_error_program_name; 416 417/* This is the default routine to handle BFD error messages. 418 Like fprintf (stderr, ...), but also handles some extra format specifiers. 419 420 %A section name from section. For group components, print group name too. 421 %B file name from bfd. For archive components, prints archive too. 422 */ 423 424void 425_bfd_default_error_handler (const char *fmt, ...) 426{ 427 va_list ap; 428 char *bufp; 429 const char *new_fmt, *p; 430 size_t avail = 1000; 431 char buf[1000]; 432 433 if (_bfd_error_program_name != NULL) 434 fprintf (stderr, "%s: ", _bfd_error_program_name); 435 else 436 fprintf (stderr, "BFD: "); 437 438 va_start (ap, fmt); 439 new_fmt = fmt; 440 bufp = buf; 441 442 /* Reserve enough space for the existing format string. */ 443 avail -= strlen (fmt) + 1; 444 if (avail > 1000) 445 _exit (EXIT_FAILURE); 446 447 p = fmt; 448 while (1) 449 { 450 char *q; 451 size_t len, extra, trim; 452 453 p = strchr (p, '%'); 454 if (p == NULL || p[1] == '\0') 455 { 456 if (new_fmt == buf) 457 { 458 len = strlen (fmt); 459 memcpy (bufp, fmt, len + 1); 460 } 461 break; 462 } 463 464 if (p[1] == 'A' || p[1] == 'B') 465 { 466 len = p - fmt; 467 memcpy (bufp, fmt, len); 468 bufp += len; 469 fmt = p + 2; 470 new_fmt = buf; 471 472 /* If we run out of space, tough, you lose your ridiculously 473 long file or section name. It's not safe to try to alloc 474 memory here; We might be printing an out of memory message. */ 475 if (avail == 0) 476 { 477 *bufp++ = '*'; 478 *bufp++ = '*'; 479 *bufp = '\0'; 480 } 481 else 482 { 483 if (p[1] == 'B') 484 { 485 bfd *abfd = va_arg (ap, bfd *); 486 if (abfd->my_archive) 487 snprintf (bufp, avail, "%s(%s)", 488 abfd->my_archive->filename, abfd->filename); 489 else 490 snprintf (bufp, avail, "%s", abfd->filename); 491 } 492 else 493 { 494 asection *sec = va_arg (ap, asection *); 495 bfd *abfd = sec->owner; 496 const char *group = NULL; 497 struct coff_comdat_info *ci; 498 499 if (abfd != NULL 500 && bfd_get_flavour (abfd) == bfd_target_elf_flavour 501 && elf_next_in_group (sec) != NULL 502 && (sec->flags & SEC_GROUP) == 0) 503 group = elf_group_name (sec); 504 else if (abfd != NULL 505 && bfd_get_flavour (abfd) == bfd_target_coff_flavour 506 && (ci = bfd_coff_get_comdat_section (sec->owner, 507 sec)) != NULL) 508 group = ci->name; 509 if (group != NULL) 510 snprintf (bufp, avail, "%s[%s]", sec->name, group); 511 else 512 snprintf (bufp, avail, "%s", sec->name); 513 } 514 len = strlen (bufp); 515 avail = avail - len + 2; 516 517 /* We need to replace any '%' we printed by "%%". 518 First count how many. */ 519 q = bufp; 520 bufp += len; 521 extra = 0; 522 while ((q = strchr (q, '%')) != NULL) 523 { 524 ++q; 525 ++extra; 526 } 527 528 /* If there isn't room, trim off the end of the string. */ 529 q = bufp; 530 bufp += extra; 531 if (extra > avail) 532 { 533 trim = extra - avail; 534 bufp -= trim; 535 do 536 { 537 if (*--q == '%') 538 --extra; 539 } 540 while (--trim != 0); 541 *q = '\0'; 542 avail = extra; 543 } 544 avail -= extra; 545 546 /* Now double all '%' chars, shuffling the string as we go. */ 547 while (extra != 0) 548 { 549 while ((q[extra] = *q) != '%') 550 --q; 551 q[--extra] = '%'; 552 --q; 553 } 554 } 555 } 556 p = p + 2; 557 } 558 559 vfprintf (stderr, new_fmt, ap); 560 va_end (ap); 561 562 putc ('\n', stderr); 563} 564 565/* This is a function pointer to the routine which should handle BFD 566 error messages. It is called when a BFD routine encounters an 567 error for which it wants to print a message. Going through a 568 function pointer permits a program linked against BFD to intercept 569 the messages and deal with them itself. */ 570 571bfd_error_handler_type _bfd_error_handler = _bfd_default_error_handler; 572 573/* 574FUNCTION 575 bfd_set_error_handler 576 577SYNOPSIS 578 bfd_error_handler_type bfd_set_error_handler (bfd_error_handler_type); 579 580DESCRIPTION 581 Set the BFD error handler function. Returns the previous 582 function. 583*/ 584 585bfd_error_handler_type 586bfd_set_error_handler (bfd_error_handler_type pnew) 587{ 588 bfd_error_handler_type pold; 589 590 pold = _bfd_error_handler; 591 _bfd_error_handler = pnew; 592 return pold; 593} 594 595/* 596FUNCTION 597 bfd_set_error_program_name 598 599SYNOPSIS 600 void bfd_set_error_program_name (const char *); 601 602DESCRIPTION 603 Set the program name to use when printing a BFD error. This 604 is printed before the error message followed by a colon and 605 space. The string must not be changed after it is passed to 606 this function. 607*/ 608 609void 610bfd_set_error_program_name (const char *name) 611{ 612 _bfd_error_program_name = name; 613} 614 615/* 616FUNCTION 617 bfd_get_error_handler 618 619SYNOPSIS 620 bfd_error_handler_type bfd_get_error_handler (void); 621 622DESCRIPTION 623 Return the BFD error handler function. 624*/ 625 626bfd_error_handler_type 627bfd_get_error_handler (void) 628{ 629 return _bfd_error_handler; 630} 631 632/* 633SECTION 634 Miscellaneous 635 636SUBSECTION 637 Miscellaneous functions 638*/ 639 640/* 641FUNCTION 642 bfd_get_reloc_upper_bound 643 644SYNOPSIS 645 long bfd_get_reloc_upper_bound (bfd *abfd, asection *sect); 646 647DESCRIPTION 648 Return the number of bytes required to store the 649 relocation information associated with section @var{sect} 650 attached to bfd @var{abfd}. If an error occurs, return -1. 651 652*/ 653 654long 655bfd_get_reloc_upper_bound (bfd *abfd, sec_ptr asect) 656{ 657 if (abfd->format != bfd_object) 658 { 659 bfd_set_error (bfd_error_invalid_operation); 660 return -1; 661 } 662 663 return BFD_SEND (abfd, _get_reloc_upper_bound, (abfd, asect)); 664} 665 666/* 667FUNCTION 668 bfd_canonicalize_reloc 669 670SYNOPSIS 671 long bfd_canonicalize_reloc 672 (bfd *abfd, asection *sec, arelent **loc, asymbol **syms); 673 674DESCRIPTION 675 Call the back end associated with the open BFD 676 @var{abfd} and translate the external form of the relocation 677 information attached to @var{sec} into the internal canonical 678 form. Place the table into memory at @var{loc}, which has 679 been preallocated, usually by a call to 680 <<bfd_get_reloc_upper_bound>>. Returns the number of relocs, or 681 -1 on error. 682 683 The @var{syms} table is also needed for horrible internal magic 684 reasons. 685 686*/ 687long 688bfd_canonicalize_reloc (bfd *abfd, 689 sec_ptr asect, 690 arelent **location, 691 asymbol **symbols) 692{ 693 if (abfd->format != bfd_object) 694 { 695 bfd_set_error (bfd_error_invalid_operation); 696 return -1; 697 } 698 699 return BFD_SEND (abfd, _bfd_canonicalize_reloc, 700 (abfd, asect, location, symbols)); 701} 702 703/* 704FUNCTION 705 bfd_set_reloc 706 707SYNOPSIS 708 void bfd_set_reloc 709 (bfd *abfd, asection *sec, arelent **rel, unsigned int count); 710 711DESCRIPTION 712 Set the relocation pointer and count within 713 section @var{sec} to the values @var{rel} and @var{count}. 714 The argument @var{abfd} is ignored. 715 716*/ 717 718void 719bfd_set_reloc (bfd *ignore_abfd ATTRIBUTE_UNUSED, 720 sec_ptr asect, 721 arelent **location, 722 unsigned int count) 723{ 724 asect->orelocation = location; 725 asect->reloc_count = count; 726} 727 728/* 729FUNCTION 730 bfd_set_file_flags 731 732SYNOPSIS 733 bfd_boolean bfd_set_file_flags (bfd *abfd, flagword flags); 734 735DESCRIPTION 736 Set the flag word in the BFD @var{abfd} to the value @var{flags}. 737 738 Possible errors are: 739 o <<bfd_error_wrong_format>> - The target bfd was not of object format. 740 o <<bfd_error_invalid_operation>> - The target bfd was open for reading. 741 o <<bfd_error_invalid_operation>> - 742 The flag word contained a bit which was not applicable to the 743 type of file. E.g., an attempt was made to set the <<D_PAGED>> bit 744 on a BFD format which does not support demand paging. 745 746*/ 747 748bfd_boolean 749bfd_set_file_flags (bfd *abfd, flagword flags) 750{ 751 if (abfd->format != bfd_object) 752 { 753 bfd_set_error (bfd_error_wrong_format); 754 return FALSE; 755 } 756 757 if (bfd_read_p (abfd)) 758 { 759 bfd_set_error (bfd_error_invalid_operation); 760 return FALSE; 761 } 762 763 bfd_get_file_flags (abfd) = flags; 764 if ((flags & bfd_applicable_file_flags (abfd)) != flags) 765 { 766 bfd_set_error (bfd_error_invalid_operation); 767 return FALSE; 768 } 769 770 return TRUE; 771} 772 773void 774bfd_assert (const char *file, int line) 775{ 776 (*_bfd_error_handler) (_("BFD %s assertion fail %s:%d"), 777 BFD_VERSION_STRING, file, line); 778} 779 780/* A more or less friendly abort message. In libbfd.h abort is 781 defined to call this function. */ 782 783void 784_bfd_abort (const char *file, int line, const char *fn) 785{ 786 if (fn != NULL) 787 (*_bfd_error_handler) 788 (_("BFD %s internal error, aborting at %s line %d in %s\n"), 789 BFD_VERSION_STRING, file, line, fn); 790 else 791 (*_bfd_error_handler) 792 (_("BFD %s internal error, aborting at %s line %d\n"), 793 BFD_VERSION_STRING, file, line); 794 (*_bfd_error_handler) (_("Please report this bug.\n")); 795 _exit (EXIT_FAILURE); 796 /* avoid gcc-2.95.3 warning about 'noreturn function that does return': */ 797 while(1); 798} 799 800/* 801FUNCTION 802 bfd_get_arch_size 803 804SYNOPSIS 805 int bfd_get_arch_size (bfd *abfd); 806 807DESCRIPTION 808 Returns the architecture address size, in bits, as determined 809 by the object file's format. For ELF, this information is 810 included in the header. 811 812RETURNS 813 Returns the arch size in bits if known, <<-1>> otherwise. 814*/ 815 816int 817bfd_get_arch_size (bfd *abfd) 818{ 819 if (abfd->xvec->flavour == bfd_target_elf_flavour) 820 return get_elf_backend_data (abfd)->s->arch_size; 821 822 return -1; 823} 824 825/* 826FUNCTION 827 bfd_get_sign_extend_vma 828 829SYNOPSIS 830 int bfd_get_sign_extend_vma (bfd *abfd); 831 832DESCRIPTION 833 Indicates if the target architecture "naturally" sign extends 834 an address. Some architectures implicitly sign extend address 835 values when they are converted to types larger than the size 836 of an address. For instance, bfd_get_start_address() will 837 return an address sign extended to fill a bfd_vma when this is 838 the case. 839 840RETURNS 841 Returns <<1>> if the target architecture is known to sign 842 extend addresses, <<0>> if the target architecture is known to 843 not sign extend addresses, and <<-1>> otherwise. 844*/ 845 846int 847bfd_get_sign_extend_vma (bfd *abfd) 848{ 849 char *name; 850 851 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour) 852 return get_elf_backend_data (abfd)->sign_extend_vma; 853 854 name = bfd_get_target (abfd); 855 856 /* Return a proper value for DJGPP & PE COFF (x86 COFF variants). 857 This function is required for DWARF2 support, but there is 858 no place to store this information in the COFF back end. 859 Should enough other COFF targets add support for DWARF2, 860 a place will have to be found. Until then, this hack will do. */ 861 if (strncmp (name, "coff-go32", sizeof ("coff-go32") - 1) == 0 862 || strcmp (name, "pe-i386") == 0 863 || strcmp (name, "pei-i386") == 0) 864 return 1; 865 866 bfd_set_error (bfd_error_wrong_format); 867 return -1; 868} 869 870/* 871FUNCTION 872 bfd_set_start_address 873 874SYNOPSIS 875 bfd_boolean bfd_set_start_address (bfd *abfd, bfd_vma vma); 876 877DESCRIPTION 878 Make @var{vma} the entry point of output BFD @var{abfd}. 879 880RETURNS 881 Returns <<TRUE>> on success, <<FALSE>> otherwise. 882*/ 883 884bfd_boolean 885bfd_set_start_address (bfd *abfd, bfd_vma vma) 886{ 887 abfd->start_address = vma; 888 return TRUE; 889} 890 891/* 892FUNCTION 893 bfd_get_gp_size 894 895SYNOPSIS 896 unsigned int bfd_get_gp_size (bfd *abfd); 897 898DESCRIPTION 899 Return the maximum size of objects to be optimized using the GP 900 register under MIPS ECOFF. This is typically set by the <<-G>> 901 argument to the compiler, assembler or linker. 902*/ 903 904unsigned int 905bfd_get_gp_size (bfd *abfd) 906{ 907 if (abfd->format == bfd_object) 908 { 909 if (abfd->xvec->flavour == bfd_target_ecoff_flavour) 910 return ecoff_data (abfd)->gp_size; 911 else if (abfd->xvec->flavour == bfd_target_elf_flavour) 912 return elf_gp_size (abfd); 913 } 914 return 0; 915} 916 917/* 918FUNCTION 919 bfd_set_gp_size 920 921SYNOPSIS 922 void bfd_set_gp_size (bfd *abfd, unsigned int i); 923 924DESCRIPTION 925 Set the maximum size of objects to be optimized using the GP 926 register under ECOFF or MIPS ELF. This is typically set by 927 the <<-G>> argument to the compiler, assembler or linker. 928*/ 929 930void 931bfd_set_gp_size (bfd *abfd, unsigned int i) 932{ 933 /* Don't try to set GP size on an archive or core file! */ 934 if (abfd->format != bfd_object) 935 return; 936 937 if (abfd->xvec->flavour == bfd_target_ecoff_flavour) 938 ecoff_data (abfd)->gp_size = i; 939 else if (abfd->xvec->flavour == bfd_target_elf_flavour) 940 elf_gp_size (abfd) = i; 941} 942 943/* Get the GP value. This is an internal function used by some of the 944 relocation special_function routines on targets which support a GP 945 register. */ 946 947bfd_vma 948_bfd_get_gp_value (bfd *abfd) 949{ 950 if (! abfd) 951 return 0; 952 if (abfd->format != bfd_object) 953 return 0; 954 955 if (abfd->xvec->flavour == bfd_target_ecoff_flavour) 956 return ecoff_data (abfd)->gp; 957 else if (abfd->xvec->flavour == bfd_target_elf_flavour) 958 return elf_gp (abfd); 959 960 return 0; 961} 962 963/* Set the GP value. */ 964 965void 966_bfd_set_gp_value (bfd *abfd, bfd_vma v) 967{ 968 if (! abfd) 969 BFD_FAIL (); 970 if (abfd->format != bfd_object) 971 return; 972 973 if (abfd->xvec->flavour == bfd_target_ecoff_flavour) 974 ecoff_data (abfd)->gp = v; 975 else if (abfd->xvec->flavour == bfd_target_elf_flavour) 976 elf_gp (abfd) = v; 977} 978 979/* 980FUNCTION 981 bfd_scan_vma 982 983SYNOPSIS 984 bfd_vma bfd_scan_vma (const char *string, const char **end, int base); 985 986DESCRIPTION 987 Convert, like <<strtoul>>, a numerical expression 988 @var{string} into a <<bfd_vma>> integer, and return that integer. 989 (Though without as many bells and whistles as <<strtoul>>.) 990 The expression is assumed to be unsigned (i.e., positive). 991 If given a @var{base}, it is used as the base for conversion. 992 A base of 0 causes the function to interpret the string 993 in hex if a leading "0x" or "0X" is found, otherwise 994 in octal if a leading zero is found, otherwise in decimal. 995 996 If the value would overflow, the maximum <<bfd_vma>> value is 997 returned. 998*/ 999 1000bfd_vma 1001bfd_scan_vma (const char *string, const char **end, int base) 1002{ 1003 bfd_vma value; 1004 bfd_vma cutoff; 1005 unsigned int cutlim; 1006 int overflow; 1007 1008 /* Let the host do it if possible. */ 1009 if (sizeof (bfd_vma) <= sizeof (unsigned long)) 1010 return strtoul (string, (char **) end, base); 1011 1012#ifdef HAVE_STRTOULL 1013 if (sizeof (bfd_vma) <= sizeof (unsigned long long)) 1014 return strtoull (string, (char **) end, base); 1015#endif 1016 1017 if (base == 0) 1018 { 1019 if (string[0] == '0') 1020 { 1021 if ((string[1] == 'x') || (string[1] == 'X')) 1022 base = 16; 1023 else 1024 base = 8; 1025 } 1026 } 1027 1028 if ((base < 2) || (base > 36)) 1029 base = 10; 1030 1031 if (base == 16 1032 && string[0] == '0' 1033 && (string[1] == 'x' || string[1] == 'X') 1034 && ISXDIGIT (string[2])) 1035 { 1036 string += 2; 1037 } 1038 1039 cutoff = (~ (bfd_vma) 0) / (bfd_vma) base; 1040 cutlim = (~ (bfd_vma) 0) % (bfd_vma) base; 1041 value = 0; 1042 overflow = 0; 1043 while (1) 1044 { 1045 unsigned int digit; 1046 1047 digit = *string; 1048 if (ISDIGIT (digit)) 1049 digit = digit - '0'; 1050 else if (ISALPHA (digit)) 1051 digit = TOUPPER (digit) - 'A' + 10; 1052 else 1053 break; 1054 if (digit >= (unsigned int) base) 1055 break; 1056 if (value > cutoff || (value == cutoff && digit > cutlim)) 1057 overflow = 1; 1058 value = value * base + digit; 1059 ++string; 1060 } 1061 1062 if (overflow) 1063 value = ~ (bfd_vma) 0; 1064 1065 if (end != NULL) 1066 *end = string; 1067 1068 return value; 1069} 1070 1071/* 1072FUNCTION 1073 bfd_copy_private_header_data 1074 1075SYNOPSIS 1076 bfd_boolean bfd_copy_private_header_data (bfd *ibfd, bfd *obfd); 1077 1078DESCRIPTION 1079 Copy private BFD header information from the BFD @var{ibfd} to the 1080 the BFD @var{obfd}. This copies information that may require 1081 sections to exist, but does not require symbol tables. Return 1082 <<true>> on success, <<false>> on error. 1083 Possible error returns are: 1084 1085 o <<bfd_error_no_memory>> - 1086 Not enough memory exists to create private data for @var{obfd}. 1087 1088.#define bfd_copy_private_header_data(ibfd, obfd) \ 1089. BFD_SEND (obfd, _bfd_copy_private_header_data, \ 1090. (ibfd, obfd)) 1091 1092*/ 1093 1094/* 1095FUNCTION 1096 bfd_copy_private_bfd_data 1097 1098SYNOPSIS 1099 bfd_boolean bfd_copy_private_bfd_data (bfd *ibfd, bfd *obfd); 1100 1101DESCRIPTION 1102 Copy private BFD information from the BFD @var{ibfd} to the 1103 the BFD @var{obfd}. Return <<TRUE>> on success, <<FALSE>> on error. 1104 Possible error returns are: 1105 1106 o <<bfd_error_no_memory>> - 1107 Not enough memory exists to create private data for @var{obfd}. 1108 1109.#define bfd_copy_private_bfd_data(ibfd, obfd) \ 1110. BFD_SEND (obfd, _bfd_copy_private_bfd_data, \ 1111. (ibfd, obfd)) 1112 1113*/ 1114 1115/* 1116FUNCTION 1117 bfd_merge_private_bfd_data 1118 1119SYNOPSIS 1120 bfd_boolean bfd_merge_private_bfd_data (bfd *ibfd, bfd *obfd); 1121 1122DESCRIPTION 1123 Merge private BFD information from the BFD @var{ibfd} to the 1124 the output file BFD @var{obfd} when linking. Return <<TRUE>> 1125 on success, <<FALSE>> on error. Possible error returns are: 1126 1127 o <<bfd_error_no_memory>> - 1128 Not enough memory exists to create private data for @var{obfd}. 1129 1130.#define bfd_merge_private_bfd_data(ibfd, obfd) \ 1131. BFD_SEND (obfd, _bfd_merge_private_bfd_data, \ 1132. (ibfd, obfd)) 1133 1134*/ 1135 1136/* 1137FUNCTION 1138 bfd_set_private_flags 1139 1140SYNOPSIS 1141 bfd_boolean bfd_set_private_flags (bfd *abfd, flagword flags); 1142 1143DESCRIPTION 1144 Set private BFD flag information in the BFD @var{abfd}. 1145 Return <<TRUE>> on success, <<FALSE>> on error. Possible error 1146 returns are: 1147 1148 o <<bfd_error_no_memory>> - 1149 Not enough memory exists to create private data for @var{obfd}. 1150 1151.#define bfd_set_private_flags(abfd, flags) \ 1152. BFD_SEND (abfd, _bfd_set_private_flags, (abfd, flags)) 1153 1154*/ 1155 1156/* 1157FUNCTION 1158 Other functions 1159 1160DESCRIPTION 1161 The following functions exist but have not yet been documented. 1162 1163.#define bfd_sizeof_headers(abfd, reloc) \ 1164. BFD_SEND (abfd, _bfd_sizeof_headers, (abfd, reloc)) 1165. 1166.#define bfd_find_nearest_line(abfd, sec, syms, off, file, func, line) \ 1167. BFD_SEND (abfd, _bfd_find_nearest_line, \ 1168. (abfd, sec, syms, off, file, func, line)) 1169. 1170.#define bfd_find_line(abfd, syms, sym, file, line) \ 1171. BFD_SEND (abfd, _bfd_find_line, \ 1172. (abfd, syms, sym, file, line)) 1173. 1174.#define bfd_find_inliner_info(abfd, file, func, line) \ 1175. BFD_SEND (abfd, _bfd_find_inliner_info, \ 1176. (abfd, file, func, line)) 1177. 1178.#define bfd_debug_info_start(abfd) \ 1179. BFD_SEND (abfd, _bfd_debug_info_start, (abfd)) 1180. 1181.#define bfd_debug_info_end(abfd) \ 1182. BFD_SEND (abfd, _bfd_debug_info_end, (abfd)) 1183. 1184.#define bfd_debug_info_accumulate(abfd, section) \ 1185. BFD_SEND (abfd, _bfd_debug_info_accumulate, (abfd, section)) 1186. 1187.#define bfd_stat_arch_elt(abfd, stat) \ 1188. BFD_SEND (abfd, _bfd_stat_arch_elt,(abfd, stat)) 1189. 1190.#define bfd_update_armap_timestamp(abfd) \ 1191. BFD_SEND (abfd, _bfd_update_armap_timestamp, (abfd)) 1192. 1193.#define bfd_set_arch_mach(abfd, arch, mach)\ 1194. BFD_SEND ( abfd, _bfd_set_arch_mach, (abfd, arch, mach)) 1195. 1196.#define bfd_relax_section(abfd, section, link_info, again) \ 1197. BFD_SEND (abfd, _bfd_relax_section, (abfd, section, link_info, again)) 1198. 1199.#define bfd_gc_sections(abfd, link_info) \ 1200. BFD_SEND (abfd, _bfd_gc_sections, (abfd, link_info)) 1201. 1202.#define bfd_merge_sections(abfd, link_info) \ 1203. BFD_SEND (abfd, _bfd_merge_sections, (abfd, link_info)) 1204. 1205.#define bfd_is_group_section(abfd, sec) \ 1206. BFD_SEND (abfd, _bfd_is_group_section, (abfd, sec)) 1207. 1208.#define bfd_discard_group(abfd, sec) \ 1209. BFD_SEND (abfd, _bfd_discard_group, (abfd, sec)) 1210. 1211.#define bfd_link_hash_table_create(abfd) \ 1212. BFD_SEND (abfd, _bfd_link_hash_table_create, (abfd)) 1213. 1214.#define bfd_link_hash_table_free(abfd, hash) \ 1215. BFD_SEND (abfd, _bfd_link_hash_table_free, (hash)) 1216. 1217.#define bfd_link_add_symbols(abfd, info) \ 1218. BFD_SEND (abfd, _bfd_link_add_symbols, (abfd, info)) 1219. 1220.#define bfd_link_just_syms(abfd, sec, info) \ 1221. BFD_SEND (abfd, _bfd_link_just_syms, (sec, info)) 1222. 1223.#define bfd_final_link(abfd, info) \ 1224. BFD_SEND (abfd, _bfd_final_link, (abfd, info)) 1225. 1226.#define bfd_free_cached_info(abfd) \ 1227. BFD_SEND (abfd, _bfd_free_cached_info, (abfd)) 1228. 1229.#define bfd_get_dynamic_symtab_upper_bound(abfd) \ 1230. BFD_SEND (abfd, _bfd_get_dynamic_symtab_upper_bound, (abfd)) 1231. 1232.#define bfd_print_private_bfd_data(abfd, file)\ 1233. BFD_SEND (abfd, _bfd_print_private_bfd_data, (abfd, file)) 1234. 1235.#define bfd_canonicalize_dynamic_symtab(abfd, asymbols) \ 1236. BFD_SEND (abfd, _bfd_canonicalize_dynamic_symtab, (abfd, asymbols)) 1237. 1238.#define bfd_get_synthetic_symtab(abfd, count, syms, dyncount, dynsyms, ret) \ 1239. BFD_SEND (abfd, _bfd_get_synthetic_symtab, (abfd, count, syms, \ 1240. dyncount, dynsyms, ret)) 1241. 1242.#define bfd_get_dynamic_reloc_upper_bound(abfd) \ 1243. BFD_SEND (abfd, _bfd_get_dynamic_reloc_upper_bound, (abfd)) 1244. 1245.#define bfd_canonicalize_dynamic_reloc(abfd, arels, asyms) \ 1246. BFD_SEND (abfd, _bfd_canonicalize_dynamic_reloc, (abfd, arels, asyms)) 1247. 1248.extern bfd_byte *bfd_get_relocated_section_contents 1249. (bfd *, struct bfd_link_info *, struct bfd_link_order *, bfd_byte *, 1250. bfd_boolean, asymbol **); 1251. 1252 1253*/ 1254 1255bfd_byte * 1256bfd_get_relocated_section_contents (bfd *abfd, 1257 struct bfd_link_info *link_info, 1258 struct bfd_link_order *link_order, 1259 bfd_byte *data, 1260 bfd_boolean relocatable, 1261 asymbol **symbols) 1262{ 1263 bfd *abfd2; 1264 bfd_byte *(*fn) (bfd *, struct bfd_link_info *, struct bfd_link_order *, 1265 bfd_byte *, bfd_boolean, asymbol **); 1266 1267 if (link_order->type == bfd_indirect_link_order) 1268 { 1269 abfd2 = link_order->u.indirect.section->owner; 1270 if (abfd2 == NULL) 1271 abfd2 = abfd; 1272 } 1273 else 1274 abfd2 = abfd; 1275 1276 fn = abfd2->xvec->_bfd_get_relocated_section_contents; 1277 1278 return (*fn) (abfd, link_info, link_order, data, relocatable, symbols); 1279} 1280 1281/* Record information about an ELF program header. */ 1282 1283bfd_boolean 1284bfd_record_phdr (bfd *abfd, 1285 unsigned long type, 1286 bfd_boolean flags_valid, 1287 flagword flags, 1288 bfd_boolean at_valid, 1289 bfd_vma at, 1290 bfd_boolean includes_filehdr, 1291 bfd_boolean includes_phdrs, 1292 unsigned int count, 1293 asection **secs) 1294{ 1295 struct elf_segment_map *m, **pm; 1296 bfd_size_type amt; 1297 1298 if (bfd_get_flavour (abfd) != bfd_target_elf_flavour) 1299 return TRUE; 1300 1301 amt = sizeof (struct elf_segment_map); 1302 amt += ((bfd_size_type) count - 1) * sizeof (asection *); 1303 m = bfd_alloc (abfd, amt); 1304 if (m == NULL) 1305 return FALSE; 1306 1307 m->next = NULL; 1308 m->p_type = type; 1309 m->p_flags = flags; 1310 m->p_paddr = at; 1311 m->p_flags_valid = flags_valid; 1312 m->p_paddr_valid = at_valid; 1313 m->includes_filehdr = includes_filehdr; 1314 m->includes_phdrs = includes_phdrs; 1315 m->count = count; 1316 if (count > 0) 1317 memcpy (m->sections, secs, count * sizeof (asection *)); 1318 1319 for (pm = &elf_tdata (abfd)->segment_map; *pm != NULL; pm = &(*pm)->next) 1320 ; 1321 *pm = m; 1322 1323 return TRUE; 1324} 1325 1326void 1327bfd_sprintf_vma (bfd *abfd, char *buf, bfd_vma value) 1328{ 1329 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour) 1330 get_elf_backend_data (abfd)->elf_backend_sprintf_vma (abfd, buf, value); 1331 else 1332 sprintf_vma (buf, value); 1333} 1334 1335void 1336bfd_fprintf_vma (bfd *abfd, void *stream, bfd_vma value) 1337{ 1338 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour) 1339 get_elf_backend_data (abfd)->elf_backend_fprintf_vma (abfd, stream, value); 1340 else 1341 fprintf_vma ((FILE *) stream, value); 1342} 1343 1344/* 1345FUNCTION 1346 bfd_alt_mach_code 1347 1348SYNOPSIS 1349 bfd_boolean bfd_alt_mach_code (bfd *abfd, int alternative); 1350 1351DESCRIPTION 1352 1353 When more than one machine code number is available for the 1354 same machine type, this function can be used to switch between 1355 the preferred one (alternative == 0) and any others. Currently, 1356 only ELF supports this feature, with up to two alternate 1357 machine codes. 1358*/ 1359 1360bfd_boolean 1361bfd_alt_mach_code (bfd *abfd, int alternative) 1362{ 1363 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour) 1364 { 1365 int code; 1366 1367 switch (alternative) 1368 { 1369 case 0: 1370 code = get_elf_backend_data (abfd)->elf_machine_code; 1371 break; 1372 1373 case 1: 1374 code = get_elf_backend_data (abfd)->elf_machine_alt1; 1375 if (code == 0) 1376 return FALSE; 1377 break; 1378 1379 case 2: 1380 code = get_elf_backend_data (abfd)->elf_machine_alt2; 1381 if (code == 0) 1382 return FALSE; 1383 break; 1384 1385 default: 1386 return FALSE; 1387 } 1388 1389 elf_elfheader (abfd)->e_machine = code; 1390 1391 return TRUE; 1392 } 1393 1394 return FALSE; 1395} 1396 1397/* 1398CODE_FRAGMENT 1399 1400.struct bfd_preserve 1401.{ 1402. void *marker; 1403. void *tdata; 1404. flagword flags; 1405. const struct bfd_arch_info *arch_info; 1406. struct bfd_section *sections; 1407. struct bfd_section *section_last; 1408. unsigned int section_count; 1409. struct bfd_hash_table section_htab; 1410.}; 1411. 1412*/ 1413 1414/* 1415FUNCTION 1416 bfd_preserve_save 1417 1418SYNOPSIS 1419 bfd_boolean bfd_preserve_save (bfd *, struct bfd_preserve *); 1420 1421DESCRIPTION 1422 When testing an object for compatibility with a particular 1423 target back-end, the back-end object_p function needs to set 1424 up certain fields in the bfd on successfully recognizing the 1425 object. This typically happens in a piecemeal fashion, with 1426 failures possible at many points. On failure, the bfd is 1427 supposed to be restored to its initial state, which is 1428 virtually impossible. However, restoring a subset of the bfd 1429 state works in practice. This function stores the subset and 1430 reinitializes the bfd. 1431 1432*/ 1433 1434bfd_boolean 1435bfd_preserve_save (bfd *abfd, struct bfd_preserve *preserve) 1436{ 1437 preserve->tdata = abfd->tdata.any; 1438 preserve->arch_info = abfd->arch_info; 1439 preserve->flags = abfd->flags; 1440 preserve->sections = abfd->sections; 1441 preserve->section_last = abfd->section_last; 1442 preserve->section_count = abfd->section_count; 1443 preserve->section_htab = abfd->section_htab; 1444 1445 if (! bfd_hash_table_init (&abfd->section_htab, bfd_section_hash_newfunc, 1446 sizeof (struct section_hash_entry))) 1447 return FALSE; 1448 1449 abfd->tdata.any = NULL; 1450 abfd->arch_info = &bfd_default_arch_struct; 1451 abfd->flags &= BFD_IN_MEMORY; 1452 abfd->sections = NULL; 1453 abfd->section_last = NULL; 1454 abfd->section_count = 0; 1455 1456 return TRUE; 1457} 1458 1459/* 1460FUNCTION 1461 bfd_preserve_restore 1462 1463SYNOPSIS 1464 void bfd_preserve_restore (bfd *, struct bfd_preserve *); 1465 1466DESCRIPTION 1467 This function restores bfd state saved by bfd_preserve_save. 1468 If MARKER is non-NULL in struct bfd_preserve then that block 1469 and all subsequently bfd_alloc'd memory is freed. 1470 1471*/ 1472 1473void 1474bfd_preserve_restore (bfd *abfd, struct bfd_preserve *preserve) 1475{ 1476 bfd_hash_table_free (&abfd->section_htab); 1477 1478 abfd->tdata.any = preserve->tdata; 1479 abfd->arch_info = preserve->arch_info; 1480 abfd->flags = preserve->flags; 1481 abfd->section_htab = preserve->section_htab; 1482 abfd->sections = preserve->sections; 1483 abfd->section_last = preserve->section_last; 1484 abfd->section_count = preserve->section_count; 1485 1486 /* bfd_release frees all memory more recently bfd_alloc'd than 1487 its arg, as well as its arg. */ 1488 if (preserve->marker != NULL) 1489 { 1490 bfd_release (abfd, preserve->marker); 1491 preserve->marker = NULL; 1492 } 1493} 1494 1495/* 1496FUNCTION 1497 bfd_preserve_finish 1498 1499SYNOPSIS 1500 void bfd_preserve_finish (bfd *, struct bfd_preserve *); 1501 1502DESCRIPTION 1503 This function should be called when the bfd state saved by 1504 bfd_preserve_save is no longer needed. ie. when the back-end 1505 object_p function returns with success. 1506 1507*/ 1508 1509void 1510bfd_preserve_finish (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_preserve *preserve) 1511{ 1512 /* It would be nice to be able to free more memory here, eg. old 1513 tdata, but that's not possible since these blocks are sitting 1514 inside bfd_alloc'd memory. The section hash is on a separate 1515 objalloc. */ 1516 bfd_hash_table_free (&preserve->section_htab); 1517} 1518