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 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., 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. {* 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 place where we add to the section list. *} 115. struct bfd_section **section_tail; 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/* provide storage for subsystem, stack and heap data which may have been 221 passed in on the command line. Ld puts this data into a bfd_link_info 222 struct which ultimately gets passed in to the bfd. When it arrives, copy 223 it to the following struct so that the data will be available in coffcode.h 224 where it is needed. The typedef's used are defined in bfd.h */ 225 226/* 227SECTION 228 Error reporting 229 230 Most BFD functions return nonzero on success (check their 231 individual documentation for precise semantics). On an error, 232 they call <<bfd_set_error>> to set an error condition that callers 233 can check by calling <<bfd_get_error>>. 234 If that returns <<bfd_error_system_call>>, then check 235 <<errno>>. 236 237 The easiest way to report a BFD error to the user is to 238 use <<bfd_perror>>. 239 240SUBSECTION 241 Type <<bfd_error_type>> 242 243 The values returned by <<bfd_get_error>> are defined by the 244 enumerated type <<bfd_error_type>>. 245 246CODE_FRAGMENT 247. 248.typedef enum bfd_error 249.{ 250. bfd_error_no_error = 0, 251. bfd_error_system_call, 252. bfd_error_invalid_target, 253. bfd_error_wrong_format, 254. bfd_error_wrong_object_format, 255. bfd_error_invalid_operation, 256. bfd_error_no_memory, 257. bfd_error_no_symbols, 258. bfd_error_no_armap, 259. bfd_error_no_more_archived_files, 260. bfd_error_malformed_archive, 261. bfd_error_file_not_recognized, 262. bfd_error_file_ambiguously_recognized, 263. bfd_error_no_contents, 264. bfd_error_nonrepresentable_section, 265. bfd_error_no_debug_section, 266. bfd_error_bad_value, 267. bfd_error_file_truncated, 268. bfd_error_file_too_big, 269. bfd_error_invalid_error_code 270.} 271.bfd_error_type; 272. 273*/ 274 275static bfd_error_type bfd_error = bfd_error_no_error; 276 277const char *const bfd_errmsgs[] = 278{ 279 N_("No error"), 280 N_("System call error"), 281 N_("Invalid bfd target"), 282 N_("File in wrong format"), 283 N_("Archive object file in wrong format"), 284 N_("Invalid operation"), 285 N_("Memory exhausted"), 286 N_("No symbols"), 287 N_("Archive has no index; run ranlib to add one"), 288 N_("No more archived files"), 289 N_("Malformed archive"), 290 N_("File format not recognized"), 291 N_("File format is ambiguous"), 292 N_("Section has no contents"), 293 N_("Nonrepresentable section on output"), 294 N_("Symbol needs debug section which does not exist"), 295 N_("Bad value"), 296 N_("File truncated"), 297 N_("File too big"), 298 N_("#<Invalid error code>") 299}; 300 301/* 302FUNCTION 303 bfd_get_error 304 305SYNOPSIS 306 bfd_error_type bfd_get_error (void); 307 308DESCRIPTION 309 Return the current BFD error condition. 310*/ 311 312bfd_error_type 313bfd_get_error (void) 314{ 315 return bfd_error; 316} 317 318/* 319FUNCTION 320 bfd_set_error 321 322SYNOPSIS 323 void bfd_set_error (bfd_error_type error_tag); 324 325DESCRIPTION 326 Set the BFD error condition to be @var{error_tag}. 327*/ 328 329void 330bfd_set_error (bfd_error_type error_tag) 331{ 332 bfd_error = error_tag; 333} 334 335/* 336FUNCTION 337 bfd_errmsg 338 339SYNOPSIS 340 const char *bfd_errmsg (bfd_error_type error_tag); 341 342DESCRIPTION 343 Return a string describing the error @var{error_tag}, or 344 the system error if @var{error_tag} is <<bfd_error_system_call>>. 345*/ 346 347const char * 348bfd_errmsg (bfd_error_type error_tag) 349{ 350#ifndef errno 351 extern int errno; 352#endif 353 if (error_tag == bfd_error_system_call) 354 return xstrerror (errno); 355 356 if (error_tag > bfd_error_invalid_error_code) 357 error_tag = bfd_error_invalid_error_code; /* sanity check */ 358 359 return _(bfd_errmsgs [error_tag]); 360} 361 362/* 363FUNCTION 364 bfd_perror 365 366SYNOPSIS 367 void bfd_perror (const char *message); 368 369DESCRIPTION 370 Print to the standard error stream a string describing the 371 last BFD error that occurred, or the last system error if 372 the last BFD error was a system call failure. If @var{message} 373 is non-NULL and non-empty, the error string printed is preceded 374 by @var{message}, a colon, and a space. It is followed by a newline. 375*/ 376 377void 378bfd_perror (const char *message) 379{ 380 if (bfd_get_error () == bfd_error_system_call) 381 /* Must be a system error then. */ 382 perror ((char *) message); 383 else 384 { 385 if (message == NULL || *message == '\0') 386 fprintf (stderr, "%s\n", bfd_errmsg (bfd_get_error ())); 387 else 388 fprintf (stderr, "%s: %s\n", message, bfd_errmsg (bfd_get_error ())); 389 } 390} 391 392/* 393SUBSECTION 394 BFD error handler 395 396 Some BFD functions want to print messages describing the 397 problem. They call a BFD error handler function. This 398 function may be overridden by the program. 399 400 The BFD error handler acts like printf. 401 402CODE_FRAGMENT 403. 404.typedef void (*bfd_error_handler_type) (const char *, ...); 405. 406*/ 407 408/* The program name used when printing BFD error messages. */ 409 410static const char *_bfd_error_program_name; 411 412/* This is the default routine to handle BFD error messages. 413 Like fprintf (stderr, ...), but also handles some extra format specifiers. 414 415 %A section name from section. For group components, print group name too. 416 %B file name from bfd. For archive components, prints archive too. 417 */ 418 419void 420_bfd_default_error_handler (const char *fmt, ...) 421{ 422 va_list ap; 423 char *bufp; 424 const char *new_fmt, *p; 425 size_t avail = 1000; 426 char buf[1000]; 427 428 if (_bfd_error_program_name != NULL) 429 fprintf (stderr, "%s: ", _bfd_error_program_name); 430 else 431 fprintf (stderr, "BFD: "); 432 433 va_start (ap, fmt); 434 new_fmt = fmt; 435 bufp = buf; 436 437 /* Reserve enough space for the existing format string. */ 438 avail -= strlen (fmt) + 1; 439 if (avail > 1000) 440 abort (); 441 442 p = fmt; 443 while (1) 444 { 445 char *q; 446 size_t len, extra, trim; 447 448 p = strchr (p, '%'); 449 if (p == NULL || p[1] == '\0') 450 { 451 if (new_fmt == buf) 452 { 453 len = strlen (fmt); 454 memcpy (bufp, fmt, len + 1); 455 } 456 break; 457 } 458 459 if (p[1] == 'A' || p[1] == 'B') 460 { 461 len = p - fmt; 462 memcpy (bufp, fmt, len); 463 bufp += len; 464 fmt = p + 2; 465 new_fmt = buf; 466 467 /* If we run out of space, tough, you lose your ridiculously 468 long file or section name. It's not safe to try to alloc 469 memory here; We might be printing an out of memory message. */ 470 if (avail == 0) 471 { 472 *bufp++ = '*'; 473 *bufp++ = '*'; 474 *bufp = '\0'; 475 } 476 else 477 { 478 if (p[1] == 'B') 479 { 480 bfd *abfd = va_arg (ap, bfd *); 481 if (abfd->my_archive) 482 snprintf (bufp, avail, "%s(%s)", 483 abfd->my_archive->filename, abfd->filename); 484 else 485 snprintf (bufp, avail, "%s", abfd->filename); 486 } 487 else 488 { 489 asection *sec = va_arg (ap, asection *); 490 bfd *abfd = sec->owner; 491 const char *group = NULL; 492 struct coff_comdat_info *ci; 493 494 if (abfd != NULL 495 && bfd_get_flavour (abfd) == bfd_target_elf_flavour 496 && elf_next_in_group (sec) != NULL 497 && (sec->flags & SEC_GROUP) == 0) 498 group = elf_group_name (sec); 499 else if (abfd != NULL 500 && bfd_get_flavour (abfd) == bfd_target_coff_flavour 501 && (ci = bfd_coff_get_comdat_section (sec->owner, 502 sec)) != NULL) 503 group = ci->name; 504 if (group != NULL) 505 snprintf (bufp, avail, "%s[%s]", sec->name, group); 506 else 507 snprintf (bufp, avail, "%s", sec->name); 508 } 509 len = strlen (bufp); 510 avail = avail - len + 2; 511 512 /* We need to replace any '%' we printed by "%%". 513 First count how many. */ 514 q = bufp; 515 bufp += len; 516 extra = 0; 517 while ((q = strchr (q, '%')) != NULL) 518 { 519 ++q; 520 ++extra; 521 } 522 523 /* If there isn't room, trim off the end of the string. */ 524 q = bufp; 525 bufp += extra; 526 if (extra > avail) 527 { 528 trim = extra - avail; 529 bufp -= trim; 530 do 531 { 532 if (*--q == '%') 533 --extra; 534 } 535 while (--trim != 0); 536 *q = '\0'; 537 avail = extra; 538 } 539 avail -= extra; 540 541 /* Now double all '%' chars, shuffling the string as we go. */ 542 while (extra != 0) 543 { 544 while ((q[extra] = *q) != '%') 545 --q; 546 q[--extra] = '%'; 547 --q; 548 } 549 } 550 } 551 p = p + 2; 552 } 553 554 vfprintf (stderr, new_fmt, ap); 555 va_end (ap); 556 557 putc ('\n', stderr); 558} 559 560/* This is a function pointer to the routine which should handle BFD 561 error messages. It is called when a BFD routine encounters an 562 error for which it wants to print a message. Going through a 563 function pointer permits a program linked against BFD to intercept 564 the messages and deal with them itself. */ 565 566bfd_error_handler_type _bfd_error_handler = _bfd_default_error_handler; 567 568/* 569FUNCTION 570 bfd_set_error_handler 571 572SYNOPSIS 573 bfd_error_handler_type bfd_set_error_handler (bfd_error_handler_type); 574 575DESCRIPTION 576 Set the BFD error handler function. Returns the previous 577 function. 578*/ 579 580bfd_error_handler_type 581bfd_set_error_handler (bfd_error_handler_type pnew) 582{ 583 bfd_error_handler_type pold; 584 585 pold = _bfd_error_handler; 586 _bfd_error_handler = pnew; 587 return pold; 588} 589 590/* 591FUNCTION 592 bfd_set_error_program_name 593 594SYNOPSIS 595 void bfd_set_error_program_name (const char *); 596 597DESCRIPTION 598 Set the program name to use when printing a BFD error. This 599 is printed before the error message followed by a colon and 600 space. The string must not be changed after it is passed to 601 this function. 602*/ 603 604void 605bfd_set_error_program_name (const char *name) 606{ 607 _bfd_error_program_name = name; 608} 609 610/* 611FUNCTION 612 bfd_get_error_handler 613 614SYNOPSIS 615 bfd_error_handler_type bfd_get_error_handler (void); 616 617DESCRIPTION 618 Return the BFD error handler function. 619*/ 620 621bfd_error_handler_type 622bfd_get_error_handler (void) 623{ 624 return _bfd_error_handler; 625} 626 627/* 628SECTION 629 Symbols 630*/ 631 632/* 633FUNCTION 634 bfd_get_reloc_upper_bound 635 636SYNOPSIS 637 long bfd_get_reloc_upper_bound (bfd *abfd, asection *sect); 638 639DESCRIPTION 640 Return the number of bytes required to store the 641 relocation information associated with section @var{sect} 642 attached to bfd @var{abfd}. If an error occurs, return -1. 643 644*/ 645 646long 647bfd_get_reloc_upper_bound (bfd *abfd, sec_ptr asect) 648{ 649 if (abfd->format != bfd_object) 650 { 651 bfd_set_error (bfd_error_invalid_operation); 652 return -1; 653 } 654 655 return BFD_SEND (abfd, _get_reloc_upper_bound, (abfd, asect)); 656} 657 658/* 659FUNCTION 660 bfd_canonicalize_reloc 661 662SYNOPSIS 663 long bfd_canonicalize_reloc 664 (bfd *abfd, asection *sec, arelent **loc, asymbol **syms); 665 666DESCRIPTION 667 Call the back end associated with the open BFD 668 @var{abfd} and translate the external form of the relocation 669 information attached to @var{sec} into the internal canonical 670 form. Place the table into memory at @var{loc}, which has 671 been preallocated, usually by a call to 672 <<bfd_get_reloc_upper_bound>>. Returns the number of relocs, or 673 -1 on error. 674 675 The @var{syms} table is also needed for horrible internal magic 676 reasons. 677 678*/ 679long 680bfd_canonicalize_reloc (bfd *abfd, 681 sec_ptr asect, 682 arelent **location, 683 asymbol **symbols) 684{ 685 if (abfd->format != bfd_object) 686 { 687 bfd_set_error (bfd_error_invalid_operation); 688 return -1; 689 } 690 691 return BFD_SEND (abfd, _bfd_canonicalize_reloc, 692 (abfd, asect, location, symbols)); 693} 694 695/* 696FUNCTION 697 bfd_set_reloc 698 699SYNOPSIS 700 void bfd_set_reloc 701 (bfd *abfd, asection *sec, arelent **rel, unsigned int count); 702 703DESCRIPTION 704 Set the relocation pointer and count within 705 section @var{sec} to the values @var{rel} and @var{count}. 706 The argument @var{abfd} is ignored. 707 708*/ 709 710void 711bfd_set_reloc (bfd *ignore_abfd ATTRIBUTE_UNUSED, 712 sec_ptr asect, 713 arelent **location, 714 unsigned int count) 715{ 716 asect->orelocation = location; 717 asect->reloc_count = count; 718} 719 720/* 721FUNCTION 722 bfd_set_file_flags 723 724SYNOPSIS 725 bfd_boolean bfd_set_file_flags (bfd *abfd, flagword flags); 726 727DESCRIPTION 728 Set the flag word in the BFD @var{abfd} to the value @var{flags}. 729 730 Possible errors are: 731 o <<bfd_error_wrong_format>> - The target bfd was not of object format. 732 o <<bfd_error_invalid_operation>> - The target bfd was open for reading. 733 o <<bfd_error_invalid_operation>> - 734 The flag word contained a bit which was not applicable to the 735 type of file. E.g., an attempt was made to set the <<D_PAGED>> bit 736 on a BFD format which does not support demand paging. 737 738*/ 739 740bfd_boolean 741bfd_set_file_flags (bfd *abfd, flagword flags) 742{ 743 if (abfd->format != bfd_object) 744 { 745 bfd_set_error (bfd_error_wrong_format); 746 return FALSE; 747 } 748 749 if (bfd_read_p (abfd)) 750 { 751 bfd_set_error (bfd_error_invalid_operation); 752 return FALSE; 753 } 754 755 bfd_get_file_flags (abfd) = flags; 756 if ((flags & bfd_applicable_file_flags (abfd)) != flags) 757 { 758 bfd_set_error (bfd_error_invalid_operation); 759 return FALSE; 760 } 761 762 return TRUE; 763} 764 765void 766bfd_assert (const char *file, int line) 767{ 768 (*_bfd_error_handler) (_("BFD %s assertion fail %s:%d"), 769 BFD_VERSION_STRING, file, line); 770} 771 772/* A more or less friendly abort message. In libbfd.h abort is 773 defined to call this function. */ 774 775#ifndef EXIT_FAILURE 776#define EXIT_FAILURE 1 777#endif 778 779void 780_bfd_abort (const char *file, int line, const char *fn) 781{ 782 if (fn != NULL) 783 (*_bfd_error_handler) 784 (_("BFD %s internal error, aborting at %s line %d in %s\n"), 785 BFD_VERSION_STRING, file, line, fn); 786 else 787 (*_bfd_error_handler) 788 (_("BFD %s internal error, aborting at %s line %d\n"), 789 BFD_VERSION_STRING, file, line); 790 (*_bfd_error_handler) (_("Please report this bug.\n")); 791 xexit (EXIT_FAILURE); 792} 793 794/* 795FUNCTION 796 bfd_get_arch_size 797 798SYNOPSIS 799 int bfd_get_arch_size (bfd *abfd); 800 801DESCRIPTION 802 Returns the architecture address size, in bits, as determined 803 by the object file's format. For ELF, this information is 804 included in the header. 805 806RETURNS 807 Returns the arch size in bits if known, <<-1>> otherwise. 808*/ 809 810int 811bfd_get_arch_size (bfd *abfd) 812{ 813 if (abfd->xvec->flavour == bfd_target_elf_flavour) 814 return get_elf_backend_data (abfd)->s->arch_size; 815 816 return -1; 817} 818 819/* 820FUNCTION 821 bfd_get_sign_extend_vma 822 823SYNOPSIS 824 int bfd_get_sign_extend_vma (bfd *abfd); 825 826DESCRIPTION 827 Indicates if the target architecture "naturally" sign extends 828 an address. Some architectures implicitly sign extend address 829 values when they are converted to types larger than the size 830 of an address. For instance, bfd_get_start_address() will 831 return an address sign extended to fill a bfd_vma when this is 832 the case. 833 834RETURNS 835 Returns <<1>> if the target architecture is known to sign 836 extend addresses, <<0>> if the target architecture is known to 837 not sign extend addresses, and <<-1>> otherwise. 838*/ 839 840int 841bfd_get_sign_extend_vma (bfd *abfd) 842{ 843 char *name; 844 845 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour) 846 return get_elf_backend_data (abfd)->sign_extend_vma; 847 848 name = bfd_get_target (abfd); 849 850 /* Return a proper value for DJGPP & PE COFF (x86 COFF variants). 851 This function is required for DWARF2 support, but there is 852 no place to store this information in the COFF back end. 853 Should enough other COFF targets add support for DWARF2, 854 a place will have to be found. Until then, this hack will do. */ 855 if (strncmp (name, "coff-go32", sizeof ("coff-go32") - 1) == 0 856 || strcmp (name, "pe-i386") == 0 857 || strcmp (name, "pei-i386") == 0) 858 return 1; 859 860 bfd_set_error (bfd_error_wrong_format); 861 return -1; 862} 863 864/* 865FUNCTION 866 bfd_set_start_address 867 868SYNOPSIS 869 bfd_boolean bfd_set_start_address (bfd *abfd, bfd_vma vma); 870 871DESCRIPTION 872 Make @var{vma} the entry point of output BFD @var{abfd}. 873 874RETURNS 875 Returns <<TRUE>> on success, <<FALSE>> otherwise. 876*/ 877 878bfd_boolean 879bfd_set_start_address (bfd *abfd, bfd_vma vma) 880{ 881 abfd->start_address = vma; 882 return TRUE; 883} 884 885/* 886FUNCTION 887 bfd_get_gp_size 888 889SYNOPSIS 890 unsigned int bfd_get_gp_size (bfd *abfd); 891 892DESCRIPTION 893 Return the maximum size of objects to be optimized using the GP 894 register under MIPS ECOFF. This is typically set by the <<-G>> 895 argument to the compiler, assembler or linker. 896*/ 897 898unsigned int 899bfd_get_gp_size (bfd *abfd) 900{ 901 if (abfd->format == bfd_object) 902 { 903 if (abfd->xvec->flavour == bfd_target_ecoff_flavour) 904 return ecoff_data (abfd)->gp_size; 905 else if (abfd->xvec->flavour == bfd_target_elf_flavour) 906 return elf_gp_size (abfd); 907 } 908 return 0; 909} 910 911/* 912FUNCTION 913 bfd_set_gp_size 914 915SYNOPSIS 916 void bfd_set_gp_size (bfd *abfd, unsigned int i); 917 918DESCRIPTION 919 Set the maximum size of objects to be optimized using the GP 920 register under ECOFF or MIPS ELF. This is typically set by 921 the <<-G>> argument to the compiler, assembler or linker. 922*/ 923 924void 925bfd_set_gp_size (bfd *abfd, unsigned int i) 926{ 927 /* Don't try to set GP size on an archive or core file! */ 928 if (abfd->format != bfd_object) 929 return; 930 931 if (abfd->xvec->flavour == bfd_target_ecoff_flavour) 932 ecoff_data (abfd)->gp_size = i; 933 else if (abfd->xvec->flavour == bfd_target_elf_flavour) 934 elf_gp_size (abfd) = i; 935} 936 937/* Get the GP value. This is an internal function used by some of the 938 relocation special_function routines on targets which support a GP 939 register. */ 940 941bfd_vma 942_bfd_get_gp_value (bfd *abfd) 943{ 944 if (! abfd) 945 return 0; 946 if (abfd->format != bfd_object) 947 return 0; 948 949 if (abfd->xvec->flavour == bfd_target_ecoff_flavour) 950 return ecoff_data (abfd)->gp; 951 else if (abfd->xvec->flavour == bfd_target_elf_flavour) 952 return elf_gp (abfd); 953 954 return 0; 955} 956 957/* Set the GP value. */ 958 959void 960_bfd_set_gp_value (bfd *abfd, bfd_vma v) 961{ 962 if (! abfd) 963 BFD_FAIL (); 964 if (abfd->format != bfd_object) 965 return; 966 967 if (abfd->xvec->flavour == bfd_target_ecoff_flavour) 968 ecoff_data (abfd)->gp = v; 969 else if (abfd->xvec->flavour == bfd_target_elf_flavour) 970 elf_gp (abfd) = v; 971} 972 973/* 974FUNCTION 975 bfd_scan_vma 976 977SYNOPSIS 978 bfd_vma bfd_scan_vma (const char *string, const char **end, int base); 979 980DESCRIPTION 981 Convert, like <<strtoul>>, a numerical expression 982 @var{string} into a <<bfd_vma>> integer, and return that integer. 983 (Though without as many bells and whistles as <<strtoul>>.) 984 The expression is assumed to be unsigned (i.e., positive). 985 If given a @var{base}, it is used as the base for conversion. 986 A base of 0 causes the function to interpret the string 987 in hex if a leading "0x" or "0X" is found, otherwise 988 in octal if a leading zero is found, otherwise in decimal. 989 990 If the value would overflow, the maximum <<bfd_vma>> value is 991 returned. 992*/ 993 994bfd_vma 995bfd_scan_vma (const char *string, const char **end, int base) 996{ 997 bfd_vma value; 998 bfd_vma cutoff; 999 unsigned int cutlim; 1000 int overflow; 1001 1002 /* Let the host do it if possible. */ 1003 if (sizeof (bfd_vma) <= sizeof (unsigned long)) 1004 return strtoul (string, (char **) end, base); 1005 1006#ifdef HAVE_STRTOULL 1007 if (sizeof (bfd_vma) <= sizeof (unsigned long long)) 1008 return strtoull (string, (char **) end, base); 1009#endif 1010 1011 if (base == 0) 1012 { 1013 if (string[0] == '0') 1014 { 1015 if ((string[1] == 'x') || (string[1] == 'X')) 1016 base = 16; 1017 else 1018 base = 8; 1019 } 1020 } 1021 1022 if ((base < 2) || (base > 36)) 1023 base = 10; 1024 1025 if (base == 16 1026 && string[0] == '0' 1027 && (string[1] == 'x' || string[1] == 'X') 1028 && ISXDIGIT (string[2])) 1029 { 1030 string += 2; 1031 } 1032 1033 cutoff = (~ (bfd_vma) 0) / (bfd_vma) base; 1034 cutlim = (~ (bfd_vma) 0) % (bfd_vma) base; 1035 value = 0; 1036 overflow = 0; 1037 while (1) 1038 { 1039 unsigned int digit; 1040 1041 digit = *string; 1042 if (ISDIGIT (digit)) 1043 digit = digit - '0'; 1044 else if (ISALPHA (digit)) 1045 digit = TOUPPER (digit) - 'A' + 10; 1046 else 1047 break; 1048 if (digit >= (unsigned int) base) 1049 break; 1050 if (value > cutoff || (value == cutoff && digit > cutlim)) 1051 overflow = 1; 1052 value = value * base + digit; 1053 ++string; 1054 } 1055 1056 if (overflow) 1057 value = ~ (bfd_vma) 0; 1058 1059 if (end != NULL) 1060 *end = string; 1061 1062 return value; 1063} 1064 1065/* 1066FUNCTION 1067 bfd_copy_private_header_data 1068 1069SYNOPSIS 1070 bfd_boolean bfd_copy_private_header_data (bfd *ibfd, bfd *obfd); 1071 1072DESCRIPTION 1073 Copy private BFD header information from the BFD @var{ibfd} to the 1074 the BFD @var{obfd}. This copies information that may require 1075 sections to exist, but does not require symbol tables. Return 1076 <<true>> on success, <<false>> on error. 1077 Possible error returns are: 1078 1079 o <<bfd_error_no_memory>> - 1080 Not enough memory exists to create private data for @var{obfd}. 1081 1082.#define bfd_copy_private_header_data(ibfd, obfd) \ 1083. BFD_SEND (obfd, _bfd_copy_private_header_data, \ 1084. (ibfd, obfd)) 1085 1086*/ 1087 1088/* 1089FUNCTION 1090 bfd_copy_private_bfd_data 1091 1092SYNOPSIS 1093 bfd_boolean bfd_copy_private_bfd_data (bfd *ibfd, bfd *obfd); 1094 1095DESCRIPTION 1096 Copy private BFD information from the BFD @var{ibfd} to the 1097 the BFD @var{obfd}. Return <<TRUE>> on success, <<FALSE>> on error. 1098 Possible error returns are: 1099 1100 o <<bfd_error_no_memory>> - 1101 Not enough memory exists to create private data for @var{obfd}. 1102 1103.#define bfd_copy_private_bfd_data(ibfd, obfd) \ 1104. BFD_SEND (obfd, _bfd_copy_private_bfd_data, \ 1105. (ibfd, obfd)) 1106 1107*/ 1108 1109/* 1110FUNCTION 1111 bfd_merge_private_bfd_data 1112 1113SYNOPSIS 1114 bfd_boolean bfd_merge_private_bfd_data (bfd *ibfd, bfd *obfd); 1115 1116DESCRIPTION 1117 Merge private BFD information from the BFD @var{ibfd} to the 1118 the output file BFD @var{obfd} when linking. Return <<TRUE>> 1119 on success, <<FALSE>> on error. Possible error returns are: 1120 1121 o <<bfd_error_no_memory>> - 1122 Not enough memory exists to create private data for @var{obfd}. 1123 1124.#define bfd_merge_private_bfd_data(ibfd, obfd) \ 1125. BFD_SEND (obfd, _bfd_merge_private_bfd_data, \ 1126. (ibfd, obfd)) 1127 1128*/ 1129 1130/* 1131FUNCTION 1132 bfd_set_private_flags 1133 1134SYNOPSIS 1135 bfd_boolean bfd_set_private_flags (bfd *abfd, flagword flags); 1136 1137DESCRIPTION 1138 Set private BFD flag information in the BFD @var{abfd}. 1139 Return <<TRUE>> on success, <<FALSE>> on error. Possible error 1140 returns are: 1141 1142 o <<bfd_error_no_memory>> - 1143 Not enough memory exists to create private data for @var{obfd}. 1144 1145.#define bfd_set_private_flags(abfd, flags) \ 1146. BFD_SEND (abfd, _bfd_set_private_flags, (abfd, flags)) 1147 1148*/ 1149 1150/* 1151FUNCTION 1152 Other functions 1153 1154DESCRIPTION 1155 The following functions exist but have not yet been documented. 1156 1157.#define bfd_sizeof_headers(abfd, reloc) \ 1158. BFD_SEND (abfd, _bfd_sizeof_headers, (abfd, reloc)) 1159. 1160.#define bfd_find_nearest_line(abfd, sec, syms, off, file, func, line) \ 1161. BFD_SEND (abfd, _bfd_find_nearest_line, \ 1162. (abfd, sec, syms, off, file, func, line)) 1163. 1164.#define bfd_debug_info_start(abfd) \ 1165. BFD_SEND (abfd, _bfd_debug_info_start, (abfd)) 1166. 1167.#define bfd_debug_info_end(abfd) \ 1168. BFD_SEND (abfd, _bfd_debug_info_end, (abfd)) 1169. 1170.#define bfd_debug_info_accumulate(abfd, section) \ 1171. BFD_SEND (abfd, _bfd_debug_info_accumulate, (abfd, section)) 1172. 1173.#define bfd_stat_arch_elt(abfd, stat) \ 1174. BFD_SEND (abfd, _bfd_stat_arch_elt,(abfd, stat)) 1175. 1176.#define bfd_update_armap_timestamp(abfd) \ 1177. BFD_SEND (abfd, _bfd_update_armap_timestamp, (abfd)) 1178. 1179.#define bfd_set_arch_mach(abfd, arch, mach)\ 1180. BFD_SEND ( abfd, _bfd_set_arch_mach, (abfd, arch, mach)) 1181. 1182.#define bfd_relax_section(abfd, section, link_info, again) \ 1183. BFD_SEND (abfd, _bfd_relax_section, (abfd, section, link_info, again)) 1184. 1185.#define bfd_gc_sections(abfd, link_info) \ 1186. BFD_SEND (abfd, _bfd_gc_sections, (abfd, link_info)) 1187. 1188.#define bfd_merge_sections(abfd, link_info) \ 1189. BFD_SEND (abfd, _bfd_merge_sections, (abfd, link_info)) 1190. 1191.#define bfd_is_group_section(abfd, sec) \ 1192. BFD_SEND (abfd, _bfd_is_group_section, (abfd, sec)) 1193. 1194.#define bfd_discard_group(abfd, sec) \ 1195. BFD_SEND (abfd, _bfd_discard_group, (abfd, sec)) 1196. 1197.#define bfd_link_hash_table_create(abfd) \ 1198. BFD_SEND (abfd, _bfd_link_hash_table_create, (abfd)) 1199. 1200.#define bfd_link_hash_table_free(abfd, hash) \ 1201. BFD_SEND (abfd, _bfd_link_hash_table_free, (hash)) 1202. 1203.#define bfd_link_add_symbols(abfd, info) \ 1204. BFD_SEND (abfd, _bfd_link_add_symbols, (abfd, info)) 1205. 1206.#define bfd_link_just_syms(sec, info) \ 1207. BFD_SEND (abfd, _bfd_link_just_syms, (sec, info)) 1208. 1209.#define bfd_final_link(abfd, info) \ 1210. BFD_SEND (abfd, _bfd_final_link, (abfd, info)) 1211. 1212.#define bfd_free_cached_info(abfd) \ 1213. BFD_SEND (abfd, _bfd_free_cached_info, (abfd)) 1214. 1215.#define bfd_get_dynamic_symtab_upper_bound(abfd) \ 1216. BFD_SEND (abfd, _bfd_get_dynamic_symtab_upper_bound, (abfd)) 1217. 1218.#define bfd_print_private_bfd_data(abfd, file)\ 1219. BFD_SEND (abfd, _bfd_print_private_bfd_data, (abfd, file)) 1220. 1221.#define bfd_canonicalize_dynamic_symtab(abfd, asymbols) \ 1222. BFD_SEND (abfd, _bfd_canonicalize_dynamic_symtab, (abfd, asymbols)) 1223. 1224.#define bfd_get_synthetic_symtab(abfd, count, syms, dyncount, dynsyms, ret) \ 1225. BFD_SEND (abfd, _bfd_get_synthetic_symtab, (abfd, count, syms, \ 1226. dyncount, dynsyms, ret)) 1227. 1228.#define bfd_get_dynamic_reloc_upper_bound(abfd) \ 1229. BFD_SEND (abfd, _bfd_get_dynamic_reloc_upper_bound, (abfd)) 1230. 1231.#define bfd_canonicalize_dynamic_reloc(abfd, arels, asyms) \ 1232. BFD_SEND (abfd, _bfd_canonicalize_dynamic_reloc, (abfd, arels, asyms)) 1233. 1234.extern bfd_byte *bfd_get_relocated_section_contents 1235. (bfd *, struct bfd_link_info *, struct bfd_link_order *, bfd_byte *, 1236. bfd_boolean, asymbol **); 1237. 1238 1239*/ 1240 1241bfd_byte * 1242bfd_get_relocated_section_contents (bfd *abfd, 1243 struct bfd_link_info *link_info, 1244 struct bfd_link_order *link_order, 1245 bfd_byte *data, 1246 bfd_boolean relocatable, 1247 asymbol **symbols) 1248{ 1249 bfd *abfd2; 1250 bfd_byte *(*fn) (bfd *, struct bfd_link_info *, struct bfd_link_order *, 1251 bfd_byte *, bfd_boolean, asymbol **); 1252 1253 if (link_order->type == bfd_indirect_link_order) 1254 { 1255 abfd2 = link_order->u.indirect.section->owner; 1256 if (abfd2 == NULL) 1257 abfd2 = abfd; 1258 } 1259 else 1260 abfd2 = abfd; 1261 1262 fn = abfd2->xvec->_bfd_get_relocated_section_contents; 1263 1264 return (*fn) (abfd, link_info, link_order, data, relocatable, symbols); 1265} 1266 1267/* Record information about an ELF program header. */ 1268 1269bfd_boolean 1270bfd_record_phdr (bfd *abfd, 1271 unsigned long type, 1272 bfd_boolean flags_valid, 1273 flagword flags, 1274 bfd_boolean at_valid, 1275 bfd_vma at, 1276 bfd_boolean includes_filehdr, 1277 bfd_boolean includes_phdrs, 1278 unsigned int count, 1279 asection **secs) 1280{ 1281 struct elf_segment_map *m, **pm; 1282 bfd_size_type amt; 1283 1284 if (bfd_get_flavour (abfd) != bfd_target_elf_flavour) 1285 return TRUE; 1286 1287 amt = sizeof (struct elf_segment_map); 1288 amt += ((bfd_size_type) count - 1) * sizeof (asection *); 1289 m = bfd_alloc (abfd, amt); 1290 if (m == NULL) 1291 return FALSE; 1292 1293 m->next = NULL; 1294 m->p_type = type; 1295 m->p_flags = flags; 1296 m->p_paddr = at; 1297 m->p_flags_valid = flags_valid; 1298 m->p_paddr_valid = at_valid; 1299 m->includes_filehdr = includes_filehdr; 1300 m->includes_phdrs = includes_phdrs; 1301 m->count = count; 1302 if (count > 0) 1303 memcpy (m->sections, secs, count * sizeof (asection *)); 1304 1305 for (pm = &elf_tdata (abfd)->segment_map; *pm != NULL; pm = &(*pm)->next) 1306 ; 1307 *pm = m; 1308 1309 return TRUE; 1310} 1311 1312void 1313bfd_sprintf_vma (bfd *abfd, char *buf, bfd_vma value) 1314{ 1315 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour) 1316 get_elf_backend_data (abfd)->elf_backend_sprintf_vma (abfd, buf, value); 1317 else 1318 sprintf_vma (buf, value); 1319} 1320 1321void 1322bfd_fprintf_vma (bfd *abfd, void *stream, bfd_vma value) 1323{ 1324 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour) 1325 get_elf_backend_data (abfd)->elf_backend_fprintf_vma (abfd, stream, value); 1326 else 1327 fprintf_vma ((FILE *) stream, value); 1328} 1329 1330/* 1331FUNCTION 1332 bfd_alt_mach_code 1333 1334SYNOPSIS 1335 bfd_boolean bfd_alt_mach_code (bfd *abfd, int alternative); 1336 1337DESCRIPTION 1338 1339 When more than one machine code number is available for the 1340 same machine type, this function can be used to switch between 1341 the preferred one (alternative == 0) and any others. Currently, 1342 only ELF supports this feature, with up to two alternate 1343 machine codes. 1344*/ 1345 1346bfd_boolean 1347bfd_alt_mach_code (bfd *abfd, int alternative) 1348{ 1349 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour) 1350 { 1351 int code; 1352 1353 switch (alternative) 1354 { 1355 case 0: 1356 code = get_elf_backend_data (abfd)->elf_machine_code; 1357 break; 1358 1359 case 1: 1360 code = get_elf_backend_data (abfd)->elf_machine_alt1; 1361 if (code == 0) 1362 return FALSE; 1363 break; 1364 1365 case 2: 1366 code = get_elf_backend_data (abfd)->elf_machine_alt2; 1367 if (code == 0) 1368 return FALSE; 1369 break; 1370 1371 default: 1372 return FALSE; 1373 } 1374 1375 elf_elfheader (abfd)->e_machine = code; 1376 1377 return TRUE; 1378 } 1379 1380 return FALSE; 1381} 1382 1383/* 1384CODE_FRAGMENT 1385 1386.struct bfd_preserve 1387.{ 1388. void *marker; 1389. void *tdata; 1390. flagword flags; 1391. const struct bfd_arch_info *arch_info; 1392. struct bfd_section *sections; 1393. struct bfd_section **section_tail; 1394. unsigned int section_count; 1395. struct bfd_hash_table section_htab; 1396.}; 1397. 1398*/ 1399 1400/* 1401FUNCTION 1402 bfd_preserve_save 1403 1404SYNOPSIS 1405 bfd_boolean bfd_preserve_save (bfd *, struct bfd_preserve *); 1406 1407DESCRIPTION 1408 When testing an object for compatibility with a particular 1409 target back-end, the back-end object_p function needs to set 1410 up certain fields in the bfd on successfully recognizing the 1411 object. This typically happens in a piecemeal fashion, with 1412 failures possible at many points. On failure, the bfd is 1413 supposed to be restored to its initial state, which is 1414 virtually impossible. However, restoring a subset of the bfd 1415 state works in practice. This function stores the subset and 1416 reinitializes the bfd. 1417 1418*/ 1419 1420bfd_boolean 1421bfd_preserve_save (bfd *abfd, struct bfd_preserve *preserve) 1422{ 1423 preserve->tdata = abfd->tdata.any; 1424 preserve->arch_info = abfd->arch_info; 1425 preserve->flags = abfd->flags; 1426 preserve->sections = abfd->sections; 1427 preserve->section_tail = abfd->section_tail; 1428 preserve->section_count = abfd->section_count; 1429 preserve->section_htab = abfd->section_htab; 1430 1431 if (! bfd_hash_table_init (&abfd->section_htab, bfd_section_hash_newfunc)) 1432 return FALSE; 1433 1434 abfd->tdata.any = NULL; 1435 abfd->arch_info = &bfd_default_arch_struct; 1436 abfd->flags &= BFD_IN_MEMORY; 1437 abfd->sections = NULL; 1438 abfd->section_tail = &abfd->sections; 1439 abfd->section_count = 0; 1440 1441 return TRUE; 1442} 1443 1444/* 1445FUNCTION 1446 bfd_preserve_restore 1447 1448SYNOPSIS 1449 void bfd_preserve_restore (bfd *, struct bfd_preserve *); 1450 1451DESCRIPTION 1452 This function restores bfd state saved by bfd_preserve_save. 1453 If MARKER is non-NULL in struct bfd_preserve then that block 1454 and all subsequently bfd_alloc'd memory is freed. 1455 1456*/ 1457 1458void 1459bfd_preserve_restore (bfd *abfd, struct bfd_preserve *preserve) 1460{ 1461 bfd_hash_table_free (&abfd->section_htab); 1462 1463 abfd->tdata.any = preserve->tdata; 1464 abfd->arch_info = preserve->arch_info; 1465 abfd->flags = preserve->flags; 1466 abfd->section_htab = preserve->section_htab; 1467 abfd->sections = preserve->sections; 1468 abfd->section_tail = preserve->section_tail; 1469 abfd->section_count = preserve->section_count; 1470 1471 /* bfd_release frees all memory more recently bfd_alloc'd than 1472 its arg, as well as its arg. */ 1473 if (preserve->marker != NULL) 1474 { 1475 bfd_release (abfd, preserve->marker); 1476 preserve->marker = NULL; 1477 } 1478} 1479 1480/* 1481FUNCTION 1482 bfd_preserve_finish 1483 1484SYNOPSIS 1485 void bfd_preserve_finish (bfd *, struct bfd_preserve *); 1486 1487DESCRIPTION 1488 This function should be called when the bfd state saved by 1489 bfd_preserve_save is no longer needed. ie. when the back-end 1490 object_p function returns with success. 1491 1492*/ 1493 1494void 1495bfd_preserve_finish (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_preserve *preserve) 1496{ 1497 /* It would be nice to be able to free more memory here, eg. old 1498 tdata, but that's not possible since these blocks are sitting 1499 inside bfd_alloc'd memory. The section hash is on a separate 1500 objalloc. */ 1501 bfd_hash_table_free (&preserve->section_htab); 1502} 1503