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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-6.8/] [gdb/] [somread.c] - Blame information for rev 827

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

Line No. Rev Author Line
1 24 jeremybenn
/* Read HP PA/Risc object files for GDB.
2
   Copyright (C) 1991, 1992, 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2002,
3
   2004, 2007, 2008 Free Software Foundation, Inc.
4
   Written by Fred Fish at Cygnus Support.
5
 
6
   This file is part of GDB.
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, see <http://www.gnu.org/licenses/>.  */
20
 
21
#include "defs.h"
22
#include "bfd.h"
23
#include <syms.h>
24
#include "symtab.h"
25
#include "symfile.h"
26
#include "objfiles.h"
27
#include "buildsym.h"
28
#include "stabsread.h"
29
#include "gdb-stabs.h"
30
#include "complaints.h"
31
#include "gdb_string.h"
32
#include "demangle.h"
33
#include "som.h"
34
#include "libhppa.h"
35
 
36
#include "solib-som.h"
37
 
38
/*
39
 
40
   LOCAL FUNCTION
41
 
42
   som_symtab_read -- read the symbol table of a SOM file
43
 
44
   SYNOPSIS
45
 
46
   void som_symtab_read (bfd *abfd, struct objfile *objfile,
47
   struct section_offsets *section_offsets)
48
 
49
   DESCRIPTION
50
 
51
   Given an open bfd, a base address to relocate symbols to, and a
52
   flag that specifies whether or not this bfd is for an executable
53
   or not (may be shared library for example), add all the global
54
   function and data symbols to the minimal symbol table.
55
 */
56
 
57
static void
58
som_symtab_read (bfd *abfd, struct objfile *objfile,
59
                 struct section_offsets *section_offsets)
60
{
61
  unsigned int number_of_symbols;
62
  int val, dynamic;
63
  char *stringtab;
64
  asection *shlib_info;
65
  struct symbol_dictionary_record *buf, *bufp, *endbufp;
66
  char *symname;
67
  CONST int symsize = sizeof (struct symbol_dictionary_record);
68
  CORE_ADDR text_offset, data_offset;
69
 
70
 
71
  text_offset = ANOFFSET (section_offsets, 0);
72
  data_offset = ANOFFSET (section_offsets, 1);
73
 
74
  number_of_symbols = bfd_get_symcount (abfd);
75
 
76
  /* Allocate a buffer to read in the debug info.
77
     We avoid using alloca because the memory size could be so large
78
     that we could hit the stack size limit.  */
79
  buf = xmalloc (symsize * number_of_symbols);
80
  make_cleanup (xfree, buf);
81
  bfd_seek (abfd, obj_som_sym_filepos (abfd), SEEK_SET);
82
  val = bfd_bread (buf, symsize * number_of_symbols, abfd);
83
  if (val != symsize * number_of_symbols)
84
    error (_("Couldn't read symbol dictionary!"));
85
 
86
  /* Allocate a buffer to read in the som stringtab section of
87
     the debugging info.  Again, we avoid using alloca because
88
     the data could be so large that we could potentially hit
89
     the stack size limitat.  */
90
  stringtab = xmalloc (obj_som_stringtab_size (abfd));
91
  make_cleanup (xfree, stringtab);
92
  bfd_seek (abfd, obj_som_str_filepos (abfd), SEEK_SET);
93
  val = bfd_bread (stringtab, obj_som_stringtab_size (abfd), abfd);
94
  if (val != obj_som_stringtab_size (abfd))
95
    error (_("Can't read in HP string table."));
96
 
97
  /* We need to determine if objfile is a dynamic executable (so we
98
     can do the right thing for ST_ENTRY vs ST_CODE symbols).
99
 
100
     There's nothing in the header which easily allows us to do
101
     this.
102
 
103
     This code used to rely upon the existence of a $SHLIB_INFO$
104
     section to make this determination.  HP claims that it is
105
     more accurate to check for a nonzero text offset, but they
106
     have not provided any information about why that test is
107
     more accurate.  */
108
  dynamic = (text_offset != 0);
109
 
110
  endbufp = buf + number_of_symbols;
111
  for (bufp = buf; bufp < endbufp; ++bufp)
112
    {
113
      enum minimal_symbol_type ms_type;
114
 
115
      QUIT;
116
 
117
      switch (bufp->symbol_scope)
118
        {
119
        case SS_UNIVERSAL:
120
        case SS_EXTERNAL:
121
          switch (bufp->symbol_type)
122
            {
123
            case ST_SYM_EXT:
124
            case ST_ARG_EXT:
125
              continue;
126
 
127
            case ST_CODE:
128
            case ST_PRI_PROG:
129
            case ST_SEC_PROG:
130
            case ST_MILLICODE:
131
              symname = bufp->name.n_strx + stringtab;
132
              ms_type = mst_text;
133
              bufp->symbol_value += text_offset;
134
              bufp->symbol_value = gdbarch_smash_text_address
135
                                     (current_gdbarch, bufp->symbol_value);
136
              break;
137
 
138
            case ST_ENTRY:
139
              symname = bufp->name.n_strx + stringtab;
140
              /* For a dynamic executable, ST_ENTRY symbols are
141
                 the stubs, while the ST_CODE symbol is the real
142
                 function.  */
143
              if (dynamic)
144
                ms_type = mst_solib_trampoline;
145
              else
146
                ms_type = mst_text;
147
              bufp->symbol_value += text_offset;
148
              bufp->symbol_value = gdbarch_smash_text_address
149
                                     (current_gdbarch, bufp->symbol_value);
150
              break;
151
 
152
            case ST_STUB:
153
              symname = bufp->name.n_strx + stringtab;
154
              ms_type = mst_solib_trampoline;
155
              bufp->symbol_value += text_offset;
156
              bufp->symbol_value = gdbarch_smash_text_address
157
                                     (current_gdbarch, bufp->symbol_value);
158
              break;
159
 
160
            case ST_DATA:
161
              symname = bufp->name.n_strx + stringtab;
162
              bufp->symbol_value += data_offset;
163
              ms_type = mst_data;
164
              break;
165
            default:
166
              continue;
167
            }
168
          break;
169
 
170
#if 0
171
          /* SS_GLOBAL and SS_LOCAL are two names for the same thing (!).  */
172
        case SS_GLOBAL:
173
#endif
174
        case SS_LOCAL:
175
          switch (bufp->symbol_type)
176
            {
177
            case ST_SYM_EXT:
178
            case ST_ARG_EXT:
179
              continue;
180
 
181
            case ST_CODE:
182
              symname = bufp->name.n_strx + stringtab;
183
              ms_type = mst_file_text;
184
              bufp->symbol_value += text_offset;
185
              bufp->symbol_value = gdbarch_smash_text_address
186
                                     (current_gdbarch, bufp->symbol_value);
187
 
188
            check_strange_names:
189
              /* Utah GCC 2.5, FSF GCC 2.6 and later generate correct local
190
                 label prefixes for stabs, constant data, etc.  So we need
191
                 only filter out L$ symbols which are left in due to
192
                 limitations in how GAS generates SOM relocations.
193
 
194
                 When linking in the HPUX C-library the HP linker has
195
                 the nasty habit of placing section symbols from the literal
196
                 subspaces in the middle of the program's text.  Filter
197
                 those out as best we can.  Check for first and last character
198
                 being '$'.
199
 
200
                 And finally, the newer HP compilers emit crud like $PIC_foo$N
201
                 in some circumstance (PIC code I guess).  It's also claimed
202
                 that they emit D$ symbols too.  What stupidity.  */
203
              if ((symname[0] == 'L' && symname[1] == '$')
204
              || (symname[0] == '$' && symname[strlen (symname) - 1] == '$')
205
                  || (symname[0] == 'D' && symname[1] == '$')
206
                  || (strncmp (symname, "L0\001", 3) == 0)
207
                  || (strncmp (symname, "$PIC", 4) == 0))
208
                continue;
209
              break;
210
 
211
            case ST_PRI_PROG:
212
            case ST_SEC_PROG:
213
            case ST_MILLICODE:
214
              symname = bufp->name.n_strx + stringtab;
215
              ms_type = mst_file_text;
216
              bufp->symbol_value += text_offset;
217
              bufp->symbol_value = gdbarch_smash_text_address
218
                                     (current_gdbarch, bufp->symbol_value);
219
              break;
220
 
221
            case ST_ENTRY:
222
              symname = bufp->name.n_strx + stringtab;
223
              /* SS_LOCAL symbols in a shared library do not have
224
                 export stubs, so we do not have to worry about
225
                 using mst_file_text vs mst_solib_trampoline here like
226
                 we do for SS_UNIVERSAL and SS_EXTERNAL symbols above.  */
227
              ms_type = mst_file_text;
228
              bufp->symbol_value += text_offset;
229
              bufp->symbol_value = gdbarch_smash_text_address
230
                                     (current_gdbarch, bufp->symbol_value);
231
              break;
232
 
233
            case ST_STUB:
234
              symname = bufp->name.n_strx + stringtab;
235
              ms_type = mst_solib_trampoline;
236
              bufp->symbol_value += text_offset;
237
              bufp->symbol_value = gdbarch_smash_text_address
238
                                     (current_gdbarch, bufp->symbol_value);
239
              break;
240
 
241
 
242
            case ST_DATA:
243
              symname = bufp->name.n_strx + stringtab;
244
              bufp->symbol_value += data_offset;
245
              ms_type = mst_file_data;
246
              goto check_strange_names;
247
 
248
            default:
249
              continue;
250
            }
251
          break;
252
 
253
          /* This can happen for common symbols when -E is passed to the
254
             final link.  No idea _why_ that would make the linker force
255
             common symbols to have an SS_UNSAT scope, but it does.
256
 
257
             This also happens for weak symbols, but their type is
258
             ST_DATA.  */
259
        case SS_UNSAT:
260
          switch (bufp->symbol_type)
261
            {
262
            case ST_STORAGE:
263
            case ST_DATA:
264
              symname = bufp->name.n_strx + stringtab;
265
              bufp->symbol_value += data_offset;
266
              ms_type = mst_data;
267
              break;
268
 
269
            default:
270
              continue;
271
            }
272
          break;
273
 
274
        default:
275
          continue;
276
        }
277
 
278
      if (bufp->name.n_strx > obj_som_stringtab_size (abfd))
279
        error (_("Invalid symbol data; bad HP string table offset: %d"),
280
               bufp->name.n_strx);
281
 
282
      prim_record_minimal_symbol (symname, bufp->symbol_value, ms_type,
283
                                  objfile);
284
    }
285
}
286
 
287
/* Scan and build partial symbols for a symbol file.
288
   We have been initialized by a call to som_symfile_init, which
289
   currently does nothing.
290
 
291
   SECTION_OFFSETS is a set of offsets to apply to relocate the symbols
292
   in each section.  This is ignored, as it isn't needed for SOM.
293
 
294
   MAINLINE is true if we are reading the main symbol
295
   table (as opposed to a shared lib or dynamically loaded file).
296
 
297
   This function only does the minimum work necessary for letting the
298
   user "name" things symbolically; it does not read the entire symtab.
299
   Instead, it reads the external and static symbols and puts them in partial
300
   symbol tables.  When more extensive information is requested of a
301
   file, the corresponding partial symbol table is mutated into a full
302
   fledged symbol table by going back and reading the symbols
303
   for real.
304
 
305
   We look for sections with specific names, to tell us what debug
306
   format to look for:  FIXME!!!
307
 
308
   somstab_build_psymtabs() handles STABS symbols.
309
 
310
   Note that SOM files have a "minimal" symbol table, which is vaguely
311
   reminiscent of a COFF symbol table, but has only the minimal information
312
   necessary for linking.  We process this also, and use the information to
313
   build gdb's minimal symbol table.  This gives us some minimal debugging
314
   capability even for files compiled without -g.  */
315
 
316
static void
317
som_symfile_read (struct objfile *objfile, int mainline)
318
{
319
  bfd *abfd = objfile->obfd;
320
  struct cleanup *back_to;
321
 
322
  init_minimal_symbol_collection ();
323
  back_to = make_cleanup_discard_minimal_symbols ();
324
 
325
  /* Process the normal SOM symbol table first.
326
     This reads in the DNTT and string table, but doesn't
327
     actually scan the DNTT. It does scan the linker symbol
328
     table and thus build up a "minimal symbol table". */
329
 
330
  som_symtab_read (abfd, objfile, objfile->section_offsets);
331
 
332
  /* Install any minimal symbols that have been collected as the current
333
     minimal symbols for this objfile.
334
     Further symbol-reading is done incrementally, file-by-file,
335
     in a step known as "psymtab-to-symtab" expansion. hp-symtab-read.c
336
     contains the code to do the actual DNTT scanning and symtab building. */
337
  install_minimal_symbols (objfile);
338
  do_cleanups (back_to);
339
 
340
  /* Now read information from the stabs debug sections.
341
     This is emitted by gcc.  */
342
  stabsect_build_psymtabs (objfile, mainline,
343
                           "$GDB_SYMBOLS$", "$GDB_STRINGS$", "$TEXT$");
344
}
345
 
346
/* Initialize anything that needs initializing when a completely new symbol
347
   file is specified (not just adding some symbols from another file, e.g. a
348
   shared library).
349
 
350
   We reinitialize buildsym, since we may be reading stabs from a SOM file.  */
351
 
352
static void
353
som_new_init (struct objfile *ignore)
354
{
355
  stabsread_new_init ();
356
  buildsym_new_init ();
357
}
358
 
359
/* Perform any local cleanups required when we are done with a particular
360
   objfile.  I.E, we are in the process of discarding all symbol information
361
   for an objfile, freeing up all memory held for it, and unlinking the
362
   objfile struct from the global list of known objfiles. */
363
 
364
static void
365
som_symfile_finish (struct objfile *objfile)
366
{
367
  if (objfile->deprecated_sym_stab_info != NULL)
368
    {
369
      xfree (objfile->deprecated_sym_stab_info);
370
    }
371
}
372
 
373
/* SOM specific initialization routine for reading symbols.  */
374
 
375
static void
376
som_symfile_init (struct objfile *objfile)
377
{
378
  /* SOM objects may be reordered, so set OBJF_REORDERED.  If we
379
     find this causes a significant slowdown in gdb then we could
380
     set it in the debug symbol readers only when necessary.  */
381
  objfile->flags |= OBJF_REORDERED;
382
}
383
 
384
/* SOM specific parsing routine for section offsets.
385
 
386
   Plain and simple for now.  */
387
 
388
static void
389
som_symfile_offsets (struct objfile *objfile, struct section_addr_info *addrs)
390
{
391
  int i;
392
  CORE_ADDR text_addr;
393
 
394
  objfile->num_sections = bfd_count_sections (objfile->obfd);
395
  objfile->section_offsets = (struct section_offsets *)
396
    obstack_alloc (&objfile->objfile_obstack,
397
                   SIZEOF_N_SECTION_OFFSETS (objfile->num_sections));
398
 
399
  /* FIXME: ezannoni 2000-04-20 The section names in SOM are not
400
     .text, .data, etc, but $TEXT$, $DATA$,... We should initialize
401
     SET_OFF_* from bfd. (See default_symfile_offsets()). But I don't
402
     know the correspondence between SOM sections and GDB's idea of
403
     section names. So for now we default to what is was before these
404
     changes.*/
405
  objfile->sect_index_text = 0;
406
  objfile->sect_index_data = 1;
407
  objfile->sect_index_bss = 2;
408
  objfile->sect_index_rodata = 3;
409
 
410
  /* First see if we're a shared library.  If so, get the section
411
     offsets from the library, else get them from addrs.  */
412
  if (!som_solib_section_offsets (objfile, objfile->section_offsets))
413
    {
414
      /* Note: Here is OK to compare with ".text" because this is the
415
         name that gdb itself gives to that section, not the SOM
416
         name. */
417
      for (i = 0; i < addrs->num_sections && addrs->other[i].name; i++)
418
        if (strcmp (addrs->other[i].name, ".text") == 0)
419
          break;
420
      text_addr = addrs->other[i].addr;
421
 
422
      for (i = 0; i < objfile->num_sections; i++)
423
        (objfile->section_offsets)->offsets[i] = text_addr;
424
    }
425
}
426
 
427
 
428
 
429
/* Register that we are able to handle SOM object file formats.  */
430
 
431
static struct sym_fns som_sym_fns =
432
{
433
  bfd_target_som_flavour,
434
  som_new_init,                 /* sym_new_init: init anything gbl to entire symtab */
435
  som_symfile_init,             /* sym_init: read initial info, setup for sym_read() */
436
  som_symfile_read,             /* sym_read: read a symbol file into symtab */
437
  som_symfile_finish,           /* sym_finish: finished with file, cleanup */
438
  som_symfile_offsets,          /* sym_offsets:  Translate ext. to int. relocation */
439
  default_symfile_segments,     /* sym_segments: Get segment information from
440
                                   a file.  */
441
  NULL,                         /* sym_read_linetable */
442
  NULL                          /* next: pointer to next struct sym_fns */
443
};
444
 
445
void
446
_initialize_somread (void)
447
{
448
  add_symtab_fns (&som_sym_fns);
449
}

powered by: WebSVN 2.1.0

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