OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-stable/] [gdb-7.2/] [bfd/] [bfd.c] - Blame information for rev 841

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.