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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-7.1/] [bfd/] [bfd.c] - Blame information for rev 856

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

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

powered by: WebSVN 2.1.0

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