GDB (xrefs)
/tmp/gdb-7.10/gdb/xcoffread.c
Go to the documentation of this file.
1 /* Read AIX xcoff symbol tables and convert to internal format, for GDB.
2  Copyright (C) 1986-2015 Free Software Foundation, Inc.
3  Derived from coffread.c, dbxread.c, and a lot of hacking.
4  Contributed by IBM Corporation.
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 
24 #include <sys/types.h>
25 #include <fcntl.h>
26 #include <ctype.h>
27 #ifdef HAVE_SYS_FILE_H
28 #include <sys/file.h>
29 #endif
30 #include <sys/stat.h>
31 
32 #include "coff/internal.h"
33 #include "libcoff.h" /* FIXME, internal data from BFD */
34 #include "coff/xcoff.h"
35 #include "libxcoff.h"
36 #include "coff/rs6000.h"
37 #include "xcoffread.h"
38 
39 #include "symtab.h"
40 #include "gdbtypes.h"
41 /* FIXME: ezannoni/2004-02-13 Verify if the include below is really needed. */
42 #include "symfile.h"
43 #include "objfiles.h"
44 #include "buildsym.h"
45 #include "stabsread.h"
46 #include "expression.h"
47 #include "complaints.h"
48 #include "psympriv.h"
49 
50 #include "gdb-stabs.h"
51 
52 /* For interface with stabsread.c. */
53 #include "aout/stab_gnu.h"
54 
55 
56 /* Key for XCOFF-associated data. */
57 
58 static const struct objfile_data *xcoff_objfile_data_key;
59 
60 /* We put a pointer to this structure in the read_symtab_private field
61  of the psymtab. */
62 
63 struct symloc
64  {
65 
66  /* First symbol number for this file. */
67 
69 
70  /* Number of symbols in the section of the symbol table devoted to
71  this file's symbols (actually, the section bracketed may contain
72  more than just this file's symbols). If numsyms is 0, the only
73  reason for this thing's existence is the dependency list. Nothing
74  else will happen when it is read in. */
75 
76  int numsyms;
77 
78  /* Position of the start of the line number information for this
79  psymtab. */
80  unsigned int lineno_off;
81  };
82 
83 /* Remember what we deduced to be the source language of this psymtab. */
84 
86 
87 
88 /* Simplified internal version of coff symbol table information. */
89 
90 struct coff_symbol
91  {
92  char *c_name;
93  int c_symnum; /* Symbol number of this entry. */
94  int c_naux; /* 0 if syment only, 1 if syment + auxent. */
96  unsigned char c_sclass;
97  int c_secnum;
98  unsigned int c_type;
99  };
100 
101 /* Last function's saved coff symbol `cs'. */
102 
103 static struct coff_symbol fcn_cs_saved;
104 
105 static bfd *symfile_bfd;
106 
107 /* Core address of start and end of text of current source file.
108  This is calculated from the first function seen after a C_FILE
109  symbol. */
110 
111 
113 
114 /* Core address of the end of the first object file. */
115 
117 
118 /* Initial symbol-table-debug-string vector length. */
119 
120 #define INITIAL_STABVECTOR_LENGTH 40
121 
122 /* Size of a COFF symbol. I think it is always 18, so I'm not sure
123  there is any reason not to just use a #define, but might as well
124  ask BFD for the size and store it here, I guess. */
125 
126 static unsigned local_symesz;
127 
128 struct coff_symfile_info
129  {
130  file_ptr min_lineno_offset; /* Where in file lowest line#s are. */
131  file_ptr max_lineno_offset; /* 1+last byte of line#s in file. */
132 
133  /* Pointer to the string table. */
134  char *strtbl;
135 
136  /* Pointer to debug section. */
137  char *debugsec;
138 
139  /* Pointer to the a.out symbol table. */
140  char *symtbl;
141 
142  /* Number of symbols in symtbl. */
144 
145  /* Offset in data section to TOC anchor. */
147  };
148 
149 /* Convenience macro to access the per-objfile XCOFF data. */
150 
151 #define XCOFF_DATA(objfile) \
152  ((struct coff_symfile_info *) objfile_data ((objfile), \
153  xcoff_objfile_data_key))
154 
155 /* XCOFF names for dwarf sections. There is no compressed sections. */
156 
157 static const struct dwarf2_debug_sections dwarf2_xcoff_names = {
158  { ".dwinfo", NULL },
159  { ".dwabrev", NULL },
160  { ".dwline", NULL },
161  { ".dwloc", NULL },
162  { NULL, NULL }, /* debug_macinfo */
163  { NULL, NULL }, /* debug_macro */
164  { ".dwstr", NULL },
165  { ".dwrnges", NULL },
166  { NULL, NULL }, /* debug_types */
167  { NULL, NULL }, /* debug_addr */
168  { ".dwframe", NULL },
169  { NULL, NULL }, /* eh_frame */
170  { NULL, NULL }, /* gdb_index */
171  23
172 };
173 
174 static void
176 {
178  _("line numbers off, `.bf' symbol not found"));
179 }
180 
181 static void
182 ef_complaint (int arg1)
183 {
185  _("Mismatched .ef symbol ignored starting at symnum %d"), arg1);
186 }
187 
188 static void
189 eb_complaint (int arg1)
190 {
192  _("Mismatched .eb symbol ignored starting at symnum %d"), arg1);
193 }
194 
195 static void xcoff_initial_scan (struct objfile *, int);
196 
197 static void scan_xcoff_symtab (struct objfile *);
198 
199 static char *xcoff_next_symbol_text (struct objfile *);
200 
201 static void record_include_begin (struct coff_symbol *);
202 
203 static void
204 enter_line_range (struct subfile *, unsigned, unsigned,
205  CORE_ADDR, CORE_ADDR, unsigned *);
206 
207 static void init_stringtab (bfd *, file_ptr, struct objfile *);
208 
209 static void xcoff_symfile_init (struct objfile *);
210 
211 static void xcoff_new_init (struct objfile *);
212 
213 static void xcoff_symfile_finish (struct objfile *);
214 
215 static char *coff_getfilename (union internal_auxent *, struct objfile *);
216 
217 static void read_symbol (struct internal_syment *, int);
218 
219 static int read_symbol_lineno (int);
220 
221 static CORE_ADDR read_symbol_nvalue (int);
222 
223 static struct symbol *process_xcoff_symbol (struct coff_symbol *,
224  struct objfile *);
225 
226 static void read_xcoff_symtab (struct objfile *, struct partial_symtab *);
227 
228 #if 0
229 static void add_stab_to_list (char *, struct pending_stabs **);
230 #endif
231 
232 static int compare_lte (const void *, const void *);
233 
234 static struct linetable *arrange_linetable (struct linetable *);
235 
236 static void record_include_end (struct coff_symbol *);
237 
238 static void process_linenos (CORE_ADDR, CORE_ADDR);
239 
240 
241 /* Translate from a COFF section number (target_index) to a SECT_OFF_*
242  code. */
243 static int secnum_to_section (int, struct objfile *);
244 static asection *secnum_to_bfd_section (int, struct objfile *);
245 
246 struct find_targ_sec_arg
247  {
248  int targ_index;
249  int *resultp;
250  asection **bfd_sect;
251  struct objfile *objfile;
252  };
253 
254 static void find_targ_sec (bfd *, asection *, void *);
255 
256 static void
257 find_targ_sec (bfd *abfd, asection *sect, void *obj)
258 {
259  struct find_targ_sec_arg *args = (struct find_targ_sec_arg *) obj;
260  struct objfile *objfile = args->objfile;
261 
262  if (sect->target_index == args->targ_index)
263  {
264  /* This is the section. Figure out what SECT_OFF_* code it is. */
265  if (bfd_get_section_flags (abfd, sect) & SEC_CODE)
266  *args->resultp = SECT_OFF_TEXT (objfile);
267  else if (bfd_get_section_flags (abfd, sect) & SEC_LOAD)
268  *args->resultp = SECT_OFF_DATA (objfile);
269  else
270  *args->resultp = gdb_bfd_section_index (abfd, sect);
271  *args->bfd_sect = sect;
272  }
273 }
274 
275 /* Search all BFD sections for the section whose target_index is
276  equal to N_SCNUM. Set *BFD_SECT to that section. The section's
277  associated index in the objfile's section_offset table is also
278  stored in *SECNUM.
279 
280  If no match is found, *BFD_SECT is set to NULL, and *SECNUM
281  is set to the text section's number. */
282 
283 static void
285  asection **bfd_sect, int *secnum)
286 {
287  struct find_targ_sec_arg args;
288 
289  args.targ_index = n_scnum;
290  args.resultp = secnum;
291  args.bfd_sect = bfd_sect;
292  args.objfile = objfile;
293 
294  *bfd_sect = NULL;
295  *secnum = SECT_OFF_TEXT (objfile);
296 
297  bfd_map_over_sections (objfile->obfd, find_targ_sec, &args);
298 }
299 
300 /* Return the section number (SECT_OFF_*) that N_SCNUM points to. */
301 
302 static int
303 secnum_to_section (int n_scnum, struct objfile *objfile)
304 {
305  int secnum;
306  asection *ignored;
307 
308  xcoff_secnum_to_sections (n_scnum, objfile, &ignored, &secnum);
309  return secnum;
310 }
311 
312 /* Return the BFD section that N_SCNUM points to. */
313 
314 static asection *
315 secnum_to_bfd_section (int n_scnum, struct objfile *objfile)
316 {
317  int ignored;
318  asection *bfd_sect;
319 
320  xcoff_secnum_to_sections (n_scnum, objfile, &bfd_sect, &ignored);
321  return bfd_sect;
322 }
323 
324 /* add a given stab string into given stab vector. */
325 
326 #if 0
327 
328 static void
329 add_stab_to_list (char *stabname, struct pending_stabs **stabvector)
330 {
331  if (*stabvector == NULL)
332  {
333  *stabvector = (struct pending_stabs *)
334  xmalloc (sizeof (struct pending_stabs) +
335  INITIAL_STABVECTOR_LENGTH * sizeof (char *));
336  (*stabvector)->count = 0;
337  (*stabvector)->length = INITIAL_STABVECTOR_LENGTH;
338  }
339  else if ((*stabvector)->count >= (*stabvector)->length)
340  {
341  (*stabvector)->length += INITIAL_STABVECTOR_LENGTH;
342  *stabvector = (struct pending_stabs *)
343  xrealloc ((char *) *stabvector, sizeof (struct pending_stabs) +
344  (*stabvector)->length * sizeof (char *));
345  }
346  (*stabvector)->stab[(*stabvector)->count++] = stabname;
347 }
348 
349 #endif
350  /* *INDENT-OFF* */
351 /* Linenos are processed on a file-by-file basis.
352 
353  Two reasons:
354 
355  1) xlc (IBM's native c compiler) postpones static function code
356  emission to the end of a compilation unit. This way it can
357  determine if those functions (statics) are needed or not, and
358  can do some garbage collection (I think). This makes line
359  numbers and corresponding addresses unordered, and we end up
360  with a line table like:
361 
362 
363  lineno addr
364  foo() 10 0x100
365  20 0x200
366  30 0x300
367 
368  foo3() 70 0x400
369  80 0x500
370  90 0x600
371 
372  static foo2()
373  40 0x700
374  50 0x800
375  60 0x900
376 
377  and that breaks gdb's binary search on line numbers, if the
378  above table is not sorted on line numbers. And that sort
379  should be on function based, since gcc can emit line numbers
380  like:
381 
382  10 0x100 - for the init/test part of a for stmt.
383  20 0x200
384  30 0x300
385  10 0x400 - for the increment part of a for stmt.
386 
387  arrange_linetable() will do this sorting.
388 
389  2) aix symbol table might look like:
390 
391  c_file // beginning of a new file
392  .bi // beginning of include file
393  .ei // end of include file
394  .bi
395  .ei
396 
397  basically, .bi/.ei pairs do not necessarily encapsulate
398  their scope. They need to be recorded, and processed later
399  on when we come the end of the compilation unit.
400  Include table (inclTable) and process_linenos() handle
401  that. */
402 /* *INDENT-ON* */
403 
404 
405 
406 /* compare line table entry addresses. */
407 
408 static int
409 compare_lte (const void *lte1p, const void *lte2p)
410 {
411  struct linetable_entry *lte1 = (struct linetable_entry *) lte1p;
412  struct linetable_entry *lte2 = (struct linetable_entry *) lte2p;
413 
414  return lte1->pc - lte2->pc;
415 }
416 
417 /* Given a line table with function entries are marked, arrange its
418  functions in ascending order and strip off function entry markers
419  and return it in a newly created table. If the old one is good
420  enough, return the old one. */
421 /* FIXME: I think all this stuff can be replaced by just passing
422  sort_linevec = 1 to end_symtab. */
423 
424 static struct linetable *
425 arrange_linetable (struct linetable *oldLineTb)
426 {
427  int ii, jj, newline, /* new line count */
428  function_count; /* # of functions */
429 
430  struct linetable_entry *fentry; /* function entry vector */
431  int fentry_size; /* # of function entries */
432  struct linetable *newLineTb; /* new line table */
433  int extra_lines = 0;
434 
435 #define NUM_OF_FUNCTIONS 20
436 
437  fentry_size = NUM_OF_FUNCTIONS;
438  fentry = (struct linetable_entry *)
439  xmalloc (fentry_size * sizeof (struct linetable_entry));
440 
441  for (function_count = 0, ii = 0; ii < oldLineTb->nitems; ++ii)
442  {
443  if (oldLineTb->item[ii].line == 0)
444  { /* Function entry found. */
445  if (function_count >= fentry_size)
446  { /* Make sure you have room. */
447  fentry_size *= 2;
448  fentry = (struct linetable_entry *)
449  xrealloc (fentry,
450  fentry_size * sizeof (struct linetable_entry));
451  }
452  fentry[function_count].line = ii;
453  fentry[function_count].pc = oldLineTb->item[ii].pc;
454  ++function_count;
455 
456  /* If the function was compiled with XLC, we may have to add an
457  extra line entry later. Reserve space for that. */
458  if (ii + 1 < oldLineTb->nitems
459  && oldLineTb->item[ii].pc != oldLineTb->item[ii + 1].pc)
460  extra_lines++;
461  }
462  }
463 
464  if (function_count == 0)
465  {
466  xfree (fentry);
467  return oldLineTb;
468  }
469  else if (function_count > 1)
470  qsort (fentry, function_count,
471  sizeof (struct linetable_entry), compare_lte);
472 
473  /* Allocate a new line table. */
474  newLineTb = (struct linetable *)
475  xmalloc
476  (sizeof (struct linetable) +
477  (oldLineTb->nitems - function_count + extra_lines) * sizeof (struct linetable_entry));
478 
479  /* If line table does not start with a function beginning, copy up until
480  a function begin. */
481 
482  newline = 0;
483  if (oldLineTb->item[0].line != 0)
484  for (newline = 0;
485  newline < oldLineTb->nitems && oldLineTb->item[newline].line; ++newline)
486  newLineTb->item[newline] = oldLineTb->item[newline];
487 
488  /* Now copy function lines one by one. */
489 
490  for (ii = 0; ii < function_count; ++ii)
491  {
492  /* If the function was compiled with XLC, we may have to add an
493  extra line to cover the function prologue. */
494  jj = fentry[ii].line;
495  if (jj + 1 < oldLineTb->nitems
496  && oldLineTb->item[jj].pc != oldLineTb->item[jj + 1].pc)
497  {
498  newLineTb->item[newline] = oldLineTb->item[jj];
499  newLineTb->item[newline].line = oldLineTb->item[jj + 1].line;
500  newline++;
501  }
502 
503  for (jj = fentry[ii].line + 1;
504  jj < oldLineTb->nitems && oldLineTb->item[jj].line != 0;
505  ++jj, ++newline)
506  newLineTb->item[newline] = oldLineTb->item[jj];
507  }
508  xfree (fentry);
509  /* The number of items in the line table must include these
510  extra lines which were added in case of XLC compiled functions. */
511  newLineTb->nitems = oldLineTb->nitems - function_count + extra_lines;
512  return newLineTb;
513 }
514 
515 /* include file support: C_BINCL/C_EINCL pairs will be kept in the
516  following `IncludeChain'. At the end of each symtab (end_symtab),
517  we will determine if we should create additional symtab's to
518  represent if (the include files. */
519 
520 
521 typedef struct _inclTable
522 {
523  char *name; /* include filename */
524 
525  /* Offsets to the line table. end points to the last entry which is
526  part of this include file. */
527  int begin, end;
528 
529  struct subfile *subfile;
530  unsigned funStartLine; /* Start line # of its function. */
531 }
532 InclTable;
533 
534 #define INITIAL_INCLUDE_TABLE_LENGTH 20
535 static InclTable *inclTable; /* global include table */
536 static int inclIndx; /* last entry to table */
537 static int inclLength; /* table length */
538 static int inclDepth; /* nested include depth */
539 
540 static void allocate_include_entry (void);
541 
542 static void
544 {
545  if (inclDepth)
546  {
547  /* In xcoff, we assume include files cannot be nested (not in .c files
548  of course, but in corresponding .s files.). */
549 
550  /* This can happen with old versions of GCC.
551  GCC 2.3.3-930426 does not exhibit this on a test case which
552  a user said produced the message for him. */
553  complaint (&symfile_complaints, _("Nested C_BINCL symbols"));
554  }
555  ++inclDepth;
556 
558 
559  inclTable[inclIndx].name = cs->c_name;
560  inclTable[inclIndx].begin = cs->c_value;
561 }
562 
563 static void
565 {
566  InclTable *pTbl;
567 
568  if (inclDepth == 0)
569  {
570  complaint (&symfile_complaints, _("Mismatched C_BINCL/C_EINCL pair"));
571  }
572 
574 
575  pTbl = &inclTable[inclIndx];
576  pTbl->end = cs->c_value;
577 
578  --inclDepth;
579  ++inclIndx;
580 }
581 
582 static void
584 {
585  if (inclTable == NULL)
586  {
587  inclTable = (InclTable *)
589  memset (inclTable,
590  '\0', sizeof (InclTable) * INITIAL_INCLUDE_TABLE_LENGTH);
591  inclLength = INITIAL_INCLUDE_TABLE_LENGTH;
592  inclIndx = 0;
593  }
594  else if (inclIndx >= inclLength)
595  {
596  inclLength += INITIAL_INCLUDE_TABLE_LENGTH;
597  inclTable = (InclTable *)
598  xrealloc (inclTable, sizeof (InclTable) * inclLength);
599  memset (inclTable + inclLength - INITIAL_INCLUDE_TABLE_LENGTH,
600  '\0', sizeof (InclTable) * INITIAL_INCLUDE_TABLE_LENGTH);
601  }
602 }
603 
604 /* Global variable to pass the psymtab down to all the routines involved
605  in psymtab to symtab processing. */
607 
608 /* Objfile related to this_symtab_psymtab; set at the same time. */
610 
611 /* given the start and end addresses of a compilation unit (or a csect,
612  at times) process its lines and create appropriate line vectors. */
613 
614 static void
616 {
617  int offset, ii;
618  file_ptr max_offset
619  = XCOFF_DATA (this_symtab_objfile)->max_lineno_offset;
620 
621  /* subfile structure for the main compilation unit. */
622  struct subfile main_subfile;
623 
624  /* In the main source file, any time we see a function entry, we
625  reset this variable to function's absolute starting line number.
626  All the following line numbers in the function are relative to
627  this, and we record absolute line numbers in record_line(). */
628 
629  unsigned int main_source_baseline = 0;
630 
631  unsigned *firstLine;
632 
633  offset =
634  ((struct symloc *) this_symtab_psymtab->read_symtab_private)->lineno_off;
635  if (offset == 0)
636  goto return_after_cleanup;
637 
638  memset (&main_subfile, '\0', sizeof (main_subfile));
639 
640  if (inclIndx == 0)
641  /* All source lines were in the main source file. None in include
642  files. */
643 
644  enter_line_range (&main_subfile, offset, 0, start, end,
645  &main_source_baseline);
646 
647  else
648  {
649  /* There was source with line numbers in include files. */
650 
651  int linesz =
652  coff_data (this_symtab_objfile->obfd)->local_linesz;
653  main_source_baseline = 0;
654 
655  for (ii = 0; ii < inclIndx; ++ii)
656  {
657  struct subfile *tmpSubfile;
658 
659  /* If there is main file source before include file, enter it. */
660  if (offset < inclTable[ii].begin)
661  {
663  (&main_subfile, offset, inclTable[ii].begin - linesz,
664  start, 0, &main_source_baseline);
665  }
666 
667  if (strcmp (inclTable[ii].name, get_last_source_file ()) == 0)
668  {
669  /* The entry in the include table refers to the main source
670  file. Add the lines to the main subfile. */
671 
672  main_source_baseline = inclTable[ii].funStartLine;
674  (&main_subfile, inclTable[ii].begin, inclTable[ii].end,
675  start, 0, &main_source_baseline);
676  inclTable[ii].subfile = &main_subfile;
677  }
678  else
679  {
680  /* Have a new subfile for the include file. */
681 
682  tmpSubfile = inclTable[ii].subfile =
683  (struct subfile *) xmalloc (sizeof (struct subfile));
684 
685  memset (tmpSubfile, '\0', sizeof (struct subfile));
686  firstLine = &(inclTable[ii].funStartLine);
687 
688  /* Enter include file's lines now. */
689  enter_line_range (tmpSubfile, inclTable[ii].begin,
690  inclTable[ii].end, start, 0, firstLine);
691  }
692 
693  if (offset <= inclTable[ii].end)
694  offset = inclTable[ii].end + linesz;
695  }
696 
697  /* All the include files' line have been processed at this point. Now,
698  enter remaining lines of the main file, if any left. */
699  if (offset < max_offset + 1 - linesz)
700  {
701  enter_line_range (&main_subfile, offset, 0, start, end,
702  &main_source_baseline);
703  }
704  }
705 
706  /* Process main file's line numbers. */
707  if (main_subfile.line_vector)
708  {
709  struct linetable *lineTb, *lv;
710 
711  lv = main_subfile.line_vector;
712 
713  /* Line numbers are not necessarily ordered. xlc compilation will
714  put static function to the end. */
715 
716  lineTb = arrange_linetable (lv);
717  if (lv == lineTb)
718  {
720  xrealloc (lv, (sizeof (struct linetable)
721  + lv->nitems * sizeof (struct linetable_entry)));
722  }
723  else
724  {
725  xfree (lv);
726  current_subfile->line_vector = lineTb;
727  }
728 
731  }
732 
733  /* Now, process included files' line numbers. */
734 
735  for (ii = 0; ii < inclIndx; ++ii)
736  {
737  if (inclTable[ii].subfile != ((struct subfile *) &main_subfile)
738  && (inclTable[ii].subfile)->line_vector) /* Useless if!!!
739  FIXMEmgo */
740  {
741  struct linetable *lineTb, *lv;
742 
743  lv = (inclTable[ii].subfile)->line_vector;
744 
745  /* Line numbers are not necessarily ordered. xlc compilation will
746  put static function to the end. */
747 
748  lineTb = arrange_linetable (lv);
749 
750  push_subfile ();
751 
752  /* For the same include file, we might want to have more than one
753  subfile. This happens if we have something like:
754 
755  ......
756  #include "foo.h"
757  ......
758  #include "foo.h"
759  ......
760 
761  while foo.h including code in it. (stupid but possible)
762  Since start_subfile() looks at the name and uses an
763  existing one if finds, we need to provide a fake name and
764  fool it. */
765 
766 #if 0
767  start_subfile (inclTable[ii].name);
768 #else
769  {
770  /* Pick a fake name that will produce the same results as this
771  one when passed to deduce_language_from_filename. Kludge on
772  top of kludge. */
773  char *fakename = strrchr (inclTable[ii].name, '.');
774 
775  if (fakename == NULL)
776  fakename = " ?";
777  start_subfile (fakename);
779  }
780  current_subfile->name = xstrdup (inclTable[ii].name);
781 #endif
782 
783  if (lv == lineTb)
784  {
786  (struct linetable *) xrealloc
787  (lv, (sizeof (struct linetable)
788  + lv->nitems * sizeof (struct linetable_entry)));
789 
790  }
791  else
792  {
793  xfree (lv);
794  current_subfile->line_vector = lineTb;
795  }
796 
800  }
801  }
802 
803 return_after_cleanup:
804 
805  /* We don't want to keep alloc/free'ing the global include file table. */
806  inclIndx = 0;
807 }
808 
809 static void
811 {
812  /* There is no linenos to read if there are only dwarf info. */
813  if (this_symtab_psymtab == NULL)
814  return;
815 
816  /* Process line numbers and enter them into line vector. */
817  process_linenos (last_source_start_addr, cur_src_end_addr);
818 }
819 
820 
821 /* Enter a given range of lines into the line vector.
822  can be called in the following two ways:
823  enter_line_range (subfile, beginoffset, endoffset,
824  startaddr, 0, firstLine) or
825  enter_line_range (subfile, beginoffset, 0,
826  startaddr, endaddr, firstLine)
827 
828  endoffset points to the last line table entry that we should pay
829  attention to. */
830 
831 static void
832 enter_line_range (struct subfile *subfile, unsigned beginoffset,
833  unsigned endoffset, /* offsets to line table */
834  CORE_ADDR startaddr, /* offsets to line table */
835  CORE_ADDR endaddr, unsigned *firstLine)
836 {
838  struct gdbarch *gdbarch = get_objfile_arch (objfile);
839  unsigned int curoffset;
840  CORE_ADDR addr;
841  void *ext_lnno;
842  struct internal_lineno int_lnno;
843  unsigned int limit_offset;
844  bfd *abfd;
845  int linesz;
846 
847  if (endoffset == 0 && startaddr == 0 && endaddr == 0)
848  return;
849  curoffset = beginoffset;
850  limit_offset = XCOFF_DATA (objfile)->max_lineno_offset;
851 
852  if (endoffset != 0)
853  {
854  if (endoffset >= limit_offset)
855  {
857  _("Bad line table offset in C_EINCL directive"));
858  return;
859  }
860  limit_offset = endoffset;
861  }
862  else
863  limit_offset -= 1;
864 
865  abfd = objfile->obfd;
866  linesz = coff_data (abfd)->local_linesz;
867  ext_lnno = alloca (linesz);
868 
869  while (curoffset <= limit_offset)
870  {
871  bfd_seek (abfd, curoffset, SEEK_SET);
872  bfd_bread (ext_lnno, linesz, abfd);
873  bfd_coff_swap_lineno_in (abfd, ext_lnno, &int_lnno);
874 
875  /* Find the address this line represents. */
876  addr = (int_lnno.l_lnno
877  ? int_lnno.l_addr.l_paddr
878  : read_symbol_nvalue (int_lnno.l_addr.l_symndx));
879  addr += ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
880 
881  if (addr < startaddr || (endaddr && addr >= endaddr))
882  return;
883 
884  if (int_lnno.l_lnno == 0)
885  {
886  *firstLine = read_symbol_lineno (int_lnno.l_addr.l_symndx);
887  record_line (subfile, 0, gdbarch_addr_bits_remove (gdbarch, addr));
888  --(*firstLine);
889  }
890  else
891  record_line (subfile, *firstLine + int_lnno.l_lnno,
892  gdbarch_addr_bits_remove (gdbarch, addr));
893  curoffset += linesz;
894  }
895 }
896 
897 
898 /* Save the vital information for use when closing off the current file.
899  NAME is the file name the symbols came from, START_ADDR is the first
900  text address for the file, and SIZE is the number of bytes of text. */
901 
902 #define complete_symtab(name, start_addr) { \
903  set_last_source_file (name); \
904  last_source_start_addr = start_addr; \
905 }
906 
907 
908 /* Refill the symbol table input buffer
909  and set the variables that control fetching entries from it.
910  Reports an error if no data available.
911  This function can read past the end of the symbol table
912  (into the string table) but this does no harm. */
913 
914 /* Create a new minimal symbol (using prim_record_minimal_symbol_and_info).
915 
916  Creation of all new minimal symbols should go through this function
917  rather than calling the various prim_record_[...] functions in order
918  to make sure that all symbol addresses get properly relocated.
919 
920  Arguments are:
921 
922  NAME - the symbol's name (but if NAME starts with a period, that
923  leading period is discarded).
924  ADDRESS - the symbol's address, prior to relocation. This function
925  relocates the address before recording the minimal symbol.
926  MS_TYPE - the symbol's type.
927  N_SCNUM - the symbol's XCOFF section number.
928  OBJFILE - the objfile associated with the minimal symbol. */
929 
930 static void
931 record_minimal_symbol (const char *name, CORE_ADDR address,
932  enum minimal_symbol_type ms_type,
933  int n_scnum,
934  struct objfile *objfile)
935 {
936  int section = secnum_to_section (n_scnum, objfile);
937 
938  if (name[0] == '.')
939  ++name;
940 
941  prim_record_minimal_symbol_and_info (name, address, ms_type,
942  secnum_to_section (n_scnum, objfile),
943  objfile);
944 }
945 
946 /* xcoff has static blocks marked in `.bs', `.es' pairs. They cannot be
947  nested. At any given time, a symbol can only be in one static block.
948  This is the base address of current static block, zero if non exists. */
949 
950 static int static_block_base = 0;
951 
952 /* Section number for the current static block. */
953 
954 static int static_block_section = -1;
955 
956 /* true if space for symbol name has been allocated. */
957 
958 static int symname_alloced = 0;
959 
960 /* Next symbol to read. Pointer into raw seething symbol table. */
961 
962 static char *raw_symbol;
963 
964 /* This is the function which stabsread.c calls to get symbol
965  continuations. */
966 
967 static char *
969 {
970  struct internal_syment symbol;
971  char *retval;
972 
973  /* FIXME: is this the same as the passed arg? */
974  if (this_symtab_objfile)
975  objfile = this_symtab_objfile;
976 
977  bfd_coff_swap_sym_in (objfile->obfd, raw_symbol, &symbol);
978  if (symbol.n_zeroes)
979  {
980  complaint (&symfile_complaints, _("Unexpected symbol continuation"));
981 
982  /* Return something which points to '\0' and hope the symbol reading
983  code does something reasonable. */
984  retval = "";
985  }
986  else if (symbol.n_sclass & 0x80)
987  {
988  retval = XCOFF_DATA (objfile)->debugsec + symbol.n_offset;
989  raw_symbol += coff_data (objfile->obfd)->local_symesz;
990  ++symnum;
991  }
992  else
993  {
994  complaint (&symfile_complaints, _("Unexpected symbol continuation"));
995 
996  /* Return something which points to '\0' and hope the symbol reading
997  code does something reasonable. */
998  retval = "";
999  }
1000  return retval;
1001 }
1002 
1003 /* Read symbols for a given partial symbol table. */
1004 
1005 static void
1007 {
1008  bfd *abfd = objfile->obfd;
1009  char *raw_auxptr; /* Pointer to first raw aux entry for sym. */
1010  struct coff_symfile_info *xcoff = XCOFF_DATA (objfile);
1011  char *strtbl = xcoff->strtbl;
1012  char *debugsec = xcoff->debugsec;
1013  const char *debugfmt = bfd_xcoff_is_xcoff64 (abfd) ? "XCOFF64" : "XCOFF";
1014 
1015  struct internal_syment symbol[1];
1016  union internal_auxent main_aux;
1017  struct coff_symbol cs[1];
1018  CORE_ADDR file_start_addr = 0;
1019  CORE_ADDR file_end_addr = 0;
1020 
1021  int next_file_symnum = -1;
1022  unsigned int max_symnum;
1023  int just_started = 1;
1024  int depth = 0;
1025  CORE_ADDR fcn_start_addr = 0;
1026 
1027  struct coff_symbol fcn_stab_saved = { 0 };
1028 
1029  /* fcn_cs_saved is global because process_xcoff_symbol needs it. */
1030  union internal_auxent fcn_aux_saved = main_aux;
1031  struct context_stack *newobj;
1032 
1033  char *filestring = " _start_ "; /* Name of the current file. */
1034 
1035  const char *last_csect_name; /* Last seen csect's name. */
1036 
1037  this_symtab_psymtab = pst;
1038  this_symtab_objfile = objfile;
1039 
1040  /* Get the appropriate COFF "constants" related to the file we're
1041  handling. */
1042  local_symesz = coff_data (abfd)->local_symesz;
1043 
1044  set_last_source_file (NULL);
1045  last_csect_name = 0;
1046 
1047  start_stabs ();
1048  start_symtab (objfile, filestring, (char *) NULL, file_start_addr);
1049  record_debugformat (debugfmt);
1050  symnum = ((struct symloc *) pst->read_symtab_private)->first_symnum;
1051  max_symnum =
1052  symnum + ((struct symloc *) pst->read_symtab_private)->numsyms;
1053  first_object_file_end = 0;
1054 
1055  raw_symbol = xcoff->symtbl + symnum * local_symesz;
1056 
1057  while (symnum < max_symnum)
1058  {
1059  QUIT; /* make this command interruptable. */
1060 
1061  /* READ_ONE_SYMBOL (symbol, cs, symname_alloced); */
1062  /* read one symbol into `cs' structure. After processing the
1063  whole symbol table, only string table will be kept in memory,
1064  symbol table and debug section of xcoff will be freed. Thus
1065  we can mark symbols with names in string table as
1066  `alloced'. */
1067  {
1068  int ii;
1069 
1070  /* Swap and align the symbol into a reasonable C structure. */
1071  bfd_coff_swap_sym_in (abfd, raw_symbol, symbol);
1072 
1073  cs->c_symnum = symnum;
1074  cs->c_naux = symbol->n_numaux;
1075  if (symbol->n_zeroes)
1076  {
1077  symname_alloced = 0;
1078  /* We must use the original, unswapped, name here so the name field
1079  pointed to by cs->c_name will persist throughout xcoffread. If
1080  we use the new field, it gets overwritten for each symbol. */
1081  cs->c_name = ((struct external_syment *) raw_symbol)->e.e_name;
1082  /* If it's exactly E_SYMNMLEN characters long it isn't
1083  '\0'-terminated. */
1084  if (cs->c_name[E_SYMNMLEN - 1] != '\0')
1085  {
1086  char *p;
1087 
1088  p = obstack_alloc (&objfile->objfile_obstack, E_SYMNMLEN + 1);
1089  strncpy (p, cs->c_name, E_SYMNMLEN);
1090  p[E_SYMNMLEN] = '\0';
1091  cs->c_name = p;
1092  symname_alloced = 1;
1093  }
1094  }
1095  else if (symbol->n_sclass & 0x80)
1096  {
1097  cs->c_name = debugsec + symbol->n_offset;
1098  symname_alloced = 0;
1099  }
1100  else
1101  {
1102  /* in string table */
1103  cs->c_name = strtbl + (int) symbol->n_offset;
1104  symname_alloced = 1;
1105  }
1106  cs->c_value = symbol->n_value;
1107  cs->c_sclass = symbol->n_sclass;
1108  cs->c_secnum = symbol->n_scnum;
1109  cs->c_type = (unsigned) symbol->n_type;
1110 
1111  raw_symbol += local_symesz;
1112  ++symnum;
1113 
1114  /* Save addr of first aux entry. */
1115  raw_auxptr = raw_symbol;
1116 
1117  /* Skip all the auxents associated with this symbol. */
1118  for (ii = symbol->n_numaux; ii; --ii)
1119  {
1120  raw_symbol += coff_data (abfd)->local_auxesz;
1121  ++symnum;
1122  }
1123  }
1124 
1125  /* if symbol name starts with ".$" or "$", ignore it. */
1126  if (cs->c_name[0] == '$'
1127  || (cs->c_name[1] == '$' && cs->c_name[0] == '.'))
1128  continue;
1129 
1130  if (cs->c_symnum == next_file_symnum && cs->c_sclass != C_FILE)
1131  {
1132  if (get_last_source_file ())
1133  {
1134  pst->compunit_symtab = end_symtab (cur_src_end_addr,
1135  SECT_OFF_TEXT (objfile));
1136  end_stabs ();
1137  }
1138 
1139  start_stabs ();
1140  start_symtab (objfile, "_globals_", (char *) NULL, (CORE_ADDR) 0);
1141  record_debugformat (debugfmt);
1142  cur_src_end_addr = first_object_file_end;
1143  /* Done with all files, everything from here on is globals. */
1144  }
1145 
1146  if ((cs->c_sclass == C_EXT || cs->c_sclass == C_HIDEXT)
1147  && cs->c_naux == 1)
1148  {
1149  /* Dealing with a symbol with a csect entry. */
1150 
1151 #define CSECT(PP) ((PP)->x_csect)
1152 #define CSECT_LEN(PP) (CSECT(PP).x_scnlen.l)
1153 #define CSECT_ALIGN(PP) (SMTYP_ALIGN(CSECT(PP).x_smtyp))
1154 #define CSECT_SMTYP(PP) (SMTYP_SMTYP(CSECT(PP).x_smtyp))
1155 #define CSECT_SCLAS(PP) (CSECT(PP).x_smclas)
1156 
1157  /* Convert the auxent to something we can access. */
1158  bfd_coff_swap_aux_in (abfd, raw_auxptr, cs->c_type, cs->c_sclass,
1159  0, cs->c_naux, &main_aux);
1160 
1161  switch (CSECT_SMTYP (&main_aux))
1162  {
1163 
1164  case XTY_ER:
1165  /* Ignore all external references. */
1166  continue;
1167 
1168  case XTY_SD:
1169  /* A section description. */
1170  {
1171  switch (CSECT_SCLAS (&main_aux))
1172  {
1173 
1174  case XMC_PR:
1175  {
1176 
1177  /* A program csect is seen. We have to allocate one
1178  symbol table for each program csect. Normally gdb
1179  prefers one symtab for each source file. In case
1180  of AIX, one source file might include more than one
1181  [PR] csect, and they don't have to be adjacent in
1182  terms of the space they occupy in memory. Thus, one
1183  single source file might get fragmented in the
1184  memory and gdb's file start and end address
1185  approach does not work! GCC (and I think xlc) seem
1186  to put all the code in the unnamed program csect. */
1187 
1188  if (last_csect_name)
1189  {
1190  complete_symtab (filestring, file_start_addr);
1191  cur_src_end_addr = file_end_addr;
1192  end_symtab (file_end_addr, SECT_OFF_TEXT (objfile));
1193  end_stabs ();
1194  start_stabs ();
1195  /* Give all csects for this source file the same
1196  name. */
1197  start_symtab (objfile, filestring, NULL,
1198  (CORE_ADDR) 0);
1199  record_debugformat (debugfmt);
1200  }
1201 
1202  /* If this is the very first csect seen,
1203  basically `__start'. */
1204  if (just_started)
1205  {
1206  first_object_file_end
1207  = cs->c_value + CSECT_LEN (&main_aux);
1208  just_started = 0;
1209  }
1210 
1211  file_start_addr =
1212  cs->c_value + ANOFFSET (objfile->section_offsets,
1213  SECT_OFF_TEXT (objfile));
1214  file_end_addr = file_start_addr + CSECT_LEN (&main_aux);
1215 
1216  if (cs->c_name && (cs->c_name[0] == '.' || cs->c_name[0] == '@'))
1217  last_csect_name = cs->c_name;
1218  }
1219  continue;
1220 
1221  /* All other symbols are put into the minimal symbol
1222  table only. */
1223 
1224  case XMC_RW:
1225  continue;
1226 
1227  case XMC_TC0:
1228  continue;
1229 
1230  case XMC_TC:
1231  continue;
1232 
1233  default:
1234  /* Ignore the symbol. */
1235  continue;
1236  }
1237  }
1238  break;
1239 
1240  case XTY_LD:
1241 
1242  switch (CSECT_SCLAS (&main_aux))
1243  {
1244  case XMC_PR:
1245  /* a function entry point. */
1246  function_entry_point:
1247 
1248  fcn_start_addr = cs->c_value;
1249 
1250  /* save the function header info, which will be used
1251  when `.bf' is seen. */
1252  fcn_cs_saved = *cs;
1253  fcn_aux_saved = main_aux;
1254  continue;
1255 
1256  case XMC_GL:
1257  /* shared library function trampoline code entry point. */
1258  continue;
1259 
1260  case XMC_DS:
1261  /* The symbols often have the same names as debug symbols for
1262  functions, and confuse lookup_symbol. */
1263  continue;
1264 
1265  default:
1266  /* xlc puts each variable in a separate csect, so we get
1267  an XTY_SD for each variable. But gcc puts several
1268  variables in a csect, so that each variable only gets
1269  an XTY_LD. This will typically be XMC_RW; I suspect
1270  XMC_RO and XMC_BS might be possible too.
1271  These variables are put in the minimal symbol table
1272  only. */
1273  continue;
1274  }
1275  break;
1276 
1277  case XTY_CM:
1278  /* Common symbols are put into the minimal symbol table only. */
1279  continue;
1280 
1281  default:
1282  break;
1283  }
1284  }
1285 
1286  /* If explicitly specified as a function, treat is as one. This check
1287  evaluates to true for @FIX* bigtoc CSECT symbols, so it must occur
1288  after the above CSECT check. */
1289  if (ISFCN (cs->c_type) && cs->c_sclass != C_TPDEF)
1290  {
1291  bfd_coff_swap_aux_in (abfd, raw_auxptr, cs->c_type, cs->c_sclass,
1292  0, cs->c_naux, &main_aux);
1293  goto function_entry_point;
1294  }
1295 
1296  switch (cs->c_sclass)
1297  {
1298  case C_FILE:
1299 
1300  /* c_value field contains symnum of next .file entry in table
1301  or symnum of first global after last .file. */
1302 
1303  next_file_symnum = cs->c_value;
1304 
1305  /* Complete symbol table for last object file containing
1306  debugging information. */
1307 
1308  /* Whether or not there was a csect in the previous file, we
1309  have to call `end_stabs' and `start_stabs' to reset
1310  type_vector, line_vector, etc. structures. */
1311 
1312  complete_symtab (filestring, file_start_addr);
1313  cur_src_end_addr = file_end_addr;
1314  end_symtab (file_end_addr, SECT_OFF_TEXT (objfile));
1315  end_stabs ();
1316 
1317  /* XCOFF, according to the AIX 3.2 documentation, puts the
1318  filename in cs->c_name. But xlc 1.3.0.2 has decided to
1319  do things the standard COFF way and put it in the auxent.
1320  We use the auxent if the symbol is ".file" and an auxent
1321  exists, otherwise use the symbol itself. Simple
1322  enough. */
1323  if (!strcmp (cs->c_name, ".file") && cs->c_naux > 0)
1324  {
1325  bfd_coff_swap_aux_in (abfd, raw_auxptr, cs->c_type, cs->c_sclass,
1326  0, cs->c_naux, &main_aux);
1327  filestring = coff_getfilename (&main_aux, objfile);
1328  }
1329  else
1330  filestring = cs->c_name;
1331 
1332  start_stabs ();
1333  start_symtab (objfile, filestring, (char *) NULL, (CORE_ADDR) 0);
1334  record_debugformat (debugfmt);
1335  last_csect_name = 0;
1336 
1337  /* reset file start and end addresses. A compilation unit
1338  with no text (only data) should have zero file
1339  boundaries. */
1340  file_start_addr = file_end_addr = 0;
1341  break;
1342 
1343  case C_FUN:
1344  fcn_stab_saved = *cs;
1345  break;
1346 
1347  case C_FCN:
1348  if (strcmp (cs->c_name, ".bf") == 0)
1349  {
1350  CORE_ADDR off = ANOFFSET (objfile->section_offsets,
1351  SECT_OFF_TEXT (objfile));
1352 
1353  bfd_coff_swap_aux_in (abfd, raw_auxptr, cs->c_type, cs->c_sclass,
1354  0, cs->c_naux, &main_aux);
1355 
1356  within_function = 1;
1357 
1358  newobj = push_context (0, fcn_start_addr + off);
1359 
1360  newobj->name = define_symbol
1361  (fcn_cs_saved.c_value + off,
1362  fcn_stab_saved.c_name, 0, 0, objfile);
1363  if (newobj->name != NULL)
1364  SYMBOL_SECTION (newobj->name) = SECT_OFF_TEXT (objfile);
1365  }
1366  else if (strcmp (cs->c_name, ".ef") == 0)
1367  {
1368  bfd_coff_swap_aux_in (abfd, raw_auxptr, cs->c_type, cs->c_sclass,
1369  0, cs->c_naux, &main_aux);
1370 
1371  /* The value of .ef is the address of epilogue code;
1372  not useful for gdb. */
1373  /* { main_aux.x_sym.x_misc.x_lnsz.x_lnno
1374  contains number of lines to '}' */
1375 
1376  if (context_stack_depth <= 0)
1377  { /* We attempted to pop an empty context stack. */
1378  ef_complaint (cs->c_symnum);
1379  within_function = 0;
1380  break;
1381  }
1382  newobj = pop_context ();
1383  /* Stack must be empty now. */
1384  if (context_stack_depth > 0 || newobj == NULL)
1385  {
1386  ef_complaint (cs->c_symnum);
1387  within_function = 0;
1388  break;
1389  }
1390 
1391  finish_block (newobj->name, &local_symbols, newobj->old_blocks,
1392  newobj->start_addr,
1394  + fcn_aux_saved.x_sym.x_misc.x_fsize
1395  + ANOFFSET (objfile->section_offsets,
1396  SECT_OFF_TEXT (objfile))));
1397  within_function = 0;
1398  }
1399  break;
1400 
1401  case C_BSTAT:
1402  /* Begin static block. */
1403  {
1404  struct internal_syment symbol;
1405 
1406  read_symbol (&symbol, cs->c_value);
1407  static_block_base = symbol.n_value;
1408  static_block_section =
1409  secnum_to_section (symbol.n_scnum, objfile);
1410  }
1411  break;
1412 
1413  case C_ESTAT:
1414  /* End of static block. */
1415  static_block_base = 0;
1416  static_block_section = -1;
1417  break;
1418 
1419  case C_ARG:
1420  case C_REGPARM:
1421  case C_REG:
1422  case C_TPDEF:
1423  case C_STRTAG:
1424  case C_UNTAG:
1425  case C_ENTAG:
1426  {
1428  _("Unrecognized storage class %d."),
1429  cs->c_sclass);
1430  }
1431  break;
1432 
1433  case C_LABEL:
1434  case C_NULL:
1435  /* Ignore these. */
1436  break;
1437 
1438  case C_HIDEXT:
1439  case C_STAT:
1440  break;
1441 
1442  case C_BINCL:
1443  /* beginning of include file */
1444  /* In xlc output, C_BINCL/C_EINCL pair doesn't show up in sorted
1445  order. Thus, when wee see them, we might not know enough info
1446  to process them. Thus, we'll be saving them into a table
1447  (inclTable) and postpone their processing. */
1448 
1449  record_include_begin (cs);
1450  break;
1451 
1452  case C_EINCL:
1453  /* End of include file. */
1454  /* See the comment after case C_BINCL. */
1455  record_include_end (cs);
1456  break;
1457 
1458  case C_BLOCK:
1459  if (strcmp (cs->c_name, ".bb") == 0)
1460  {
1461  depth++;
1462  newobj = push_context (depth,
1463  (cs->c_value
1464  + ANOFFSET (objfile->section_offsets,
1465  SECT_OFF_TEXT (objfile))));
1466  }
1467  else if (strcmp (cs->c_name, ".eb") == 0)
1468  {
1469  if (context_stack_depth <= 0)
1470  { /* We attempted to pop an empty context stack. */
1471  eb_complaint (cs->c_symnum);
1472  break;
1473  }
1474  newobj = pop_context ();
1475  if (depth-- != newobj->depth)
1476  {
1477  eb_complaint (cs->c_symnum);
1478  break;
1479  }
1481  {
1482  /* Make a block for the local symbols within. */
1483  finish_block (newobj->name, &local_symbols, newobj->old_blocks,
1484  newobj->start_addr,
1485  (cs->c_value
1486  + ANOFFSET (objfile->section_offsets,
1487  SECT_OFF_TEXT (objfile))));
1488  }
1489  local_symbols = newobj->locals;
1490  }
1491  break;
1492 
1493  default:
1494  process_xcoff_symbol (cs, objfile);
1495  break;
1496  }
1497  }
1498 
1499  if (get_last_source_file ())
1500  {
1501  struct compunit_symtab *cust;
1502 
1503  complete_symtab (filestring, file_start_addr);
1504  cur_src_end_addr = file_end_addr;
1505  cust = end_symtab (file_end_addr, SECT_OFF_TEXT (objfile));
1506  /* When reading symbols for the last C_FILE of the objfile, try
1507  to make sure that we set pst->compunit_symtab to the symtab for the
1508  file, not to the _globals_ symtab. I'm not sure whether this
1509  actually works right or when/if it comes up. */
1510  if (pst->compunit_symtab == NULL)
1511  pst->compunit_symtab = cust;
1512  end_stabs ();
1513  }
1514 }
1515 
1516 #define SYMBOL_DUP(SYMBOL1, SYMBOL2) \
1517  (SYMBOL2) = (struct symbol *) \
1518  obstack_alloc (&objfile->objfile_obstack, sizeof (struct symbol)); \
1519  *(SYMBOL2) = *(SYMBOL1);
1520 
1521 
1522 #define SYMNAME_ALLOC(NAME, ALLOCED) \
1523  ((ALLOCED) ? (NAME) : obstack_copy0 (&objfile->objfile_obstack, \
1524  (NAME), strlen (NAME)))
1525 
1526 
1527 /* process one xcoff symbol. */
1528 
1529 static struct symbol *
1531 {
1532  struct symbol onesymbol;
1533  struct symbol *sym = &onesymbol;
1534  struct symbol *sym2 = NULL;
1535  char *name, *pp;
1536 
1537  int sec;
1538  CORE_ADDR off;
1539 
1540  if (cs->c_secnum < 0)
1541  {
1542  /* The value is a register number, offset within a frame, etc.,
1543  and does not get relocated. */
1544  off = 0;
1545  sec = -1;
1546  }
1547  else
1548  {
1549  sec = secnum_to_section (cs->c_secnum, objfile);
1550  off = ANOFFSET (objfile->section_offsets, sec);
1551  }
1552 
1553  name = cs->c_name;
1554  if (name[0] == '.')
1555  ++name;
1556 
1558 
1559  /* default assumptions */
1560  SYMBOL_VALUE_ADDRESS (sym) = cs->c_value + off;
1561  SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
1562  SYMBOL_SECTION (sym) = secnum_to_section (cs->c_secnum, objfile);
1563 
1564  if (ISFCN (cs->c_type))
1565  {
1566  /* At this point, we don't know the type of the function. This
1567  will be patched with the type from its stab entry later on in
1568  patch_block_stabs (), unless the file was compiled without -g. */
1569 
1570  SYMBOL_SET_LINKAGE_NAME (sym, SYMNAME_ALLOC (name, symname_alloced));
1571  SYMBOL_TYPE (sym) = objfile_type (objfile)->nodebug_text_symbol;
1572 
1574  SYMBOL_DUP (sym, sym2);
1575 
1576  if (cs->c_sclass == C_EXT)
1578  else if (cs->c_sclass == C_HIDEXT || cs->c_sclass == C_STAT)
1580  }
1581  else
1582  {
1583  /* In case we can't figure out the type, provide default. */
1584  SYMBOL_TYPE (sym) = objfile_type (objfile)->nodebug_data_symbol;
1585 
1586  switch (cs->c_sclass)
1587  {
1588 #if 0
1589  /* The values of functions and global symbols are now resolved
1590  via the global_sym_chain in stabsread.c. */
1591  case C_FUN:
1592  if (fcn_cs_saved.c_sclass == C_EXT)
1593  add_stab_to_list (name, &global_stabs);
1594  else
1595  add_stab_to_list (name, &file_stabs);
1596  break;
1597 
1598  case C_GSYM:
1599  add_stab_to_list (name, &global_stabs);
1600  break;
1601 #endif
1602 
1603  case C_BCOMM:
1604  common_block_start (cs->c_name, objfile);
1605  break;
1606 
1607  case C_ECOMM:
1608  common_block_end (objfile);
1609  break;
1610 
1611  default:
1612  complaint (&symfile_complaints, _("Unexpected storage class: %d"),
1613  cs->c_sclass);
1614  /* FALLTHROUGH */
1615 
1616  case C_DECL:
1617  case C_PSYM:
1618  case C_RPSYM:
1619  case C_ECOML:
1620  case C_LSYM:
1621  case C_RSYM:
1622  case C_GSYM:
1623 
1624  {
1625  sym = define_symbol (cs->c_value + off, cs->c_name, 0, 0, objfile);
1626  if (sym != NULL)
1627  {
1628  SYMBOL_SECTION (sym) = sec;
1629  }
1630  return sym;
1631  }
1632 
1633  case C_STSYM:
1634 
1635  /* For xlc (not GCC), the 'V' symbol descriptor is used for
1636  all statics and we need to distinguish file-scope versus
1637  function-scope using within_function. We do this by
1638  changing the string we pass to define_symbol to use 'S'
1639  where we need to, which is not necessarily super-clean,
1640  but seems workable enough. */
1641 
1642  if (*name == ':')
1643  return NULL;
1644 
1645  pp = strchr (name, ':');
1646  if (pp == NULL)
1647  return NULL;
1648 
1649  ++pp;
1650  if (*pp == 'V' && !within_function)
1651  *pp = 'S';
1652  sym = define_symbol ((cs->c_value
1653  + ANOFFSET (objfile->section_offsets,
1654  static_block_section)),
1655  cs->c_name, 0, 0, objfile);
1656  if (sym != NULL)
1657  {
1660  }
1661  return sym;
1662 
1663  }
1664  }
1665  return sym2;
1666 }
1667 
1668 /* Extract the file name from the aux entry of a C_FILE symbol.
1669  Result is in static storage and is only good for temporary use. */
1670 
1671 static char *
1672 coff_getfilename (union internal_auxent *aux_entry, struct objfile *objfile)
1673 {
1674  static char buffer[BUFSIZ];
1675 
1676  if (aux_entry->x_file.x_n.x_zeroes == 0)
1677  strcpy (buffer, (XCOFF_DATA (objfile)->strtbl
1678  + aux_entry->x_file.x_n.x_offset));
1679  else
1680  {
1681  strncpy (buffer, aux_entry->x_file.x_fname, FILNMLEN);
1682  buffer[FILNMLEN] = '\0';
1683  }
1684  return (buffer);
1685 }
1686 
1687 /* Set *SYMBOL to symbol number symno in symtbl. */
1688 static void
1689 read_symbol (struct internal_syment *symbol, int symno)
1690 {
1691  struct coff_symfile_info *xcoff = XCOFF_DATA (this_symtab_objfile);
1692  int nsyms = xcoff->symtbl_num_syms;
1693  char *stbl = xcoff->symtbl;
1694 
1695  if (symno < 0 || symno >= nsyms)
1696  {
1697  complaint (&symfile_complaints, _("Invalid symbol offset"));
1698  symbol->n_value = 0;
1699  symbol->n_scnum = -1;
1700  return;
1701  }
1702  bfd_coff_swap_sym_in (this_symtab_objfile->obfd,
1703  stbl + (symno * local_symesz),
1704  symbol);
1705 }
1706 
1707 /* Get value corresponding to symbol number symno in symtbl. */
1708 
1709 static CORE_ADDR
1711 {
1712  struct internal_syment symbol[1];
1713 
1714  read_symbol (symbol, symno);
1715  return symbol->n_value;
1716 }
1717 
1718 
1719 /* Find the address of the function corresponding to symno, where
1720  symno is the symbol pointed to by the linetable. */
1721 
1722 static int
1724 {
1726  int xcoff64 = bfd_xcoff_is_xcoff64 (objfile->obfd);
1727 
1728  struct coff_symfile_info *info = XCOFF_DATA (objfile);
1729  int nsyms = info->symtbl_num_syms;
1730  char *stbl = info->symtbl;
1731  char *strtbl = info->strtbl;
1732 
1733  struct internal_syment symbol[1];
1734  union internal_auxent main_aux[1];
1735 
1736  if (symno < 0)
1737  {
1739  return 0;
1740  }
1741 
1742  /* Note that just searching for a short distance (e.g. 50 symbols)
1743  is not enough, at least in the following case.
1744 
1745  .extern foo
1746  [many .stabx entries]
1747  [a few functions, referring to foo]
1748  .globl foo
1749  .bf
1750 
1751  What happens here is that the assembler moves the .stabx entries
1752  to right before the ".bf" for foo, but the symbol for "foo" is before
1753  all the stabx entries. See PR gdb/2222. */
1754 
1755  /* Maintaining a table of .bf entries might be preferable to this search.
1756  If I understand things correctly it would need to be done only for
1757  the duration of a single psymtab to symtab conversion. */
1758  while (symno < nsyms)
1759  {
1760  bfd_coff_swap_sym_in (symfile_bfd,
1761  stbl + (symno * local_symesz), symbol);
1762  if (symbol->n_sclass == C_FCN)
1763  {
1764  char *name = xcoff64 ? strtbl + symbol->n_offset : symbol->n_name;
1765 
1766  if (strcmp (name, ".bf") == 0)
1767  goto gotit;
1768  }
1769  symno += symbol->n_numaux + 1;
1770  }
1771 
1773  return 0;
1774 
1775 gotit:
1776  /* Take aux entry and return its lineno. */
1777  symno++;
1778  bfd_coff_swap_aux_in (objfile->obfd, stbl + symno * local_symesz,
1779  symbol->n_type, symbol->n_sclass,
1780  0, symbol->n_numaux, main_aux);
1781 
1782  return main_aux->x_sym.x_misc.x_lnsz.x_lnno;
1783 }
1784 
1785 /* Support for line number handling. */
1786 
1787 /* This function is called for every section; it finds the outer limits
1788  * of the line table (minimum and maximum file offset) so that the
1789  * mainline code can read the whole thing for efficiency.
1790  */
1791 static void
1792 find_linenos (struct bfd *abfd, struct bfd_section *asect, void *vpinfo)
1793 {
1794  struct coff_symfile_info *info;
1795  int size, count;
1796  file_ptr offset, maxoff;
1797 
1798  count = asect->lineno_count;
1799 
1800  if (strcmp (asect->name, ".text") != 0 || count == 0)
1801  return;
1802 
1803  size = count * coff_data (abfd)->local_linesz;
1804  info = (struct coff_symfile_info *) vpinfo;
1805  offset = asect->line_filepos;
1806  maxoff = offset + size;
1807 
1808  if (offset < info->min_lineno_offset || info->min_lineno_offset == 0)
1809  info->min_lineno_offset = offset;
1810 
1811  if (maxoff > info->max_lineno_offset)
1812  info->max_lineno_offset = maxoff;
1813 }
1814 
1815 static void
1817 {
1818  struct cleanup *old_chain;
1819  int i;
1820 
1821  if (!pst)
1822  return;
1823 
1824  if (pst->readin)
1825  {
1827  (gdb_stderr, "Psymtab for %s already read in. Shouldn't happen.\n",
1828  pst->filename);
1829  return;
1830  }
1831 
1832  /* Read in all partial symtabs on which this one is dependent. */
1833  for (i = 0; i < pst->number_of_dependencies; i++)
1834  if (!pst->dependencies[i]->readin)
1835  {
1836  /* Inform about additional files that need to be read in. */
1837  if (info_verbose)
1838  {
1839  fputs_filtered (" ", gdb_stdout);
1840  wrap_here ("");
1841  fputs_filtered ("and ", gdb_stdout);
1842  wrap_here ("");
1843  printf_filtered ("%s...", pst->dependencies[i]->filename);
1844  wrap_here (""); /* Flush output */
1846  }
1847  xcoff_psymtab_to_symtab_1 (objfile, pst->dependencies[i]);
1848  }
1849 
1850  if (((struct symloc *) pst->read_symtab_private)->numsyms != 0)
1851  {
1852  /* Init stuff necessary for reading in symbols. */
1853  stabsread_init ();
1854  buildsym_init ();
1855  old_chain = make_cleanup (really_free_pendings, 0);
1856 
1857  read_xcoff_symtab (objfile, pst);
1858 
1859  do_cleanups (old_chain);
1860  }
1861 
1862  pst->readin = 1;
1863 }
1864 
1865 /* Read in all of the symbols for a given psymtab for real.
1866  Be verbose about it if the user wants that. SELF is not NULL. */
1867 
1868 static void
1870 {
1871  if (self->readin)
1872  {
1874  (gdb_stderr, "Psymtab for %s already read in. Shouldn't happen.\n",
1875  self->filename);
1876  return;
1877  }
1878 
1879  if (((struct symloc *) self->read_symtab_private)->numsyms != 0
1880  || self->number_of_dependencies)
1881  {
1882  /* Print the message now, before reading the string table,
1883  to avoid disconcerting pauses. */
1884  if (info_verbose)
1885  {
1886  printf_filtered ("Reading in symbols for %s...", self->filename);
1888  }
1889 
1891 
1892  xcoff_psymtab_to_symtab_1 (objfile, self);
1893 
1894  /* Match with global symbols. This only needs to be done once,
1895  after all of the symtabs and dependencies have been read in. */
1896  scan_file_globals (objfile);
1897 
1898  /* Finish up the debug error message. */
1899  if (info_verbose)
1900  printf_filtered ("done.\n");
1901  }
1902 }
1903 
1904 static void
1906 {
1907  stabsread_new_init ();
1908  buildsym_new_init ();
1909 }
1910 
1911 /* Do initialization in preparation for reading symbols from OBJFILE.
1912 
1913  We will only be called if this is an XCOFF or XCOFF-like file.
1914  BFD handles figuring out the format of the file, and code in symfile.c
1915  uses BFD's determination to vector to us. */
1916 
1917 static void
1919 {
1920  struct coff_symfile_info *xcoff;
1921 
1922  /* Allocate struct to keep track of the symfile. */
1923  xcoff = XNEW (struct coff_symfile_info);
1924  set_objfile_data (objfile, xcoff_objfile_data_key, xcoff);
1925 
1926  /* XCOFF objects may be reordered, so set OBJF_REORDERED. If we
1927  find this causes a significant slowdown in gdb then we could
1928  set it in the debug symbol readers only when necessary. */
1929  objfile->flags |= OBJF_REORDERED;
1930 }
1931 
1932 /* Perform any local cleanups required when we are done with a particular
1933  objfile. I.E, we are in the process of discarding all symbol information
1934  for an objfile, freeing up all memory held for it, and unlinking the
1935  objfile struct from the global list of known objfiles. */
1936 
1937 static void
1939 {
1940  /* Start with a fresh include table for the next objfile. */
1941  if (inclTable)
1942  {
1943  xfree (inclTable);
1944  inclTable = NULL;
1945  }
1946  inclIndx = inclLength = inclDepth = 0;
1947 
1948  dwarf2_free_objfile (objfile);
1949 }
1950 
1951 
1952 static void
1953 init_stringtab (bfd *abfd, file_ptr offset, struct objfile *objfile)
1954 {
1955  long length;
1956  int val;
1957  unsigned char lengthbuf[4];
1958  char *strtbl;
1959  struct coff_symfile_info *xcoff = XCOFF_DATA (objfile);
1960 
1961  xcoff->strtbl = NULL;
1962 
1963  if (bfd_seek (abfd, offset, SEEK_SET) < 0)
1964  error (_("cannot seek to string table in %s: %s"),
1965  bfd_get_filename (abfd), bfd_errmsg (bfd_get_error ()));
1966 
1967  val = bfd_bread ((char *) lengthbuf, sizeof lengthbuf, abfd);
1968  length = bfd_h_get_32 (abfd, lengthbuf);
1969 
1970  /* If no string table is needed, then the file may end immediately
1971  after the symbols. Just return with `strtbl' set to NULL. */
1972 
1973  if (val != sizeof lengthbuf || length < sizeof lengthbuf)
1974  return;
1975 
1976  /* Allocate string table from objfile_obstack. We will need this table
1977  as long as we have its symbol table around. */
1978 
1979  strtbl = (char *) obstack_alloc (&objfile->objfile_obstack, length);
1980  xcoff->strtbl = strtbl;
1981 
1982  /* Copy length buffer, the first byte is usually zero and is
1983  used for stabs with a name length of zero. */
1984  memcpy (strtbl, lengthbuf, sizeof lengthbuf);
1985  if (length == sizeof lengthbuf)
1986  return;
1987 
1988  val = bfd_bread (strtbl + sizeof lengthbuf, length - sizeof lengthbuf, abfd);
1989 
1990  if (val != length - sizeof lengthbuf)
1991  error (_("cannot read string table from %s: %s"),
1992  bfd_get_filename (abfd), bfd_errmsg (bfd_get_error ()));
1993  if (strtbl[length - 1] != '\0')
1994  error (_("bad symbol file: string table "
1995  "does not end with null character"));
1996 
1997  return;
1998 }
1999 
2000 /* If we have not yet seen a function for this psymtab, this is 0. If we
2001  have seen one, it is the offset in the line numbers of the line numbers
2002  for the psymtab. */
2003 static unsigned int first_fun_line_offset;
2004 
2005 /* Allocate and partially fill a partial symtab. It will be
2006  completely filled at the end of the symbol list.
2007 
2008  SYMFILE_NAME is the name of the symbol-file we are reading from, and ADDR
2009  is the address relative to which its symbols are (incremental) or 0
2010  (normal). */
2011 
2012 static struct partial_symtab *
2014  const char *filename, int first_symnum,
2015  struct partial_symbol **global_syms,
2016  struct partial_symbol **static_syms)
2017 {
2018  struct partial_symtab *result =
2019  start_psymtab_common (objfile,
2020  filename,
2021  /* We fill in textlow later. */
2022  0,
2023  global_syms, static_syms);
2024 
2025  result->read_symtab_private = obstack_alloc (&objfile->objfile_obstack,
2026  sizeof (struct symloc));
2027  ((struct symloc *) result->read_symtab_private)->first_symnum = first_symnum;
2028  result->read_symtab = xcoff_read_symtab;
2029 
2030  /* Deduce the source language from the filename for this psymtab. */
2031  psymtab_language = deduce_language_from_filename (filename);
2032 
2033  return result;
2034 }
2035 
2036 /* Close off the current usage of PST.
2037  Returns PST, or NULL if the partial symtab was empty and thrown away.
2038 
2039  CAPPING_SYMBOL_NUMBER is the end of pst (exclusive).
2040 
2041  INCLUDE_LIST, NUM_INCLUDES, DEPENDENCY_LIST, and NUMBER_DEPENDENCIES
2042  are the information for includes and dependencies. */
2043 
2044 static struct partial_symtab *
2046  const char **include_list, int num_includes,
2047  int capping_symbol_number,
2048  struct partial_symtab **dependency_list,
2049  int number_dependencies, int textlow_not_set)
2050 {
2051  int i;
2052 
2053  if (capping_symbol_number != -1)
2054  ((struct symloc *) pst->read_symtab_private)->numsyms =
2055  capping_symbol_number
2056  - ((struct symloc *) pst->read_symtab_private)->first_symnum;
2057  ((struct symloc *) pst->read_symtab_private)->lineno_off =
2059  first_fun_line_offset = 0;
2060  pst->n_global_syms = objfile->global_psymbols.next
2061  - (objfile->global_psymbols.list + pst->globals_offset);
2062  pst->n_static_syms = objfile->static_psymbols.next
2063  - (objfile->static_psymbols.list + pst->statics_offset);
2064 
2065  pst->number_of_dependencies = number_dependencies;
2066  if (number_dependencies)
2067  {
2068  pst->dependencies = (struct partial_symtab **)
2069  obstack_alloc (&objfile->objfile_obstack,
2070  number_dependencies * sizeof (struct partial_symtab *));
2071  memcpy (pst->dependencies, dependency_list,
2072  number_dependencies * sizeof (struct partial_symtab *));
2073  }
2074  else
2075  pst->dependencies = 0;
2076 
2077  for (i = 0; i < num_includes; i++)
2078  {
2079  struct partial_symtab *subpst =
2080  allocate_psymtab (include_list[i], objfile);
2081 
2082  subpst->read_symtab_private = obstack_alloc (&objfile->objfile_obstack,
2083  sizeof (struct symloc));
2084  ((struct symloc *) subpst->read_symtab_private)->first_symnum = 0;
2085  ((struct symloc *) subpst->read_symtab_private)->numsyms = 0;
2086  subpst->textlow = 0;
2087  subpst->texthigh = 0;
2088 
2089  /* We could save slight bits of space by only making one of these,
2090  shared by the entire set of include files. FIXME-someday. */
2091  subpst->dependencies = (struct partial_symtab **)
2092  obstack_alloc (&objfile->objfile_obstack,
2093  sizeof (struct partial_symtab *));
2094  subpst->dependencies[0] = pst;
2095  subpst->number_of_dependencies = 1;
2096 
2097  subpst->globals_offset =
2098  subpst->n_global_syms =
2099  subpst->statics_offset =
2100  subpst->n_static_syms = 0;
2101 
2102  subpst->readin = 0;
2103  subpst->compunit_symtab = NULL;
2104  subpst->read_symtab = pst->read_symtab;
2105  }
2106 
2107  sort_pst_symbols (objfile, pst);
2108 
2109  if (num_includes == 0
2110  && number_dependencies == 0
2111  && pst->n_global_syms == 0
2112  && pst->n_static_syms == 0)
2113  {
2114  /* Throw away this psymtab, it's empty. We can't deallocate it, since
2115  it is on the obstack, but we can forget to chain it on the list. */
2116  /* Empty psymtabs happen as a result of header files which don't have
2117  any symbols in them. There can be a lot of them. */
2118 
2119  discard_psymtab (objfile, pst);
2120 
2121  /* Indicate that psymtab was thrown away. */
2122  pst = (struct partial_symtab *) NULL;
2123  }
2124  return pst;
2125 }
2126 
2127 /* Swap raw symbol at *RAW and put the name in *NAME, the symbol in
2128  *SYMBOL, the first auxent in *AUX. Advance *RAW and *SYMNUMP over
2129  the symbol and its auxents. */
2130 
2131 static void
2132 swap_sym (struct internal_syment *symbol, union internal_auxent *aux,
2133  const char **name, char **raw, unsigned int *symnump,
2134  struct objfile *objfile)
2135 {
2136  bfd_coff_swap_sym_in (objfile->obfd, *raw, symbol);
2137  if (symbol->n_zeroes)
2138  {
2139  /* If it's exactly E_SYMNMLEN characters long it isn't
2140  '\0'-terminated. */
2141  if (symbol->n_name[E_SYMNMLEN - 1] != '\0')
2142  {
2143  /* FIXME: wastes memory for symbols which we don't end up putting
2144  into the minimal symbols. */
2145  char *p;
2146 
2147  p = obstack_alloc (&objfile->objfile_obstack, E_SYMNMLEN + 1);
2148  strncpy (p, symbol->n_name, E_SYMNMLEN);
2149  p[E_SYMNMLEN] = '\0';
2150  *name = p;
2151  }
2152  else
2153  /* Point to the unswapped name as that persists as long as the
2154  objfile does. */
2155  *name = ((struct external_syment *) *raw)->e.e_name;
2156  }
2157  else if (symbol->n_sclass & 0x80)
2158  {
2159  *name = XCOFF_DATA (objfile)->debugsec + symbol->n_offset;
2160  }
2161  else
2162  {
2163  *name = XCOFF_DATA (objfile)->strtbl + symbol->n_offset;
2164  }
2165  ++*symnump;
2166  *raw += coff_data (objfile->obfd)->local_symesz;
2167  if (symbol->n_numaux > 0)
2168  {
2169  bfd_coff_swap_aux_in (objfile->obfd, *raw, symbol->n_type,
2170  symbol->n_sclass, 0, symbol->n_numaux, aux);
2171 
2172  *symnump += symbol->n_numaux;
2173  *raw += coff_data (objfile->obfd)->local_symesz * symbol->n_numaux;
2174  }
2175 }
2176 
2177 static void
2179 {
2181  _("function `%s' appears to be defined "
2182  "outside of all compilation units"),
2183  arg1);
2184 }
2185 
2186 static void
2188 {
2189  struct gdbarch *gdbarch = get_objfile_arch (objfile);
2190  CORE_ADDR toc_offset = 0; /* toc offset value in data section. */
2191  const char *filestring = NULL;
2192 
2193  const char *namestring;
2194  int past_first_source_file = 0;
2195  bfd *abfd;
2196  asection *bfd_sect;
2197  unsigned int nsyms;
2198 
2199  /* Current partial symtab */
2200  struct partial_symtab *pst;
2201 
2202  /* List of current psymtab's include files. */
2203  const char **psymtab_include_list;
2204  int includes_allocated;
2205  int includes_used;
2206 
2207  /* Index within current psymtab dependency list. */
2208  struct partial_symtab **dependency_list;
2209  int dependencies_used, dependencies_allocated;
2210 
2211  char *sraw_symbol;
2212  struct internal_syment symbol;
2213  union internal_auxent main_aux[5];
2214  unsigned int ssymnum;
2215 
2216  const char *last_csect_name = NULL; /* Last seen csect's name and value. */
2217  CORE_ADDR last_csect_val = 0;
2218  int last_csect_sec = 0;
2219  int misc_func_recorded = 0; /* true if any misc. function. */
2220  int textlow_not_set = 1;
2221 
2222  pst = (struct partial_symtab *) 0;
2223 
2224  includes_allocated = 30;
2225  includes_used = 0;
2226  psymtab_include_list = (const char **) alloca (includes_allocated *
2227  sizeof (const char *));
2228 
2229  dependencies_allocated = 30;
2230  dependencies_used = 0;
2231  dependency_list =
2232  (struct partial_symtab **) alloca (dependencies_allocated *
2233  sizeof (struct partial_symtab *));
2234 
2235  set_last_source_file (NULL);
2236 
2237  abfd = objfile->obfd;
2239 
2240  sraw_symbol = XCOFF_DATA (objfile)->symtbl;
2241  nsyms = XCOFF_DATA (objfile)->symtbl_num_syms;
2242  ssymnum = 0;
2243  while (ssymnum < nsyms)
2244  {
2245  int sclass;
2246 
2247  QUIT;
2248 
2249  bfd_coff_swap_sym_in (abfd, sraw_symbol, &symbol);
2250  sclass = symbol.n_sclass;
2251 
2252  switch (sclass)
2253  {
2254  case C_EXT:
2255  case C_HIDEXT:
2256  {
2257  /* The CSECT auxent--always the last auxent. */
2258  union internal_auxent csect_aux;
2259  unsigned int symnum_before = ssymnum;
2260 
2261  swap_sym (&symbol, &main_aux[0], &namestring, &sraw_symbol,
2262  &ssymnum, objfile);
2263  if (symbol.n_numaux > 1)
2264  {
2265  bfd_coff_swap_aux_in
2266  (objfile->obfd,
2267  sraw_symbol - coff_data (abfd)->local_symesz,
2268  symbol.n_type,
2269  symbol.n_sclass,
2270  symbol.n_numaux - 1,
2271  symbol.n_numaux,
2272  &csect_aux);
2273  }
2274  else
2275  csect_aux = main_aux[0];
2276 
2277  /* If symbol name starts with ".$" or "$", ignore it. */
2278  if (namestring[0] == '$'
2279  || (namestring[0] == '.' && namestring[1] == '$'))
2280  break;
2281 
2282  switch (csect_aux.x_csect.x_smtyp & 0x7)
2283  {
2284  case XTY_SD:
2285  switch (csect_aux.x_csect.x_smclas)
2286  {
2287  case XMC_PR:
2288  if (last_csect_name)
2289  {
2290  /* If no misc. function recorded in the last
2291  seen csect, enter it as a function. This
2292  will take care of functions like strcmp()
2293  compiled by xlc. */
2294 
2295  if (!misc_func_recorded)
2296  {
2298  (last_csect_name, last_csect_val,
2299  mst_text, last_csect_sec, objfile);
2300  misc_func_recorded = 1;
2301  }
2302 
2303  if (pst != NULL)
2304  {
2305  /* We have to allocate one psymtab for
2306  each program csect, because their text
2307  sections need not be adjacent. */
2309  (objfile, pst, psymtab_include_list,
2310  includes_used, symnum_before, dependency_list,
2311  dependencies_used, textlow_not_set);
2312  includes_used = 0;
2313  dependencies_used = 0;
2314  /* Give all psymtabs for this source file the same
2315  name. */
2316  pst = xcoff_start_psymtab
2317  (objfile,
2318  filestring,
2319  symnum_before,
2320  objfile->global_psymbols.next,
2321  objfile->static_psymbols.next);
2322  }
2323  }
2324  /* Activate the misc_func_recorded mechanism for
2325  compiler- and linker-generated CSECTs like ".strcmp"
2326  and "@FIX1". */
2327  if (namestring && (namestring[0] == '.'
2328  || namestring[0] == '@'))
2329  {
2330  last_csect_name = namestring;
2331  last_csect_val = symbol.n_value;
2332  last_csect_sec = symbol.n_scnum;
2333  }
2334  if (pst != NULL)
2335  {
2336  CORE_ADDR highval =
2337  symbol.n_value + csect_aux.x_csect.x_scnlen.l;
2338 
2339  if (highval > pst->texthigh)
2340  pst->texthigh = highval;
2341  if (pst->textlow == 0 || symbol.n_value < pst->textlow)
2342  pst->textlow = symbol.n_value;
2343  }
2344  misc_func_recorded = 0;
2345  break;
2346 
2347  case XMC_RW:
2348  case XMC_TD:
2349  /* Data variables are recorded in the minimal symbol
2350  table, except for section symbols. */
2351  if (*namestring != '.')
2353  (namestring, symbol.n_value,
2354  sclass == C_HIDEXT ? mst_file_data : mst_data,
2355  symbol.n_scnum, objfile);
2356  break;
2357 
2358  case XMC_TC0:
2359  if (toc_offset)
2360  warning (_("More than one XMC_TC0 symbol found."));
2361  toc_offset = symbol.n_value;
2362 
2363  /* Make TOC offset relative to start address of
2364  section. */
2365  bfd_sect = secnum_to_bfd_section (symbol.n_scnum, objfile);
2366  if (bfd_sect)
2367  toc_offset -= bfd_section_vma (objfile->obfd, bfd_sect);
2368  break;
2369 
2370  case XMC_TC:
2371  /* These symbols tell us where the TOC entry for a
2372  variable is, not the variable itself. */
2373  break;
2374 
2375  default:
2376  break;
2377  }
2378  break;
2379 
2380  case XTY_LD:
2381  switch (csect_aux.x_csect.x_smclas)
2382  {
2383  case XMC_PR:
2384  /* A function entry point. */
2385 
2386  if (first_fun_line_offset == 0 && symbol.n_numaux > 1)
2387  first_fun_line_offset =
2388  main_aux[0].x_sym.x_fcnary.x_fcn.x_lnnoptr;
2389  {
2391  (namestring, symbol.n_value,
2392  sclass == C_HIDEXT ? mst_file_text : mst_text,
2393  symbol.n_scnum, objfile);
2394  misc_func_recorded = 1;
2395  }
2396  break;
2397 
2398  case XMC_GL:
2399  /* shared library function trampoline code entry
2400  point. */
2401 
2402  /* record trampoline code entries as
2403  mst_solib_trampoline symbol. When we lookup mst
2404  symbols, we will choose mst_text over
2405  mst_solib_trampoline. */
2407  (namestring, symbol.n_value,
2408  mst_solib_trampoline, symbol.n_scnum, objfile);
2409  misc_func_recorded = 1;
2410  break;
2411 
2412  case XMC_DS:
2413  /* The symbols often have the same names as
2414  debug symbols for functions, and confuse
2415  lookup_symbol. */
2416  break;
2417 
2418  default:
2419 
2420  /* xlc puts each variable in a separate csect,
2421  so we get an XTY_SD for each variable. But
2422  gcc puts several variables in a csect, so
2423  that each variable only gets an XTY_LD. We
2424  still need to record them. This will
2425  typically be XMC_RW; I suspect XMC_RO and
2426  XMC_BS might be possible too. */
2427  if (*namestring != '.')
2429  (namestring, symbol.n_value,
2430  sclass == C_HIDEXT ? mst_file_data : mst_data,
2431  symbol.n_scnum, objfile);
2432  break;
2433  }
2434  break;
2435 
2436  case XTY_CM:
2437  switch (csect_aux.x_csect.x_smclas)
2438  {
2439  case XMC_RW:
2440  case XMC_BS:
2441  /* Common variables are recorded in the minimal symbol
2442  table, except for section symbols. */
2443  if (*namestring != '.')
2445  (namestring, symbol.n_value,
2446  sclass == C_HIDEXT ? mst_file_bss : mst_bss,
2447  symbol.n_scnum, objfile);
2448  break;
2449  }
2450  break;
2451 
2452  default:
2453  break;
2454  }
2455  }
2456  break;
2457  case C_FILE:
2458  {
2459  unsigned int symnum_before;
2460 
2461  symnum_before = ssymnum;
2462  swap_sym (&symbol, &main_aux[0], &namestring, &sraw_symbol,
2463  &ssymnum, objfile);
2464 
2465  /* See if the last csect needs to be recorded. */
2466 
2467  if (last_csect_name && !misc_func_recorded)
2468  {
2469  /* If no misc. function recorded in the last seen csect, enter
2470  it as a function. This will take care of functions like
2471  strcmp() compiled by xlc. */
2472 
2473  record_minimal_symbol (last_csect_name, last_csect_val,
2474  mst_text, last_csect_sec, objfile);
2475  misc_func_recorded = 1;
2476  }
2477 
2478  if (pst)
2479  {
2480  xcoff_end_psymtab (objfile, pst, psymtab_include_list,
2481  includes_used, symnum_before,
2482  dependency_list, dependencies_used,
2483  textlow_not_set);
2484  includes_used = 0;
2485  dependencies_used = 0;
2486  }
2487  first_fun_line_offset = 0;
2488 
2489  /* XCOFF, according to the AIX 3.2 documentation, puts the
2490  filename in cs->c_name. But xlc 1.3.0.2 has decided to
2491  do things the standard COFF way and put it in the auxent.
2492  We use the auxent if the symbol is ".file" and an auxent
2493  exists, otherwise use the symbol itself. */
2494  if (!strcmp (namestring, ".file") && symbol.n_numaux > 0)
2495  {
2496  filestring = coff_getfilename (&main_aux[0], objfile);
2497  }
2498  else
2499  filestring = namestring;
2500 
2501  pst = xcoff_start_psymtab (objfile,
2502  filestring,
2503  symnum_before,
2504  objfile->global_psymbols.next,
2505  objfile->static_psymbols.next);
2506  last_csect_name = NULL;
2507  }
2508  break;
2509 
2510  default:
2511  {
2513  _("Storage class %d not recognized during scan"),
2514  sclass);
2515  }
2516  /* FALLTHROUGH */
2517 
2518  /* C_FCN is .bf and .ef symbols. I think it is sufficient
2519  to handle only the C_FUN and C_EXT. */
2520  case C_FCN:
2521 
2522  case C_BSTAT:
2523  case C_ESTAT:
2524  case C_ARG:
2525  case C_REGPARM:
2526  case C_REG:
2527  case C_TPDEF:
2528  case C_STRTAG:
2529  case C_UNTAG:
2530  case C_ENTAG:
2531  case C_LABEL:
2532  case C_NULL:
2533 
2534  /* C_EINCL means we are switching back to the main file. But there
2535  is no reason to care; the only thing we want to know about
2536  includes is the names of all the included (.h) files. */
2537  case C_EINCL:
2538 
2539  case C_BLOCK:
2540 
2541  /* I don't think C_STAT is used in xcoff; C_HIDEXT appears to be
2542  used instead. */
2543  case C_STAT:
2544 
2545  /* I don't think the name of the common block (as opposed to the
2546  variables within it) is something which is user visible
2547  currently. */
2548  case C_BCOMM:
2549  case C_ECOMM:
2550 
2551  case C_PSYM:
2552  case C_RPSYM:
2553 
2554  /* I think we can ignore C_LSYM; types on xcoff seem to use C_DECL
2555  so C_LSYM would appear to be only for locals. */
2556  case C_LSYM:
2557 
2558  case C_AUTO:
2559  case C_RSYM:
2560  {
2561  /* We probably could save a few instructions by assuming that
2562  C_LSYM, C_PSYM, etc., never have auxents. */
2563  int naux1 = symbol.n_numaux + 1;
2564 
2565  ssymnum += naux1;
2566  sraw_symbol += bfd_coff_symesz (abfd) * naux1;
2567  }
2568  break;
2569 
2570  case C_BINCL:
2571  {
2572  /* Mark down an include file in the current psymtab. */
2573  enum language tmp_language;
2574 
2575  swap_sym (&symbol, &main_aux[0], &namestring, &sraw_symbol,
2576  &ssymnum, objfile);
2577 
2578  tmp_language = deduce_language_from_filename (namestring);
2579 
2580  /* Only change the psymtab's language if we've learned
2581  something useful (eg. tmp_language is not language_unknown).
2582  In addition, to match what start_subfile does, never change
2583  from C++ to C. */
2584  if (tmp_language != language_unknown
2585  && (tmp_language != language_c
2586  || psymtab_language != language_cplus))
2587  psymtab_language = tmp_language;
2588 
2589  /* In C++, one may expect the same filename to come round many
2590  times, when code is coming alternately from the main file
2591  and from inline functions in other files. So I check to see
2592  if this is a file we've seen before -- either the main
2593  source file, or a previously included file.
2594 
2595  This seems to be a lot of time to be spending on N_SOL, but
2596  things like "break c-exp.y:435" need to work (I
2597  suppose the psymtab_include_list could be hashed or put
2598  in a binary tree, if profiling shows this is a major hog). */
2599  if (pst && strcmp (namestring, pst->filename) == 0)
2600  continue;
2601 
2602  {
2603  int i;
2604 
2605  for (i = 0; i < includes_used; i++)
2606  if (strcmp (namestring, psymtab_include_list[i]) == 0)
2607  {
2608  i = -1;
2609  break;
2610  }
2611  if (i == -1)
2612  continue;
2613  }
2614  psymtab_include_list[includes_used++] = namestring;
2615  if (includes_used >= includes_allocated)
2616  {
2617  const char **orig = psymtab_include_list;
2618 
2619  psymtab_include_list = (const char **)
2620  alloca ((includes_allocated *= 2) *
2621  sizeof (const char *));
2622  memcpy (psymtab_include_list, orig,
2623  includes_used * sizeof (const char *));
2624  }
2625  continue;
2626  }
2627  case C_FUN:
2628  /* The value of the C_FUN is not the address of the function (it
2629  appears to be the address before linking), but as long as it
2630  is smaller than the actual address, then find_pc_partial_function
2631  will use the minimal symbols instead. I hope. */
2632 
2633  case C_GSYM:
2634  case C_ECOML:
2635  case C_DECL:
2636  case C_STSYM:
2637  {
2638  const char *p;
2639 
2640  swap_sym (&symbol, &main_aux[0], &namestring, &sraw_symbol,
2641  &ssymnum, objfile);
2642 
2643  p = strchr (namestring, ':');
2644  if (!p)
2645  continue; /* Not a debugging symbol. */
2646 
2647  /* Main processing section for debugging symbols which
2648  the initial read through the symbol tables needs to worry
2649  about. If we reach this point, the symbol which we are
2650  considering is definitely one we are interested in.
2651  p must also contain the (valid) index into the namestring
2652  which indicates the debugging type symbol. */
2653 
2654  switch (p[1])
2655  {
2656  case 'S':
2657  symbol.n_value += ANOFFSET (objfile->section_offsets,
2658  SECT_OFF_DATA (objfile));
2659 
2660  if (gdbarch_static_transform_name_p (gdbarch))
2661  namestring = gdbarch_static_transform_name
2662  (gdbarch, namestring);
2663 
2664  add_psymbol_to_list (namestring, p - namestring, 1,
2666  &objfile->static_psymbols,
2667  0, symbol.n_value,
2668  psymtab_language, objfile);
2669  continue;
2670 
2671  case 'G':
2672  symbol.n_value += ANOFFSET (objfile->section_offsets,
2673  SECT_OFF_DATA (objfile));
2674  /* The addresses in these entries are reported to be
2675  wrong. See the code that reads 'G's for symtabs. */
2676  add_psymbol_to_list (namestring, p - namestring, 1,
2678  &objfile->global_psymbols,
2679  0, symbol.n_value,
2680  psymtab_language, objfile);
2681  continue;
2682 
2683  case 'T':
2684  /* When a 'T' entry is defining an anonymous enum, it
2685  may have a name which is the empty string, or a
2686  single space. Since they're not really defining a
2687  symbol, those shouldn't go in the partial symbol
2688  table. We do pick up the elements of such enums at
2689  'check_enum:', below. */
2690  if (p >= namestring + 2
2691  || (p == namestring + 1
2692  && namestring[0] != ' '))
2693  {
2694  add_psymbol_to_list (namestring, p - namestring, 1,
2696  &objfile->static_psymbols,
2697  symbol.n_value, 0,
2698  psymtab_language, objfile);
2699  if (p[2] == 't')
2700  {
2701  /* Also a typedef with the same name. */
2702  add_psymbol_to_list (namestring, p - namestring, 1,
2704  &objfile->static_psymbols,
2705  symbol.n_value, 0,
2706  psymtab_language, objfile);
2707  p += 1;
2708  }
2709  }
2710  goto check_enum;
2711 
2712  case 't':
2713  if (p != namestring) /* a name is there, not just :T... */
2714  {
2715  add_psymbol_to_list (namestring, p - namestring, 1,
2717  &objfile->static_psymbols,
2718  symbol.n_value, 0,
2719  psymtab_language, objfile);
2720  }
2721  check_enum:
2722  /* If this is an enumerated type, we need to
2723  add all the enum constants to the partial symbol
2724  table. This does not cover enums without names, e.g.
2725  "enum {a, b} c;" in C, but fortunately those are
2726  rare. There is no way for GDB to find those from the
2727  enum type without spending too much time on it. Thus
2728  to solve this problem, the compiler needs to put out the
2729  enum in a nameless type. GCC2 does this. */
2730 
2731  /* We are looking for something of the form
2732  <name> ":" ("t" | "T") [<number> "="] "e"
2733  {<constant> ":" <value> ","} ";". */
2734 
2735  /* Skip over the colon and the 't' or 'T'. */
2736  p += 2;
2737  /* This type may be given a number. Also, numbers can come
2738  in pairs like (0,26). Skip over it. */
2739  while ((*p >= '0' && *p <= '9')
2740  || *p == '(' || *p == ',' || *p == ')'
2741  || *p == '=')
2742  p++;
2743 
2744  if (*p++ == 'e')
2745  {
2746  /* The aix4 compiler emits extra crud before the
2747  members. */
2748  if (*p == '-')
2749  {
2750  /* Skip over the type (?). */
2751  while (*p != ':')
2752  p++;
2753 
2754  /* Skip over the colon. */
2755  p++;
2756  }
2757 
2758  /* We have found an enumerated type. */
2759  /* According to comments in read_enum_type
2760  a comma could end it instead of a semicolon.
2761  I don't know where that happens.
2762  Accept either. */
2763  while (*p && *p != ';' && *p != ',')
2764  {
2765  const char *q;
2766 
2767  /* Check for and handle cretinous dbx symbol name
2768  continuation! */
2769  if (*p == '\\' || (*p == '?' && p[1] == '\0'))
2770  p = next_symbol_text (objfile);
2771 
2772  /* Point to the character after the name
2773  of the enum constant. */
2774  for (q = p; *q && *q != ':'; q++)
2775  ;
2776  /* Note that the value doesn't matter for
2777  enum constants in psymtabs, just in symtabs. */
2778  add_psymbol_to_list (p, q - p, 1,
2780  &objfile->static_psymbols, 0,
2781  0, psymtab_language, objfile);
2782  /* Point past the name. */
2783  p = q;
2784  /* Skip over the value. */
2785  while (*p && *p != ',')
2786  p++;
2787  /* Advance past the comma. */
2788  if (*p)
2789  p++;
2790  }
2791  }
2792  continue;
2793 
2794  case 'c':
2795  /* Constant, e.g. from "const" in Pascal. */
2796  add_psymbol_to_list (namestring, p - namestring, 1,
2798  &objfile->static_psymbols, symbol.n_value,
2799  0, psymtab_language, objfile);
2800  continue;
2801 
2802  case 'f':
2803  if (! pst)
2804  {
2805  int name_len = p - namestring;
2806  char *name = xmalloc (name_len + 1);
2807 
2808  memcpy (name, namestring, name_len);
2809  name[name_len] = '\0';
2811  xfree (name);
2812  }
2813  symbol.n_value += ANOFFSET (objfile->section_offsets,
2814  SECT_OFF_TEXT (objfile));
2815  add_psymbol_to_list (namestring, p - namestring, 1,
2817  &objfile->static_psymbols,
2818  0, symbol.n_value,
2819  psymtab_language, objfile);
2820  continue;
2821 
2822  /* Global functions were ignored here, but now they
2823  are put into the global psymtab like one would expect.
2824  They're also in the minimal symbol table. */
2825  case 'F':
2826  if (! pst)
2827  {
2828  int name_len = p - namestring;
2829  char *name = xmalloc (name_len + 1);
2830 
2831  memcpy (name, namestring, name_len);
2832  name[name_len] = '\0';
2834  xfree (name);
2835  }
2836 
2837  /* We need only the minimal symbols for these
2838  loader-generated definitions. Keeping the global
2839  symbols leads to "in psymbols but not in symbols"
2840  errors. */
2841  if (startswith (namestring, "@FIX"))
2842  continue;
2843 
2844  symbol.n_value += ANOFFSET (objfile->section_offsets,
2845  SECT_OFF_TEXT (objfile));
2846  add_psymbol_to_list (namestring, p - namestring, 1,
2848  &objfile->global_psymbols,
2849  0, symbol.n_value,
2850  psymtab_language, objfile);
2851  continue;
2852 
2853  /* Two things show up here (hopefully); static symbols of
2854  local scope (static used inside braces) or extensions
2855  of structure symbols. We can ignore both. */
2856  case 'V':
2857  case '(':
2858  case '0':
2859  case '1':
2860  case '2':
2861  case '3':
2862  case '4':
2863  case '5':
2864  case '6':
2865  case '7':
2866  case '8':
2867  case '9':
2868  case '-':
2869  case '#': /* For symbol identification (used in
2870  live ranges). */
2871  continue;
2872 
2873  case ':':
2874  /* It is a C++ nested symbol. We don't need to record it
2875  (I don't think); if we try to look up foo::bar::baz,
2876  then symbols for the symtab containing foo should get
2877  read in, I think. */
2878  /* Someone says sun cc puts out symbols like
2879  /foo/baz/maclib::/usr/local/bin/maclib,
2880  which would get here with a symbol type of ':'. */
2881  continue;
2882 
2883  default:
2884  /* Unexpected symbol descriptor. The second and
2885  subsequent stabs of a continued stab can show up
2886  here. The question is whether they ever can mimic
2887  a normal stab--it would be nice if not, since we
2888  certainly don't want to spend the time searching to
2889  the end of every string looking for a
2890  backslash. */
2891 
2893  _("unknown symbol descriptor `%c'"), p[1]);
2894 
2895  /* Ignore it; perhaps it is an extension that we don't
2896  know about. */
2897  continue;
2898  }
2899  }
2900  }
2901  }
2902 
2903  if (pst)
2904  {
2905  xcoff_end_psymtab (objfile, pst, psymtab_include_list, includes_used,
2906  ssymnum, dependency_list,
2907  dependencies_used, textlow_not_set);
2908  }
2909 
2910  /* Record the toc offset value of this symbol table into objfile
2911  structure. If no XMC_TC0 is found, toc_offset should be zero.
2912  Another place to obtain this information would be file auxiliary
2913  header. */
2914 
2915  XCOFF_DATA (objfile)->toc_offset = toc_offset;
2916 }
2917 
2918 /* Return the toc offset value for a given objfile. */
2919 
2920 CORE_ADDR
2922 {
2923  if (objfile)
2924  return XCOFF_DATA (objfile)->toc_offset;
2925  return 0;
2926 }
2927 
2928 /* Scan and build partial symbols for a symbol file.
2929  We have been initialized by a call to dbx_symfile_init, which
2930  put all the relevant info into a "struct dbx_symfile_info",
2931  hung off the objfile structure.
2932 
2933  SECTION_OFFSETS contains offsets relative to which the symbols in the
2934  various sections are (depending where the sections were actually
2935  loaded). */
2936 
2937 static void
2938 xcoff_initial_scan (struct objfile *objfile, int symfile_flags)
2939 {
2940  bfd *abfd;
2941  int val;
2942  struct cleanup *back_to;
2943  int num_symbols; /* # of symbols */
2944  file_ptr symtab_offset; /* symbol table and */
2945  file_ptr stringtab_offset; /* string table file offsets */
2946  struct coff_symfile_info *info;
2947  const char *name;
2948  unsigned int size;
2949 
2950  info = XCOFF_DATA (objfile);
2951  symfile_bfd = abfd = objfile->obfd;
2952  name = objfile_name (objfile);
2953 
2954  num_symbols = bfd_get_symcount (abfd); /* # of symbols */
2955  symtab_offset = obj_sym_filepos (abfd); /* symbol table file offset */
2956  stringtab_offset = symtab_offset +
2957  num_symbols * coff_data (abfd)->local_symesz;
2958 
2959  info->min_lineno_offset = 0;
2960  info->max_lineno_offset = 0;
2961  bfd_map_over_sections (abfd, find_linenos, info);
2962 
2963  if (num_symbols > 0)
2964  {
2965  /* Read the string table. */
2966  init_stringtab (abfd, stringtab_offset, objfile);
2967 
2968  /* Read the .debug section, if present. */
2969  {
2970  struct bfd_section *secp;
2971  bfd_size_type length;
2972  bfd_byte *debugsec = NULL;
2973 
2974  secp = bfd_get_section_by_name (abfd, ".debug");
2975  if (secp)
2976  {
2977  length = bfd_section_size (abfd, secp);
2978  if (length)
2979  {
2980  debugsec = obstack_alloc (&objfile->objfile_obstack, length);
2981 
2982  if (!bfd_get_full_section_contents (abfd, secp, &debugsec))
2983  {
2984  error (_("Error reading .debug section of `%s': %s"),
2985  name, bfd_errmsg (bfd_get_error ()));
2986  }
2987  }
2988  }
2989  info->debugsec = (char *) debugsec;
2990  }
2991  }
2992 
2993  /* Read the symbols. We keep them in core because we will want to
2994  access them randomly in read_symbol*. */
2995  val = bfd_seek (abfd, symtab_offset, SEEK_SET);
2996  if (val < 0)
2997  error (_("Error reading symbols from %s: %s"),
2998  name, bfd_errmsg (bfd_get_error ()));
2999  size = coff_data (abfd)->local_symesz * num_symbols;
3000  info->symtbl = obstack_alloc (&objfile->objfile_obstack, size);
3001  info->symtbl_num_syms = num_symbols;
3002 
3003  val = bfd_bread (info->symtbl, size, abfd);
3004  if (val != size)
3005  perror_with_name (_("reading symbol table"));
3006 
3007  /* If we are reinitializing, or if we have never loaded syms yet, init. */
3008  if (objfile->global_psymbols.size == 0 && objfile->static_psymbols.size == 0)
3009  /* I'm not sure how how good num_symbols is; the rule of thumb in
3010  init_psymbol_list was developed for a.out. On the one hand,
3011  num_symbols includes auxents. On the other hand, it doesn't
3012  include N_SLINE. */
3013  init_psymbol_list (objfile, num_symbols);
3014 
3016  back_to = make_cleanup (really_free_pendings, 0);
3017 
3020 
3021  /* Now that the symbol table data of the executable file are all in core,
3022  process them and define symbols accordingly. */
3023 
3024  scan_xcoff_symtab (objfile);
3025 
3026  /* Install any minimal symbols that have been collected as the current
3027  minimal symbols for this objfile. */
3028 
3029  install_minimal_symbols (objfile);
3030 
3031  /* DWARF2 sections. */
3032 
3033  if (dwarf2_has_info (objfile, &dwarf2_xcoff_names))
3034  dwarf2_build_psymtabs (objfile);
3035 
3036  dwarf2_build_frame_info (objfile);
3037 
3038  do_cleanups (back_to);
3039 }
3040 
3041 static void
3043  const struct section_addr_info *addrs)
3044 {
3045  const char *first_section_name;
3046 
3047  default_symfile_offsets (objfile, addrs);
3048 
3049  /* Oneof the weird side-effects of default_symfile_offsets is that
3050  it sometimes sets some section indices to zero for sections that,
3051  in fact do not exist. See the body of default_symfile_offsets
3052  for more info on when that happens. Undo that, as this then allows
3053  us to test whether the associated section exists or not, and then
3054  access it quickly (without searching it again). */
3055 
3056  if (objfile->num_sections == 0)
3057  return; /* Is that even possible? Better safe than sorry. */
3058 
3059  first_section_name
3060  = bfd_section_name (objfile->obfd, objfile->sections[0].the_bfd_section);
3061 
3062  if (objfile->sect_index_text == 0
3063  && strcmp (first_section_name, ".text") != 0)
3064  objfile->sect_index_text = -1;
3065 
3066  if (objfile->sect_index_data == 0
3067  && strcmp (first_section_name, ".data") != 0)
3068  objfile->sect_index_data = -1;
3069 
3070  if (objfile->sect_index_bss == 0
3071  && strcmp (first_section_name, ".bss") != 0)
3072  objfile->sect_index_bss = -1;
3073 
3074  if (objfile->sect_index_rodata == 0
3075  && strcmp (first_section_name, ".rodata") != 0)
3076  objfile->sect_index_rodata = -1;
3077 }
3078 
3079 /* Register our ability to parse symbols for xcoff BFD files. */
3080 
3081 static const struct sym_fns xcoff_sym_fns =
3082 {
3083 
3084  /* It is possible that coff and xcoff should be merged as
3085  they do have fundamental similarities (for example, the extra storage
3086  classes used for stabs could presumably be recognized in any COFF file).
3087  However, in addition to obvious things like all the csect hair, there are
3088  some subtler differences between xcoffread.c and coffread.c, notably
3089  the fact that coffread.c has no need to read in all the symbols, but
3090  xcoffread.c reads all the symbols and does in fact randomly access them
3091  (in C_BSTAT and line number processing). */
3092 
3093  xcoff_new_init, /* init anything gbl to entire symtab */
3094  xcoff_symfile_init, /* read initial info, setup for sym_read() */
3095  xcoff_initial_scan, /* read a symbol file into symtab */
3096  NULL, /* sym_read_psymbols */
3097  xcoff_symfile_finish, /* finished with file, cleanup */
3098  xcoff_symfile_offsets, /* xlate offsets ext->int form */
3099  default_symfile_segments, /* Get segment information from a file. */
3101  default_symfile_relocate, /* Relocate a debug section. */
3102  NULL, /* sym_probe_fns */
3104 };
3105 
3106 /* Same as xcoff_get_n_import_files, but for core files. */
3107 
3108 static int
3110 {
3111  asection *sect = bfd_get_section_by_name (abfd, ".ldinfo");
3112  gdb_byte buf[4];
3113  file_ptr offset = 0;
3114  int n_entries = 0;
3115 
3116  if (sect == NULL)
3117  return -1; /* Not a core file. */
3118 
3119  for (offset = 0; offset < bfd_get_section_size (sect);)
3120  {
3121  int next;
3122 
3123  n_entries++;
3124 
3125  if (!bfd_get_section_contents (abfd, sect, buf, offset, 4))
3126  return -1;
3127  next = bfd_get_32 (abfd, buf);
3128  if (next == 0)
3129  break; /* This is the last entry. */
3130  offset += next;
3131  }
3132 
3133  /* Return the number of entries, excluding the first one, which is
3134  the path to the executable that produced this core file. */
3135  return n_entries - 1;
3136 }
3137 
3138 /* Return the number of import files (shared libraries) that the given
3139  BFD depends on. Return -1 if this number could not be computed. */
3140 
3141 int
3143 {
3144  asection *sect = bfd_get_section_by_name (abfd, ".loader");
3145  gdb_byte buf[4];
3146  int l_nimpid;
3147 
3148  /* If the ".loader" section does not exist, the objfile is probably
3149  not an executable. Might be a core file... */
3150  if (sect == NULL)
3151  return xcoff_get_core_n_import_files (abfd);
3152 
3153  /* The number of entries in the Import Files Table is stored in
3154  field l_nimpid. This field is always at offset 16, and is
3155  always 4 bytes long. Read those 4 bytes. */
3156 
3157  if (!bfd_get_section_contents (abfd, sect, buf, 16, 4))
3158  return -1;
3159  l_nimpid = bfd_get_32 (abfd, buf);
3160 
3161  /* By convention, the first entry is the default LIBPATH value
3162  to be used by the system loader, so it does not count towards
3163  the number of import files. */
3164  return l_nimpid - 1;
3165 }
3166 
3167 /* Free the per-objfile xcoff data. */
3168 
3169 static void
3170 xcoff_free_info (struct objfile *objfile, void *arg)
3171 {
3172  xfree (arg);
3173 }
3174 
3175 /* Provide a prototype to silence -Wmissing-prototypes. */
3177 
3178 void
3180 {
3181  add_symtab_fns (bfd_target_xcoff_flavour, &xcoff_sym_fns);
3182 
3183  xcoff_objfile_data_key = register_objfile_data_with_cleanup (NULL,
3184  xcoff_free_info);
3185 }
const char * filename
Definition: psympriv.h:91
int sect_index_text
Definition: objfiles.h:372
struct psymbol_allocation_list static_psymbols
Definition: objfiles.h:339
int c_secnum
Definition: coffread.c:143
void discard_psymtab(struct objfile *, struct partial_symtab *)
Definition: psymtab.c:1824
void stabsread_new_init(void)
Definition: stabsread.c:4764
Definition: dbxread.c:70
int dwarf2_has_info(struct objfile *objfile, const struct dwarf2_debug_sections *names)
Definition: dwarf2read.c:2032
static int inclDepth
Definition: xcoffread.c:538
void common_block_end(struct objfile *objfile)
Definition: stabsread.c:4346
static struct partial_symtab * xcoff_start_psymtab(struct objfile *objfile, const char *filename, int first_symnum, struct partial_symbol **global_syms, struct partial_symbol **static_syms)
Definition: xcoffread.c:2013
bfd * obfd
Definition: objfiles.h:313
#define SECT_OFF_TEXT(objfile)
Definition: objfiles.h:683
unsigned char readin
Definition: psympriv.h:173
static void allocate_include_entry(void)
Definition: xcoffread.c:583
void dwarf2_build_frame_info(struct objfile *objfile)
bfd_vma CORE_ADDR
Definition: common-types.h:41
struct linetable_entry item[1]
Definition: symtab.h:892
static int compare_lte(const void *, const void *)
Definition: xcoffread.c:409
char * pop_subfile(void)
Definition: buildsym.c:869
int gdb_bfd_section_index(bfd *abfd, asection *section)
Definition: gdb_bfd.c:806
void xfree(void *)
Definition: common-utils.c:97
void add_symbol_to_list(struct symbol *symbol, struct pending **listhead)
Definition: buildsym.c:216
struct _inclTable InclTable
struct bfd_section * the_bfd_section
Definition: objfiles.h:121
void warning(const char *fmt,...)
Definition: errors.c:26
struct psymbol_allocation_list global_psymbols
Definition: objfiles.h:338
static int secnum_to_section(int, struct objfile *)
Definition: xcoffread.c:303
void set_last_source_file(const char *name)
Definition: buildsym.c:1720
char * name
Definition: xcoffread.c:523
struct ui_file * gdb_stdout
Definition: main.c:71
#define SYMBOL_SET_LINKAGE_NAME(symbol, linkage_name)
Definition: symtab.h:207
const struct objfile_type * objfile_type(struct objfile *objfile)
Definition: gdbtypes.c:4909
struct compunit_symtab * end_symtab(CORE_ADDR end_addr, int section)
Definition: buildsym.c:1529
void add_symtab_fns(enum bfd_flavour flavour, const struct sym_fns *sf)
Definition: symfile.c:1800
static void find_linenos(struct bfd *abfd, struct bfd_section *asect, void *vpinfo)
Definition: xcoffread.c:1792
int info_verbose
Definition: top.c:1699
EXTERN struct pending * file_symbols
Definition: buildsym.h:109
static int xcoff_get_core_n_import_files(bfd *abfd)
Definition: xcoffread.c:3109
static void record_include_begin(struct coff_symbol *)
Definition: xcoffread.c:543
void start_stabs(void)
Definition: stabsread.c:4774
static struct symbol * process_xcoff_symbol(struct coff_symbol *, struct objfile *)
Definition: xcoffread.c:1530
initialize_file_ftype _initialize_xcoffread
struct symfile_segment_data * default_symfile_segments(bfd *abfd)
Definition: symfile.c:812
struct objfile * objfile
Definition: xcoffread.c:251
static void function_outside_compilation_unit_complaint(const char *arg1)
Definition: xcoffread.c:2178
char * name
Definition: buildsym.h:63
struct subfile * subfile
Definition: xcoffread.c:529
void initialize_objfile_symbol(struct symbol *sym)
Definition: symtab.c:6194
void dwarf2_build_psymtabs(struct objfile *objfile)
Definition: dwarf2read.c:4236
static InclTable * inclTable
Definition: xcoffread.c:535
struct type * nodebug_data_symbol
Definition: gdbtypes.h:1597
static int static_block_section
Definition: xcoffread.c:954
#define CSECT_LEN(PP)
static int static_block_base
Definition: xcoffread.c:950
struct minimal_symbol * prim_record_minimal_symbol_and_info(const char *name, CORE_ADDR address, enum minimal_symbol_type ms_type, int section, struct objfile *objfile)
Definition: minsyms.c:1043
#define _(String)
Definition: gdb_locale.h:40
EXTERN int context_stack_depth
Definition: buildsym.h:162
static char * coff_getfilename(union internal_auxent *, struct objfile *)
Definition: xcoffread.c:1672
CORE_ADDR xcoff_get_toc_offset(struct objfile *objfile)
Definition: xcoffread.c:2921
static void xcoff_new_init(struct objfile *)
Definition: xcoffread.c:1905
void free_pending_blocks(void)
Definition: buildsym.c:320
static CORE_ADDR read_symbol_nvalue(int)
Definition: xcoffread.c:1710
int first_symnum
Definition: xcoffread.c:68
#define INITIAL_STABVECTOR_LENGTH
Definition: xcoffread.c:120
void printf_filtered(const char *format,...)
Definition: utils.c:2388
int n_static_syms
Definition: psympriv.h:167
EXTERN struct subfile * current_subfile
Definition: buildsym.h:73
struct obstack objfile_obstack
Definition: objfiles.h:328
static void find_targ_sec(bfd *, asection *, void *)
Definition: xcoffread.c:257
int globals_offset
Definition: psympriv.h:155
static void xcoff_symfile_offsets(struct objfile *objfile, const struct section_addr_info *addrs)
Definition: xcoffread.c:3042
static bfd * symfile_bfd
Definition: xcoffread.c:105
void common_block_start(char *name, struct objfile *objfile)
Definition: stabsread.c:4330
static void xcoff_initial_scan(struct objfile *, int)
Definition: xcoffread.c:2938
static void eb_complaint(int arg1)
Definition: xcoffread.c:189
const char *const name
Definition: aarch64-tdep.c:68
static struct linetable * arrange_linetable(struct linetable *)
Definition: xcoffread.c:425
bfd_byte * default_symfile_relocate(struct objfile *objfile, asection *sectp, bfd_byte *buf)
Definition: symfile.c:3740
EXTERN unsigned int symnum
Definition: buildsym.h:90
static char * raw_symbol
Definition: xcoffread.c:962
#define SYMBOL_ACLASS_INDEX(symbol)
Definition: symtab.h:792
static struct objfile * this_symtab_objfile
Definition: xcoffread.c:609
#define SYMBOL_VALUE_ADDRESS(symbol)
Definition: symtab.h:182
static enum language psymtab_language
Definition: xcoffread.c:85
void dwarf2_free_objfile(struct objfile *objfile)
Definition: dwarf2read.c:22162
CORE_ADDR gdbarch_addr_bits_remove(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition: gdbarch.c:2992
#define SYMBOL_DOMAIN(symbol)
Definition: symtab.h:790
CORE_ADDR pc
Definition: symtab.h:865
void initialize_file_ftype(void)
Definition: defs.h:281
EXTERN struct pending * global_symbols
Definition: buildsym.h:113
struct pending_block * old_blocks
Definition: buildsym.h:138
struct partial_symbol ** next
Definition: symfile.h:64
void scan_file_globals(struct objfile *objfile)
Definition: stabsread.c:4616
static const struct objfile_data * xcoff_objfile_data_key
Definition: xcoffread.c:58
#define XCOFF_DATA(objfile)
Definition: xcoffread.c:151
void init_psymbol_list(struct objfile *, int)
Definition: psymtab.c:1737
void fprintf_unfiltered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2361
struct partial_symtab * start_psymtab_common(struct objfile *, const char *, CORE_ADDR, struct partial_symbol **, struct partial_symbol **)
Definition: psymtab.c:1516
static void record_include_end(struct coff_symbol *)
Definition: xcoffread.c:564
static void swap_sym(struct internal_syment *symbol, union internal_auxent *aux, const char **name, char **raw, unsigned int *symnump, struct objfile *objfile)
Definition: xcoffread.c:2132
void fputs_filtered(const char *linebuffer, struct ui_file *stream)
Definition: utils.c:2145
static void read_symbol(struct internal_syment *, int)
Definition: xcoffread.c:1689
#define SECT_OFF_DATA(objfile)
Definition: objfiles.h:671
void buildsym_new_init(void)
Definition: buildsym.c:1773
void complaint(struct complaints **complaints, const char *fmt,...)
Definition: complaints.c:251
#define SYMBOL_DUP(SYMBOL1, SYMBOL2)
Definition: xcoffread.c:1516
struct cleanup * make_cleanup(make_cleanup_ftype *function, void *arg)
Definition: cleanups.c:117
CORE_ADDR toc_offset
Definition: xcoffread.c:146
#define ANOFFSET(secoff, whichone)
Definition: symtab.h:910
int sect_index_rodata
Definition: objfiles.h:375
struct gdbarch * get_objfile_arch(const struct objfile *objfile)
Definition: objfiles.c:368
EXTERN struct pending * local_symbols
Definition: buildsym.h:117
struct obj_section * sections
Definition: objfiles.h:386
static void xcoff_secnum_to_sections(int n_scnum, struct objfile *objfile, asection **bfd_sect, int *secnum)
Definition: xcoffread.c:284
Definition: symtab.h:862
static CORE_ADDR cur_src_end_addr
Definition: xcoffread.c:112
#define complete_symtab(name, start_addr)
Definition: xcoffread.c:902
asection ** resultp
Definition: coffread.c:278
#define next_symbol_text(objfile)
Definition: buildsym.h:182
int statics_offset
Definition: psympriv.h:166
struct symbol * define_symbol(CORE_ADDR valu, char *string, int desc, int type, struct objfile *objfile)
Definition: stabsread.c:625
struct context_stack * pop_context(void)
Definition: buildsym.c:1653
#define SYMNAME_ALLOC(NAME, ALLOCED)
Definition: xcoffread.c:1522
int c_sclass
Definition: coffread.c:142
const char * get_last_source_file(void)
Definition: buildsym.c:1729
static int startswith(const char *string, const char *pattern)
Definition: common-utils.h:75
struct cleanup * make_cleanup_discard_minimal_symbols(void)
Definition: minsyms.c:1115
static int inclLength
Definition: xcoffread.c:537
CORE_ADDR textlow
Definition: psympriv.h:105
static void xcoff_symfile_finish(struct objfile *)
Definition: xcoffread.c:1938
void wrap_here(char *indent)
Definition: utils.c:1930
static void xcoff_free_info(struct objfile *objfile, void *arg)
Definition: xcoffread.c:3170
int number_of_dependencies
Definition: psympriv.h:148
const char * objfile_name(const struct objfile *objfile)
Definition: objfiles.c:1499
void * xmalloc(YYSIZE_T)
struct compunit_symtab * start_symtab(struct objfile *objfile, const char *name, const char *comp_dir, CORE_ADDR start_addr)
Definition: buildsym.c:1036
void * read_symtab_private
Definition: psympriv.h:204
static void init_stringtab(bfd *, file_ptr, struct objfile *)
Definition: xcoffread.c:1953
static void ef_complaint(int arg1)
Definition: xcoffread.c:182
struct partial_symtab * allocate_psymtab(const char *, struct objfile *) ATTRIBUTE_NONNULL(1)
Definition: psymtab.c:1774
static unsigned int first_fun_line_offset
Definition: xcoffread.c:2003
void init_minimal_symbol_collection(void)
Definition: minsyms.c:925
file_ptr max_lineno_offset
Definition: coffread.c:59
void add_psymbol_to_list(const char *, int, int, domain_enum, enum address_class, struct psymbol_allocation_list *, long, CORE_ADDR, enum language, struct objfile *)
static void xcoff_symfile_init(struct objfile *)
Definition: xcoffread.c:1918
EXTERN struct pending_stabs * global_stabs
Definition: stabsread.h:55
unsigned int lineno_off
Definition: xcoffread.c:80
asection ** bfd_sect
Definition: xcoffread.c:250
PTR xrealloc(PTR ptr, size_t size)
Definition: common-utils.c:51
int c_naux
Definition: coffread.c:139
int n_global_syms
Definition: psympriv.h:156
static void record_minimal_symbol(const char *name, CORE_ADDR address, enum minimal_symbol_type ms_type, int n_scnum, struct objfile *objfile)
Definition: xcoffread.c:931
static struct coff_symbol fcn_cs_saved
Definition: xcoffread.c:103
const char const char int
Definition: command.h:229
bfd_byte gdb_byte
Definition: common-types.h:38
void sort_pst_symbols(struct objfile *, struct partial_symtab *)
Definition: psymtab.c:1501
static void enter_line_range(struct subfile *, unsigned, unsigned, CORE_ADDR, CORE_ADDR, unsigned *)
Definition: xcoffread.c:832
static void xcoff_read_symtab(struct partial_symtab *self, struct objfile *objfile)
Definition: xcoffread.c:1869
void void void void void void void void void perror_with_name(const char *string) ATTRIBUTE_NORETURN
Definition: utils.c:979
static void process_linenos(CORE_ADDR, CORE_ADDR)
Definition: xcoffread.c:615
struct pending * locals
Definition: buildsym.h:130
static void bf_notfound_complaint(void)
Definition: xcoffread.c:175
static unsigned local_symesz
Definition: xcoffread.c:126
static struct partial_symtab * xcoff_end_psymtab(struct objfile *objfile, struct partial_symtab *pst, const char **include_list, int num_includes, int capping_symbol_number, struct partial_symtab **dependency_list, int number_dependencies, int textlow_not_set)
Definition: xcoffread.c:2045
#define SEEK_SET
Definition: defs.h:87
char * c_name
Definition: coffread.c:137
int num_sections
Definition: objfiles.h:363
enum language deduce_language_from_filename(const char *filename)
Definition: symfile.c:2880
unsigned funStartLine
Definition: xcoffread.c:530
int line_vector_length
Definition: buildsym.h:66
int xcoff_get_n_import_files(bfd *abfd)
Definition: xcoffread.c:3142
struct partial_symtab ** dependencies
Definition: psympriv.h:146
struct ui_file * gdb_stderr
Definition: main.c:72
void record_debugformat(const char *format)
Definition: buildsym.c:1671
struct complaints * symfile_complaints
Definition: complaints.c:105
const char * gdbarch_static_transform_name(struct gdbarch *gdbarch, const char *name)
Definition: gdbarch.c:3830
file_ptr min_lineno_offset
Definition: coffread.c:58
void push_subfile(void)
Definition: buildsym.c:853
const struct quick_symbol_functions psym_functions
Definition: psymtab.c:1466
void really_free_pendings(void *dummy)
Definition: buildsym.c:279
#define INITIAL_INCLUDE_TABLE_LENGTH
Definition: xcoffread.c:534
static int inclIndx
Definition: xcoffread.c:536
int offset
Definition: agent.c:65
record_line_ftype record_line
Definition: buffer.h:23
CORE_ADDR start_addr
Definition: buildsym.h:146
EXTERN CORE_ADDR last_source_start_addr
Definition: buildsym.h:53
#define qsort
Definition: ada-exp.c:2747
int line
Definition: symtab.h:1570
void default_symfile_offsets(struct objfile *objfile, const struct section_addr_info *addrs)
Definition: symfile.c:722
static struct partial_symtab * this_symtab_psymtab
Definition: xcoffread.c:606
void start_subfile(const char *name)
Definition: buildsym.c:656
#define CSECT_SCLAS(PP)
static int read_symbol_lineno(int)
Definition: xcoffread.c:1723
struct type * nodebug_text_symbol
Definition: gdbtypes.h:1594
struct partial_symbol ** list
Definition: symfile.h:59
void(* read_symtab)(struct partial_symtab *, struct objfile *)
Definition: psympriv.h:197
int c_symnum
Definition: coffread.c:138
struct symbol * name
Definition: buildsym.h:142
EXTERN char *(* next_symbol_text_func)(struct objfile *)
Definition: buildsym.h:186
language
Definition: defs.h:167
void buildsym_init(void)
Definition: buildsym.c:1741
static CORE_ADDR first_object_file_end
Definition: xcoffread.c:116
int nitems
Definition: symtab.h:887
#define SYMBOL_TYPE(symbol)
Definition: symtab.h:799
Definition: symtab.h:703
#define NUM_OF_FUNCTIONS
struct context_stack * push_context(int desc, CORE_ADDR valu)
Definition: buildsym.c:1623
unsigned short flags
Definition: objfiles.h:282
static asection * secnum_to_bfd_section(int, struct objfile *)
Definition: xcoffread.c:315
int sect_index_bss
Definition: objfiles.h:374
void stabsread_init(void)
Definition: stabsread.c:4755
#define SYMBOL_SECTION(symbol)
Definition: symtab.h:188
struct compunit_symtab * compunit_symtab
Definition: psympriv.h:192
struct section_offsets * section_offsets
Definition: objfiles.h:362
#define CSECT_SMTYP(PP)
void gdb_flush(struct ui_file *file)
Definition: ui-file.c:192
int line
Definition: symtab.h:864
minimal_symbol_type
Definition: symtab.h:287
#define QUIT
Definition: defs.h:160
int numsyms
Definition: xcoffread.c:76
int gdbarch_static_transform_name_p(struct gdbarch *gdbarch)
Definition: gdbarch.c:3823
#define OBJF_REORDERED
Definition: objfiles.h:425
int sect_index_data
Definition: objfiles.h:373
static char * xcoff_next_symbol_text(struct objfile *)
Definition: xcoffread.c:968
EXTERN int within_function
Definition: buildsym.h:174
void install_minimal_symbols(struct objfile *objfile)
Definition: minsyms.c:1248
static void read_xcoff_symtab(struct objfile *, struct partial_symtab *)
Definition: xcoffread.c:1006
static void aix_process_linenos(struct objfile *objfile)
Definition: xcoffread.c:810
struct linetable * line_vector
Definition: buildsym.h:65
static void xcoff_psymtab_to_symtab_1(struct objfile *objfile, struct partial_symtab *pst)
Definition: xcoffread.c:1816
void error(const char *fmt,...)
Definition: errors.c:38
size_t size
Definition: go32-nat.c:242
CORE_ADDR texthigh
Definition: psympriv.h:106
static void scan_xcoff_symtab(struct objfile *)
Definition: xcoffread.c:2187
void do_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:175
void end_stabs(void)
Definition: stabsread.c:4789
unsigned int c_type
Definition: coffread.c:144
CORE_ADDR c_value
Definition: coffread.c:141
struct block * finish_block(struct symbol *symbol, struct pending **listhead, struct pending_block *old_blocks, CORE_ADDR start, CORE_ADDR end)
Definition: buildsym.c:515
unsigned char c_sclass
Definition: xcoffread.c:96