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 161

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 148 khays
      || strcmp (name, "pei-arm-wince-little") == 0
1035
      || strcmp (name, "aixcoff-rs6000") == 0)
1036 14 khays
    return 1;
1037
 
1038
  if (CONST_STRNEQ (name, "mach-o"))
1039
    return 0;
1040
 
1041
  bfd_set_error (bfd_error_wrong_format);
1042
  return -1;
1043
}
1044
 
1045
/*
1046
FUNCTION
1047
        bfd_set_start_address
1048
 
1049
SYNOPSIS
1050
        bfd_boolean bfd_set_start_address (bfd *abfd, bfd_vma vma);
1051
 
1052
DESCRIPTION
1053
        Make @var{vma} the entry point of output BFD @var{abfd}.
1054
 
1055
RETURNS
1056
        Returns <<TRUE>> on success, <<FALSE>> otherwise.
1057
*/
1058
 
1059
bfd_boolean
1060
bfd_set_start_address (bfd *abfd, bfd_vma vma)
1061
{
1062
  abfd->start_address = vma;
1063
  return TRUE;
1064
}
1065
 
1066
/*
1067
FUNCTION
1068
        bfd_get_gp_size
1069
 
1070
SYNOPSIS
1071
        unsigned int bfd_get_gp_size (bfd *abfd);
1072
 
1073
DESCRIPTION
1074
        Return the maximum size of objects to be optimized using the GP
1075
        register under MIPS ECOFF.  This is typically set by the <<-G>>
1076
        argument to the compiler, assembler or linker.
1077
*/
1078
 
1079
unsigned int
1080
bfd_get_gp_size (bfd *abfd)
1081
{
1082
  if (abfd->format == bfd_object)
1083
    {
1084
      if (abfd->xvec->flavour == bfd_target_ecoff_flavour)
1085
        return ecoff_data (abfd)->gp_size;
1086
      else if (abfd->xvec->flavour == bfd_target_elf_flavour)
1087
        return elf_gp_size (abfd);
1088
    }
1089
  return 0;
1090
}
1091
 
1092
/*
1093
FUNCTION
1094
        bfd_set_gp_size
1095
 
1096
SYNOPSIS
1097
        void bfd_set_gp_size (bfd *abfd, unsigned int i);
1098
 
1099
DESCRIPTION
1100
        Set the maximum size of objects to be optimized using the GP
1101
        register under ECOFF or MIPS ELF.  This is typically set by
1102
        the <<-G>> argument to the compiler, assembler or linker.
1103
*/
1104
 
1105
void
1106
bfd_set_gp_size (bfd *abfd, unsigned int i)
1107
{
1108
  /* Don't try to set GP size on an archive or core file!  */
1109
  if (abfd->format != bfd_object)
1110
    return;
1111
 
1112
  if (abfd->xvec->flavour == bfd_target_ecoff_flavour)
1113
    ecoff_data (abfd)->gp_size = i;
1114
  else if (abfd->xvec->flavour == bfd_target_elf_flavour)
1115
    elf_gp_size (abfd) = i;
1116
}
1117
 
1118
/* Get the GP value.  This is an internal function used by some of the
1119
   relocation special_function routines on targets which support a GP
1120
   register.  */
1121
 
1122
bfd_vma
1123
_bfd_get_gp_value (bfd *abfd)
1124
{
1125
  if (! abfd)
1126
    return 0;
1127
  if (abfd->format != bfd_object)
1128
    return 0;
1129
 
1130
  if (abfd->xvec->flavour == bfd_target_ecoff_flavour)
1131
    return ecoff_data (abfd)->gp;
1132
  else if (abfd->xvec->flavour == bfd_target_elf_flavour)
1133
    return elf_gp (abfd);
1134
 
1135
  return 0;
1136
}
1137
 
1138
/* Set the GP value.  */
1139
 
1140
void
1141
_bfd_set_gp_value (bfd *abfd, bfd_vma v)
1142
{
1143
  if (! abfd)
1144
    abort ();
1145
  if (abfd->format != bfd_object)
1146
    return;
1147
 
1148
  if (abfd->xvec->flavour == bfd_target_ecoff_flavour)
1149
    ecoff_data (abfd)->gp = v;
1150
  else if (abfd->xvec->flavour == bfd_target_elf_flavour)
1151
    elf_gp (abfd) = v;
1152
}
1153
 
1154
/*
1155
FUNCTION
1156
        bfd_scan_vma
1157
 
1158
SYNOPSIS
1159
        bfd_vma bfd_scan_vma (const char *string, const char **end, int base);
1160
 
1161
DESCRIPTION
1162
        Convert, like <<strtoul>>, a numerical expression
1163
        @var{string} into a <<bfd_vma>> integer, and return that integer.
1164
        (Though without as many bells and whistles as <<strtoul>>.)
1165
        The expression is assumed to be unsigned (i.e., positive).
1166
        If given a @var{base}, it is used as the base for conversion.
1167
        A base of 0 causes the function to interpret the string
1168
        in hex if a leading "0x" or "0X" is found, otherwise
1169
        in octal if a leading zero is found, otherwise in decimal.
1170
 
1171
        If the value would overflow, the maximum <<bfd_vma>> value is
1172
        returned.
1173
*/
1174
 
1175
bfd_vma
1176
bfd_scan_vma (const char *string, const char **end, int base)
1177
{
1178
  bfd_vma value;
1179
  bfd_vma cutoff;
1180
  unsigned int cutlim;
1181
  int overflow;
1182
 
1183
  /* Let the host do it if possible.  */
1184
  if (sizeof (bfd_vma) <= sizeof (unsigned long))
1185
    return strtoul (string, (char **) end, base);
1186
 
1187
#ifdef HAVE_STRTOULL
1188
  if (sizeof (bfd_vma) <= sizeof (unsigned long long))
1189
    return strtoull (string, (char **) end, base);
1190
#endif
1191
 
1192
  if (base == 0)
1193
    {
1194
      if (string[0] == '0')
1195
        {
1196
          if ((string[1] == 'x') || (string[1] == 'X'))
1197
            base = 16;
1198
          else
1199
            base = 8;
1200
        }
1201
    }
1202
 
1203
  if ((base < 2) || (base > 36))
1204
    base = 10;
1205
 
1206
  if (base == 16
1207
      && string[0] == '0'
1208
      && (string[1] == 'x' || string[1] == 'X')
1209
      && ISXDIGIT (string[2]))
1210
    {
1211
      string += 2;
1212
    }
1213
 
1214
  cutoff = (~ (bfd_vma) 0) / (bfd_vma) base;
1215
  cutlim = (~ (bfd_vma) 0) % (bfd_vma) base;
1216
  value = 0;
1217
  overflow = 0;
1218
  while (1)
1219
    {
1220
      unsigned int digit;
1221
 
1222
      digit = *string;
1223
      if (ISDIGIT (digit))
1224
        digit = digit - '0';
1225
      else if (ISALPHA (digit))
1226
        digit = TOUPPER (digit) - 'A' + 10;
1227
      else
1228
        break;
1229
      if (digit >= (unsigned int) base)
1230
        break;
1231
      if (value > cutoff || (value == cutoff && digit > cutlim))
1232
        overflow = 1;
1233
      value = value * base + digit;
1234
      ++string;
1235
    }
1236
 
1237
  if (overflow)
1238
    value = ~ (bfd_vma) 0;
1239
 
1240
  if (end != NULL)
1241
    *end = string;
1242
 
1243
  return value;
1244
}
1245
 
1246
/*
1247
FUNCTION
1248
        bfd_copy_private_header_data
1249
 
1250
SYNOPSIS
1251
        bfd_boolean bfd_copy_private_header_data (bfd *ibfd, bfd *obfd);
1252
 
1253
DESCRIPTION
1254
        Copy private BFD header information from the BFD @var{ibfd} to the
1255
        the BFD @var{obfd}.  This copies information that may require
1256
        sections to exist, but does not require symbol tables.  Return
1257
        <<true>> on success, <<false>> on error.
1258
        Possible error returns are:
1259
 
1260
        o <<bfd_error_no_memory>> -
1261
        Not enough memory exists to create private data for @var{obfd}.
1262
 
1263
.#define bfd_copy_private_header_data(ibfd, obfd) \
1264
.     BFD_SEND (obfd, _bfd_copy_private_header_data, \
1265
.               (ibfd, obfd))
1266
 
1267
*/
1268
 
1269
/*
1270
FUNCTION
1271
        bfd_copy_private_bfd_data
1272
 
1273
SYNOPSIS
1274
        bfd_boolean bfd_copy_private_bfd_data (bfd *ibfd, bfd *obfd);
1275
 
1276
DESCRIPTION
1277
        Copy private BFD information from the BFD @var{ibfd} to the
1278
        the BFD @var{obfd}.  Return <<TRUE>> on success, <<FALSE>> on error.
1279
        Possible error returns are:
1280
 
1281
        o <<bfd_error_no_memory>> -
1282
        Not enough memory exists to create private data for @var{obfd}.
1283
 
1284
.#define bfd_copy_private_bfd_data(ibfd, obfd) \
1285
.     BFD_SEND (obfd, _bfd_copy_private_bfd_data, \
1286
.               (ibfd, obfd))
1287
 
1288
*/
1289
 
1290
/*
1291
FUNCTION
1292
        bfd_merge_private_bfd_data
1293
 
1294
SYNOPSIS
1295
        bfd_boolean bfd_merge_private_bfd_data (bfd *ibfd, bfd *obfd);
1296
 
1297
DESCRIPTION
1298
        Merge private BFD information from the BFD @var{ibfd} to the
1299
        the output file BFD @var{obfd} when linking.  Return <<TRUE>>
1300
        on success, <<FALSE>> on error.  Possible error returns are:
1301
 
1302
        o <<bfd_error_no_memory>> -
1303
        Not enough memory exists to create private data for @var{obfd}.
1304
 
1305
.#define bfd_merge_private_bfd_data(ibfd, obfd) \
1306
.     BFD_SEND (obfd, _bfd_merge_private_bfd_data, \
1307
.               (ibfd, obfd))
1308
 
1309
*/
1310
 
1311
/*
1312
FUNCTION
1313
        bfd_set_private_flags
1314
 
1315
SYNOPSIS
1316
        bfd_boolean bfd_set_private_flags (bfd *abfd, flagword flags);
1317
 
1318
DESCRIPTION
1319
        Set private BFD flag information in the BFD @var{abfd}.
1320
        Return <<TRUE>> on success, <<FALSE>> on error.  Possible error
1321
        returns are:
1322
 
1323
        o <<bfd_error_no_memory>> -
1324
        Not enough memory exists to create private data for @var{obfd}.
1325
 
1326
.#define bfd_set_private_flags(abfd, flags) \
1327
.     BFD_SEND (abfd, _bfd_set_private_flags, (abfd, flags))
1328
 
1329
*/
1330
 
1331
/*
1332
FUNCTION
1333
        Other functions
1334
 
1335
DESCRIPTION
1336
        The following functions exist but have not yet been documented.
1337
 
1338
.#define bfd_sizeof_headers(abfd, info) \
1339
.       BFD_SEND (abfd, _bfd_sizeof_headers, (abfd, info))
1340
.
1341
.#define bfd_find_nearest_line(abfd, sec, syms, off, file, func, line) \
1342
.       BFD_SEND (abfd, _bfd_find_nearest_line, \
1343
.                 (abfd, sec, syms, off, file, func, line))
1344
.
1345
.#define bfd_find_line(abfd, syms, sym, file, line) \
1346
.       BFD_SEND (abfd, _bfd_find_line, \
1347
.                 (abfd, syms, sym, file, line))
1348
.
1349
.#define bfd_find_inliner_info(abfd, file, func, line) \
1350
.       BFD_SEND (abfd, _bfd_find_inliner_info, \
1351
.                 (abfd, file, func, line))
1352
.
1353
.#define bfd_debug_info_start(abfd) \
1354
.       BFD_SEND (abfd, _bfd_debug_info_start, (abfd))
1355
.
1356
.#define bfd_debug_info_end(abfd) \
1357
.       BFD_SEND (abfd, _bfd_debug_info_end, (abfd))
1358
.
1359
.#define bfd_debug_info_accumulate(abfd, section) \
1360
.       BFD_SEND (abfd, _bfd_debug_info_accumulate, (abfd, section))
1361
.
1362
.#define bfd_stat_arch_elt(abfd, stat) \
1363
.       BFD_SEND (abfd, _bfd_stat_arch_elt,(abfd, stat))
1364
.
1365
.#define bfd_update_armap_timestamp(abfd) \
1366
.       BFD_SEND (abfd, _bfd_update_armap_timestamp, (abfd))
1367
.
1368
.#define bfd_set_arch_mach(abfd, arch, mach)\
1369
.       BFD_SEND ( abfd, _bfd_set_arch_mach, (abfd, arch, mach))
1370
.
1371
.#define bfd_relax_section(abfd, section, link_info, again) \
1372
.       BFD_SEND (abfd, _bfd_relax_section, (abfd, section, link_info, again))
1373
.
1374
.#define bfd_gc_sections(abfd, link_info) \
1375
.       BFD_SEND (abfd, _bfd_gc_sections, (abfd, link_info))
1376
.
1377 161 khays
.#define bfd_lookup_section_flags(link_info, flag_info) \
1378
.       BFD_SEND (abfd, _bfd_lookup_section_flags, (link_info, flag_info))
1379
.
1380 14 khays
.#define bfd_merge_sections(abfd, link_info) \
1381
.       BFD_SEND (abfd, _bfd_merge_sections, (abfd, link_info))
1382
.
1383
.#define bfd_is_group_section(abfd, sec) \
1384
.       BFD_SEND (abfd, _bfd_is_group_section, (abfd, sec))
1385
.
1386
.#define bfd_discard_group(abfd, sec) \
1387
.       BFD_SEND (abfd, _bfd_discard_group, (abfd, sec))
1388
.
1389
.#define bfd_link_hash_table_create(abfd) \
1390
.       BFD_SEND (abfd, _bfd_link_hash_table_create, (abfd))
1391
.
1392
.#define bfd_link_hash_table_free(abfd, hash) \
1393
.       BFD_SEND (abfd, _bfd_link_hash_table_free, (hash))
1394
.
1395
.#define bfd_link_add_symbols(abfd, info) \
1396
.       BFD_SEND (abfd, _bfd_link_add_symbols, (abfd, info))
1397
.
1398
.#define bfd_link_just_syms(abfd, sec, info) \
1399
.       BFD_SEND (abfd, _bfd_link_just_syms, (sec, info))
1400
.
1401
.#define bfd_final_link(abfd, info) \
1402
.       BFD_SEND (abfd, _bfd_final_link, (abfd, info))
1403
.
1404
.#define bfd_free_cached_info(abfd) \
1405
.       BFD_SEND (abfd, _bfd_free_cached_info, (abfd))
1406
.
1407
.#define bfd_get_dynamic_symtab_upper_bound(abfd) \
1408
.       BFD_SEND (abfd, _bfd_get_dynamic_symtab_upper_bound, (abfd))
1409
.
1410
.#define bfd_print_private_bfd_data(abfd, file)\
1411
.       BFD_SEND (abfd, _bfd_print_private_bfd_data, (abfd, file))
1412
.
1413
.#define bfd_canonicalize_dynamic_symtab(abfd, asymbols) \
1414
.       BFD_SEND (abfd, _bfd_canonicalize_dynamic_symtab, (abfd, asymbols))
1415
.
1416
.#define bfd_get_synthetic_symtab(abfd, count, syms, dyncount, dynsyms, ret) \
1417
.       BFD_SEND (abfd, _bfd_get_synthetic_symtab, (abfd, count, syms, \
1418
.                                                   dyncount, dynsyms, ret))
1419
.
1420
.#define bfd_get_dynamic_reloc_upper_bound(abfd) \
1421
.       BFD_SEND (abfd, _bfd_get_dynamic_reloc_upper_bound, (abfd))
1422
.
1423
.#define bfd_canonicalize_dynamic_reloc(abfd, arels, asyms) \
1424
.       BFD_SEND (abfd, _bfd_canonicalize_dynamic_reloc, (abfd, arels, asyms))
1425
.
1426
.extern bfd_byte *bfd_get_relocated_section_contents
1427
.  (bfd *, struct bfd_link_info *, struct bfd_link_order *, bfd_byte *,
1428
.   bfd_boolean, asymbol **);
1429
.
1430
 
1431
*/
1432
 
1433
bfd_byte *
1434
bfd_get_relocated_section_contents (bfd *abfd,
1435
                                    struct bfd_link_info *link_info,
1436
                                    struct bfd_link_order *link_order,
1437
                                    bfd_byte *data,
1438
                                    bfd_boolean relocatable,
1439
                                    asymbol **symbols)
1440
{
1441
  bfd *abfd2;
1442
  bfd_byte *(*fn) (bfd *, struct bfd_link_info *, struct bfd_link_order *,
1443
                   bfd_byte *, bfd_boolean, asymbol **);
1444
 
1445
  if (link_order->type == bfd_indirect_link_order)
1446
    {
1447
      abfd2 = link_order->u.indirect.section->owner;
1448
      if (abfd2 == NULL)
1449
        abfd2 = abfd;
1450
    }
1451
  else
1452
    abfd2 = abfd;
1453
 
1454
  fn = abfd2->xvec->_bfd_get_relocated_section_contents;
1455
 
1456
  return (*fn) (abfd, link_info, link_order, data, relocatable, symbols);
1457
}
1458
 
1459
/* Record information about an ELF program header.  */
1460
 
1461
bfd_boolean
1462
bfd_record_phdr (bfd *abfd,
1463
                 unsigned long type,
1464
                 bfd_boolean flags_valid,
1465
                 flagword flags,
1466
                 bfd_boolean at_valid,
1467
                 bfd_vma at,
1468
                 bfd_boolean includes_filehdr,
1469
                 bfd_boolean includes_phdrs,
1470
                 unsigned int count,
1471
                 asection **secs)
1472
{
1473
  struct elf_segment_map *m, **pm;
1474
  bfd_size_type amt;
1475
 
1476
  if (bfd_get_flavour (abfd) != bfd_target_elf_flavour)
1477
    return TRUE;
1478
 
1479
  amt = sizeof (struct elf_segment_map);
1480
  amt += ((bfd_size_type) count - 1) * sizeof (asection *);
1481
  m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
1482
  if (m == NULL)
1483
    return FALSE;
1484
 
1485
  m->p_type = type;
1486
  m->p_flags = flags;
1487
  m->p_paddr = at;
1488
  m->p_flags_valid = flags_valid;
1489
  m->p_paddr_valid = at_valid;
1490
  m->includes_filehdr = includes_filehdr;
1491
  m->includes_phdrs = includes_phdrs;
1492
  m->count = count;
1493
  if (count > 0)
1494
    memcpy (m->sections, secs, count * sizeof (asection *));
1495
 
1496
  for (pm = &elf_tdata (abfd)->segment_map; *pm != NULL; pm = &(*pm)->next)
1497
    ;
1498
  *pm = m;
1499
 
1500
  return TRUE;
1501
}
1502
 
1503
#ifdef BFD64
1504
/* Return true iff this target is 32-bit.  */
1505
 
1506
static bfd_boolean
1507
is32bit (bfd *abfd)
1508
{
1509
  if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
1510
    {
1511
      const struct elf_backend_data *bed = get_elf_backend_data (abfd);
1512
      return bed->s->elfclass == ELFCLASS32;
1513
    }
1514
 
1515
  /* For non-ELF targets, use architecture information.  */
1516
  return bfd_arch_bits_per_address (abfd) <= 32;
1517
}
1518
#endif
1519
 
1520
/* bfd_sprintf_vma and bfd_fprintf_vma display an address in the
1521
   target's address size.  */
1522
 
1523
void
1524
bfd_sprintf_vma (bfd *abfd ATTRIBUTE_UNUSED, char *buf, bfd_vma value)
1525
{
1526
#ifdef BFD64
1527
  if (is32bit (abfd))
1528
    {
1529
      sprintf (buf, "%08lx", (unsigned long) value & 0xffffffff);
1530
      return;
1531
    }
1532
#endif
1533
  sprintf_vma (buf, value);
1534
}
1535
 
1536
void
1537
bfd_fprintf_vma (bfd *abfd ATTRIBUTE_UNUSED, void *stream, bfd_vma value)
1538
{
1539
#ifdef BFD64
1540
  if (is32bit (abfd))
1541
    {
1542
      fprintf ((FILE *) stream, "%08lx", (unsigned long) value & 0xffffffff);
1543
      return;
1544
    }
1545
#endif
1546
  fprintf_vma ((FILE *) stream, value);
1547
}
1548
 
1549
/*
1550
FUNCTION
1551
        bfd_alt_mach_code
1552
 
1553
SYNOPSIS
1554
        bfd_boolean bfd_alt_mach_code (bfd *abfd, int alternative);
1555
 
1556
DESCRIPTION
1557
 
1558
        When more than one machine code number is available for the
1559
        same machine type, this function can be used to switch between
1560
        the preferred one (alternative == 0) and any others.  Currently,
1561
        only ELF supports this feature, with up to two alternate
1562
        machine codes.
1563
*/
1564
 
1565
bfd_boolean
1566
bfd_alt_mach_code (bfd *abfd, int alternative)
1567
{
1568
  if (bfd_get_flavour (abfd) == bfd_target_elf_flavour)
1569
    {
1570
      int code;
1571
 
1572
      switch (alternative)
1573
        {
1574
        case 0:
1575
          code = get_elf_backend_data (abfd)->elf_machine_code;
1576
          break;
1577
 
1578
        case 1:
1579
          code = get_elf_backend_data (abfd)->elf_machine_alt1;
1580
          if (code == 0)
1581
            return FALSE;
1582
          break;
1583
 
1584
        case 2:
1585
          code = get_elf_backend_data (abfd)->elf_machine_alt2;
1586
          if (code == 0)
1587
            return FALSE;
1588
          break;
1589
 
1590
        default:
1591
          return FALSE;
1592
        }
1593
 
1594
      elf_elfheader (abfd)->e_machine = code;
1595
 
1596
      return TRUE;
1597
    }
1598
 
1599
  return FALSE;
1600
}
1601
 
1602
/*
1603
CODE_FRAGMENT
1604
 
1605
.struct bfd_preserve
1606
.{
1607
.  void *marker;
1608
.  void *tdata;
1609
.  flagword flags;
1610
.  const struct bfd_arch_info *arch_info;
1611
.  struct bfd_section *sections;
1612
.  struct bfd_section *section_last;
1613
.  unsigned int section_count;
1614
.  struct bfd_hash_table section_htab;
1615
.};
1616
.
1617
*/
1618
 
1619
/*
1620
FUNCTION
1621
        bfd_preserve_save
1622
 
1623
SYNOPSIS
1624
        bfd_boolean bfd_preserve_save (bfd *, struct bfd_preserve *);
1625
 
1626
DESCRIPTION
1627
        When testing an object for compatibility with a particular
1628
        target back-end, the back-end object_p function needs to set
1629
        up certain fields in the bfd on successfully recognizing the
1630
        object.  This typically happens in a piecemeal fashion, with
1631
        failures possible at many points.  On failure, the bfd is
1632
        supposed to be restored to its initial state, which is
1633
        virtually impossible.  However, restoring a subset of the bfd
1634
        state works in practice.  This function stores the subset and
1635
        reinitializes the bfd.
1636
 
1637
*/
1638
 
1639
bfd_boolean
1640
bfd_preserve_save (bfd *abfd, struct bfd_preserve *preserve)
1641
{
1642
  preserve->tdata = abfd->tdata.any;
1643
  preserve->arch_info = abfd->arch_info;
1644
  preserve->flags = abfd->flags;
1645
  preserve->sections = abfd->sections;
1646
  preserve->section_last = abfd->section_last;
1647
  preserve->section_count = abfd->section_count;
1648
  preserve->section_htab = abfd->section_htab;
1649
 
1650
  if (! bfd_hash_table_init (&abfd->section_htab, bfd_section_hash_newfunc,
1651
                             sizeof (struct section_hash_entry)))
1652
    return FALSE;
1653
 
1654
  abfd->tdata.any = NULL;
1655
  abfd->arch_info = &bfd_default_arch_struct;
1656
  abfd->flags &= BFD_FLAGS_SAVED;
1657
  abfd->sections = NULL;
1658
  abfd->section_last = NULL;
1659
  abfd->section_count = 0;
1660
 
1661
  return TRUE;
1662
}
1663
 
1664
/*
1665
FUNCTION
1666
        bfd_preserve_restore
1667
 
1668
SYNOPSIS
1669
        void bfd_preserve_restore (bfd *, struct bfd_preserve *);
1670
 
1671
DESCRIPTION
1672
        This function restores bfd state saved by bfd_preserve_save.
1673
        If MARKER is non-NULL in struct bfd_preserve then that block
1674
        and all subsequently bfd_alloc'd memory is freed.
1675
 
1676
*/
1677
 
1678
void
1679
bfd_preserve_restore (bfd *abfd, struct bfd_preserve *preserve)
1680
{
1681
  bfd_hash_table_free (&abfd->section_htab);
1682
 
1683
  abfd->tdata.any = preserve->tdata;
1684
  abfd->arch_info = preserve->arch_info;
1685
  abfd->flags = preserve->flags;
1686
  abfd->section_htab = preserve->section_htab;
1687
  abfd->sections = preserve->sections;
1688
  abfd->section_last = preserve->section_last;
1689
  abfd->section_count = preserve->section_count;
1690
 
1691
  /* bfd_release frees all memory more recently bfd_alloc'd than
1692
     its arg, as well as its arg.  */
1693
  if (preserve->marker != NULL)
1694
    {
1695
      bfd_release (abfd, preserve->marker);
1696
      preserve->marker = NULL;
1697
    }
1698
}
1699
 
1700
/*
1701
FUNCTION
1702
        bfd_preserve_finish
1703
 
1704
SYNOPSIS
1705
        void bfd_preserve_finish (bfd *, struct bfd_preserve *);
1706
 
1707
DESCRIPTION
1708
        This function should be called when the bfd state saved by
1709
        bfd_preserve_save is no longer needed.  ie. when the back-end
1710
        object_p function returns with success.
1711
 
1712
*/
1713
 
1714
void
1715
bfd_preserve_finish (bfd *abfd ATTRIBUTE_UNUSED, struct bfd_preserve *preserve)
1716
{
1717
  /* It would be nice to be able to free more memory here, eg. old
1718
     tdata, but that's not possible since these blocks are sitting
1719
     inside bfd_alloc'd memory.  The section hash is on a separate
1720
     objalloc.  */
1721
  bfd_hash_table_free (&preserve->section_htab);
1722
}
1723
 
1724
/*
1725
FUNCTION
1726
        bfd_emul_get_maxpagesize
1727
 
1728
SYNOPSIS
1729
        bfd_vma bfd_emul_get_maxpagesize (const char *);
1730
 
1731
DESCRIPTION
1732
        Returns the maximum page size, in bytes, as determined by
1733
        emulation.
1734
 
1735
RETURNS
1736
        Returns the maximum page size in bytes for ELF, 0 otherwise.
1737
*/
1738
 
1739
bfd_vma
1740
bfd_emul_get_maxpagesize (const char *emul)
1741
{
1742
  const bfd_target *target;
1743
 
1744
  target = bfd_find_target (emul, NULL);
1745
  if (target != NULL
1746
      && target->flavour == bfd_target_elf_flavour)
1747
    return xvec_get_elf_backend_data (target)->maxpagesize;
1748
 
1749
  return 0;
1750
}
1751
 
1752
static void
1753
bfd_elf_set_pagesize (const bfd_target *target, bfd_vma size,
1754
                      int offset, const bfd_target *orig_target)
1755
{
1756
  if (target->flavour == bfd_target_elf_flavour)
1757
    {
1758
      const struct elf_backend_data *bed;
1759
 
1760
      bed = xvec_get_elf_backend_data (target);
1761
      *((bfd_vma *) ((char *) bed + offset)) = size;
1762
    }
1763
 
1764
  if (target->alternative_target
1765
      && target->alternative_target != orig_target)
1766
    bfd_elf_set_pagesize (target->alternative_target, size, offset,
1767
                          orig_target);
1768
}
1769
 
1770
/*
1771
FUNCTION
1772
        bfd_emul_set_maxpagesize
1773
 
1774
SYNOPSIS
1775
        void bfd_emul_set_maxpagesize (const char *, bfd_vma);
1776
 
1777
DESCRIPTION
1778
        For ELF, set the maximum page size for the emulation.  It is
1779
        a no-op for other formats.
1780
 
1781
*/
1782
 
1783
void
1784
bfd_emul_set_maxpagesize (const char *emul, bfd_vma size)
1785
{
1786
  const bfd_target *target;
1787
 
1788
  target = bfd_find_target (emul, NULL);
1789
  if (target)
1790
    bfd_elf_set_pagesize (target, size,
1791
                          offsetof (struct elf_backend_data,
1792
                                    maxpagesize), target);
1793
}
1794
 
1795
/*
1796
FUNCTION
1797
        bfd_emul_get_commonpagesize
1798
 
1799
SYNOPSIS
1800
        bfd_vma bfd_emul_get_commonpagesize (const char *);
1801
 
1802
DESCRIPTION
1803
        Returns the common page size, in bytes, as determined by
1804
        emulation.
1805
 
1806
RETURNS
1807
        Returns the common page size in bytes for ELF, 0 otherwise.
1808
*/
1809
 
1810
bfd_vma
1811
bfd_emul_get_commonpagesize (const char *emul)
1812
{
1813
  const bfd_target *target;
1814
 
1815
  target = bfd_find_target (emul, NULL);
1816
  if (target != NULL
1817
      && target->flavour == bfd_target_elf_flavour)
1818
    return xvec_get_elf_backend_data (target)->commonpagesize;
1819
 
1820
  return 0;
1821
}
1822
 
1823
/*
1824
FUNCTION
1825
        bfd_emul_set_commonpagesize
1826
 
1827
SYNOPSIS
1828
        void bfd_emul_set_commonpagesize (const char *, bfd_vma);
1829
 
1830
DESCRIPTION
1831
        For ELF, set the common page size for the emulation.  It is
1832
        a no-op for other formats.
1833
 
1834
*/
1835
 
1836
void
1837
bfd_emul_set_commonpagesize (const char *emul, bfd_vma size)
1838
{
1839
  const bfd_target *target;
1840
 
1841
  target = bfd_find_target (emul, NULL);
1842
  if (target)
1843
    bfd_elf_set_pagesize (target, size,
1844
                          offsetof (struct elf_backend_data,
1845
                                    commonpagesize), target);
1846
}
1847
 
1848
/*
1849
FUNCTION
1850
        bfd_demangle
1851
 
1852
SYNOPSIS
1853
        char *bfd_demangle (bfd *, const char *, int);
1854
 
1855
DESCRIPTION
1856
        Wrapper around cplus_demangle.  Strips leading underscores and
1857
        other such chars that would otherwise confuse the demangler.
1858
        If passed a g++ v3 ABI mangled name, returns a buffer allocated
1859
        with malloc holding the demangled name.  Returns NULL otherwise
1860
        and on memory alloc failure.
1861
*/
1862
 
1863
char *
1864
bfd_demangle (bfd *abfd, const char *name, int options)
1865
{
1866
  char *res, *alloc;
1867
  const char *pre, *suf;
1868
  size_t pre_len;
1869
  bfd_boolean skip_lead;
1870
 
1871
  skip_lead = (abfd != NULL
1872
               && *name != '\0'
1873
               && bfd_get_symbol_leading_char (abfd) == *name);
1874
  if (skip_lead)
1875
    ++name;
1876
 
1877
  /* This is a hack for better error reporting on XCOFF, PowerPC64-ELF
1878
     or the MS PE format.  These formats have a number of leading '.'s
1879
     on at least some symbols, so we remove all dots to avoid
1880
     confusing the demangler.  */
1881
  pre = name;
1882
  while (*name == '.' || *name == '$')
1883
    ++name;
1884
  pre_len = name - pre;
1885
 
1886
  /* Strip off @plt and suchlike too.  */
1887
  alloc = NULL;
1888
  suf = strchr (name, '@');
1889
  if (suf != NULL)
1890
    {
1891
      alloc = (char *) bfd_malloc (suf - name + 1);
1892
      if (alloc == NULL)
1893
        return NULL;
1894
      memcpy (alloc, name, suf - name);
1895
      alloc[suf - name] = '\0';
1896
      name = alloc;
1897
    }
1898
 
1899
  res = cplus_demangle (name, options);
1900
 
1901
  if (alloc != NULL)
1902
    free (alloc);
1903
 
1904
  if (res == NULL)
1905
    {
1906
      if (skip_lead)
1907
        {
1908
          size_t len = strlen (pre) + 1;
1909
          alloc = (char *) bfd_malloc (len);
1910
          if (alloc == NULL)
1911
            return NULL;
1912
          memcpy (alloc, pre, len);
1913
          return alloc;
1914
        }
1915
      return NULL;
1916
    }
1917
 
1918
  /* Put back any prefix or suffix.  */
1919
  if (pre_len != 0 || suf != NULL)
1920
    {
1921
      size_t len;
1922
      size_t suf_len;
1923
      char *final;
1924
 
1925
      len = strlen (res);
1926
      if (suf == NULL)
1927
        suf = res + len;
1928
      suf_len = strlen (suf) + 1;
1929
      final = (char *) bfd_malloc (pre_len + len + suf_len);
1930
      if (final != NULL)
1931
        {
1932
          memcpy (final, pre, pre_len);
1933
          memcpy (final + pre_len, res, len);
1934
          memcpy (final + pre_len + len, suf, suf_len);
1935
        }
1936
      free (res);
1937
      res = final;
1938
    }
1939
 
1940
  return res;
1941
}

powered by: WebSVN 2.1.0

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