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