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