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