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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [binutils-2.18.50/] [binutils/] [rddbg.c] - Blame information for rev 816

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 38 julius
/* rddbg.c -- Read debugging information into a generic form.
2
   Copyright 1995, 1996, 1997, 2000, 2002, 2003, 2005, 2007
3
   Free Software Foundation, Inc.
4
   Written by Ian Lance Taylor <ian@cygnus.com>.
5
 
6
   This file is part of GNU Binutils.
7
 
8
   This program is free software; you can redistribute it and/or modify
9
   it under the terms of the GNU General Public License as published by
10
   the Free Software Foundation; either version 3 of the License, or
11
   (at your option) any later version.
12
 
13
   This program is distributed in the hope that it will be useful,
14
   but WITHOUT ANY WARRANTY; without even the implied warranty of
15
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16
   GNU General Public License for more details.
17
 
18
   You should have received a copy of the GNU General Public License
19
   along with this program; if not, write to the Free Software
20
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
21
   02110-1301, USA.  */
22
 
23
 
24
/* This file reads debugging information into a generic form.  This
25
   file knows how to dig the debugging information out of an object
26
   file.  */
27
 
28
#include "sysdep.h"
29
#include "bfd.h"
30
#include "libiberty.h"
31
#include "bucomm.h"
32
#include "debug.h"
33
#include "budbg.h"
34
 
35
static bfd_boolean read_section_stabs_debugging_info
36
  (bfd *, asymbol **, long, void *, bfd_boolean *);
37
static bfd_boolean read_symbol_stabs_debugging_info
38
  (bfd *, asymbol **, long, void *, bfd_boolean *);
39
static bfd_boolean read_ieee_debugging_info (bfd *, void *, bfd_boolean *);
40
static void save_stab (int, int, bfd_vma, const char *);
41
static void stab_context (void);
42
static void free_saved_stabs (void);
43
 
44
/* Read debugging information from a BFD.  Returns a generic debugging
45
   pointer.  */
46
 
47
void *
48
read_debugging_info (bfd *abfd, asymbol **syms, long symcount)
49
{
50
  void *dhandle;
51
  bfd_boolean found;
52
 
53
  dhandle = debug_init ();
54
  if (dhandle == NULL)
55
    return NULL;
56
 
57
  if (! read_section_stabs_debugging_info (abfd, syms, symcount, dhandle,
58
                                           &found))
59
    return NULL;
60
 
61
  if (bfd_get_flavour (abfd) == bfd_target_aout_flavour)
62
    {
63
      if (! read_symbol_stabs_debugging_info (abfd, syms, symcount, dhandle,
64
                                              &found))
65
        return NULL;
66
    }
67
 
68
  if (bfd_get_flavour (abfd) == bfd_target_ieee_flavour)
69
    {
70
      if (! read_ieee_debugging_info (abfd, dhandle, &found))
71
        return NULL;
72
    }
73
 
74
  /* Try reading the COFF symbols if we didn't find any stabs in COFF
75
     sections.  */
76
  if (! found
77
      && bfd_get_flavour (abfd) == bfd_target_coff_flavour
78
      && symcount > 0)
79
    {
80
      if (! parse_coff (abfd, syms, symcount, dhandle))
81
        return NULL;
82
      found = TRUE;
83
    }
84
 
85
  if (! found)
86
    {
87
      non_fatal (_("%s: no recognized debugging information"),
88
                 bfd_get_filename (abfd));
89
      return NULL;
90
    }
91
 
92
  return dhandle;
93
}
94
 
95
/* Read stabs in sections debugging information from a BFD.  */
96
 
97
static bfd_boolean
98
read_section_stabs_debugging_info (bfd *abfd, asymbol **syms, long symcount,
99
                                   void *dhandle, bfd_boolean *pfound)
100
{
101
  static struct
102
    {
103
      const char *secname;
104
      const char *strsecname;
105
    }
106
  names[] =
107
    {
108
      { ".stab", ".stabstr" },
109
      { "LC_SYMTAB.stabs", "LC_SYMTAB.stabstr" },
110
      { "$GDB_SYMBOLS$", "$GDB_STRINGS$" }
111
    };
112
  unsigned int i;
113
  void *shandle;
114
 
115
  *pfound = FALSE;
116
  shandle = NULL;
117
 
118
  for (i = 0; i < sizeof names / sizeof names[0]; i++)
119
    {
120
      asection *sec, *strsec;
121
 
122
      sec = bfd_get_section_by_name (abfd, names[i].secname);
123
      strsec = bfd_get_section_by_name (abfd, names[i].strsecname);
124
      if (sec != NULL && strsec != NULL)
125
        {
126
          bfd_size_type stabsize, strsize;
127
          bfd_byte *stabs, *strings;
128
          bfd_byte *stab;
129
          bfd_size_type stroff, next_stroff;
130
 
131
          stabsize = bfd_section_size (abfd, sec);
132
          stabs = (bfd_byte *) xmalloc (stabsize);
133
          if (! bfd_get_section_contents (abfd, sec, stabs, 0, stabsize))
134
            {
135
              fprintf (stderr, "%s: %s: %s\n",
136
                       bfd_get_filename (abfd), names[i].secname,
137
                       bfd_errmsg (bfd_get_error ()));
138
              return FALSE;
139
            }
140
 
141
          strsize = bfd_section_size (abfd, strsec);
142
          strings = (bfd_byte *) xmalloc (strsize);
143
          if (! bfd_get_section_contents (abfd, strsec, strings, 0, strsize))
144
            {
145
              fprintf (stderr, "%s: %s: %s\n",
146
                       bfd_get_filename (abfd), names[i].strsecname,
147
                       bfd_errmsg (bfd_get_error ()));
148
              return FALSE;
149
            }
150
 
151
          if (shandle == NULL)
152
            {
153
              shandle = start_stab (dhandle, abfd, TRUE, syms, symcount);
154
              if (shandle == NULL)
155
                return FALSE;
156
            }
157
 
158
          *pfound = TRUE;
159
 
160
          stroff = 0;
161
          next_stroff = 0;
162
          for (stab = stabs; stab < stabs + stabsize; stab += 12)
163
            {
164
              unsigned int strx;
165
              int type;
166
              int other;
167
              int desc;
168
              bfd_vma value;
169
 
170
              /* This code presumes 32 bit values.  */
171
 
172
              strx = bfd_get_32 (abfd, stab);
173
              type = bfd_get_8 (abfd, stab + 4);
174
              other = bfd_get_8 (abfd, stab + 5);
175
              desc = bfd_get_16 (abfd, stab + 6);
176
              value = bfd_get_32 (abfd, stab + 8);
177
 
178
              if (type == 0)
179
                {
180
                  /* Special type 0 stabs indicate the offset to the
181
                     next string table.  */
182
                  stroff = next_stroff;
183
                  next_stroff += value;
184
                }
185
              else
186
                {
187
                  char *f, *s;
188
 
189
                  f = NULL;
190
 
191
                  if (stroff + strx > strsize)
192
                    {
193
                      fprintf (stderr, "%s: %s: stab entry %ld is corrupt, strx = 0x%x, type = %d\n",
194
                               bfd_get_filename (abfd), names[i].secname,
195
                               (long) (stab - stabs) / 12, strx, type);
196
                      continue;
197
                    }
198
 
199
                  s = (char *) strings + stroff + strx;
200
 
201
                  while (s[strlen (s) - 1] == '\\'
202
                         && stab + 12 < stabs + stabsize)
203
                    {
204
                      char *p;
205
 
206
                      stab += 12;
207
                      p = s + strlen (s) - 1;
208
                      *p = '\0';
209
                      s = concat (s,
210
                                  ((char *) strings
211
                                   + stroff
212
                                   + bfd_get_32 (abfd, stab)),
213
                                  (const char *) NULL);
214
 
215
                      /* We have to restore the backslash, because, if
216
                         the linker is hashing stabs strings, we may
217
                         see the same string more than once.  */
218
                      *p = '\\';
219
 
220
                      if (f != NULL)
221
                        free (f);
222
                      f = s;
223
                    }
224
 
225
                  save_stab (type, desc, value, s);
226
 
227
                  if (! parse_stab (dhandle, shandle, type, desc, value, s))
228
                    {
229
                      stab_context ();
230
                      free_saved_stabs ();
231
                      return FALSE;
232
                    }
233
 
234
                  /* Don't free f, since I think the stabs code
235
                     expects strings to hang around.  This should be
236
                     straightened out.  FIXME.  */
237
                }
238
            }
239
 
240
          free_saved_stabs ();
241
          free (stabs);
242
 
243
          /* Don't free strings, since I think the stabs code expects
244
             the strings to hang around.  This should be straightened
245
             out.  FIXME.  */
246
        }
247
    }
248
 
249
  if (shandle != NULL)
250
    {
251
      if (! finish_stab (dhandle, shandle))
252
        return FALSE;
253
    }
254
 
255
  return TRUE;
256
}
257
 
258
/* Read stabs in the symbol table.  */
259
 
260
static bfd_boolean
261
read_symbol_stabs_debugging_info (bfd *abfd, asymbol **syms, long symcount,
262
                                  void *dhandle, bfd_boolean *pfound)
263
{
264
  void *shandle;
265
  asymbol **ps, **symend;
266
 
267
  shandle = NULL;
268
  symend = syms + symcount;
269
  for (ps = syms; ps < symend; ps++)
270
    {
271
      symbol_info i;
272
 
273
      bfd_get_symbol_info (abfd, *ps, &i);
274
 
275
      if (i.type == '-')
276
        {
277
          const char *s;
278
          char *f;
279
 
280
          if (shandle == NULL)
281
            {
282
              shandle = start_stab (dhandle, abfd, FALSE, syms, symcount);
283
              if (shandle == NULL)
284
                return FALSE;
285
            }
286
 
287
          *pfound = TRUE;
288
 
289
          s = i.name;
290
          f = NULL;
291
          while (s[strlen (s) - 1] == '\\'
292
                 && ps + 1 < symend)
293
            {
294
              char *sc, *n;
295
 
296
              ++ps;
297
              sc = xstrdup (s);
298
              sc[strlen (sc) - 1] = '\0';
299
              n = concat (sc, bfd_asymbol_name (*ps), (const char *) NULL);
300
              free (sc);
301
              if (f != NULL)
302
                free (f);
303
              f = n;
304
              s = n;
305
            }
306
 
307
          save_stab (i.stab_type, i.stab_desc, i.value, s);
308
 
309
          if (! parse_stab (dhandle, shandle, i.stab_type, i.stab_desc,
310
                            i.value, s))
311
            {
312
              stab_context ();
313
              free_saved_stabs ();
314
              return FALSE;
315
            }
316
 
317
          /* Don't free f, since I think the stabs code expects
318
             strings to hang around.  This should be straightened out.
319
             FIXME.  */
320
        }
321
    }
322
 
323
  free_saved_stabs ();
324
 
325
  if (shandle != NULL)
326
    {
327
      if (! finish_stab (dhandle, shandle))
328
        return FALSE;
329
    }
330
 
331
  return TRUE;
332
}
333
 
334
/* Read IEEE debugging information.  */
335
 
336
static bfd_boolean
337
read_ieee_debugging_info (bfd *abfd, void *dhandle, bfd_boolean *pfound)
338
{
339
  asection *dsec;
340
  bfd_size_type size;
341
  bfd_byte *contents;
342
 
343
  /* The BFD backend puts the debugging information into a section
344
     named .debug.  */
345
 
346
  dsec = bfd_get_section_by_name (abfd, ".debug");
347
  if (dsec == NULL)
348
    return TRUE;
349
 
350
  size = bfd_section_size (abfd, dsec);
351
  contents = (bfd_byte *) xmalloc (size);
352
  if (! bfd_get_section_contents (abfd, dsec, contents, 0, size))
353
    return FALSE;
354
 
355
  if (! parse_ieee (dhandle, abfd, contents, size))
356
    return FALSE;
357
 
358
  free (contents);
359
 
360
  *pfound = TRUE;
361
 
362
  return TRUE;
363
}
364
 
365
/* Record stabs strings, so that we can give some context for errors.  */
366
 
367
#define SAVE_STABS_COUNT (16)
368
 
369
struct saved_stab
370
{
371
  int type;
372
  int desc;
373
  bfd_vma value;
374
  char *string;
375
};
376
 
377
static struct saved_stab saved_stabs[SAVE_STABS_COUNT];
378
static int saved_stabs_index;
379
 
380
/* Save a stabs string.  */
381
 
382
static void
383
save_stab (int type, int desc, bfd_vma value, const char *string)
384
{
385
  if (saved_stabs[saved_stabs_index].string != NULL)
386
    free (saved_stabs[saved_stabs_index].string);
387
  saved_stabs[saved_stabs_index].type = type;
388
  saved_stabs[saved_stabs_index].desc = desc;
389
  saved_stabs[saved_stabs_index].value = value;
390
  saved_stabs[saved_stabs_index].string = xstrdup (string);
391
  saved_stabs_index = (saved_stabs_index + 1) % SAVE_STABS_COUNT;
392
}
393
 
394
/* Provide context for an error.  */
395
 
396
static void
397
stab_context (void)
398
{
399
  int i;
400
 
401
  fprintf (stderr, _("Last stabs entries before error:\n"));
402
  fprintf (stderr, "n_type n_desc n_value  string\n");
403
 
404
  i = saved_stabs_index;
405
  do
406
    {
407
      struct saved_stab *stabp;
408
 
409
      stabp = saved_stabs + i;
410
      if (stabp->string != NULL)
411
        {
412
          const char *s;
413
 
414
          s = bfd_get_stab_name (stabp->type);
415
          if (s != NULL)
416
            fprintf (stderr, "%-6s", s);
417
          else if (stabp->type == 0)
418
            fprintf (stderr, "HdrSym");
419
          else
420
            fprintf (stderr, "%-6d", stabp->type);
421
          fprintf (stderr, " %-6d ", stabp->desc);
422
          fprintf_vma (stderr, stabp->value);
423
          if (stabp->type != 0)
424
            fprintf (stderr, " %s", stabp->string);
425
          fprintf (stderr, "\n");
426
        }
427
      i = (i + 1) % SAVE_STABS_COUNT;
428
    }
429
  while (i != saved_stabs_index);
430
}
431
 
432
/* Free the saved stab strings.  */
433
 
434
static void
435
free_saved_stabs (void)
436
{
437
  int i;
438
 
439
  for (i = 0; i < SAVE_STABS_COUNT; i++)
440
    {
441
      if (saved_stabs[i].string != NULL)
442
        {
443
          free (saved_stabs[i].string);
444
          saved_stabs[i].string = NULL;
445
        }
446
    }
447
 
448
  saved_stabs_index = 0;
449
}

powered by: WebSVN 2.1.0

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