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