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

Subversion Repositories open8_urisc

[/] [open8_urisc/] [trunk/] [gnu/] [binutils/] [bfd/] [bfd.c] - Blame information for rev 58

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

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

powered by: WebSVN 2.1.0

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