| bfd.c (107492) | bfd.c (130561) |
|---|---|
| 1/* Generic BFD library interface and support routines. 2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, | 1/* Generic BFD library interface and support routines. 2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, |
| 3 2000, 2001, 2002 | 3 2000, 2001, 2002, 2003 |
| 4 Free Software Foundation, Inc. 5 Written by Cygnus Support. 6 | 4 Free Software Foundation, Inc. 5 Written by Cygnus Support. 6 |
| 7This file is part of BFD, the Binary File Descriptor library. | 7 This file is part of BFD, the Binary File Descriptor library. |
| 8 | 8 |
| 9This program is free software; you can redistribute it and/or modify 10it under the terms of the GNU General Public License as published by 11the Free Software Foundation; either version 2 of the License, or 12(at your option) any later version. | 9 This program is free software; you can redistribute it and/or modify 10 it under the terms of the GNU General Public License as published by 11 the Free Software Foundation; either version 2 of the License, or 12 (at your option) any later version. |
| 13 | 13 |
| 14This program is distributed in the hope that it will be useful, 15but WITHOUT ANY WARRANTY; without even the implied warranty of 16MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17GNU General Public License for more details. | 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 | 18 |
| 19You should have received a copy of the GNU General Public License 20along with this program; if not, write to the Free Software 21Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ | 19 You should have received a copy of the GNU General Public License 20 along with this program; if not, write to the Free Software 21 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ |
| 22 23/* 24SECTION 25 <<typedef bfd>> 26 27 A BFD has type <<bfd>>; objects of this type are the 28 cornerstone of any application using BFD. Using BFD 29 consists of making references though the BFD and to data in the BFD. 30 31 Here is the structure that defines the type <<bfd>>. It 32 contains the major data about the file and pointers 33 to the rest of the data. 34 35CODE_FRAGMENT 36. | 22 23/* 24SECTION 25 <<typedef bfd>> 26 27 A BFD has type <<bfd>>; objects of this type are the 28 cornerstone of any application using BFD. Using BFD 29 consists of making references though the BFD and to data in the BFD. 30 31 Here is the structure that defines the type <<bfd>>. It 32 contains the major data about the file and pointers 33 to the rest of the data. 34 35CODE_FRAGMENT 36. |
| 37.struct _bfd | 37.struct bfd |
| 38.{ | 38.{ |
| 39. {* A unique identifier of the BFD *} 40. unsigned int id; 41. |
|
| 39. {* The filename the application opened the BFD with. *} 40. const char *filename; 41. 42. {* A pointer to the target jump table. *} 43. const struct bfd_target *xvec; 44. 45. {* To avoid dragging too many header files into every file that 46. includes `<<bfd.h>>', IOSTREAM has been declared as a "char *", 47. and MTIME as a "long". Their correct types, to which they 48. are cast when used, are "FILE *" and "time_t". The iostream 49. is the result of an fopen on the filename. However, if the 50. BFD_IN_MEMORY flag is set, then iostream is actually a pointer 51. to a bfd_in_memory struct. *} | 42. {* The filename the application opened the BFD with. *} 43. const char *filename; 44. 45. {* A pointer to the target jump table. *} 46. const struct bfd_target *xvec; 47. 48. {* To avoid dragging too many header files into every file that 49. includes `<<bfd.h>>', IOSTREAM has been declared as a "char *", 50. and MTIME as a "long". Their correct types, to which they 51. are cast when used, are "FILE *" and "time_t". The iostream 52. is the result of an fopen on the filename. However, if the 53. BFD_IN_MEMORY flag is set, then iostream is actually a pointer 54. to a bfd_in_memory struct. *} |
| 52. PTR iostream; | 55. void *iostream; |
| 53. 54. {* Is the file descriptor being cached? That is, can it be closed as 55. needed, and re-opened when accessed later? *} | 56. 57. {* Is the file descriptor being cached? That is, can it be closed as 58. needed, and re-opened when accessed later? *} |
| 56. boolean cacheable; | 59. bfd_boolean cacheable; |
| 57. 58. {* Marks whether there was a default target specified when the 59. BFD was opened. This is used to select which matching algorithm 60. to use to choose the back end. *} | 60. 61. {* Marks whether there was a default target specified when the 62. BFD was opened. This is used to select which matching algorithm 63. to use to choose the back end. *} |
| 61. boolean target_defaulted; | 64. bfd_boolean target_defaulted; |
| 62. 63. {* The caching routines use these to maintain a 64. least-recently-used list of BFDs. *} | 65. 66. {* The caching routines use these to maintain a 67. least-recently-used list of BFDs. *} |
| 65. struct _bfd *lru_prev, *lru_next; | 68. struct bfd *lru_prev, *lru_next; |
| 66. 67. {* When a file is closed by the caching routines, BFD retains 68. state information on the file here... *} 69. ufile_ptr where; 70. 71. {* ... and here: (``once'' means at least once). *} | 69. 70. {* When a file is closed by the caching routines, BFD retains 71. state information on the file here... *} 72. ufile_ptr where; 73. 74. {* ... and here: (``once'' means at least once). *} |
| 72. boolean opened_once; | 75. bfd_boolean opened_once; |
| 73. 74. {* Set if we have a locally maintained mtime value, rather than 75. getting it from the file each time. *} | 76. 77. {* Set if we have a locally maintained mtime value, rather than 78. getting it from the file each time. *} |
| 76. boolean mtime_set; | 79. bfd_boolean mtime_set; |
| 77. | 80. |
| 78. {* File modified time, if mtime_set is true. *} | 81. {* File modified time, if mtime_set is TRUE. *} |
| 79. long mtime; 80. 81. {* Reserved for an unimplemented file locking extension. *} 82. int ifd; 83. 84. {* The format which belongs to the BFD. (object, core, etc.) *} 85. bfd_format format; 86. --- 12 unchanged lines hidden (view full) --- 99. 100. {* Currently my_archive is tested before adding origin to 101. anything. I believe that this can become always an add of 102. origin, with origin set to 0 for non archive files. *} 103. ufile_ptr origin; 104. 105. {* Remember when output has begun, to stop strange things 106. from happening. *} | 82. long mtime; 83. 84. {* Reserved for an unimplemented file locking extension. *} 85. int ifd; 86. 87. {* The format which belongs to the BFD. (object, core, etc.) *} 88. bfd_format format; 89. --- 12 unchanged lines hidden (view full) --- 102. 103. {* Currently my_archive is tested before adding origin to 104. anything. I believe that this can become always an add of 105. origin, with origin set to 0 for non archive files. *} 106. ufile_ptr origin; 107. 108. {* Remember when output has begun, to stop strange things 109. from happening. *} |
| 107. boolean output_has_begun; | 110. bfd_boolean output_has_begun; |
| 108. 109. {* A hash table for section names. *} 110. struct bfd_hash_table section_htab; 111. 112. {* Pointer to linked list of sections. *} | 111. 112. {* A hash table for section names. *} 113. struct bfd_hash_table section_htab; 114. 115. {* Pointer to linked list of sections. *} |
| 113. struct sec *sections; | 116. struct bfd_section *sections; |
| 114. 115. {* The place where we add to the section list. *} | 117. 118. {* The place where we add to the section list. *} |
| 116. struct sec **section_tail; | 119. struct bfd_section **section_tail; |
| 117. 118. {* The number of sections. *} 119. unsigned int section_count; 120. 121. {* Stuff only useful for object files: 122. The start address. *} 123. bfd_vma start_address; 124. 125. {* Used for input and output. *} 126. unsigned int symcount; 127. 128. {* Symbol table for output BFD (with symcount entries). *} | 120. 121. {* The number of sections. *} 122. unsigned int section_count; 123. 124. {* Stuff only useful for object files: 125. The start address. *} 126. bfd_vma start_address; 127. 128. {* Used for input and output. *} 129. unsigned int symcount; 130. 131. {* Symbol table for output BFD (with symcount entries). *} |
| 129. struct symbol_cache_entry **outsymbols; | 132. struct bfd_symbol **outsymbols; |
| 130. 131. {* Used for slurped dynamic symbol tables. *} 132. unsigned int dynsymcount; 133. 134. {* Pointer to structure which contains architecture information. *} 135. const struct bfd_arch_info *arch_info; 136. 137. {* Stuff only useful for archives. *} | 133. 134. {* Used for slurped dynamic symbol tables. *} 135. unsigned int dynsymcount; 136. 137. {* Pointer to structure which contains architecture information. *} 138. const struct bfd_arch_info *arch_info; 139. 140. {* Stuff only useful for archives. *} |
| 138. PTR arelt_data; 139. struct _bfd *my_archive; {* The containing archive BFD. *} 140. struct _bfd *next; {* The next BFD in the archive. *} 141. struct _bfd *archive_head; {* The first BFD in the archive. *} 142. boolean has_armap; | 141. void *arelt_data; 142. struct bfd *my_archive; {* The containing archive BFD. *} 143. struct bfd *next; {* The next BFD in the archive. *} 144. struct bfd *archive_head; {* The first BFD in the archive. *} 145. bfd_boolean has_armap; |
| 143. 144. {* A chain of BFD structures involved in a link. *} | 146. 147. {* A chain of BFD structures involved in a link. *} |
| 145. struct _bfd *link_next; | 148. struct bfd *link_next; |
| 146. 147. {* A field used by _bfd_generic_link_add_archive_symbols. This will 148. be used only for archive elements. *} 149. int archive_pass; 150. 151. {* Used by the back end to hold private data. *} 152. union 153. { --- 21 unchanged lines hidden (view full) --- 175. struct hpux_core_struct *hpux_core_data; 176. struct hppabsd_core_struct *hppabsd_core_data; 177. struct sgi_core_struct *sgi_core_data; 178. struct lynx_core_struct *lynx_core_data; 179. struct osf_core_struct *osf_core_data; 180. struct cisco_core_struct *cisco_core_data; 181. struct versados_data_struct *versados_data; 182. struct netbsd_core_struct *netbsd_core_data; | 149. 150. {* A field used by _bfd_generic_link_add_archive_symbols. This will 151. be used only for archive elements. *} 152. int archive_pass; 153. 154. {* Used by the back end to hold private data. *} 155. union 156. { --- 21 unchanged lines hidden (view full) --- 178. struct hpux_core_struct *hpux_core_data; 179. struct hppabsd_core_struct *hppabsd_core_data; 180. struct sgi_core_struct *sgi_core_data; 181. struct lynx_core_struct *lynx_core_data; 182. struct osf_core_struct *osf_core_data; 183. struct cisco_core_struct *cisco_core_data; 184. struct versados_data_struct *versados_data; 185. struct netbsd_core_struct *netbsd_core_data; |
| 183. PTR any; | 186. struct mach_o_data_struct *mach_o_data; 187. struct mach_o_fat_data_struct *mach_o_fat_data; 188. struct bfd_pef_data_struct *pef_data; 189. struct bfd_pef_xlib_data_struct *pef_xlib_data; 190. struct bfd_sym_data_struct *sym_data; 191. void *any; |
| 184. } 185. tdata; 186. 187. {* Used by the application to hold private data. *} | 192. } 193. tdata; 194. 195. {* Used by the application to hold private data. *} |
| 188. PTR usrdata; | 196. void *usrdata; |
| 189. 190. {* Where all the allocated stuff under this BFD goes. This is a | 197. 198. {* Where all the allocated stuff under this BFD goes. This is a |
| 191. struct objalloc *, but we use PTR to avoid requiring the inclusion of 192. objalloc.h. *} 193. PTR memory; | 199. struct objalloc *, but we use void * to avoid requiring the inclusion 200. of objalloc.h. *} 201. void *memory; |
| 194.}; 195. 196*/ 197 198#include "bfd.h" | 202.}; 203. 204*/ 205 206#include "bfd.h" |
| 207#include "bfdver.h" |
|
| 199#include "sysdep.h" | 208#include "sysdep.h" |
| 200 201#ifdef ANSI_PROTOTYPES | |
| 202#include <stdarg.h> | 209#include <stdarg.h> |
| 203#else 204#include <varargs.h> 205#endif 206 | |
| 207#include "libiberty.h" 208#include "safe-ctype.h" 209#include "bfdlink.h" 210#include "libbfd.h" 211#include "coff/internal.h" 212#include "coff/sym.h" 213#include "libcoff.h" 214#include "libecoff.h" --- 88 unchanged lines hidden (view full) --- 303SYNOPSIS 304 bfd_error_type bfd_get_error (void); 305 306DESCRIPTION 307 Return the current BFD error condition. 308*/ 309 310bfd_error_type | 210#include "libiberty.h" 211#include "safe-ctype.h" 212#include "bfdlink.h" 213#include "libbfd.h" 214#include "coff/internal.h" 215#include "coff/sym.h" 216#include "libcoff.h" 217#include "libecoff.h" --- 88 unchanged lines hidden (view full) --- 306SYNOPSIS 307 bfd_error_type bfd_get_error (void); 308 309DESCRIPTION 310 Return the current BFD error condition. 311*/ 312 313bfd_error_type |
| 311bfd_get_error () | 314bfd_get_error (void) |
| 312{ 313 return bfd_error; 314} 315 316/* 317FUNCTION 318 bfd_set_error 319 320SYNOPSIS 321 void bfd_set_error (bfd_error_type error_tag); 322 323DESCRIPTION 324 Set the BFD error condition to be @var{error_tag}. 325*/ 326 327void | 315{ 316 return bfd_error; 317} 318 319/* 320FUNCTION 321 bfd_set_error 322 323SYNOPSIS 324 void bfd_set_error (bfd_error_type error_tag); 325 326DESCRIPTION 327 Set the BFD error condition to be @var{error_tag}. 328*/ 329 330void |
| 328bfd_set_error (error_tag) 329 bfd_error_type error_tag; | 331bfd_set_error (bfd_error_type error_tag) |
| 330{ 331 bfd_error = error_tag; 332} 333 334/* 335FUNCTION 336 bfd_errmsg 337 338SYNOPSIS 339 const char *bfd_errmsg (bfd_error_type error_tag); 340 341DESCRIPTION 342 Return a string describing the error @var{error_tag}, or 343 the system error if @var{error_tag} is <<bfd_error_system_call>>. 344*/ 345 346const char * | 332{ 333 bfd_error = error_tag; 334} 335 336/* 337FUNCTION 338 bfd_errmsg 339 340SYNOPSIS 341 const char *bfd_errmsg (bfd_error_type error_tag); 342 343DESCRIPTION 344 Return a string describing the error @var{error_tag}, or 345 the system error if @var{error_tag} is <<bfd_error_system_call>>. 346*/ 347 348const char * |
| 347bfd_errmsg (error_tag) 348 bfd_error_type error_tag; | 349bfd_errmsg (bfd_error_type error_tag) |
| 349{ 350#ifndef errno 351 extern int errno; 352#endif 353 if (error_tag == bfd_error_system_call) 354 return xstrerror (errno); 355 | 350{ 351#ifndef errno 352 extern int errno; 353#endif 354 if (error_tag == bfd_error_system_call) 355 return xstrerror (errno); 356 |
| 356 if ((((int) error_tag < (int) bfd_error_no_error) || 357 ((int) error_tag > (int) bfd_error_invalid_error_code))) 358 error_tag = bfd_error_invalid_error_code;/* sanity check */ | 357 if (error_tag > bfd_error_invalid_error_code) 358 error_tag = bfd_error_invalid_error_code; /* sanity check */ |
| 359 | 359 |
| 360 return _(bfd_errmsgs [(int)error_tag]); | 360 return _(bfd_errmsgs [error_tag]); |
| 361} 362 363/* 364FUNCTION 365 bfd_perror 366 367SYNOPSIS 368 void bfd_perror (const char *message); 369 370DESCRIPTION 371 Print to the standard error stream a string describing the 372 last BFD error that occurred, or the last system error if 373 the last BFD error was a system call failure. If @var{message} 374 is non-NULL and non-empty, the error string printed is preceded 375 by @var{message}, a colon, and a space. It is followed by a newline. 376*/ 377 378void | 361} 362 363/* 364FUNCTION 365 bfd_perror 366 367SYNOPSIS 368 void bfd_perror (const char *message); 369 370DESCRIPTION 371 Print to the standard error stream a string describing the 372 last BFD error that occurred, or the last system error if 373 the last BFD error was a system call failure. If @var{message} 374 is non-NULL and non-empty, the error string printed is preceded 375 by @var{message}, a colon, and a space. It is followed by a newline. 376*/ 377 378void |
| 379bfd_perror (message) 380 const char *message; | 379bfd_perror (const char *message) |
| 381{ 382 if (bfd_get_error () == bfd_error_system_call) 383 /* Must be a system error then. */ | 380{ 381 if (bfd_get_error () == bfd_error_system_call) 382 /* Must be a system error then. */ |
| 384 perror ((char *)message); | 383 perror ((char *) message); |
| 385 else 386 { 387 if (message == NULL || *message == '\0') 388 fprintf (stderr, "%s\n", bfd_errmsg (bfd_get_error ())); 389 else 390 fprintf (stderr, "%s: %s\n", message, bfd_errmsg (bfd_get_error ())); 391 } 392} 393 394/* 395SUBSECTION 396 BFD error handler 397 398 Some BFD functions want to print messages describing the 399 problem. They call a BFD error handler function. This | 384 else 385 { 386 if (message == NULL || *message == '\0') 387 fprintf (stderr, "%s\n", bfd_errmsg (bfd_get_error ())); 388 else 389 fprintf (stderr, "%s: %s\n", message, bfd_errmsg (bfd_get_error ())); 390 } 391} 392 393/* 394SUBSECTION 395 BFD error handler 396 397 Some BFD functions want to print messages describing the 398 problem. They call a BFD error handler function. This |
| 400 function may be overriden by the program. | 399 function may be overridden by the program. |
| 401 402 The BFD error handler acts like printf. 403 404CODE_FRAGMENT 405. | 400 401 The BFD error handler acts like printf. 402 403CODE_FRAGMENT 404. |
| 406.typedef void (*bfd_error_handler_type) PARAMS ((const char *, ...)); | 405.typedef void (*bfd_error_handler_type) (const char *, ...); |
| 407. 408*/ 409 410/* The program name used when printing BFD error messages. */ 411 412static const char *_bfd_error_program_name; 413 414/* This is the default routine to handle BFD error messages. */ 415 | 406. 407*/ 408 409/* The program name used when printing BFD error messages. */ 410 411static const char *_bfd_error_program_name; 412 413/* This is the default routine to handle BFD error messages. */ 414 |
| 416static void _bfd_default_error_handler PARAMS ((const char *s, ...)); 417 | |
| 418static void | 415static void |
| 419_bfd_default_error_handler VPARAMS ((const char *s, ...)) | 416_bfd_default_error_handler (const char *s, ...) |
| 420{ | 417{ |
| 418 va_list p; 419 |
|
| 421 if (_bfd_error_program_name != NULL) 422 fprintf (stderr, "%s: ", _bfd_error_program_name); 423 else 424 fprintf (stderr, "BFD: "); 425 | 420 if (_bfd_error_program_name != NULL) 421 fprintf (stderr, "%s: ", _bfd_error_program_name); 422 else 423 fprintf (stderr, "BFD: "); 424 |
| 426 VA_OPEN (p, s); 427 VA_FIXEDARG (p, const char *, s); | 425 va_start (p, s); |
| 428 vfprintf (stderr, s, p); | 426 vfprintf (stderr, s, p); |
| 429 VA_CLOSE (p); | 427 va_end (p); |
| 430 431 fprintf (stderr, "\n"); 432} 433 434/* This is a function pointer to the routine which should handle BFD 435 error messages. It is called when a BFD routine encounters an 436 error for which it wants to print a message. Going through a 437 function pointer permits a program linked against BFD to intercept --- 9 unchanged lines hidden (view full) --- 447 bfd_error_handler_type bfd_set_error_handler (bfd_error_handler_type); 448 449DESCRIPTION 450 Set the BFD error handler function. Returns the previous 451 function. 452*/ 453 454bfd_error_handler_type | 428 429 fprintf (stderr, "\n"); 430} 431 432/* This is a function pointer to the routine which should handle BFD 433 error messages. It is called when a BFD routine encounters an 434 error for which it wants to print a message. Going through a 435 function pointer permits a program linked against BFD to intercept --- 9 unchanged lines hidden (view full) --- 445 bfd_error_handler_type bfd_set_error_handler (bfd_error_handler_type); 446 447DESCRIPTION 448 Set the BFD error handler function. Returns the previous 449 function. 450*/ 451 452bfd_error_handler_type |
| 455bfd_set_error_handler (pnew) 456 bfd_error_handler_type pnew; | 453bfd_set_error_handler (bfd_error_handler_type pnew) |
| 457{ 458 bfd_error_handler_type pold; 459 460 pold = _bfd_error_handler; 461 _bfd_error_handler = pnew; 462 return pold; 463} 464 --- 7 unchanged lines hidden (view full) --- 472DESCRIPTION 473 Set the program name to use when printing a BFD error. This 474 is printed before the error message followed by a colon and 475 space. The string must not be changed after it is passed to 476 this function. 477*/ 478 479void | 454{ 455 bfd_error_handler_type pold; 456 457 pold = _bfd_error_handler; 458 _bfd_error_handler = pnew; 459 return pold; 460} 461 --- 7 unchanged lines hidden (view full) --- 469DESCRIPTION 470 Set the program name to use when printing a BFD error. This 471 is printed before the error message followed by a colon and 472 space. The string must not be changed after it is passed to 473 this function. 474*/ 475 476void |
| 480bfd_set_error_program_name (name) 481 const char *name; | 477bfd_set_error_program_name (const char *name) |
| 482{ 483 _bfd_error_program_name = name; 484} 485 486/* 487FUNCTION 488 bfd_get_error_handler 489 490SYNOPSIS 491 bfd_error_handler_type bfd_get_error_handler (void); 492 493DESCRIPTION 494 Return the BFD error handler function. 495*/ 496 497bfd_error_handler_type | 478{ 479 _bfd_error_program_name = name; 480} 481 482/* 483FUNCTION 484 bfd_get_error_handler 485 486SYNOPSIS 487 bfd_error_handler_type bfd_get_error_handler (void); 488 489DESCRIPTION 490 Return the BFD error handler function. 491*/ 492 493bfd_error_handler_type |
| 498bfd_get_error_handler () | 494bfd_get_error_handler (void) |
| 499{ 500 return _bfd_error_handler; 501} 502 503/* 504FUNCTION 505 bfd_archive_filename 506 507SYNOPSIS 508 const char *bfd_archive_filename (bfd *); 509 510DESCRIPTION 511 For a BFD that is a component of an archive, returns a string 512 with both the archive name and file name. For other BFDs, just 513 returns the file name. 514*/ 515 516const char * | 495{ 496 return _bfd_error_handler; 497} 498 499/* 500FUNCTION 501 bfd_archive_filename 502 503SYNOPSIS 504 const char *bfd_archive_filename (bfd *); 505 506DESCRIPTION 507 For a BFD that is a component of an archive, returns a string 508 with both the archive name and file name. For other BFDs, just 509 returns the file name. 510*/ 511 512const char * |
| 517bfd_archive_filename (abfd) 518 bfd *abfd; | 513bfd_archive_filename (bfd *abfd) |
| 519{ | 514{ |
| 515 if (abfd == NULL) 516 return _("<unknown>"); 517 |
|
| 520 if (abfd->my_archive) 521 { 522 static size_t curr = 0; 523 static char *buf; 524 size_t needed; 525 526 needed = (strlen (bfd_get_filename (abfd->my_archive)) 527 + strlen (bfd_get_filename (abfd)) + 3); 528 if (needed > curr) 529 { 530 if (curr) 531 free (buf); 532 curr = needed + (needed >> 1); | 518 if (abfd->my_archive) 519 { 520 static size_t curr = 0; 521 static char *buf; 522 size_t needed; 523 524 needed = (strlen (bfd_get_filename (abfd->my_archive)) 525 + strlen (bfd_get_filename (abfd)) + 3); 526 if (needed > curr) 527 { 528 if (curr) 529 free (buf); 530 curr = needed + (needed >> 1); |
| 533 buf = bfd_malloc ((bfd_size_type) curr); | 531 buf = bfd_malloc (curr); |
| 534 /* If we can't malloc, fail safe by returning just the file 535 name. This function is only used when building error 536 messages. */ 537 if (!buf) 538 { 539 curr = 0; 540 return bfd_get_filename (abfd); 541 } --- 11 unchanged lines hidden (view full) --- 553 Symbols 554*/ 555 556/* 557FUNCTION 558 bfd_get_reloc_upper_bound 559 560SYNOPSIS | 532 /* If we can't malloc, fail safe by returning just the file 533 name. This function is only used when building error 534 messages. */ 535 if (!buf) 536 { 537 curr = 0; 538 return bfd_get_filename (abfd); 539 } --- 11 unchanged lines hidden (view full) --- 551 Symbols 552*/ 553 554/* 555FUNCTION 556 bfd_get_reloc_upper_bound 557 558SYNOPSIS |
| 561 long bfd_get_reloc_upper_bound(bfd *abfd, asection *sect); | 559 long bfd_get_reloc_upper_bound (bfd *abfd, asection *sect); |
| 562 563DESCRIPTION 564 Return the number of bytes required to store the 565 relocation information associated with section @var{sect} 566 attached to bfd @var{abfd}. If an error occurs, return -1. 567 568*/ 569 570long | 560 561DESCRIPTION 562 Return the number of bytes required to store the 563 relocation information associated with section @var{sect} 564 attached to bfd @var{abfd}. If an error occurs, return -1. 565 566*/ 567 568long |
| 571bfd_get_reloc_upper_bound (abfd, asect) 572 bfd *abfd; 573 sec_ptr asect; | 569bfd_get_reloc_upper_bound (bfd *abfd, sec_ptr asect) |
| 574{ 575 if (abfd->format != bfd_object) 576 { 577 bfd_set_error (bfd_error_invalid_operation); 578 return -1; 579 } 580 581 return BFD_SEND (abfd, _get_reloc_upper_bound, (abfd, asect)); 582} 583 584/* 585FUNCTION 586 bfd_canonicalize_reloc 587 588SYNOPSIS 589 long bfd_canonicalize_reloc | 570{ 571 if (abfd->format != bfd_object) 572 { 573 bfd_set_error (bfd_error_invalid_operation); 574 return -1; 575 } 576 577 return BFD_SEND (abfd, _get_reloc_upper_bound, (abfd, asect)); 578} 579 580/* 581FUNCTION 582 bfd_canonicalize_reloc 583 584SYNOPSIS 585 long bfd_canonicalize_reloc |
| 590 (bfd *abfd, 591 asection *sec, 592 arelent **loc, 593 asymbol **syms); | 586 (bfd *abfd, asection *sec, arelent **loc, asymbol **syms); |
| 594 595DESCRIPTION 596 Call the back end associated with the open BFD 597 @var{abfd} and translate the external form of the relocation 598 information attached to @var{sec} into the internal canonical 599 form. Place the table into memory at @var{loc}, which has 600 been preallocated, usually by a call to 601 <<bfd_get_reloc_upper_bound>>. Returns the number of relocs, or 602 -1 on error. 603 604 The @var{syms} table is also needed for horrible internal magic 605 reasons. 606 607*/ 608long | 587 588DESCRIPTION 589 Call the back end associated with the open BFD 590 @var{abfd} and translate the external form of the relocation 591 information attached to @var{sec} into the internal canonical 592 form. Place the table into memory at @var{loc}, which has 593 been preallocated, usually by a call to 594 <<bfd_get_reloc_upper_bound>>. Returns the number of relocs, or 595 -1 on error. 596 597 The @var{syms} table is also needed for horrible internal magic 598 reasons. 599 600*/ 601long |
| 609bfd_canonicalize_reloc (abfd, asect, location, symbols) 610 bfd *abfd; 611 sec_ptr asect; 612 arelent **location; 613 asymbol **symbols; | 602bfd_canonicalize_reloc (bfd *abfd, 603 sec_ptr asect, 604 arelent **location, 605 asymbol **symbols) |
| 614{ 615 if (abfd->format != bfd_object) 616 { 617 bfd_set_error (bfd_error_invalid_operation); 618 return -1; 619 } 620 621 return BFD_SEND (abfd, _bfd_canonicalize_reloc, --- 11 unchanged lines hidden (view full) --- 633DESCRIPTION 634 Set the relocation pointer and count within 635 section @var{sec} to the values @var{rel} and @var{count}. 636 The argument @var{abfd} is ignored. 637 638*/ 639 640void | 606{ 607 if (abfd->format != bfd_object) 608 { 609 bfd_set_error (bfd_error_invalid_operation); 610 return -1; 611 } 612 613 return BFD_SEND (abfd, _bfd_canonicalize_reloc, --- 11 unchanged lines hidden (view full) --- 625DESCRIPTION 626 Set the relocation pointer and count within 627 section @var{sec} to the values @var{rel} and @var{count}. 628 The argument @var{abfd} is ignored. 629 630*/ 631 632void |
| 641bfd_set_reloc (ignore_abfd, asect, location, count) 642 bfd *ignore_abfd ATTRIBUTE_UNUSED; 643 sec_ptr asect; 644 arelent **location; 645 unsigned int count; | 633bfd_set_reloc (bfd *ignore_abfd ATTRIBUTE_UNUSED, 634 sec_ptr asect, 635 arelent **location, 636 unsigned int count) |
| 646{ 647 asect->orelocation = location; 648 asect->reloc_count = count; 649} 650 651/* 652FUNCTION 653 bfd_set_file_flags 654 655SYNOPSIS | 637{ 638 asect->orelocation = location; 639 asect->reloc_count = count; 640} 641 642/* 643FUNCTION 644 bfd_set_file_flags 645 646SYNOPSIS |
| 656 boolean bfd_set_file_flags(bfd *abfd, flagword flags); | 647 bfd_boolean bfd_set_file_flags (bfd *abfd, flagword flags); |
| 657 658DESCRIPTION 659 Set the flag word in the BFD @var{abfd} to the value @var{flags}. 660 661 Possible errors are: 662 o <<bfd_error_wrong_format>> - The target bfd was not of object format. 663 o <<bfd_error_invalid_operation>> - The target bfd was open for reading. 664 o <<bfd_error_invalid_operation>> - 665 The flag word contained a bit which was not applicable to the 666 type of file. E.g., an attempt was made to set the <<D_PAGED>> bit 667 on a BFD format which does not support demand paging. 668 669*/ 670 | 648 649DESCRIPTION 650 Set the flag word in the BFD @var{abfd} to the value @var{flags}. 651 652 Possible errors are: 653 o <<bfd_error_wrong_format>> - The target bfd was not of object format. 654 o <<bfd_error_invalid_operation>> - The target bfd was open for reading. 655 o <<bfd_error_invalid_operation>> - 656 The flag word contained a bit which was not applicable to the 657 type of file. E.g., an attempt was made to set the <<D_PAGED>> bit 658 on a BFD format which does not support demand paging. 659 660*/ 661 |
| 671boolean 672bfd_set_file_flags (abfd, flags) 673 bfd *abfd; 674 flagword flags; | 662bfd_boolean 663bfd_set_file_flags (bfd *abfd, flagword flags) |
| 675{ 676 if (abfd->format != bfd_object) 677 { 678 bfd_set_error (bfd_error_wrong_format); | 664{ 665 if (abfd->format != bfd_object) 666 { 667 bfd_set_error (bfd_error_wrong_format); |
| 679 return false; | 668 return FALSE; |
| 680 } 681 682 if (bfd_read_p (abfd)) 683 { 684 bfd_set_error (bfd_error_invalid_operation); | 669 } 670 671 if (bfd_read_p (abfd)) 672 { 673 bfd_set_error (bfd_error_invalid_operation); |
| 685 return false; | 674 return FALSE; |
| 686 } 687 688 bfd_get_file_flags (abfd) = flags; 689 if ((flags & bfd_applicable_file_flags (abfd)) != flags) 690 { 691 bfd_set_error (bfd_error_invalid_operation); | 675 } 676 677 bfd_get_file_flags (abfd) = flags; 678 if ((flags & bfd_applicable_file_flags (abfd)) != flags) 679 { 680 bfd_set_error (bfd_error_invalid_operation); |
| 692 return false; | 681 return FALSE; |
| 693 } 694 | 682 } 683 |
| 695 return true; | 684 return TRUE; |
| 696} 697 698void | 685} 686 687void |
| 699bfd_assert (file, line) 700 const char *file; 701 int line; | 688bfd_assert (const char *file, int line) |
| 702{ 703 (*_bfd_error_handler) (_("BFD %s assertion fail %s:%d"), 704 BFD_VERSION_STRING, file, line); 705} 706 707/* A more or less friendly abort message. In libbfd.h abort is 708 defined to call this function. */ 709 710#ifndef EXIT_FAILURE 711#define EXIT_FAILURE 1 712#endif 713 714void | 689{ 690 (*_bfd_error_handler) (_("BFD %s assertion fail %s:%d"), 691 BFD_VERSION_STRING, file, line); 692} 693 694/* A more or less friendly abort message. In libbfd.h abort is 695 defined to call this function. */ 696 697#ifndef EXIT_FAILURE 698#define EXIT_FAILURE 1 699#endif 700 701void |
| 715_bfd_abort (file, line, fn) 716 const char *file; 717 int line; 718 const char *fn; | 702_bfd_abort (const char *file, int line, const char *fn) |
| 719{ 720 if (fn != NULL) 721 (*_bfd_error_handler) 722 (_("BFD %s internal error, aborting at %s line %d in %s\n"), 723 BFD_VERSION_STRING, file, line, fn); 724 else 725 (*_bfd_error_handler) 726 (_("BFD %s internal error, aborting at %s line %d\n"), --- 14 unchanged lines hidden (view full) --- 741 by the object file's format. For ELF, this information is 742 included in the header. 743 744RETURNS 745 Returns the arch size in bits if known, <<-1>> otherwise. 746*/ 747 748int | 703{ 704 if (fn != NULL) 705 (*_bfd_error_handler) 706 (_("BFD %s internal error, aborting at %s line %d in %s\n"), 707 BFD_VERSION_STRING, file, line, fn); 708 else 709 (*_bfd_error_handler) 710 (_("BFD %s internal error, aborting at %s line %d\n"), --- 14 unchanged lines hidden (view full) --- 725 by the object file's format. For ELF, this information is 726 included in the header. 727 728RETURNS 729 Returns the arch size in bits if known, <<-1>> otherwise. 730*/ 731 732int |
| 749bfd_get_arch_size (abfd) 750 bfd *abfd; | 733bfd_get_arch_size (bfd *abfd) |
| 751{ 752 if (abfd->xvec->flavour == bfd_target_elf_flavour) | 734{ 735 if (abfd->xvec->flavour == bfd_target_elf_flavour) |
| 753 return (get_elf_backend_data (abfd))->s->arch_size; | 736 return get_elf_backend_data (abfd)->s->arch_size; |
| 754 755 return -1; 756} 757 758/* 759FUNCTION 760 bfd_get_sign_extend_vma 761 --- 10 unchanged lines hidden (view full) --- 772 773RETURNS 774 Returns <<1>> if the target architecture is known to sign 775 extend addresses, <<0>> if the target architecture is known to 776 not sign extend addresses, and <<-1>> otherwise. 777*/ 778 779int | 737 738 return -1; 739} 740 741/* 742FUNCTION 743 bfd_get_sign_extend_vma 744 --- 10 unchanged lines hidden (view full) --- 755 756RETURNS 757 Returns <<1>> if the target architecture is known to sign 758 extend addresses, <<0>> if the target architecture is known to 759 not sign extend addresses, and <<-1>> otherwise. 760*/ 761 762int |
| 780bfd_get_sign_extend_vma (abfd) 781 bfd *abfd; | 763bfd_get_sign_extend_vma (bfd *abfd) |
| 782{ 783 char *name; 784 785 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour) | 764{ 765 char *name; 766 767 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour) |
| 786 return (get_elf_backend_data (abfd)->sign_extend_vma); | 768 return get_elf_backend_data (abfd)->sign_extend_vma; |
| 787 788 name = bfd_get_target (abfd); 789 790 /* Return a proper value for DJGPP COFF (an x86 COFF variant). 791 This function is required for DWARF2 support, but there is 792 no place to store this information in the COFF back end. 793 Should enough other COFF targets add support for DWARF2, 794 a place will have to be found. Until then, this hack will do. */ --- 4 unchanged lines hidden (view full) --- 799 return -1; 800} 801 802/* 803FUNCTION 804 bfd_set_start_address 805 806SYNOPSIS | 769 770 name = bfd_get_target (abfd); 771 772 /* Return a proper value for DJGPP COFF (an x86 COFF variant). 773 This function is required for DWARF2 support, but there is 774 no place to store this information in the COFF back end. 775 Should enough other COFF targets add support for DWARF2, 776 a place will have to be found. Until then, this hack will do. */ --- 4 unchanged lines hidden (view full) --- 781 return -1; 782} 783 784/* 785FUNCTION 786 bfd_set_start_address 787 788SYNOPSIS |
| 807 boolean bfd_set_start_address(bfd *abfd, bfd_vma vma); | 789 bfd_boolean bfd_set_start_address (bfd *abfd, bfd_vma vma); |
| 808 809DESCRIPTION 810 Make @var{vma} the entry point of output BFD @var{abfd}. 811 812RETURNS | 790 791DESCRIPTION 792 Make @var{vma} the entry point of output BFD @var{abfd}. 793 794RETURNS |
| 813 Returns <<true>> on success, <<false>> otherwise. | 795 Returns <<TRUE>> on success, <<FALSE>> otherwise. |
| 814*/ 815 | 796*/ 797 |
| 816boolean 817bfd_set_start_address (abfd, vma) 818 bfd *abfd; 819 bfd_vma vma; | 798bfd_boolean 799bfd_set_start_address (bfd *abfd, bfd_vma vma) |
| 820{ 821 abfd->start_address = vma; | 800{ 801 abfd->start_address = vma; |
| 822 return true; | 802 return TRUE; |
| 823} 824 825/* 826FUNCTION | 803} 804 805/* 806FUNCTION |
| 827 bfd_get_mtime 828 829SYNOPSIS 830 long bfd_get_mtime(bfd *abfd); 831 832DESCRIPTION 833 Return the file modification time (as read from the file system, or 834 from the archive header for archive members). 835 836*/ 837 838long 839bfd_get_mtime (abfd) 840 bfd *abfd; 841{ 842 FILE *fp; 843 struct stat buf; 844 845 if (abfd->mtime_set) 846 return abfd->mtime; 847 848 fp = bfd_cache_lookup (abfd); 849 if (0 != fstat (fileno (fp), &buf)) 850 return 0; 851 852 abfd->mtime = buf.st_mtime; /* Save value in case anyone wants it */ 853 return buf.st_mtime; 854} 855 856/* 857FUNCTION 858 bfd_get_size 859 860SYNOPSIS 861 long bfd_get_size(bfd *abfd); 862 863DESCRIPTION 864 Return the file size (as read from file system) for the file 865 associated with BFD @var{abfd}. 866 867 The initial motivation for, and use of, this routine is not 868 so we can get the exact size of the object the BFD applies to, since 869 that might not be generally possible (archive members for example). 870 It would be ideal if someone could eventually modify 871 it so that such results were guaranteed. 872 873 Instead, we want to ask questions like "is this NNN byte sized 874 object I'm about to try read from file offset YYY reasonable?" 875 As as example of where we might do this, some object formats 876 use string tables for which the first <<sizeof (long)>> bytes of the 877 table contain the size of the table itself, including the size bytes. 878 If an application tries to read what it thinks is one of these 879 string tables, without some way to validate the size, and for 880 some reason the size is wrong (byte swapping error, wrong location 881 for the string table, etc.), the only clue is likely to be a read 882 error when it tries to read the table, or a "virtual memory 883 exhausted" error when it tries to allocate 15 bazillon bytes 884 of space for the 15 bazillon byte table it is about to read. 885 This function at least allows us to answer the quesion, "is the 886 size reasonable?". 887*/ 888 889long 890bfd_get_size (abfd) 891 bfd *abfd; 892{ 893 FILE *fp; 894 struct stat buf; 895 896 if ((abfd->flags & BFD_IN_MEMORY) != 0) 897 return ((struct bfd_in_memory *) abfd->iostream)->size; 898 899 fp = bfd_cache_lookup (abfd); 900 if (0 != fstat (fileno (fp), & buf)) 901 return 0; 902 903 return buf.st_size; 904} 905 906/* 907FUNCTION | |
| 908 bfd_get_gp_size 909 910SYNOPSIS | 807 bfd_get_gp_size 808 809SYNOPSIS |
| 911 unsigned int bfd_get_gp_size(bfd *abfd); | 810 unsigned int bfd_get_gp_size (bfd *abfd); |
| 912 913DESCRIPTION 914 Return the maximum size of objects to be optimized using the GP 915 register under MIPS ECOFF. This is typically set by the <<-G>> 916 argument to the compiler, assembler or linker. 917*/ 918 919unsigned int | 811 812DESCRIPTION 813 Return the maximum size of objects to be optimized using the GP 814 register under MIPS ECOFF. This is typically set by the <<-G>> 815 argument to the compiler, assembler or linker. 816*/ 817 818unsigned int |
| 920bfd_get_gp_size (abfd) 921 bfd *abfd; | 819bfd_get_gp_size (bfd *abfd) |
| 922{ 923 if (abfd->format == bfd_object) 924 { 925 if (abfd->xvec->flavour == bfd_target_ecoff_flavour) 926 return ecoff_data (abfd)->gp_size; 927 else if (abfd->xvec->flavour == bfd_target_elf_flavour) 928 return elf_gp_size (abfd); 929 } 930 return 0; 931} 932 933/* 934FUNCTION 935 bfd_set_gp_size 936 937SYNOPSIS | 820{ 821 if (abfd->format == bfd_object) 822 { 823 if (abfd->xvec->flavour == bfd_target_ecoff_flavour) 824 return ecoff_data (abfd)->gp_size; 825 else if (abfd->xvec->flavour == bfd_target_elf_flavour) 826 return elf_gp_size (abfd); 827 } 828 return 0; 829} 830 831/* 832FUNCTION 833 bfd_set_gp_size 834 835SYNOPSIS |
| 938 void bfd_set_gp_size(bfd *abfd, unsigned int i); | 836 void bfd_set_gp_size (bfd *abfd, unsigned int i); |
| 939 940DESCRIPTION 941 Set the maximum size of objects to be optimized using the GP 942 register under ECOFF or MIPS ELF. This is typically set by 943 the <<-G>> argument to the compiler, assembler or linker. 944*/ 945 946void | 837 838DESCRIPTION 839 Set the maximum size of objects to be optimized using the GP 840 register under ECOFF or MIPS ELF. This is typically set by 841 the <<-G>> argument to the compiler, assembler or linker. 842*/ 843 844void |
| 947bfd_set_gp_size (abfd, i) 948 bfd *abfd; 949 unsigned int i; | 845bfd_set_gp_size (bfd *abfd, unsigned int i) |
| 950{ 951 /* Don't try to set GP size on an archive or core file! */ 952 if (abfd->format != bfd_object) 953 return; 954 955 if (abfd->xvec->flavour == bfd_target_ecoff_flavour) 956 ecoff_data (abfd)->gp_size = i; 957 else if (abfd->xvec->flavour == bfd_target_elf_flavour) 958 elf_gp_size (abfd) = i; 959} 960 961/* Get the GP value. This is an internal function used by some of the 962 relocation special_function routines on targets which support a GP 963 register. */ 964 965bfd_vma | 846{ 847 /* Don't try to set GP size on an archive or core file! */ 848 if (abfd->format != bfd_object) 849 return; 850 851 if (abfd->xvec->flavour == bfd_target_ecoff_flavour) 852 ecoff_data (abfd)->gp_size = i; 853 else if (abfd->xvec->flavour == bfd_target_elf_flavour) 854 elf_gp_size (abfd) = i; 855} 856 857/* Get the GP value. This is an internal function used by some of the 858 relocation special_function routines on targets which support a GP 859 register. */ 860 861bfd_vma |
| 966_bfd_get_gp_value (abfd) 967 bfd *abfd; | 862_bfd_get_gp_value (bfd *abfd) |
| 968{ | 863{ |
| 864 if (! abfd) 865 return 0; |
|
| 969 if (abfd->format != bfd_object) 970 return 0; 971 972 if (abfd->xvec->flavour == bfd_target_ecoff_flavour) 973 return ecoff_data (abfd)->gp; 974 else if (abfd->xvec->flavour == bfd_target_elf_flavour) 975 return elf_gp (abfd); 976 977 return 0; 978} 979 980/* Set the GP value. */ 981 982void | 866 if (abfd->format != bfd_object) 867 return 0; 868 869 if (abfd->xvec->flavour == bfd_target_ecoff_flavour) 870 return ecoff_data (abfd)->gp; 871 else if (abfd->xvec->flavour == bfd_target_elf_flavour) 872 return elf_gp (abfd); 873 874 return 0; 875} 876 877/* Set the GP value. */ 878 879void |
| 983_bfd_set_gp_value (abfd, v) 984 bfd *abfd; 985 bfd_vma v; | 880_bfd_set_gp_value (bfd *abfd, bfd_vma v) |
| 986{ | 881{ |
| 882 if (! abfd) 883 BFD_FAIL (); |
|
| 987 if (abfd->format != bfd_object) 988 return; 989 990 if (abfd->xvec->flavour == bfd_target_ecoff_flavour) 991 ecoff_data (abfd)->gp = v; 992 else if (abfd->xvec->flavour == bfd_target_elf_flavour) 993 elf_gp (abfd) = v; 994} 995 996/* 997FUNCTION 998 bfd_scan_vma 999 1000SYNOPSIS | 884 if (abfd->format != bfd_object) 885 return; 886 887 if (abfd->xvec->flavour == bfd_target_ecoff_flavour) 888 ecoff_data (abfd)->gp = v; 889 else if (abfd->xvec->flavour == bfd_target_elf_flavour) 890 elf_gp (abfd) = v; 891} 892 893/* 894FUNCTION 895 bfd_scan_vma 896 897SYNOPSIS |
| 1001 bfd_vma bfd_scan_vma(const char *string, const char **end, int base); | 898 bfd_vma bfd_scan_vma (const char *string, const char **end, int base); |
| 1002 1003DESCRIPTION 1004 Convert, like <<strtoul>>, a numerical expression 1005 @var{string} into a <<bfd_vma>> integer, and return that integer. 1006 (Though without as many bells and whistles as <<strtoul>>.) 1007 The expression is assumed to be unsigned (i.e., positive). 1008 If given a @var{base}, it is used as the base for conversion. 1009 A base of 0 causes the function to interpret the string 1010 in hex if a leading "0x" or "0X" is found, otherwise 1011 in octal if a leading zero is found, otherwise in decimal. 1012 1013 If the value would overflow, the maximum <<bfd_vma>> value is 1014 returned. 1015*/ 1016 1017bfd_vma | 899 900DESCRIPTION 901 Convert, like <<strtoul>>, a numerical expression 902 @var{string} into a <<bfd_vma>> integer, and return that integer. 903 (Though without as many bells and whistles as <<strtoul>>.) 904 The expression is assumed to be unsigned (i.e., positive). 905 If given a @var{base}, it is used as the base for conversion. 906 A base of 0 causes the function to interpret the string 907 in hex if a leading "0x" or "0X" is found, otherwise 908 in octal if a leading zero is found, otherwise in decimal. 909 910 If the value would overflow, the maximum <<bfd_vma>> value is 911 returned. 912*/ 913 914bfd_vma |
| 1018bfd_scan_vma (string, end, base) 1019 const char *string; 1020 const char **end; 1021 int base; | 915bfd_scan_vma (const char *string, const char **end, int base) |
| 1022{ 1023 bfd_vma value; 1024 bfd_vma cutoff; 1025 unsigned int cutlim; 1026 int overflow; 1027 1028 /* Let the host do it if possible. */ 1029 if (sizeof (bfd_vma) <= sizeof (unsigned long)) | 916{ 917 bfd_vma value; 918 bfd_vma cutoff; 919 unsigned int cutlim; 920 int overflow; 921 922 /* Let the host do it if possible. */ 923 if (sizeof (bfd_vma) <= sizeof (unsigned long)) |
| 1030 return (bfd_vma) strtoul (string, (char **) end, base); | 924 return strtoul (string, (char **) end, base); |
| 1031 | 925 |
| 926#ifdef HAVE_STRTOULL 927 if (sizeof (bfd_vma) <= sizeof (unsigned long long)) 928 return strtoull (string, (char **) end, base); 929#endif 930 |
|
| 1032 if (base == 0) 1033 { 1034 if (string[0] == '0') 1035 { 1036 if ((string[1] == 'x') || (string[1] == 'X')) 1037 base = 16; 1038 else 1039 base = 8; --- 43 unchanged lines hidden (view full) --- 1083 return value; 1084} 1085 1086/* 1087FUNCTION 1088 bfd_copy_private_bfd_data 1089 1090SYNOPSIS | 931 if (base == 0) 932 { 933 if (string[0] == '0') 934 { 935 if ((string[1] == 'x') || (string[1] == 'X')) 936 base = 16; 937 else 938 base = 8; --- 43 unchanged lines hidden (view full) --- 982 return value; 983} 984 985/* 986FUNCTION 987 bfd_copy_private_bfd_data 988 989SYNOPSIS |
| 1091 boolean bfd_copy_private_bfd_data(bfd *ibfd, bfd *obfd); | 990 bfd_boolean bfd_copy_private_bfd_data (bfd *ibfd, bfd *obfd); |
| 1092 1093DESCRIPTION 1094 Copy private BFD information from the BFD @var{ibfd} to the | 991 992DESCRIPTION 993 Copy private BFD information from the BFD @var{ibfd} to the |
| 1095 the BFD @var{obfd}. Return <<true>> on success, <<false>> on error. | 994 the BFD @var{obfd}. Return <<TRUE>> on success, <<FALSE>> on error. |
| 1096 Possible error returns are: 1097 1098 o <<bfd_error_no_memory>> - 1099 Not enough memory exists to create private data for @var{obfd}. 1100 1101.#define bfd_copy_private_bfd_data(ibfd, obfd) \ 1102. BFD_SEND (obfd, _bfd_copy_private_bfd_data, \ 1103. (ibfd, obfd)) 1104 1105*/ 1106 1107/* 1108FUNCTION 1109 bfd_merge_private_bfd_data 1110 1111SYNOPSIS | 995 Possible error returns are: 996 997 o <<bfd_error_no_memory>> - 998 Not enough memory exists to create private data for @var{obfd}. 999 1000.#define bfd_copy_private_bfd_data(ibfd, obfd) \ 1001. BFD_SEND (obfd, _bfd_copy_private_bfd_data, \ 1002. (ibfd, obfd)) 1003 1004*/ 1005 1006/* 1007FUNCTION 1008 bfd_merge_private_bfd_data 1009 1010SYNOPSIS |
| 1112 boolean bfd_merge_private_bfd_data(bfd *ibfd, bfd *obfd); | 1011 bfd_boolean bfd_merge_private_bfd_data (bfd *ibfd, bfd *obfd); |
| 1113 1114DESCRIPTION 1115 Merge private BFD information from the BFD @var{ibfd} to the | 1012 1013DESCRIPTION 1014 Merge private BFD information from the BFD @var{ibfd} to the |
| 1116 the output file BFD @var{obfd} when linking. Return <<true>> 1117 on success, <<false>> on error. Possible error returns are: | 1015 the output file BFD @var{obfd} when linking. Return <<TRUE>> 1016 on success, <<FALSE>> on error. Possible error returns are: |
| 1118 1119 o <<bfd_error_no_memory>> - 1120 Not enough memory exists to create private data for @var{obfd}. 1121 1122.#define bfd_merge_private_bfd_data(ibfd, obfd) \ 1123. BFD_SEND (obfd, _bfd_merge_private_bfd_data, \ 1124. (ibfd, obfd)) 1125 1126*/ 1127 1128/* 1129FUNCTION 1130 bfd_set_private_flags 1131 1132SYNOPSIS | 1017 1018 o <<bfd_error_no_memory>> - 1019 Not enough memory exists to create private data for @var{obfd}. 1020 1021.#define bfd_merge_private_bfd_data(ibfd, obfd) \ 1022. BFD_SEND (obfd, _bfd_merge_private_bfd_data, \ 1023. (ibfd, obfd)) 1024 1025*/ 1026 1027/* 1028FUNCTION 1029 bfd_set_private_flags 1030 1031SYNOPSIS |
| 1133 boolean bfd_set_private_flags(bfd *abfd, flagword flags); | 1032 bfd_boolean bfd_set_private_flags (bfd *abfd, flagword flags); |
| 1134 1135DESCRIPTION 1136 Set private BFD flag information in the BFD @var{abfd}. | 1033 1034DESCRIPTION 1035 Set private BFD flag information in the BFD @var{abfd}. |
| 1137 Return <<true>> on success, <<false>> on error. Possible error | 1036 Return <<TRUE>> on success, <<FALSE>> on error. Possible error |
| 1138 returns are: 1139 1140 o <<bfd_error_no_memory>> - 1141 Not enough memory exists to create private data for @var{obfd}. 1142 1143.#define bfd_set_private_flags(abfd, flags) \ | 1037 returns are: 1038 1039 o <<bfd_error_no_memory>> - 1040 Not enough memory exists to create private data for @var{obfd}. 1041 1042.#define bfd_set_private_flags(abfd, flags) \ |
| 1144. BFD_SEND (abfd, _bfd_set_private_flags, \ 1145. (abfd, flags)) | 1043. BFD_SEND (abfd, _bfd_set_private_flags, (abfd, flags)) |
| 1146 1147*/ 1148 1149/* 1150FUNCTION | 1044 1045*/ 1046 1047/* 1048FUNCTION |
| 1151 stuff | 1049 Other functions |
| 1152 1153DESCRIPTION | 1050 1051DESCRIPTION |
| 1154 Stuff which should be documented: | 1052 The following functions exist but have not yet been documented. |
| 1155 1156.#define bfd_sizeof_headers(abfd, reloc) \ | 1053 1054.#define bfd_sizeof_headers(abfd, reloc) \ |
| 1157. BFD_SEND (abfd, _bfd_sizeof_headers, (abfd, reloc)) | 1055. BFD_SEND (abfd, _bfd_sizeof_headers, (abfd, reloc)) |
| 1158. 1159.#define bfd_find_nearest_line(abfd, sec, syms, off, file, func, line) \ | 1056. 1057.#define bfd_find_nearest_line(abfd, sec, syms, off, file, func, line) \ |
| 1160. BFD_SEND (abfd, _bfd_find_nearest_line, (abfd, sec, syms, off, file, func, line)) | 1058. BFD_SEND (abfd, _bfd_find_nearest_line, \ 1059. (abfd, sec, syms, off, file, func, line)) |
| 1161. | 1060. |
| 1162. {* Do these three do anything useful at all, for any back end? *} | |
| 1163.#define bfd_debug_info_start(abfd) \ | 1061.#define bfd_debug_info_start(abfd) \ |
| 1164. BFD_SEND (abfd, _bfd_debug_info_start, (abfd)) | 1062. BFD_SEND (abfd, _bfd_debug_info_start, (abfd)) |
| 1165. 1166.#define bfd_debug_info_end(abfd) \ | 1063. 1064.#define bfd_debug_info_end(abfd) \ |
| 1167. BFD_SEND (abfd, _bfd_debug_info_end, (abfd)) | 1065. BFD_SEND (abfd, _bfd_debug_info_end, (abfd)) |
| 1168. 1169.#define bfd_debug_info_accumulate(abfd, section) \ | 1066. 1067.#define bfd_debug_info_accumulate(abfd, section) \ |
| 1170. BFD_SEND (abfd, _bfd_debug_info_accumulate, (abfd, section)) | 1068. BFD_SEND (abfd, _bfd_debug_info_accumulate, (abfd, section)) |
| 1171. | 1069. |
| 1172. | |
| 1173.#define bfd_stat_arch_elt(abfd, stat) \ | 1070.#define bfd_stat_arch_elt(abfd, stat) \ |
| 1174. BFD_SEND (abfd, _bfd_stat_arch_elt,(abfd, stat)) | 1071. BFD_SEND (abfd, _bfd_stat_arch_elt,(abfd, stat)) |
| 1175. 1176.#define bfd_update_armap_timestamp(abfd) \ | 1072. 1073.#define bfd_update_armap_timestamp(abfd) \ |
| 1177. BFD_SEND (abfd, _bfd_update_armap_timestamp, (abfd)) | 1074. BFD_SEND (abfd, _bfd_update_armap_timestamp, (abfd)) |
| 1178. 1179.#define bfd_set_arch_mach(abfd, arch, mach)\ | 1075. 1076.#define bfd_set_arch_mach(abfd, arch, mach)\ |
| 1180. BFD_SEND ( abfd, _bfd_set_arch_mach, (abfd, arch, mach)) | 1077. BFD_SEND ( abfd, _bfd_set_arch_mach, (abfd, arch, mach)) |
| 1181. 1182.#define bfd_relax_section(abfd, section, link_info, again) \ 1183. BFD_SEND (abfd, _bfd_relax_section, (abfd, section, link_info, again)) 1184. 1185.#define bfd_gc_sections(abfd, link_info) \ 1186. BFD_SEND (abfd, _bfd_gc_sections, (abfd, link_info)) 1187. 1188.#define bfd_merge_sections(abfd, link_info) \ --- 31 unchanged lines hidden (view full) --- 1220. 1221.#define bfd_get_dynamic_reloc_upper_bound(abfd) \ 1222. BFD_SEND (abfd, _bfd_get_dynamic_reloc_upper_bound, (abfd)) 1223. 1224.#define bfd_canonicalize_dynamic_reloc(abfd, arels, asyms) \ 1225. BFD_SEND (abfd, _bfd_canonicalize_dynamic_reloc, (abfd, arels, asyms)) 1226. 1227.extern bfd_byte *bfd_get_relocated_section_contents | 1078. 1079.#define bfd_relax_section(abfd, section, link_info, again) \ 1080. BFD_SEND (abfd, _bfd_relax_section, (abfd, section, link_info, again)) 1081. 1082.#define bfd_gc_sections(abfd, link_info) \ 1083. BFD_SEND (abfd, _bfd_gc_sections, (abfd, link_info)) 1084. 1085.#define bfd_merge_sections(abfd, link_info) \ --- 31 unchanged lines hidden (view full) --- 1117. 1118.#define bfd_get_dynamic_reloc_upper_bound(abfd) \ 1119. BFD_SEND (abfd, _bfd_get_dynamic_reloc_upper_bound, (abfd)) 1120. 1121.#define bfd_canonicalize_dynamic_reloc(abfd, arels, asyms) \ 1122. BFD_SEND (abfd, _bfd_canonicalize_dynamic_reloc, (abfd, arels, asyms)) 1123. 1124.extern bfd_byte *bfd_get_relocated_section_contents |
| 1228. PARAMS ((bfd *, struct bfd_link_info *, 1229. struct bfd_link_order *, bfd_byte *, 1230. boolean, asymbol **)); | 1125. (bfd *, struct bfd_link_info *, struct bfd_link_order *, bfd_byte *, 1126. bfd_boolean, asymbol **); |
| 1231. 1232 1233*/ 1234 1235bfd_byte * | 1127. 1128 1129*/ 1130 1131bfd_byte * |
| 1236bfd_get_relocated_section_contents (abfd, link_info, link_order, data, 1237 relocateable, symbols) 1238 bfd *abfd; 1239 struct bfd_link_info *link_info; 1240 struct bfd_link_order *link_order; 1241 bfd_byte *data; 1242 boolean relocateable; 1243 asymbol **symbols; | 1132bfd_get_relocated_section_contents (bfd *abfd, 1133 struct bfd_link_info *link_info, 1134 struct bfd_link_order *link_order, 1135 bfd_byte *data, 1136 bfd_boolean relocatable, 1137 asymbol **symbols) |
| 1244{ 1245 bfd *abfd2; | 1138{ 1139 bfd *abfd2; |
| 1246 bfd_byte *(*fn) PARAMS ((bfd *, struct bfd_link_info *, 1247 struct bfd_link_order *, bfd_byte *, boolean, 1248 asymbol **)); | 1140 bfd_byte *(*fn) (bfd *, struct bfd_link_info *, struct bfd_link_order *, 1141 bfd_byte *, bfd_boolean, asymbol **); |
| 1249 1250 if (link_order->type == bfd_indirect_link_order) 1251 { 1252 abfd2 = link_order->u.indirect.section->owner; 1253 if (abfd2 == NULL) 1254 abfd2 = abfd; 1255 } 1256 else 1257 abfd2 = abfd; 1258 1259 fn = abfd2->xvec->_bfd_get_relocated_section_contents; 1260 | 1142 1143 if (link_order->type == bfd_indirect_link_order) 1144 { 1145 abfd2 = link_order->u.indirect.section->owner; 1146 if (abfd2 == NULL) 1147 abfd2 = abfd; 1148 } 1149 else 1150 abfd2 = abfd; 1151 1152 fn = abfd2->xvec->_bfd_get_relocated_section_contents; 1153 |
| 1261 return (*fn) (abfd, link_info, link_order, data, relocateable, symbols); | 1154 return (*fn) (abfd, link_info, link_order, data, relocatable, symbols); |
| 1262} 1263 1264/* Record information about an ELF program header. */ 1265 | 1155} 1156 1157/* Record information about an ELF program header. */ 1158 |
| 1266boolean 1267bfd_record_phdr (abfd, type, flags_valid, flags, at_valid, at, 1268 includes_filehdr, includes_phdrs, count, secs) 1269 bfd *abfd; 1270 unsigned long type; 1271 boolean flags_valid; 1272 flagword flags; 1273 boolean at_valid; 1274 bfd_vma at; 1275 boolean includes_filehdr; 1276 boolean includes_phdrs; 1277 unsigned int count; 1278 asection **secs; | 1159bfd_boolean 1160bfd_record_phdr (bfd *abfd, 1161 unsigned long type, 1162 bfd_boolean flags_valid, 1163 flagword flags, 1164 bfd_boolean at_valid, 1165 bfd_vma at, 1166 bfd_boolean includes_filehdr, 1167 bfd_boolean includes_phdrs, 1168 unsigned int count, 1169 asection **secs) |
| 1279{ 1280 struct elf_segment_map *m, **pm; 1281 bfd_size_type amt; 1282 1283 if (bfd_get_flavour (abfd) != bfd_target_elf_flavour) | 1170{ 1171 struct elf_segment_map *m, **pm; 1172 bfd_size_type amt; 1173 1174 if (bfd_get_flavour (abfd) != bfd_target_elf_flavour) |
| 1284 return true; | 1175 return TRUE; |
| 1285 1286 amt = sizeof (struct elf_segment_map); 1287 amt += ((bfd_size_type) count - 1) * sizeof (asection *); | 1176 1177 amt = sizeof (struct elf_segment_map); 1178 amt += ((bfd_size_type) count - 1) * sizeof (asection *); |
| 1288 m = (struct elf_segment_map *) bfd_alloc (abfd, amt); | 1179 m = bfd_alloc (abfd, amt); |
| 1289 if (m == NULL) | 1180 if (m == NULL) |
| 1290 return false; | 1181 return FALSE; |
| 1291 1292 m->next = NULL; 1293 m->p_type = type; 1294 m->p_flags = flags; 1295 m->p_paddr = at; | 1182 1183 m->next = NULL; 1184 m->p_type = type; 1185 m->p_flags = flags; 1186 m->p_paddr = at; |
| 1296 m->p_flags_valid = (unsigned int) flags_valid; 1297 m->p_paddr_valid = (unsigned int) at_valid; 1298 m->includes_filehdr = (unsigned int) includes_filehdr; 1299 m->includes_phdrs = (unsigned int) includes_phdrs; | 1187 m->p_flags_valid = flags_valid; 1188 m->p_paddr_valid = at_valid; 1189 m->includes_filehdr = includes_filehdr; 1190 m->includes_phdrs = includes_phdrs; |
| 1300 m->count = count; 1301 if (count > 0) 1302 memcpy (m->sections, secs, count * sizeof (asection *)); 1303 1304 for (pm = &elf_tdata (abfd)->segment_map; *pm != NULL; pm = &(*pm)->next) 1305 ; 1306 *pm = m; 1307 | 1191 m->count = count; 1192 if (count > 0) 1193 memcpy (m->sections, secs, count * sizeof (asection *)); 1194 1195 for (pm = &elf_tdata (abfd)->segment_map; *pm != NULL; pm = &(*pm)->next) 1196 ; 1197 *pm = m; 1198 |
| 1308 return true; | 1199 return TRUE; |
| 1309} 1310 1311void | 1200} 1201 1202void |
| 1312bfd_sprintf_vma (abfd, buf, value) 1313 bfd *abfd; 1314 char *buf; 1315 bfd_vma value; | 1203bfd_sprintf_vma (bfd *abfd, char *buf, bfd_vma value) |
| 1316{ 1317 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour) 1318 get_elf_backend_data (abfd)->elf_backend_sprintf_vma (abfd, buf, value); 1319 else 1320 sprintf_vma (buf, value); 1321} 1322 1323void | 1204{ 1205 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour) 1206 get_elf_backend_data (abfd)->elf_backend_sprintf_vma (abfd, buf, value); 1207 else 1208 sprintf_vma (buf, value); 1209} 1210 1211void |
| 1324bfd_fprintf_vma (abfd, stream, value) 1325 bfd *abfd; 1326 PTR stream; 1327 bfd_vma value; | 1212bfd_fprintf_vma (bfd *abfd, void *stream, bfd_vma value) |
| 1328{ 1329 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour) 1330 get_elf_backend_data (abfd)->elf_backend_fprintf_vma (abfd, stream, value); 1331 else 1332 fprintf_vma ((FILE *) stream, value); 1333} 1334 1335/* 1336FUNCTION 1337 bfd_alt_mach_code 1338 1339SYNOPSIS | 1213{ 1214 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour) 1215 get_elf_backend_data (abfd)->elf_backend_fprintf_vma (abfd, stream, value); 1216 else 1217 fprintf_vma ((FILE *) stream, value); 1218} 1219 1220/* 1221FUNCTION 1222 bfd_alt_mach_code 1223 1224SYNOPSIS |
| 1340 boolean bfd_alt_mach_code(bfd *abfd, int alternative); | 1225 bfd_boolean bfd_alt_mach_code (bfd *abfd, int alternative); |
| 1341 1342DESCRIPTION 1343 1344 When more than one machine code number is available for the 1345 same machine type, this function can be used to switch between 1346 the preferred one (alternative == 0) and any others. Currently, 1347 only ELF supports this feature, with up to two alternate 1348 machine codes. 1349*/ 1350 | 1226 1227DESCRIPTION 1228 1229 When more than one machine code number is available for the 1230 same machine type, this function can be used to switch between 1231 the preferred one (alternative == 0) and any others. Currently, 1232 only ELF supports this feature, with up to two alternate 1233 machine codes. 1234*/ 1235 |
| 1351boolean 1352bfd_alt_mach_code (abfd, alternative) 1353 bfd *abfd; 1354 int alternative; | 1236bfd_boolean 1237bfd_alt_mach_code (bfd *abfd, int alternative) |
| 1355{ 1356 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour) 1357 { 1358 int code; 1359 1360 switch (alternative) 1361 { 1362 case 0: 1363 code = get_elf_backend_data (abfd)->elf_machine_code; 1364 break; 1365 1366 case 1: 1367 code = get_elf_backend_data (abfd)->elf_machine_alt1; 1368 if (code == 0) | 1238{ 1239 if (bfd_get_flavour (abfd) == bfd_target_elf_flavour) 1240 { 1241 int code; 1242 1243 switch (alternative) 1244 { 1245 case 0: 1246 code = get_elf_backend_data (abfd)->elf_machine_code; 1247 break; 1248 1249 case 1: 1250 code = get_elf_backend_data (abfd)->elf_machine_alt1; 1251 if (code == 0) |
| 1369 return false; | 1252 return FALSE; |
| 1370 break; 1371 1372 case 2: 1373 code = get_elf_backend_data (abfd)->elf_machine_alt2; 1374 if (code == 0) | 1253 break; 1254 1255 case 2: 1256 code = get_elf_backend_data (abfd)->elf_machine_alt2; 1257 if (code == 0) |
| 1375 return false; | 1258 return FALSE; |
| 1376 break; 1377 1378 default: | 1259 break; 1260 1261 default: |
| 1379 return false; | 1262 return FALSE; |
| 1380 } 1381 1382 elf_elfheader (abfd)->e_machine = code; 1383 | 1263 } 1264 1265 elf_elfheader (abfd)->e_machine = code; 1266 |
| 1384 return true; | 1267 return TRUE; |
| 1385 } 1386 | 1268 } 1269 |
| 1387 return false; | 1270 return FALSE; |
| 1388} | 1271} |
| 1272 1273/* 1274CODE_FRAGMENT 1275 1276.struct bfd_preserve 1277.{ 1278. void *marker; 1279. void *tdata; 1280. flagword flags; 1281. const struct bfd_arch_info *arch_info; 1282. struct bfd_section *sections; 1283. struct bfd_section **section_tail; 1284. unsigned int section_count; 1285. struct bfd_hash_table section_htab; 1286.}; 1287. 1288*/ 1289 1290/* 1291FUNCTION 1292 bfd_preserve_save 1293 1294SYNOPSIS 1295 bfd_boolean bfd_preserve_save (bfd *, struct bfd_preserve *); 1296 1297DESCRIPTION 1298 When testing an object for compatibility with a particular 1299 target back-end, the back-end object_p function needs to set 1300 up certain fields in the bfd on successfully recognizing the 1301 object. This typically happens in a piecemeal fashion, with 1302 failures possible at many points. On failure, the bfd is 1303 supposed to be restored to its initial state, which is 1304 virtually impossible. However, restoring a subset of the bfd 1305 state works in practice. This function stores the subset and 1306 reinitializes the bfd. 1307 1308*/ 1309 1310bfd_boolean 1311bfd_preserve_save (bfd *abfd, struct bfd_preserve *preserve) 1312{ 1313 preserve->tdata = abfd->tdata.any; 1314 preserve->arch_info = abfd->arch_info; 1315 preserve->flags = abfd->flags; 1316 preserve->sections = abfd->sections; 1317 preserve->section_tail = abfd->section_tail; 1318 preserve->section_count = abfd->section_count; 1319 preserve->section_htab = abfd->section_htab; 1320 1321 if (! bfd_hash_table_init (&abfd->section_htab, bfd_section_hash_newfunc)) 1322 return FALSE; 1323 1324 abfd->tdata.any = NULL; 1325 abfd->arch_info = &bfd_default_arch_struct; 1326 abfd->flags &= BFD_IN_MEMORY; 1327 abfd->sections = NULL; 1328 abfd->section_tail = &abfd->sections; 1329 abfd->section_count = 0; 1330 1331 return TRUE; 1332} 1333 1334/* 1335FUNCTION 1336 bfd_preserve_restore 1337 1338SYNOPSIS 1339 void bfd_preserve_restore (bfd *, struct bfd_preserve *); 1340 1341DESCRIPTION 1342 This function restores bfd state saved by bfd_preserve_save. 1343 If MARKER is non-NULL in struct bfd_preserve then that block 1344 and all subsequently bfd_alloc'd memory is freed. 1345 1346*/ 1347 1348void 1349bfd_preserve_restore (bfd *abfd, struct bfd_preserve *preserve) 1350{ 1351 bfd_hash_table_free (&abfd->section_htab); 1352 1353 abfd->tdata.any = preserve->tdata; 1354 abfd->arch_info = preserve->arch_info; 1355 abfd->flags = preserve->flags; 1356 abfd->section_htab = preserve->section_htab; 1357 abfd->sections = preserve->sections; 1358 abfd->section_tail = preserve->section_tail; 1359 abfd->section_count = preserve->section_count; 1360 1361 /* bfd_release frees all memory more recently bfd_alloc'd than 1362 its arg, as well as its arg. */ 1363 if (preserve->marker != NULL) 1364 { 1365 bfd_release (abfd, preserve->marker); 1366 preserve->marker = NULL; 1367 } 1368} 1369 1370/* 1371FUNCTION 1372 bfd_preserve_finish 1373 1374SYNOPSIS 1375 void bfd_preserve_finish (bfd *, struct bfd_preserve *); 1376 1377DESCRIPTION 1378 This function should be called when the bfd state saved by 1379 bfd_preserve_save is no longer needed. ie. when the back-end 1380 object_p function returns with success. 1381 1382*/ 1383 1384void 1385bfd_preserve_finish (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_preserve *preserve) 1386{ 1387 /* It would be nice to be able to free more memory here, eg. old 1388 tdata, but that's not possible since these blocks are sitting 1389 inside bfd_alloc'd memory. The section hash is on a separate 1390 objalloc. */ 1391 bfd_hash_table_free (&preserve->section_htab); 1392} |
|