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