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