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

Subversion Repositories open8_urisc

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

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 14 khays
/* Generic symbol-table support for the BFD library.
2
   Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3
   2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009
4
   Free Software Foundation, Inc.
5
   Written by Cygnus Support.
6
 
7
   This file is part of BFD, the Binary File Descriptor library.
8
 
9
   This program is free software; you can redistribute it and/or modify
10
   it under the terms of the GNU General Public License as published by
11
   the Free Software Foundation; either version 3 of the License, or
12
   (at your option) any later version.
13
 
14
   This program is distributed in the hope that it will be useful,
15
   but WITHOUT ANY WARRANTY; without even the implied warranty of
16
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17
   GNU General Public License for more details.
18
 
19
   You should have received a copy of the GNU General Public License
20
   along with this program; if not, write to the Free Software
21
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
22
   MA 02110-1301, USA.  */
23
 
24
/*
25
SECTION
26
        Symbols
27
 
28
        BFD tries to maintain as much symbol information as it can when
29
        it moves information from file to file. BFD passes information
30
        to applications though the <<asymbol>> structure. When the
31
        application requests the symbol table, BFD reads the table in
32
        the native form and translates parts of it into the internal
33
        format. To maintain more than the information passed to
34
        applications, some targets keep some information ``behind the
35
        scenes'' in a structure only the particular back end knows
36
        about. For example, the coff back end keeps the original
37
        symbol table structure as well as the canonical structure when
38
        a BFD is read in. On output, the coff back end can reconstruct
39
        the output symbol table so that no information is lost, even
40
        information unique to coff which BFD doesn't know or
41
        understand. If a coff symbol table were read, but were written
42
        through an a.out back end, all the coff specific information
43
        would be lost. The symbol table of a BFD
44
        is not necessarily read in until a canonicalize request is
45
        made. Then the BFD back end fills in a table provided by the
46
        application with pointers to the canonical information.  To
47
        output symbols, the application provides BFD with a table of
48
        pointers to pointers to <<asymbol>>s. This allows applications
49
        like the linker to output a symbol as it was read, since the ``behind
50
        the scenes'' information will be still available.
51
@menu
52
@* Reading Symbols::
53
@* Writing Symbols::
54
@* Mini Symbols::
55
@* typedef asymbol::
56
@* symbol handling functions::
57
@end menu
58
 
59
INODE
60
Reading Symbols, Writing Symbols, Symbols, Symbols
61
SUBSECTION
62
        Reading symbols
63
 
64
        There are two stages to reading a symbol table from a BFD:
65
        allocating storage, and the actual reading process. This is an
66
        excerpt from an application which reads the symbol table:
67
 
68
|         long storage_needed;
69
|         asymbol **symbol_table;
70
|         long number_of_symbols;
71
|         long i;
72
|
73
|         storage_needed = bfd_get_symtab_upper_bound (abfd);
74
|
75
|         if (storage_needed < 0)
76
|           FAIL
77
|
78
|         if (storage_needed == 0)
79
|           return;
80
|
81
|         symbol_table = xmalloc (storage_needed);
82
|           ...
83
|         number_of_symbols =
84
|            bfd_canonicalize_symtab (abfd, symbol_table);
85
|
86
|         if (number_of_symbols < 0)
87
|           FAIL
88
|
89
|         for (i = 0; i < number_of_symbols; i++)
90
|           process_symbol (symbol_table[i]);
91
 
92
        All storage for the symbols themselves is in an objalloc
93
        connected to the BFD; it is freed when the BFD is closed.
94
 
95
INODE
96
Writing Symbols, Mini Symbols, Reading Symbols, Symbols
97
SUBSECTION
98
        Writing symbols
99
 
100
        Writing of a symbol table is automatic when a BFD open for
101
        writing is closed. The application attaches a vector of
102
        pointers to pointers to symbols to the BFD being written, and
103
        fills in the symbol count. The close and cleanup code reads
104
        through the table provided and performs all the necessary
105
        operations. The BFD output code must always be provided with an
106
        ``owned'' symbol: one which has come from another BFD, or one
107
        which has been created using <<bfd_make_empty_symbol>>.  Here is an
108
        example showing the creation of a symbol table with only one element:
109
 
110
|       #include "bfd.h"
111
|       int main (void)
112
|       {
113
|         bfd *abfd;
114
|         asymbol *ptrs[2];
115
|         asymbol *new;
116
|
117
|         abfd = bfd_openw ("foo","a.out-sunos-big");
118
|         bfd_set_format (abfd, bfd_object);
119
|         new = bfd_make_empty_symbol (abfd);
120
|         new->name = "dummy_symbol";
121
|         new->section = bfd_make_section_old_way (abfd, ".text");
122
|         new->flags = BSF_GLOBAL;
123
|         new->value = 0x12345;
124
|
125
|         ptrs[0] = new;
126
|         ptrs[1] = 0;
127
|
128
|         bfd_set_symtab (abfd, ptrs, 1);
129
|         bfd_close (abfd);
130
|         return 0;
131
|       }
132
|
133
|       ./makesym
134
|       nm foo
135
|       00012345 A dummy_symbol
136
 
137
        Many formats cannot represent arbitrary symbol information; for
138
        instance, the <<a.out>> object format does not allow an
139
        arbitrary number of sections. A symbol pointing to a section
140
        which is not one  of <<.text>>, <<.data>> or <<.bss>> cannot
141
        be described.
142
 
143
INODE
144
Mini Symbols, typedef asymbol, Writing Symbols, Symbols
145
SUBSECTION
146
        Mini Symbols
147
 
148
        Mini symbols provide read-only access to the symbol table.
149
        They use less memory space, but require more time to access.
150
        They can be useful for tools like nm or objdump, which may
151
        have to handle symbol tables of extremely large executables.
152
 
153
        The <<bfd_read_minisymbols>> function will read the symbols
154
        into memory in an internal form.  It will return a <<void *>>
155
        pointer to a block of memory, a symbol count, and the size of
156
        each symbol.  The pointer is allocated using <<malloc>>, and
157
        should be freed by the caller when it is no longer needed.
158
 
159
        The function <<bfd_minisymbol_to_symbol>> will take a pointer
160
        to a minisymbol, and a pointer to a structure returned by
161
        <<bfd_make_empty_symbol>>, and return a <<asymbol>> structure.
162
        The return value may or may not be the same as the value from
163
        <<bfd_make_empty_symbol>> which was passed in.
164
 
165
*/
166
 
167
/*
168
DOCDD
169
INODE
170
typedef asymbol, symbol handling functions, Mini Symbols, Symbols
171
 
172
*/
173
/*
174
SUBSECTION
175
        typedef asymbol
176
 
177
        An <<asymbol>> has the form:
178
 
179
*/
180
 
181
/*
182
CODE_FRAGMENT
183
 
184
.
185
.typedef struct bfd_symbol
186
.{
187
.  {* A pointer to the BFD which owns the symbol. This information
188
.     is necessary so that a back end can work out what additional
189
.     information (invisible to the application writer) is carried
190
.     with the symbol.
191
.
192
.     This field is *almost* redundant, since you can use section->owner
193
.     instead, except that some symbols point to the global sections
194
.     bfd_{abs,com,und}_section.  This could be fixed by making
195
.     these globals be per-bfd (or per-target-flavor).  FIXME.  *}
196
.  struct bfd *the_bfd; {* Use bfd_asymbol_bfd(sym) to access this field.  *}
197
.
198
.  {* The text of the symbol. The name is left alone, and not copied; the
199
.     application may not alter it.  *}
200
.  const char *name;
201
.
202
.  {* The value of the symbol.  This really should be a union of a
203
.     numeric value with a pointer, since some flags indicate that
204
.     a pointer to another symbol is stored here.  *}
205
.  symvalue value;
206
.
207
.  {* Attributes of a symbol.  *}
208
.#define BSF_NO_FLAGS           0x00
209
.
210
.  {* The symbol has local scope; <<static>> in <<C>>. The value
211
.     is the offset into the section of the data.  *}
212
.#define BSF_LOCAL              (1 << 0)
213
.
214
.  {* The symbol has global scope; initialized data in <<C>>. The
215
.     value is the offset into the section of the data.  *}
216
.#define BSF_GLOBAL             (1 << 1)
217
.
218
.  {* The symbol has global scope and is exported. The value is
219
.     the offset into the section of the data.  *}
220
.#define BSF_EXPORT     BSF_GLOBAL {* No real difference.  *}
221
.
222
.  {* A normal C symbol would be one of:
223
.     <<BSF_LOCAL>>, <<BSF_COMMON>>,  <<BSF_UNDEFINED>> or
224
.     <<BSF_GLOBAL>>.  *}
225
.
226
.  {* The symbol is a debugging record. The value has an arbitrary
227
.     meaning, unless BSF_DEBUGGING_RELOC is also set.  *}
228
.#define BSF_DEBUGGING          (1 << 2)
229
.
230
.  {* The symbol denotes a function entry point.  Used in ELF,
231
.     perhaps others someday.  *}
232
.#define BSF_FUNCTION           (1 << 3)
233
.
234
.  {* Used by the linker.  *}
235
.#define BSF_KEEP               (1 << 5)
236
.#define BSF_KEEP_G             (1 << 6)
237
.
238
.  {* A weak global symbol, overridable without warnings by
239
.     a regular global symbol of the same name.  *}
240
.#define BSF_WEAK               (1 << 7)
241
.
242
.  {* This symbol was created to point to a section, e.g. ELF's
243
.     STT_SECTION symbols.  *}
244
.#define BSF_SECTION_SYM        (1 << 8)
245
.
246
.  {* The symbol used to be a common symbol, but now it is
247
.     allocated.  *}
248
.#define BSF_OLD_COMMON         (1 << 9)
249
.
250
.  {* In some files the type of a symbol sometimes alters its
251
.     location in an output file - ie in coff a <<ISFCN>> symbol
252
.     which is also <<C_EXT>> symbol appears where it was
253
.     declared and not at the end of a section.  This bit is set
254
.     by the target BFD part to convey this information.  *}
255
.#define BSF_NOT_AT_END         (1 << 10)
256
.
257
.  {* Signal that the symbol is the label of constructor section.  *}
258
.#define BSF_CONSTRUCTOR        (1 << 11)
259
.
260
.  {* Signal that the symbol is a warning symbol.  The name is a
261
.     warning.  The name of the next symbol is the one to warn about;
262
.     if a reference is made to a symbol with the same name as the next
263
.     symbol, a warning is issued by the linker.  *}
264
.#define BSF_WARNING            (1 << 12)
265
.
266
.  {* Signal that the symbol is indirect.  This symbol is an indirect
267
.     pointer to the symbol with the same name as the next symbol.  *}
268
.#define BSF_INDIRECT           (1 << 13)
269
.
270
.  {* BSF_FILE marks symbols that contain a file name.  This is used
271
.     for ELF STT_FILE symbols.  *}
272
.#define BSF_FILE               (1 << 14)
273
.
274
.  {* Symbol is from dynamic linking information.  *}
275
.#define BSF_DYNAMIC            (1 << 15)
276
.
277
.  {* The symbol denotes a data object.  Used in ELF, and perhaps
278
.     others someday.  *}
279
.#define BSF_OBJECT             (1 << 16)
280
.
281
.  {* This symbol is a debugging symbol.  The value is the offset
282
.     into the section of the data.  BSF_DEBUGGING should be set
283
.     as well.  *}
284
.#define BSF_DEBUGGING_RELOC    (1 << 17)
285
.
286
.  {* This symbol is thread local.  Used in ELF.  *}
287
.#define BSF_THREAD_LOCAL       (1 << 18)
288
.
289
.  {* This symbol represents a complex relocation expression,
290
.     with the expression tree serialized in the symbol name.  *}
291
.#define BSF_RELC               (1 << 19)
292
.
293
.  {* This symbol represents a signed complex relocation expression,
294
.     with the expression tree serialized in the symbol name.  *}
295
.#define BSF_SRELC              (1 << 20)
296
.
297
.  {* This symbol was created by bfd_get_synthetic_symtab.  *}
298
.#define BSF_SYNTHETIC          (1 << 21)
299
.
300
.  {* This symbol is an indirect code object.  Unrelated to BSF_INDIRECT.
301
.     The dynamic linker will compute the value of this symbol by
302
.     calling the function that it points to.  BSF_FUNCTION must
303
.     also be also set.  *}
304
.#define BSF_GNU_INDIRECT_FUNCTION (1 << 22)
305
.  {* This symbol is a globally unique data object.  The dynamic linker
306
.     will make sure that in the entire process there is just one symbol
307
.     with this name and type in use.  BSF_OBJECT must also be set.  *}
308
.#define BSF_GNU_UNIQUE         (1 << 23)
309
.
310
.  flagword flags;
311
.
312
.  {* A pointer to the section to which this symbol is
313
.     relative.  This will always be non NULL, there are special
314
.     sections for undefined and absolute symbols.  *}
315
.  struct bfd_section *section;
316
.
317
.  {* Back end special data.  *}
318
.  union
319
.    {
320
.      void *p;
321
.      bfd_vma i;
322
.    }
323
.  udata;
324
.}
325
.asymbol;
326
.
327
*/
328
 
329
#include "sysdep.h"
330
#include "bfd.h"
331
#include "libbfd.h"
332
#include "safe-ctype.h"
333
#include "bfdlink.h"
334
#include "aout/stab_gnu.h"
335
 
336
/*
337
DOCDD
338
INODE
339
symbol handling functions,  , typedef asymbol, Symbols
340
SUBSECTION
341
        Symbol handling functions
342
*/
343
 
344
/*
345
FUNCTION
346
        bfd_get_symtab_upper_bound
347
 
348
DESCRIPTION
349
        Return the number of bytes required to store a vector of pointers
350
        to <<asymbols>> for all the symbols in the BFD @var{abfd},
351
        including a terminal NULL pointer. If there are no symbols in
352
        the BFD, then return 0.  If an error occurs, return -1.
353
 
354
.#define bfd_get_symtab_upper_bound(abfd) \
355
.     BFD_SEND (abfd, _bfd_get_symtab_upper_bound, (abfd))
356
.
357
*/
358
 
359
/*
360
FUNCTION
361
        bfd_is_local_label
362
 
363
SYNOPSIS
364
        bfd_boolean bfd_is_local_label (bfd *abfd, asymbol *sym);
365
 
366
DESCRIPTION
367
        Return TRUE if the given symbol @var{sym} in the BFD @var{abfd} is
368
        a compiler generated local label, else return FALSE.
369
*/
370
 
371
bfd_boolean
372
bfd_is_local_label (bfd *abfd, asymbol *sym)
373
{
374
  /* The BSF_SECTION_SYM check is needed for IA-64, where every label that
375
     starts with '.' is local.  This would accidentally catch section names
376
     if we didn't reject them here.  */
377
  if ((sym->flags & (BSF_GLOBAL | BSF_WEAK | BSF_FILE | BSF_SECTION_SYM)) != 0)
378
    return FALSE;
379
  if (sym->name == NULL)
380
    return FALSE;
381
  return bfd_is_local_label_name (abfd, sym->name);
382
}
383
 
384
/*
385
FUNCTION
386
        bfd_is_local_label_name
387
 
388
SYNOPSIS
389
        bfd_boolean bfd_is_local_label_name (bfd *abfd, const char *name);
390
 
391
DESCRIPTION
392
        Return TRUE if a symbol with the name @var{name} in the BFD
393
        @var{abfd} is a compiler generated local label, else return
394
        FALSE.  This just checks whether the name has the form of a
395
        local label.
396
 
397
.#define bfd_is_local_label_name(abfd, name) \
398
.  BFD_SEND (abfd, _bfd_is_local_label_name, (abfd, name))
399
.
400
*/
401
 
402
/*
403
FUNCTION
404
        bfd_is_target_special_symbol
405
 
406
SYNOPSIS
407
        bfd_boolean bfd_is_target_special_symbol (bfd *abfd, asymbol *sym);
408
 
409
DESCRIPTION
410
        Return TRUE iff a symbol @var{sym} in the BFD @var{abfd} is something
411
        special to the particular target represented by the BFD.  Such symbols
412
        should normally not be mentioned to the user.
413
 
414
.#define bfd_is_target_special_symbol(abfd, sym) \
415
.  BFD_SEND (abfd, _bfd_is_target_special_symbol, (abfd, sym))
416
.
417
*/
418
 
419
/*
420
FUNCTION
421
        bfd_canonicalize_symtab
422
 
423
DESCRIPTION
424
        Read the symbols from the BFD @var{abfd}, and fills in
425
        the vector @var{location} with pointers to the symbols and
426
        a trailing NULL.
427
        Return the actual number of symbol pointers, not
428
        including the NULL.
429
 
430
.#define bfd_canonicalize_symtab(abfd, location) \
431
.  BFD_SEND (abfd, _bfd_canonicalize_symtab, (abfd, location))
432
.
433
*/
434
 
435
/*
436
FUNCTION
437
        bfd_set_symtab
438
 
439
SYNOPSIS
440
        bfd_boolean bfd_set_symtab
441
          (bfd *abfd, asymbol **location, unsigned int count);
442
 
443
DESCRIPTION
444
        Arrange that when the output BFD @var{abfd} is closed,
445
        the table @var{location} of @var{count} pointers to symbols
446
        will be written.
447
*/
448
 
449
bfd_boolean
450
bfd_set_symtab (bfd *abfd, asymbol **location, unsigned int symcount)
451
{
452
  if (abfd->format != bfd_object || bfd_read_p (abfd))
453
    {
454
      bfd_set_error (bfd_error_invalid_operation);
455
      return FALSE;
456
    }
457
 
458
  bfd_get_outsymbols (abfd) = location;
459
  bfd_get_symcount (abfd) = symcount;
460
  return TRUE;
461
}
462
 
463
/*
464
FUNCTION
465
        bfd_print_symbol_vandf
466
 
467
SYNOPSIS
468
        void bfd_print_symbol_vandf (bfd *abfd, void *file, asymbol *symbol);
469
 
470
DESCRIPTION
471
        Print the value and flags of the @var{symbol} supplied to the
472
        stream @var{file}.
473
*/
474
void
475
bfd_print_symbol_vandf (bfd *abfd, void *arg, asymbol *symbol)
476
{
477
  FILE *file = (FILE *) arg;
478
 
479
  flagword type = symbol->flags;
480
 
481
  if (symbol->section != NULL)
482
    bfd_fprintf_vma (abfd, file, symbol->value + symbol->section->vma);
483
  else
484
    bfd_fprintf_vma (abfd, file, symbol->value);
485
 
486
  /* This presumes that a symbol can not be both BSF_DEBUGGING and
487
     BSF_DYNAMIC, nor more than one of BSF_FUNCTION, BSF_FILE, and
488
     BSF_OBJECT.  */
489
  fprintf (file, " %c%c%c%c%c%c%c",
490
           ((type & BSF_LOCAL)
491
            ? (type & BSF_GLOBAL) ? '!' : 'l'
492
            : (type & BSF_GLOBAL) ? 'g'
493
            : (type & BSF_GNU_UNIQUE) ? 'u' : ' '),
494
           (type & BSF_WEAK) ? 'w' : ' ',
495
           (type & BSF_CONSTRUCTOR) ? 'C' : ' ',
496
           (type & BSF_WARNING) ? 'W' : ' ',
497
           (type & BSF_INDIRECT) ? 'I' : (type & BSF_GNU_INDIRECT_FUNCTION) ? 'i' : ' ',
498
           (type & BSF_DEBUGGING) ? 'd' : (type & BSF_DYNAMIC) ? 'D' : ' ',
499
           ((type & BSF_FUNCTION)
500
            ? 'F'
501
            : ((type & BSF_FILE)
502
               ? 'f'
503
               : ((type & BSF_OBJECT) ? 'O' : ' '))));
504
}
505
 
506
/*
507
FUNCTION
508
        bfd_make_empty_symbol
509
 
510
DESCRIPTION
511
        Create a new <<asymbol>> structure for the BFD @var{abfd}
512
        and return a pointer to it.
513
 
514
        This routine is necessary because each back end has private
515
        information surrounding the <<asymbol>>. Building your own
516
        <<asymbol>> and pointing to it will not create the private
517
        information, and will cause problems later on.
518
 
519
.#define bfd_make_empty_symbol(abfd) \
520
.  BFD_SEND (abfd, _bfd_make_empty_symbol, (abfd))
521
.
522
*/
523
 
524
/*
525
FUNCTION
526
        _bfd_generic_make_empty_symbol
527
 
528
SYNOPSIS
529
        asymbol *_bfd_generic_make_empty_symbol (bfd *);
530
 
531
DESCRIPTION
532
        Create a new <<asymbol>> structure for the BFD @var{abfd}
533
        and return a pointer to it.  Used by core file routines,
534
        binary back-end and anywhere else where no private info
535
        is needed.
536
*/
537
 
538
asymbol *
539
_bfd_generic_make_empty_symbol (bfd *abfd)
540
{
541
  bfd_size_type amt = sizeof (asymbol);
542
  asymbol *new_symbol = (asymbol *) bfd_zalloc (abfd, amt);
543
  if (new_symbol)
544
    new_symbol->the_bfd = abfd;
545
  return new_symbol;
546
}
547
 
548
/*
549
FUNCTION
550
        bfd_make_debug_symbol
551
 
552
DESCRIPTION
553
        Create a new <<asymbol>> structure for the BFD @var{abfd},
554
        to be used as a debugging symbol.  Further details of its use have
555
        yet to be worked out.
556
 
557
.#define bfd_make_debug_symbol(abfd,ptr,size) \
558
.  BFD_SEND (abfd, _bfd_make_debug_symbol, (abfd, ptr, size))
559
.
560
*/
561
 
562
struct section_to_type
563
{
564
  const char *section;
565
  char type;
566
};
567
 
568
/* Map section names to POSIX/BSD single-character symbol types.
569
   This table is probably incomplete.  It is sorted for convenience of
570
   adding entries.  Since it is so short, a linear search is used.  */
571
static const struct section_to_type stt[] =
572
{
573
  {".bss", 'b'},
574
  {"code", 't'},                /* MRI .text */
575
  {".data", 'd'},
576
  {"*DEBUG*", 'N'},
577
  {".debug", 'N'},              /* MSVC's .debug (non-standard debug syms) */
578
  {".drectve", 'i'},            /* MSVC's .drective section */
579
  {".edata", 'e'},              /* MSVC's .edata (export) section */
580
  {".fini", 't'},               /* ELF fini section */
581
  {".idata", 'i'},              /* MSVC's .idata (import) section */
582
  {".init", 't'},               /* ELF init section */
583
  {".pdata", 'p'},              /* MSVC's .pdata (stack unwind) section */
584
  {".rdata", 'r'},              /* Read only data.  */
585
  {".rodata", 'r'},             /* Read only data.  */
586
  {".sbss", 's'},               /* Small BSS (uninitialized data).  */
587
  {".scommon", 'c'},            /* Small common.  */
588
  {".sdata", 'g'},              /* Small initialized data.  */
589
  {".text", 't'},
590
  {"vars", 'd'},                /* MRI .data */
591
  {"zerovars", 'b'},            /* MRI .bss */
592
  {0, 0}
593
};
594
 
595
/* Return the single-character symbol type corresponding to
596
   section S, or '?' for an unknown COFF section.
597
 
598
   Check for any leading string which matches, so .text5 returns
599
   't' as well as .text */
600
 
601
static char
602
coff_section_type (const char *s)
603
{
604
  const struct section_to_type *t;
605
 
606
  for (t = &stt[0]; t->section; t++)
607
    if (!strncmp (s, t->section, strlen (t->section)))
608
      return t->type;
609
 
610
  return '?';
611
}
612
 
613
/* Return the single-character symbol type corresponding to section
614
   SECTION, or '?' for an unknown section.  This uses section flags to
615
   identify sections.
616
 
617
   FIXME These types are unhandled: c, i, e, p.  If we handled these also,
618
   we could perhaps obsolete coff_section_type.  */
619
 
620
static char
621
decode_section_type (const struct bfd_section *section)
622
{
623
  if (section->flags & SEC_CODE)
624
    return 't';
625
  if (section->flags & SEC_DATA)
626
    {
627
      if (section->flags & SEC_READONLY)
628
        return 'r';
629
      else if (section->flags & SEC_SMALL_DATA)
630
        return 'g';
631
      else
632
        return 'd';
633
    }
634
  if ((section->flags & SEC_HAS_CONTENTS) == 0)
635
    {
636
      if (section->flags & SEC_SMALL_DATA)
637
        return 's';
638
      else
639
        return 'b';
640
    }
641
  if (section->flags & SEC_DEBUGGING)
642
    return 'N';
643
  if ((section->flags & SEC_HAS_CONTENTS) && (section->flags & SEC_READONLY))
644
    return 'n';
645
 
646
  return '?';
647
}
648
 
649
/*
650
FUNCTION
651
        bfd_decode_symclass
652
 
653
DESCRIPTION
654
        Return a character corresponding to the symbol
655
        class of @var{symbol}, or '?' for an unknown class.
656
 
657
SYNOPSIS
658
        int bfd_decode_symclass (asymbol *symbol);
659
*/
660
int
661
bfd_decode_symclass (asymbol *symbol)
662
{
663
  char c;
664
 
665
  if (symbol->section && bfd_is_com_section (symbol->section))
666
    return 'C';
667
  if (bfd_is_und_section (symbol->section))
668
    {
669
      if (symbol->flags & BSF_WEAK)
670
        {
671
          /* If weak, determine if it's specifically an object
672
             or non-object weak.  */
673
          if (symbol->flags & BSF_OBJECT)
674
            return 'v';
675
          else
676
            return 'w';
677
        }
678
      else
679
        return 'U';
680
    }
681
  if (bfd_is_ind_section (symbol->section))
682
    return 'I';
683
  if (symbol->flags & BSF_GNU_INDIRECT_FUNCTION)
684
    return 'i';
685
  if (symbol->flags & BSF_WEAK)
686
    {
687
      /* If weak, determine if it's specifically an object
688
         or non-object weak.  */
689
      if (symbol->flags & BSF_OBJECT)
690
        return 'V';
691
      else
692
        return 'W';
693
    }
694
  if (symbol->flags & BSF_GNU_UNIQUE)
695
    return 'u';
696
  if (!(symbol->flags & (BSF_GLOBAL | BSF_LOCAL)))
697
    return '?';
698
 
699
  if (bfd_is_abs_section (symbol->section))
700
    c = 'a';
701
  else if (symbol->section)
702
    {
703
      c = coff_section_type (symbol->section->name);
704
      if (c == '?')
705
        c = decode_section_type (symbol->section);
706
    }
707
  else
708
    return '?';
709
  if (symbol->flags & BSF_GLOBAL)
710
    c = TOUPPER (c);
711
  return c;
712
 
713
  /* We don't have to handle these cases just yet, but we will soon:
714
     N_SETV: 'v';
715
     N_SETA: 'l';
716
     N_SETT: 'x';
717
     N_SETD: 'z';
718
     N_SETB: 's';
719
     N_INDR: 'i';
720
     */
721
}
722
 
723
/*
724
FUNCTION
725
        bfd_is_undefined_symclass
726
 
727
DESCRIPTION
728
        Returns non-zero if the class symbol returned by
729
        bfd_decode_symclass represents an undefined symbol.
730
        Returns zero otherwise.
731
 
732
SYNOPSIS
733
        bfd_boolean bfd_is_undefined_symclass (int symclass);
734
*/
735
 
736
bfd_boolean
737
bfd_is_undefined_symclass (int symclass)
738
{
739
  return symclass == 'U' || symclass == 'w' || symclass == 'v';
740
}
741
 
742
/*
743
FUNCTION
744
        bfd_symbol_info
745
 
746
DESCRIPTION
747
        Fill in the basic info about symbol that nm needs.
748
        Additional info may be added by the back-ends after
749
        calling this function.
750
 
751
SYNOPSIS
752
        void bfd_symbol_info (asymbol *symbol, symbol_info *ret);
753
*/
754
 
755
void
756
bfd_symbol_info (asymbol *symbol, symbol_info *ret)
757
{
758
  ret->type = bfd_decode_symclass (symbol);
759
 
760
  if (bfd_is_undefined_symclass (ret->type))
761
    ret->value = 0;
762
  else
763
    ret->value = symbol->value + symbol->section->vma;
764
 
765
  ret->name = symbol->name;
766
}
767
 
768
/*
769
FUNCTION
770
        bfd_copy_private_symbol_data
771
 
772
SYNOPSIS
773
        bfd_boolean bfd_copy_private_symbol_data
774
          (bfd *ibfd, asymbol *isym, bfd *obfd, asymbol *osym);
775
 
776
DESCRIPTION
777
        Copy private symbol information from @var{isym} in the BFD
778
        @var{ibfd} to the symbol @var{osym} in the BFD @var{obfd}.
779
        Return <<TRUE>> on success, <<FALSE>> on error.  Possible error
780
        returns are:
781
 
782
        o <<bfd_error_no_memory>> -
783
        Not enough memory exists to create private data for @var{osec}.
784
 
785
.#define bfd_copy_private_symbol_data(ibfd, isymbol, obfd, osymbol) \
786
.  BFD_SEND (obfd, _bfd_copy_private_symbol_data, \
787
.            (ibfd, isymbol, obfd, osymbol))
788
.
789
*/
790
 
791
/* The generic version of the function which returns mini symbols.
792
   This is used when the backend does not provide a more efficient
793
   version.  It just uses BFD asymbol structures as mini symbols.  */
794
 
795
long
796
_bfd_generic_read_minisymbols (bfd *abfd,
797
                               bfd_boolean dynamic,
798
                               void **minisymsp,
799
                               unsigned int *sizep)
800
{
801
  long storage;
802
  asymbol **syms = NULL;
803
  long symcount;
804
 
805
  if (dynamic)
806
    storage = bfd_get_dynamic_symtab_upper_bound (abfd);
807
  else
808
    storage = bfd_get_symtab_upper_bound (abfd);
809
  if (storage < 0)
810
    goto error_return;
811
  if (storage == 0)
812
    return 0;
813
 
814
  syms = (asymbol **) bfd_malloc (storage);
815
  if (syms == NULL)
816
    goto error_return;
817
 
818
  if (dynamic)
819
    symcount = bfd_canonicalize_dynamic_symtab (abfd, syms);
820
  else
821
    symcount = bfd_canonicalize_symtab (abfd, syms);
822
  if (symcount < 0)
823
    goto error_return;
824
 
825
  *minisymsp = syms;
826
  *sizep = sizeof (asymbol *);
827
  return symcount;
828
 
829
 error_return:
830
  bfd_set_error (bfd_error_no_symbols);
831
  if (syms != NULL)
832
    free (syms);
833
  return -1;
834
}
835
 
836
/* The generic version of the function which converts a minisymbol to
837
   an asymbol.  We don't worry about the sym argument we are passed;
838
   we just return the asymbol the minisymbol points to.  */
839
 
840
asymbol *
841
_bfd_generic_minisymbol_to_symbol (bfd *abfd ATTRIBUTE_UNUSED,
842
                                   bfd_boolean dynamic ATTRIBUTE_UNUSED,
843
                                   const void *minisym,
844
                                   asymbol *sym ATTRIBUTE_UNUSED)
845
{
846
  return *(asymbol **) minisym;
847
}
848
 
849
/* Look through stabs debugging information in .stab and .stabstr
850
   sections to find the source file and line closest to a desired
851
   location.  This is used by COFF and ELF targets.  It sets *pfound
852
   to TRUE if it finds some information.  The *pinfo field is used to
853
   pass cached information in and out of this routine; this first time
854
   the routine is called for a BFD, *pinfo should be NULL.  The value
855
   placed in *pinfo should be saved with the BFD, and passed back each
856
   time this function is called.  */
857
 
858
/* We use a cache by default.  */
859
 
860
#define ENABLE_CACHING
861
 
862
/* We keep an array of indexentry structures to record where in the
863
   stabs section we should look to find line number information for a
864
   particular address.  */
865
 
866
struct indexentry
867
{
868
  bfd_vma val;
869
  bfd_byte *stab;
870
  bfd_byte *str;
871
  char *directory_name;
872
  char *file_name;
873
  char *function_name;
874
};
875
 
876
/* Compare two indexentry structures.  This is called via qsort.  */
877
 
878
static int
879
cmpindexentry (const void *a, const void *b)
880
{
881
  const struct indexentry *contestantA = (const struct indexentry *) a;
882
  const struct indexentry *contestantB = (const struct indexentry *) b;
883
 
884
  if (contestantA->val < contestantB->val)
885
    return -1;
886
  else if (contestantA->val > contestantB->val)
887
    return 1;
888
  else
889
    return 0;
890
}
891
 
892
/* A pointer to this structure is stored in *pinfo.  */
893
 
894
struct stab_find_info
895
{
896
  /* The .stab section.  */
897
  asection *stabsec;
898
  /* The .stabstr section.  */
899
  asection *strsec;
900
  /* The contents of the .stab section.  */
901
  bfd_byte *stabs;
902
  /* The contents of the .stabstr section.  */
903
  bfd_byte *strs;
904
 
905
  /* A table that indexes stabs by memory address.  */
906
  struct indexentry *indextable;
907
  /* The number of entries in indextable.  */
908
  int indextablesize;
909
 
910
#ifdef ENABLE_CACHING
911
  /* Cached values to restart quickly.  */
912
  struct indexentry *cached_indexentry;
913
  bfd_vma cached_offset;
914
  bfd_byte *cached_stab;
915
  char *cached_file_name;
916
#endif
917
 
918
  /* Saved ptr to malloc'ed filename.  */
919
  char *filename;
920
};
921
 
922
bfd_boolean
923
_bfd_stab_section_find_nearest_line (bfd *abfd,
924
                                     asymbol **symbols,
925
                                     asection *section,
926
                                     bfd_vma offset,
927
                                     bfd_boolean *pfound,
928
                                     const char **pfilename,
929
                                     const char **pfnname,
930
                                     unsigned int *pline,
931
                                     void **pinfo)
932
{
933
  struct stab_find_info *info;
934
  bfd_size_type stabsize, strsize;
935
  bfd_byte *stab, *str;
936
  bfd_byte *last_stab = NULL;
937
  bfd_size_type stroff;
938
  struct indexentry *indexentry;
939
  char *file_name;
940
  char *directory_name;
941
  int saw_fun;
942
  bfd_boolean saw_line, saw_func;
943
 
944
  *pfound = FALSE;
945
  *pfilename = bfd_get_filename (abfd);
946
  *pfnname = NULL;
947
  *pline = 0;
948
 
949
  /* Stabs entries use a 12 byte format:
950
       4 byte string table index
951
       1 byte stab type
952
       1 byte stab other field
953
       2 byte stab desc field
954
       4 byte stab value
955
     FIXME: This will have to change for a 64 bit object format.
956
 
957
     The stabs symbols are divided into compilation units.  For the
958
     first entry in each unit, the type of 0, the value is the length
959
     of the string table for this unit, and the desc field is the
960
     number of stabs symbols for this unit.  */
961
 
962
#define STRDXOFF (0)
963
#define TYPEOFF (4)
964
#define OTHEROFF (5)
965
#define DESCOFF (6)
966
#define VALOFF (8)
967
#define STABSIZE (12)
968
 
969
  info = (struct stab_find_info *) *pinfo;
970
  if (info != NULL)
971
    {
972
      if (info->stabsec == NULL || info->strsec == NULL)
973
        {
974
          /* No stabs debugging information.  */
975
          return TRUE;
976
        }
977
 
978
      stabsize = (info->stabsec->rawsize
979
                  ? info->stabsec->rawsize
980
                  : info->stabsec->size);
981
      strsize = (info->strsec->rawsize
982
                 ? info->strsec->rawsize
983
                 : info->strsec->size);
984
    }
985
  else
986
    {
987
      long reloc_size, reloc_count;
988
      arelent **reloc_vector;
989
      int i;
990
      char *name;
991
      char *function_name;
992
      bfd_size_type amt = sizeof *info;
993
 
994
      info = (struct stab_find_info *) bfd_zalloc (abfd, amt);
995
      if (info == NULL)
996
        return FALSE;
997
 
998
      /* FIXME: When using the linker --split-by-file or
999
         --split-by-reloc options, it is possible for the .stab and
1000
         .stabstr sections to be split.  We should handle that.  */
1001
 
1002
      info->stabsec = bfd_get_section_by_name (abfd, ".stab");
1003
      info->strsec = bfd_get_section_by_name (abfd, ".stabstr");
1004
 
1005
      if (info->stabsec == NULL || info->strsec == NULL)
1006
        {
1007
          /* Try SOM section names.  */
1008
          info->stabsec = bfd_get_section_by_name (abfd, "$GDB_SYMBOLS$");
1009
          info->strsec  = bfd_get_section_by_name (abfd, "$GDB_STRINGS$");
1010
 
1011
          if (info->stabsec == NULL || info->strsec == NULL)
1012
            {
1013
              /* No stabs debugging information.  Set *pinfo so that we
1014
                 can return quickly in the info != NULL case above.  */
1015
              *pinfo = info;
1016
              return TRUE;
1017
            }
1018
        }
1019
 
1020
      stabsize = (info->stabsec->rawsize
1021
                  ? info->stabsec->rawsize
1022
                  : info->stabsec->size);
1023
      strsize = (info->strsec->rawsize
1024
                 ? info->strsec->rawsize
1025
                 : info->strsec->size);
1026
 
1027
      info->stabs = (bfd_byte *) bfd_alloc (abfd, stabsize);
1028
      info->strs = (bfd_byte *) bfd_alloc (abfd, strsize);
1029
      if (info->stabs == NULL || info->strs == NULL)
1030
        return FALSE;
1031
 
1032
      if (! bfd_get_section_contents (abfd, info->stabsec, info->stabs,
1033
                                      0, stabsize)
1034
          || ! bfd_get_section_contents (abfd, info->strsec, info->strs,
1035
                                         0, strsize))
1036
        return FALSE;
1037
 
1038
      /* If this is a relocatable object file, we have to relocate
1039
         the entries in .stab.  This should always be simple 32 bit
1040
         relocations against symbols defined in this object file, so
1041
         this should be no big deal.  */
1042
      reloc_size = bfd_get_reloc_upper_bound (abfd, info->stabsec);
1043
      if (reloc_size < 0)
1044
        return FALSE;
1045
      reloc_vector = (arelent **) bfd_malloc (reloc_size);
1046
      if (reloc_vector == NULL && reloc_size != 0)
1047
        return FALSE;
1048
      reloc_count = bfd_canonicalize_reloc (abfd, info->stabsec, reloc_vector,
1049
                                            symbols);
1050
      if (reloc_count < 0)
1051
        {
1052
          if (reloc_vector != NULL)
1053
            free (reloc_vector);
1054
          return FALSE;
1055
        }
1056
      if (reloc_count > 0)
1057
        {
1058
          arelent **pr;
1059
 
1060
          for (pr = reloc_vector; *pr != NULL; pr++)
1061
            {
1062
              arelent *r;
1063
              unsigned long val;
1064
              asymbol *sym;
1065
 
1066
              r = *pr;
1067
              /* Ignore R_*_NONE relocs.  */
1068
              if (r->howto->dst_mask == 0)
1069
                continue;
1070
 
1071
              if (r->howto->rightshift != 0
1072
                  || r->howto->size != 2
1073
                  || r->howto->bitsize != 32
1074
                  || r->howto->pc_relative
1075
                  || r->howto->bitpos != 0
1076
                  || r->howto->dst_mask != 0xffffffff)
1077
                {
1078
                  (*_bfd_error_handler)
1079
                    (_("Unsupported .stab relocation"));
1080
                  bfd_set_error (bfd_error_invalid_operation);
1081
                  if (reloc_vector != NULL)
1082
                    free (reloc_vector);
1083
                  return FALSE;
1084
                }
1085
 
1086
              val = bfd_get_32 (abfd, info->stabs + r->address);
1087
              val &= r->howto->src_mask;
1088
              sym = *r->sym_ptr_ptr;
1089
              val += sym->value + sym->section->vma + r->addend;
1090
              bfd_put_32 (abfd, (bfd_vma) val, info->stabs + r->address);
1091
            }
1092
        }
1093
 
1094
      if (reloc_vector != NULL)
1095
        free (reloc_vector);
1096
 
1097
      /* First time through this function, build a table matching
1098
         function VM addresses to stabs, then sort based on starting
1099
         VM address.  Do this in two passes: once to count how many
1100
         table entries we'll need, and a second to actually build the
1101
         table.  */
1102
 
1103
      info->indextablesize = 0;
1104
      saw_fun = 1;
1105
      for (stab = info->stabs; stab < info->stabs + stabsize; stab += STABSIZE)
1106
        {
1107
          if (stab[TYPEOFF] == (bfd_byte) N_SO)
1108
            {
1109
              /* N_SO with null name indicates EOF */
1110
              if (bfd_get_32 (abfd, stab + STRDXOFF) == 0)
1111
                continue;
1112
 
1113
              /* if we did not see a function def, leave space for one.  */
1114
              if (saw_fun == 0)
1115
                ++info->indextablesize;
1116
 
1117
              saw_fun = 0;
1118
 
1119
              /* two N_SO's in a row is a filename and directory. Skip */
1120
              if (stab + STABSIZE < info->stabs + stabsize
1121
                  && *(stab + STABSIZE + TYPEOFF) == (bfd_byte) N_SO)
1122
                {
1123
                  stab += STABSIZE;
1124
                }
1125
            }
1126
          else if (stab[TYPEOFF] == (bfd_byte) N_FUN)
1127
            {
1128
              saw_fun = 1;
1129
              ++info->indextablesize;
1130
            }
1131
        }
1132
 
1133
      if (saw_fun == 0)
1134
        ++info->indextablesize;
1135
 
1136
      if (info->indextablesize == 0)
1137
        return TRUE;
1138
      ++info->indextablesize;
1139
 
1140
      amt = info->indextablesize;
1141
      amt *= sizeof (struct indexentry);
1142
      info->indextable = (struct indexentry *) bfd_alloc (abfd, amt);
1143
      if (info->indextable == NULL)
1144
        return FALSE;
1145
 
1146
      file_name = NULL;
1147
      directory_name = NULL;
1148
      saw_fun = 1;
1149
 
1150
      for (i = 0, stroff = 0, stab = info->stabs, str = info->strs;
1151
           i < info->indextablesize && stab < info->stabs + stabsize;
1152
           stab += STABSIZE)
1153
        {
1154
          switch (stab[TYPEOFF])
1155
            {
1156
            case 0:
1157
              /* This is the first entry in a compilation unit.  */
1158
              if ((bfd_size_type) ((info->strs + strsize) - str) < stroff)
1159
                break;
1160
              str += stroff;
1161
              stroff = bfd_get_32 (abfd, stab + VALOFF);
1162
              break;
1163
 
1164
            case N_SO:
1165
              /* The main file name.  */
1166
 
1167
              /* The following code creates a new indextable entry with
1168
                 a NULL function name if there were no N_FUNs in a file.
1169
                 Note that a N_SO without a file name is an EOF and
1170
                 there could be 2 N_SO following it with the new filename
1171
                 and directory.  */
1172
              if (saw_fun == 0)
1173
                {
1174
                  info->indextable[i].val = bfd_get_32 (abfd, last_stab + VALOFF);
1175
                  info->indextable[i].stab = last_stab;
1176
                  info->indextable[i].str = str;
1177
                  info->indextable[i].directory_name = directory_name;
1178
                  info->indextable[i].file_name = file_name;
1179
                  info->indextable[i].function_name = NULL;
1180
                  ++i;
1181
                }
1182
              saw_fun = 0;
1183
 
1184
              file_name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF);
1185
              if (*file_name == '\0')
1186
                {
1187
                  directory_name = NULL;
1188
                  file_name = NULL;
1189
                  saw_fun = 1;
1190
                }
1191
              else
1192
                {
1193
                  last_stab = stab;
1194
                  if (stab + STABSIZE >= info->stabs + stabsize
1195
                      || *(stab + STABSIZE + TYPEOFF) != (bfd_byte) N_SO)
1196
                    {
1197
                      directory_name = NULL;
1198
                    }
1199
                  else
1200
                    {
1201
                      /* Two consecutive N_SOs are a directory and a
1202
                         file name.  */
1203
                      stab += STABSIZE;
1204
                      directory_name = file_name;
1205
                      file_name = ((char *) str
1206
                                   + bfd_get_32 (abfd, stab + STRDXOFF));
1207
                    }
1208
                }
1209
              break;
1210
 
1211
            case N_SOL:
1212
              /* The name of an include file.  */
1213
              file_name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF);
1214
              break;
1215
 
1216
            case N_FUN:
1217
              /* A function name.  */
1218
              saw_fun = 1;
1219
              name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF);
1220
 
1221
              if (*name == '\0')
1222
                name = NULL;
1223
 
1224
              function_name = name;
1225
 
1226
              if (name == NULL)
1227
                continue;
1228
 
1229
              info->indextable[i].val = bfd_get_32 (abfd, stab + VALOFF);
1230
              info->indextable[i].stab = stab;
1231
              info->indextable[i].str = str;
1232
              info->indextable[i].directory_name = directory_name;
1233
              info->indextable[i].file_name = file_name;
1234
              info->indextable[i].function_name = function_name;
1235
              ++i;
1236
              break;
1237
            }
1238
        }
1239
 
1240
      if (saw_fun == 0)
1241
        {
1242
          info->indextable[i].val = bfd_get_32 (abfd, last_stab + VALOFF);
1243
          info->indextable[i].stab = last_stab;
1244
          info->indextable[i].str = str;
1245
          info->indextable[i].directory_name = directory_name;
1246
          info->indextable[i].file_name = file_name;
1247
          info->indextable[i].function_name = NULL;
1248
          ++i;
1249
        }
1250
 
1251
      info->indextable[i].val = (bfd_vma) -1;
1252
      info->indextable[i].stab = info->stabs + stabsize;
1253
      info->indextable[i].str = str;
1254
      info->indextable[i].directory_name = NULL;
1255
      info->indextable[i].file_name = NULL;
1256
      info->indextable[i].function_name = NULL;
1257
      ++i;
1258
 
1259
      info->indextablesize = i;
1260
      qsort (info->indextable, (size_t) i, sizeof (struct indexentry),
1261
             cmpindexentry);
1262
 
1263
      *pinfo = info;
1264
    }
1265
 
1266
  /* We are passed a section relative offset.  The offsets in the
1267
     stabs information are absolute.  */
1268
  offset += bfd_get_section_vma (abfd, section);
1269
 
1270
#ifdef ENABLE_CACHING
1271
  if (info->cached_indexentry != NULL
1272
      && offset >= info->cached_offset
1273
      && offset < (info->cached_indexentry + 1)->val)
1274
    {
1275
      stab = info->cached_stab;
1276
      indexentry = info->cached_indexentry;
1277
      file_name = info->cached_file_name;
1278
    }
1279
  else
1280
#endif
1281
    {
1282
      long low, high;
1283
      long mid = -1;
1284
 
1285
      /* Cache non-existent or invalid.  Do binary search on
1286
         indextable.  */
1287
      indexentry = NULL;
1288
 
1289
      low = 0;
1290
      high = info->indextablesize - 1;
1291
      while (low != high)
1292
        {
1293
          mid = (high + low) / 2;
1294
          if (offset >= info->indextable[mid].val
1295
              && offset < info->indextable[mid + 1].val)
1296
            {
1297
              indexentry = &info->indextable[mid];
1298
              break;
1299
            }
1300
 
1301
          if (info->indextable[mid].val > offset)
1302
            high = mid;
1303
          else
1304
            low = mid + 1;
1305
        }
1306
 
1307
      if (indexentry == NULL)
1308
        return TRUE;
1309
 
1310
      stab = indexentry->stab + STABSIZE;
1311
      file_name = indexentry->file_name;
1312
    }
1313
 
1314
  directory_name = indexentry->directory_name;
1315
  str = indexentry->str;
1316
 
1317
  saw_line = FALSE;
1318
  saw_func = FALSE;
1319
  for (; stab < (indexentry+1)->stab; stab += STABSIZE)
1320
    {
1321
      bfd_boolean done;
1322
      bfd_vma val;
1323
 
1324
      done = FALSE;
1325
 
1326
      switch (stab[TYPEOFF])
1327
        {
1328
        case N_SOL:
1329
          /* The name of an include file.  */
1330
          val = bfd_get_32 (abfd, stab + VALOFF);
1331
          if (val <= offset)
1332
            {
1333
              file_name = (char *) str + bfd_get_32 (abfd, stab + STRDXOFF);
1334
              *pline = 0;
1335
            }
1336
          break;
1337
 
1338
        case N_SLINE:
1339
        case N_DSLINE:
1340
        case N_BSLINE:
1341
          /* A line number.  If the function was specified, then the value
1342
             is relative to the start of the function.  Otherwise, the
1343
             value is an absolute address.  */
1344
          val = ((indexentry->function_name ? indexentry->val : 0)
1345
                 + bfd_get_32 (abfd, stab + VALOFF));
1346
          /* If this line starts before our desired offset, or if it's
1347
             the first line we've been able to find, use it.  The
1348
             !saw_line check works around a bug in GCC 2.95.3, which emits
1349
             the first N_SLINE late.  */
1350
          if (!saw_line || val <= offset)
1351
            {
1352
              *pline = bfd_get_16 (abfd, stab + DESCOFF);
1353
 
1354
#ifdef ENABLE_CACHING
1355
              info->cached_stab = stab;
1356
              info->cached_offset = val;
1357
              info->cached_file_name = file_name;
1358
              info->cached_indexentry = indexentry;
1359
#endif
1360
            }
1361
          if (val > offset)
1362
            done = TRUE;
1363
          saw_line = TRUE;
1364
          break;
1365
 
1366
        case N_FUN:
1367
        case N_SO:
1368
          if (saw_func || saw_line)
1369
            done = TRUE;
1370
          saw_func = TRUE;
1371
          break;
1372
        }
1373
 
1374
      if (done)
1375
        break;
1376
    }
1377
 
1378
  *pfound = TRUE;
1379
 
1380
  if (file_name == NULL || IS_ABSOLUTE_PATH (file_name)
1381
      || directory_name == NULL)
1382
    *pfilename = file_name;
1383
  else
1384
    {
1385
      size_t dirlen;
1386
 
1387
      dirlen = strlen (directory_name);
1388
      if (info->filename == NULL
1389
          || filename_ncmp (info->filename, directory_name, dirlen) != 0
1390
          || filename_cmp (info->filename + dirlen, file_name) != 0)
1391
        {
1392
          size_t len;
1393
 
1394
          /* Don't free info->filename here.  objdump and other
1395
             apps keep a copy of a previously returned file name
1396
             pointer.  */
1397
          len = strlen (file_name) + 1;
1398
          info->filename = (char *) bfd_alloc (abfd, dirlen + len);
1399
          if (info->filename == NULL)
1400
            return FALSE;
1401
          memcpy (info->filename, directory_name, dirlen);
1402
          memcpy (info->filename + dirlen, file_name, len);
1403
        }
1404
 
1405
      *pfilename = info->filename;
1406
    }
1407
 
1408
  if (indexentry->function_name != NULL)
1409
    {
1410
      char *s;
1411
 
1412
      /* This will typically be something like main:F(0,1), so we want
1413
         to clobber the colon.  It's OK to change the name, since the
1414
         string is in our own local storage anyhow.  */
1415
      s = strchr (indexentry->function_name, ':');
1416
      if (s != NULL)
1417
        *s = '\0';
1418
 
1419
      *pfnname = indexentry->function_name;
1420
    }
1421
 
1422
  return TRUE;
1423
}

powered by: WebSVN 2.1.0

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