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