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