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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [binutils-2.18.50/] [bfd/] [bfd.c] - Blame information for rev 179

Go to most recent revision | Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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