GDB (xrefs)

/tmp/gdb-8.1/gdb/coffread.c
Go to the documentation of this file.
1 /* Read coff symbol tables and convert to internal format, for GDB.
2 Copyright (C) 1987-2018 Free Software Foundation, Inc.
3 Contributed by David D. Johnson, Brown University (ddj@cs.brown.edu).
4
5 This file is part of GDB.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
19
20 #include "defs.h"
21 #include "symtab.h"
22 #include "gdbtypes.h"
23 #include "demangle.h"
24 #include "breakpoint.h"
25
26 #include "bfd.h"
27 #include "gdb_obstack.h"
28 #include <ctype.h>
29
30 #include "coff/internal.h" /* Internal format of COFF symbols in BFD */
31 #include "libcoff.h" /* FIXME secret internal data from BFD */
32 #include "objfiles.h"
33 #include "buildsym.h"
34 #include "gdb-stabs.h"
35 #include "stabsread.h"
36 #include "complaints.h"
37 #include "target.h"
38 #include "block.h"
39 #include "dictionary.h"
40
41 #include "coff-pe-read.h"
42
43 #include "psymtab.h"
44 #include "build-id.h"
45
46 /* Key for COFF-associated data. */
47
48 static const struct objfile_data *coff_objfile_data_key;
49
50 /* The objfile we are currently reading. */
51
52 static struct objfile *coffread_objfile;
53
54 struct coff_symfile_info
55 {
56 file_ptr min_lineno_offset; /* Where in file lowest line#s are. */
57 file_ptr max_lineno_offset; /* 1+last byte of line#s in file. */
58
59 CORE_ADDR textaddr; /* Addr of .text section. */
60 unsigned int textsize; /* Size of .text section. */
61 struct stab_section_list *stabsects; /* .stab sections. */
62 asection *stabstrsect; /* Section pointer for .stab section. */
63 char *stabstrdata;
64 };
65
66 /* Translate an external name string into a user-visible name. */
67 #define EXTERNAL_NAME(string, abfd) \
68 (string[0] == bfd_get_symbol_leading_char (abfd) \
69 ? string + 1 : string)
70
71 /* To be an sdb debug type, type must have at least a basic or primary
72 derived type. Using this rather than checking against T_NULL is
73 said to prevent core dumps if we try to operate on Michael Bloom
74 dbx-in-coff file. */
75
76 #define SDB_TYPE(type) (BTYPE(type) | (type & N_TMASK))
77
78 /* Core address of start and end of text of current source file.
79 This comes from a ".text" symbol where x_nlinno > 0. */
80
81 static CORE_ADDR current_source_start_addr;
82 static CORE_ADDR current_source_end_addr;
83
84 /* The addresses of the symbol table stream and number of symbols
85 of the object file we are reading (as copied into core). */
86
87 static bfd *nlist_bfd_global;
88 static int nlist_nsyms_global;
89
90
91 /* Pointers to scratch storage, used for reading raw symbols and
92 auxents. */
93
94 static char *temp_sym;
95 static char *temp_aux;
96
97 /* Local variables that hold the shift and mask values for the
98 COFF file that we are currently reading. These come back to us
99 from BFD, and are referenced by their macro names, as well as
100 internally to the BTYPE, ISPTR, ISFCN, ISARY, ISTAG, and DECREF
101 macros from include/coff/internal.h . */
102
103 static unsigned local_n_btmask;
104 static unsigned local_n_btshft;
105 static unsigned local_n_tmask;
106 static unsigned local_n_tshift;
107
108 #define N_BTMASK local_n_btmask
109 #define N_BTSHFT local_n_btshft
110 #define N_TMASK local_n_tmask
111 #define N_TSHIFT local_n_tshift
112
113 /* Local variables that hold the sizes in the file of various COFF
114 structures. (We only need to know this to read them from the file
115 -- BFD will then translate the data in them, into `internal_xxx'
116 structs in the right byte order, alignment, etc.) */
117
118 static unsigned local_linesz;
119 static unsigned local_symesz;
120 static unsigned local_auxesz;
121
122 /* This is set if this is a PE format file. */
123
124 static int pe_file;
125
126 /* Chain of typedefs of pointers to empty struct/union types.
127 They are chained thru the SYMBOL_VALUE_CHAIN. */
128
129 static struct symbol *opaque_type_chain[HASHSIZE];
130
131 /* Simplified internal version of coff symbol table information. */
132
133 struct coff_symbol
134 {
135 char *c_name;
136 int c_symnum; /* Symbol number of this entry. */
137 int c_naux; /* 0 if syment only, 1 if syment +
138 auxent, etc. */
139 CORE_ADDR c_value;
140 int c_sclass;
141 int c_secnum;
142 unsigned int c_type;
143 };
144
145 /* Vector of types defined so far, indexed by their type numbers. */
146
147 static struct type **type_vector;
148
149 /* Number of elements allocated for type_vector currently. */
150
151 static int type_vector_length;
152
153 /* Initial size of type vector. Is realloc'd larger if needed, and
154 realloc'd down to the size actually used, when completed. */
155
156 #define INITIAL_TYPE_VECTOR_LENGTH 160
157
158 extern void stabsread_clear_cache (void);
159
160 static struct type *coff_read_struct_type (int, int, int,
161 struct objfile *);
162
163 static struct type *decode_base_type (struct coff_symbol *,
164 unsigned int,
165 union internal_auxent *,
166 struct objfile *);
167
168 static struct type *decode_type (struct coff_symbol *, unsigned int,
169 union internal_auxent *,
170 struct objfile *);
171
172 static struct type *decode_function_type (struct coff_symbol *,
173 unsigned int,
174 union internal_auxent *,
175 struct objfile *);
176
177 static struct type *coff_read_enum_type (int, int, int,
178 struct objfile *);
179
180 static struct symbol *process_coff_symbol (struct coff_symbol *,
181 union internal_auxent *,
182 struct objfile *);
183
184 static void patch_opaque_types (struct symtab *);
185
186 static void enter_linenos (long, int, int, struct objfile *);
187
188 static void free_linetab (void);
189
190 static void free_linetab_cleanup (void *ignore);
191
192 static int init_lineno (bfd *, long, int);
193
194 static char *getsymname (struct internal_syment *);
195
196 static const char *coff_getfilename (union internal_auxent *);
197
198 static void free_stringtab (void);
199
200 static void free_stringtab_cleanup (void *ignore);
201
202 static int init_stringtab (bfd *, long);
203
204 static void read_one_sym (struct coff_symbol *,
205 struct internal_syment *,
206 union internal_auxent *);
207
208 static void coff_symtab_read (minimal_symbol_reader &,
209 long, unsigned int, struct objfile *);
210
211 /* We are called once per section from coff_symfile_read. We
212 need to examine each section we are passed, check to see
213 if it is something we are interested in processing, and
214 if so, stash away some access information for the section.
215
216 FIXME: The section names should not be hardwired strings (what
217 should they be? I don't think most object file formats have enough
218 section flags to specify what kind of debug section it is
219 -kingdon). */
220
221 static void
222 coff_locate_sections (bfd *abfd, asection *sectp, void *csip)
223 {
224 struct coff_symfile_info *csi;
225 const char *name;
226
227 csi = (struct coff_symfile_info *) csip;
228 name = bfd_get_section_name (abfd, sectp);
229 if (strcmp (name, ".text") == 0)
230 {
231 csi->textaddr = bfd_section_vma (abfd, sectp);
232 csi->textsize += bfd_section_size (abfd, sectp);
233 }
234 else if (startswith (name, ".text"))
235 {
236 csi->textsize += bfd_section_size (abfd, sectp);
237 }
238 else if (strcmp (name, ".stabstr") == 0)
239 {
240 csi->stabstrsect = sectp;
241 }
242 else if (startswith (name, ".stab"))
243 {
244 const char *s;
245
246 /* We can have multiple .stab sections if linked with
247 --split-by-reloc. */
248 for (s = name + sizeof ".stab" - 1; *s != '\0'; s++)
249 if (!isdigit (*s))
250 break;
251 if (*s == '\0')
252 {
253 struct stab_section_list *n, **pn;
254
255 n = XNEW (struct stab_section_list);
256 n->section = sectp;
257 n->next = NULL;
258 for (pn = &csi->stabsects; *pn != NULL; pn = &(*pn)->next)
259 ;
260 *pn = n;
261
262 /* This will be run after coffstab_build_psymtabs is called
263 in coff_symfile_read, at which point we no longer need
264 the information. */
265 make_cleanup (xfree, n);
266 }
267 }
268 }
269
270 /* Return the section_offsets* that CS points to. */
271 static int cs_to_section (struct coff_symbol *, struct objfile *);
272
273 struct find_targ_sec_arg
274 {
275 int targ_index;
276 asection **resultp;
277 };
278
279 static void
280 find_targ_sec (bfd *abfd, asection *sect, void *obj)
281 {
282 struct find_targ_sec_arg *args = (struct find_targ_sec_arg *) obj;
283
284 if (sect->target_index == args->targ_index)
285 *args->resultp = sect;
286 }
287
288 /* Return the bfd_section that CS points to. */
289 static struct bfd_section*
290 cs_to_bfd_section (struct coff_symbol *cs, struct objfile *objfile)
291 {
292 asection *sect = NULL;
293 struct find_targ_sec_arg args;
294
295 args.targ_index = cs->c_secnum;
296 args.resultp = &sect;
297 bfd_map_over_sections (objfile->obfd, find_targ_sec, &args);
298 return sect;
299 }
300
301 /* Return the section number (SECT_OFF_*) that CS points to. */
302 static int
303 cs_to_section (struct coff_symbol *cs, struct objfile *objfile)
304 {
305 asection *sect = cs_to_bfd_section (cs, objfile);
306
307 if (sect == NULL)
308 return SECT_OFF_TEXT (objfile);
309 return gdb_bfd_section_index (objfile->obfd, sect);
310 }
311
312 /* Return the address of the section of a COFF symbol. */
313
314 static CORE_ADDR cs_section_address (struct coff_symbol *, bfd *);
315
316 static CORE_ADDR
317 cs_section_address (struct coff_symbol *cs, bfd *abfd)
318 {
319 asection *sect = NULL;
320 struct find_targ_sec_arg args;
321 CORE_ADDR addr = 0;
322
323 args.targ_index = cs->c_secnum;
324 args.resultp = &sect;
325 bfd_map_over_sections (abfd, find_targ_sec, &args);
326 if (sect != NULL)
327 addr = bfd_get_section_vma (abfd, sect);
328 return addr;
329 }
330
331 /* Look up a coff type-number index. Return the address of the slot
332 where the type for that index is stored.
333 The type-number is in INDEX.
334
335 This can be used for finding the type associated with that index
336 or for associating a new type with the index. */
337
338 static struct type **
339 coff_lookup_type (int index)
340 {
341 if (index >= type_vector_length)
342 {
343 int old_vector_length = type_vector_length;
344
345 type_vector_length *= 2;
346 if (index /* is still */ >= type_vector_length)
347 type_vector_length = index * 2;
348
349 type_vector = (struct type **)
350 xrealloc ((char *) type_vector,
351 type_vector_length * sizeof (struct type *));
352 memset (&type_vector[old_vector_length], 0,
353 (type_vector_length - old_vector_length) * sizeof (struct type *));
354 }
355 return &type_vector[index];
356 }
357
358 /* Make sure there is a type allocated for type number index
359 and return the type object.
360 This can create an empty (zeroed) type object. */
361
362 static struct type *
363 coff_alloc_type (int index)
364 {
365 struct type **type_addr = coff_lookup_type (index);
366 struct type *type = *type_addr;
367
368 /* If we are referring to a type not known at all yet,
369 allocate an empty type for it.
370 We will fill it in later if we find out how. */
371 if (type == NULL)
372 {
373 type = alloc_type (coffread_objfile);
374 *type_addr = type;
375 }
376 return type;
377 }
378
379 /* Start a new symtab for a new source file.
380 This is called when a COFF ".file" symbol is seen;
381 it indicates the start of data for one original source file. */
382
383 static void
384 coff_start_symtab (struct objfile *objfile, const char *name)
385 {
386 start_symtab (objfile,
387 /* We fill in the filename later. start_symtab puts this pointer
388 into last_source_file and we put it in subfiles->name, which
389 end_symtab frees; that's why it must be malloc'd. */
390 xstrdup (name),
391 /* We never know the directory name for COFF. */
392 NULL,
393 /* The start address is irrelevant, since we set
394 last_source_start_addr in coff_end_symtab. */
395 0,
396 /* Let buildsym.c deduce the language for this symtab. */
397 language_unknown);
398 record_debugformat ("COFF");
399 }
400
401 /* Save the vital information from when starting to read a file,
402 for use when closing off the current file.
403 NAME is the file name the symbols came from, START_ADDR is the
404 first text address for the file, and SIZE is the number of bytes of
405 text. */
406
407 static void
408 complete_symtab (const char *name, CORE_ADDR start_addr, unsigned int size)
409 {
410 set_last_source_file (name);
411 current_source_start_addr = start_addr;
412 current_source_end_addr = start_addr + size;
413 }
414
415 /* Finish the symbol definitions for one main source file, close off
416 all the lexical contexts for that file (creating struct block's for
417 them), then make the struct symtab for that file and put it in the
418 list of all such. */
419
420 static void
421 coff_end_symtab (struct objfile *objfile)
422 {
423 last_source_start_addr = current_source_start_addr;
424
425 end_symtab (current_source_end_addr, SECT_OFF_TEXT (objfile));
426
427 /* Reinitialize for beginning of new file. */
428 set_last_source_file (NULL);
429 }
430
431 /* The linker sometimes generates some non-function symbols inside
432 functions referencing variables imported from another DLL.
433 Return nonzero if the given symbol corresponds to one of them. */
434
435 static int
436 is_import_fixup_symbol (struct coff_symbol *cs,
437 enum minimal_symbol_type type)
438 {
439 /* The following is a bit of a heuristic using the characterictics
440 of these fixup symbols, but should work well in practice... */
441 int i;
442
443 /* Must be a non-static text symbol. */
444 if (type != mst_text)
445 return 0;
446
447 /* Must be a non-function symbol. */
448 if (ISFCN (cs->c_type))
449 return 0;
450
451 /* The name must start with "__fu<digits>__". */
452 if (!startswith (cs->c_name, "__fu"))
453 return 0;
454 if (! isdigit (cs->c_name[4]))
455 return 0;
456 for (i = 5; cs->c_name[i] != '\0' && isdigit (cs->c_name[i]); i++)
457 /* Nothing, just incrementing index past all digits. */;
458 if (cs->c_name[i] != '_' || cs->c_name[i + 1] != '_')
459 return 0;
460
461 return 1;
462 }
463
464 static struct minimal_symbol *
465 record_minimal_symbol (minimal_symbol_reader &reader,
466 struct coff_symbol *cs, CORE_ADDR address,
467 enum minimal_symbol_type type, int section,
468 struct objfile *objfile)
469 {
470 /* We don't want TDESC entry points in the minimal symbol table. */
471 if (cs->c_name[0] == '@')
472 return NULL;
473
474 if (is_import_fixup_symbol (cs, type))
475 {
476 /* Because the value of these symbols is within a function code
477 range, these symbols interfere with the symbol-from-address
478 reverse lookup; this manifests itselfs in backtraces, or any
479 other commands that prints symbolic addresses. Just pretend
480 these symbols do not exist. */
481 return NULL;
482 }
483
484 return reader.record_with_info (cs->c_name, address, type, section);
485 }
486
487 /* coff_symfile_init ()
488 is the coff-specific initialization routine for reading symbols.
489 It is passed a struct objfile which contains, among other things,
490 the BFD for the file whose symbols are being read, and a slot for
491 a pointer to "private data" which we fill with cookies and other
492 treats for coff_symfile_read ().
493
494 We will only be called if this is a COFF or COFF-like file. BFD
495 handles figuring out the format of the file, and code in symtab.c
496 uses BFD's determination to vector to us.
497
498 The ultimate result is a new symtab (or, FIXME, eventually a
499 psymtab). */
500
501 static void
502 coff_symfile_init (struct objfile *objfile)
503 {
504 struct dbx_symfile_info *dbx;
505 struct coff_symfile_info *coff;
506
507 /* Allocate struct to keep track of stab reading. */
508 dbx = XCNEW (struct dbx_symfile_info);
509 set_objfile_data (objfile, dbx_objfile_data_key, dbx);
510
511 /* Allocate struct to keep track of the symfile. */
512 coff = XCNEW (struct coff_symfile_info);
513 set_objfile_data (objfile, coff_objfile_data_key, coff);
514
515 /* COFF objects may be reordered, so set OBJF_REORDERED. If we
516 find this causes a significant slowdown in gdb then we could
517 set it in the debug symbol readers only when necessary. */
518 objfile->flags |= OBJF_REORDERED;
519 }
520
521 /* This function is called for every section; it finds the outer
522 limits of the line table (minimum and maximum file offset) so that
523 the mainline code can read the whole thing for efficiency. */
524
525 static void
526 find_linenos (bfd *abfd, struct bfd_section *asect, void *vpinfo)
527 {
528 struct coff_symfile_info *info;
529 int size, count;
530 file_ptr offset, maxoff;
531
532 /* WARNING WILL ROBINSON! ACCESSING BFD-PRIVATE DATA HERE! FIXME! */
533 count = asect->lineno_count;
534 /* End of warning. */
535
536 if (count == 0)
537 return;
538 size = count * local_linesz;
539
540 info = (struct coff_symfile_info *) vpinfo;
541 /* WARNING WILL ROBINSON! ACCESSING BFD-PRIVATE DATA HERE! FIXME! */
542 offset = asect->line_filepos;
543 /* End of warning. */
544
545 if (offset < info->min_lineno_offset || info->min_lineno_offset == 0)
546 info->min_lineno_offset = offset;
547
548 maxoff = offset + size;
549 if (maxoff > info->max_lineno_offset)
550 info->max_lineno_offset = maxoff;
551 }
552
553
554 /* The BFD for this file -- only good while we're actively reading
555 symbols into a psymtab or a symtab. */
556
557 static bfd *symfile_bfd;
558
559 /* Read a symbol file, after initialization by coff_symfile_init. */
560
561 static void
562 coff_symfile_read (struct objfile *objfile, symfile_add_flags symfile_flags)
563 {
564 struct coff_symfile_info *info;
565 bfd *abfd = objfile->obfd;
566 coff_data_type *cdata = coff_data (abfd);
567 char *name = bfd_get_filename (abfd);
568 int val;
569 unsigned int num_symbols;
570 int symtab_offset;
571 int stringtab_offset;
572 struct cleanup *back_to;
573 int stabstrsize;
574
575 info = (struct coff_symfile_info *) objfile_data (objfile,
576 coff_objfile_data_key);
577 symfile_bfd = abfd; /* Kludge for swap routines. */
578
579 /* WARNING WILL ROBINSON! ACCESSING BFD-PRIVATE DATA HERE! FIXME! */
580 num_symbols = bfd_get_symcount (abfd); /* How many syms */
581 symtab_offset = cdata->sym_filepos; /* Symbol table file offset */
582 stringtab_offset = symtab_offset + /* String table file offset */
583 num_symbols * cdata->local_symesz;
584
585 /* Set a few file-statics that give us specific information about
586 the particular COFF file format we're reading. */
587 local_n_btmask = cdata->local_n_btmask;
588 local_n_btshft = cdata->local_n_btshft;
589 local_n_tmask = cdata->local_n_tmask;
590 local_n_tshift = cdata->local_n_tshift;
591 local_linesz = cdata->local_linesz;
592 local_symesz = cdata->local_symesz;
593 local_auxesz = cdata->local_auxesz;
594
595 /* Allocate space for raw symbol and aux entries, based on their
596 space requirements as reported by BFD. */
597 temp_sym = (char *) xmalloc
598 (cdata->local_symesz + cdata->local_auxesz);
599 temp_aux = temp_sym + cdata->local_symesz;
600 back_to = make_cleanup (free_current_contents, &temp_sym);
601
602 /* We need to know whether this is a PE file, because in PE files,
603 unlike standard COFF files, symbol values are stored as offsets
604 from the section address, rather than as absolute addresses.
605 FIXME: We should use BFD to read the symbol table, and thus avoid
606 this problem. */
607 pe_file =
608 startswith (bfd_get_target (objfile->obfd), "pe")
609 || startswith (bfd_get_target (objfile->obfd), "epoc-pe");
610
611 /* End of warning. */
612
613 info->min_lineno_offset = 0;
614 info->max_lineno_offset = 0;
615
616 /* Only read line number information if we have symbols.
617
618 On Windows NT, some of the system's DLL's have sections with
619 PointerToLinenumbers fields that are non-zero, but point at
620 random places within the image file. (In the case I found,
621 KERNEL32.DLL's .text section has a line number info pointer that
622 points into the middle of the string `lib\\i386\kernel32.dll'.)
623
624 However, these DLL's also have no symbols. The line number
625 tables are meaningless without symbols. And in fact, GDB never
626 uses the line number information unless there are symbols. So we
627 can avoid spurious error messages (and maybe run a little
628 faster!) by not even reading the line number table unless we have
629 symbols. */
630 if (num_symbols > 0)
631 {
632 /* Read the line number table, all at once. */
633 bfd_map_over_sections (abfd, find_linenos, (void *) info);
634
635 make_cleanup (free_linetab_cleanup, 0 /*ignore*/);
636 val = init_lineno (abfd, info->min_lineno_offset,
637 info->max_lineno_offset - info->min_lineno_offset);
638 if (val < 0)
639 error (_("\"%s\": error reading line numbers."), name);
640 }
641
642 /* Now read the string table, all at once. */
643
644 make_cleanup (free_stringtab_cleanup, 0 /*ignore*/);
645 val = init_stringtab (abfd, stringtab_offset);
646 if (val < 0)
647 error (_("\"%s\": can't get string table"), name);
648
649 minimal_symbol_reader reader (objfile);
650
651 /* Now that the executable file is positioned at symbol table,
652 process it and define symbols accordingly. */
653
654 coff_symtab_read (reader, (long) symtab_offset, num_symbols, objfile);
655
656 /* Install any minimal symbols that have been collected as the
657 current minimal symbols for this objfile. */
658
659 reader.install ();
660
661 if (pe_file)
662 {
663 struct minimal_symbol *msym;
664
665 ALL_OBJFILE_MSYMBOLS (objfile, msym)
666 {
667 const char *name = MSYMBOL_LINKAGE_NAME (msym);
668
669 /* If the minimal symbols whose name are prefixed by "__imp_"
670 or "_imp_", get rid of the prefix, and search the minimal
671 symbol in OBJFILE. Note that 'maintenance print msymbols'
672 shows that type of these "_imp_XXXX" symbols is mst_data. */
673 if (MSYMBOL_TYPE (msym) == mst_data)
674 {
675 const char *name1 = NULL;
676
677 if (startswith (name, "_imp_"))
678 name1 = name + 5;
679 else if (startswith (name, "__imp_"))
680 name1 = name + 6;
681 if (name1 != NULL)
682 {
683 int lead = bfd_get_symbol_leading_char (objfile->obfd);
684 struct bound_minimal_symbol found;
685
686 if (lead != '\0' && *name1 == lead)
687 name1 += 1;
688
689 found = lookup_minimal_symbol (name1, NULL, objfile);
690
691 /* If found, there are symbols named "_imp_foo" and "foo"
692 respectively in OBJFILE. Set the type of symbol "foo"
693 as 'mst_solib_trampoline'. */
694 if (found.minsym != NULL
695 && MSYMBOL_TYPE (found.minsym) == mst_text)
696 MSYMBOL_TYPE (found.minsym) = mst_solib_trampoline;
697 }
698 }
699 }
700 }
701
702 if (!(objfile->flags & OBJF_READNEVER))
703 bfd_map_over_sections (abfd, coff_locate_sections, (void *) info);
704
705 if (info->stabsects)
706 {
707 if (!info->stabstrsect)
708 {
709 error (_("The debugging information in `%s' is corrupted.\nThe "
710 "file has a `.stabs' section, but no `.stabstr' section."),
711 name);
712 }
713
714 /* FIXME: dubious. Why can't we use something normal like
715 bfd_get_section_contents? */
716 bfd_seek (abfd, abfd->where, 0);
717
718 stabstrsize = bfd_section_size (abfd, info->stabstrsect);
719
720 coffstab_build_psymtabs (objfile,
721 info->textaddr, info->textsize,
722 info->stabsects,
723 info->stabstrsect->filepos, stabstrsize);
724 }
725 if (dwarf2_has_info (objfile, NULL))
726 {
727 /* DWARF2 sections. */
728 dwarf2_build_psymtabs (objfile);
729 }
730
731 dwarf2_build_frame_info (objfile);
732
733 /* Try to add separate debug file if no symbols table found. */
734 if (!objfile_has_partial_symbols (objfile))
735 {
736 char *debugfile;
737
738 debugfile = find_separate_debug_file_by_buildid (objfile);
739
740 if (debugfile == NULL)
741 debugfile = find_separate_debug_file_by_debuglink (objfile);
742 make_cleanup (xfree, debugfile);
743
744 if (debugfile)
745 {
746 gdb_bfd_ref_ptr abfd (symfile_bfd_open (debugfile));
747
748 symbol_file_add_separate (abfd.get (), debugfile, symfile_flags,
749 objfile);
750 }
751 }
752
753 do_cleanups (back_to);
754 }
755
756 static void
757 coff_new_init (struct objfile *ignore)
758 {
759 }
760
761 /* Perform any local cleanups required when we are done with a
762 particular objfile. I.E, we are in the process of discarding all
763 symbol information for an objfile, freeing up all memory held for
764 it, and unlinking the objfile struct from the global list of known
765 objfiles. */
766
767 static void
768 coff_symfile_finish (struct objfile *objfile)
769 {
770 /* Let stabs reader clean up. */
771 stabsread_clear_cache ();
772
773 dwarf2_free_objfile (objfile);
774 }
775
776
777 /* Given pointers to a symbol table in coff style exec file,
778 analyze them and create struct symtab's describing the symbols.
779 NSYMS is the number of symbols in the symbol table.
780 We read them one at a time using read_one_sym (). */
781
782 static void
783 coff_symtab_read (minimal_symbol_reader &reader,
784 long symtab_offset, unsigned int nsyms,
785 struct objfile *objfile)
786 {
787 struct gdbarch *gdbarch = get_objfile_arch (objfile);
788 struct context_stack *newobj;
789 struct coff_symbol coff_symbol;
790 struct coff_symbol *cs = &coff_symbol;
791 static struct internal_syment main_sym;
792 static union internal_auxent main_aux;
793 struct coff_symbol fcn_cs_saved;
794 static struct internal_syment fcn_sym_saved;
795 static union internal_auxent fcn_aux_saved;
796 /* A .file is open. */
797 int in_source_file = 0;
798 int next_file_symnum = -1;
799 /* Name of the current file. */
800 const char *filestring = "";
801 int depth = 0;
802 int fcn_first_line = 0;
803 CORE_ADDR fcn_first_line_addr = 0;
804 int fcn_last_line = 0;
805 int fcn_start_addr = 0;
806 long fcn_line_ptr = 0;
807 int val;
808 CORE_ADDR tmpaddr;
809 struct minimal_symbol *msym;
810
811 /* Work around a stdio bug in SunOS4.1.1 (this makes me nervous....
812 it's hard to know I've really worked around it. The fix should
813 be harmless, anyway). The symptom of the bug is that the first
814 fread (in read_one_sym), will (in my example) actually get data
815 from file offset 268, when the fseek was to 264 (and ftell shows
816 264). This causes all hell to break loose. I was unable to
817 reproduce this on a short test program which operated on the same
818 file, performing (I think) the same sequence of operations.
819
820 It stopped happening when I put in this (former) rewind().
821
822 FIXME: Find out if this has been reported to Sun, whether it has
823 been fixed in a later release, etc. */
824
825 bfd_seek (objfile->obfd, 0, 0);
826
827 /* Position to read the symbol table. */
828 val = bfd_seek (objfile->obfd, (long) symtab_offset, 0);
829 if (val < 0)
830 perror_with_name (objfile_name (objfile));
831
832 coffread_objfile = objfile;
833 nlist_bfd_global = objfile->obfd;
834 nlist_nsyms_global = nsyms;
835 set_last_source_file (NULL);
836 memset (opaque_type_chain, 0, sizeof opaque_type_chain);
837
838 if (type_vector) /* Get rid of previous one. */
839 xfree (type_vector);
840 type_vector_length = INITIAL_TYPE_VECTOR_LENGTH;
841 type_vector = XCNEWVEC (struct type *, type_vector_length);
842
843 coff_start_symtab (objfile, "");
844
845 symnum = 0;
846 while (symnum < nsyms)
847 {
848 QUIT; /* Make this command interruptable. */
849
850 read_one_sym (cs, &main_sym, &main_aux);
851
852 if (cs->c_symnum == next_file_symnum && cs->c_sclass != C_FILE)
853 {
854 if (get_last_source_file ())
855 coff_end_symtab (objfile);
856
857 coff_start_symtab (objfile, "_globals_");
858 /* coff_start_symtab will set the language of this symtab to
859 language_unknown, since such a ``file name'' is not
860 recognized. Override that with the minimal language to
861 allow printing values in this symtab. */
862 current_subfile->language = language_minimal;
863 complete_symtab ("_globals_", 0, 0);
864 /* Done with all files, everything from here on out is
865 globals. */
866 }
867
868 /* Special case for file with type declarations only, no
869 text. */
870 if (!get_last_source_file () && SDB_TYPE (cs->c_type)
871 && cs->c_secnum == N_DEBUG)
872 complete_symtab (filestring, 0, 0);
873
874 /* Typedefs should not be treated as symbol definitions. */
875 if (ISFCN (cs->c_type) && cs->c_sclass != C_TPDEF)
876 {
877 /* Record all functions -- external and static -- in
878 minsyms. */
879 int section = cs_to_section (cs, objfile);
880
881 tmpaddr = cs->c_value;
882 record_minimal_symbol (reader, cs, tmpaddr, mst_text,
883 section, objfile);
884
885 fcn_line_ptr = main_aux.x_sym.x_fcnary.x_fcn.x_lnnoptr;
886 fcn_start_addr = tmpaddr;
887 fcn_cs_saved = *cs;
888 fcn_sym_saved = main_sym;
889 fcn_aux_saved = main_aux;
890 continue;
891 }
892
893 switch (cs->c_sclass)
894 {
895 case C_EFCN:
896 case C_EXTDEF:
897 case C_ULABEL:
898 case C_USTATIC:
899 case C_LINE:
900 case C_ALIAS:
901 case C_HIDDEN:
902 complaint (&symfile_complaints,
903 _("Bad n_sclass for symbol %s"),
904 cs->c_name);
905 break;
906
907 case C_FILE:
908 /* c_value field contains symnum of next .file entry in
909 table or symnum of first global after last .file. */
910 next_file_symnum = cs->c_value;
911 if (cs->c_naux > 0)
912 filestring = coff_getfilename (&main_aux);
913 else
914 filestring = "";
915
916 /* Complete symbol table for last object file
917 containing debugging information. */
918 if (get_last_source_file ())
919 {
920 coff_end_symtab (objfile);
921 coff_start_symtab (objfile, filestring);
922 }
923 in_source_file = 1;
924 break;
925
926 /* C_LABEL is used for labels and static functions.
927 Including it here allows gdb to see static functions when
928 no debug info is available. */
929 case C_LABEL:
930 /* However, labels within a function can make weird
931 backtraces, so filter them out (from phdm@macqel.be). */
932 if (within_function)
933 break;
934 case C_STAT:
935 case C_THUMBLABEL:
936 case C_THUMBSTAT:
937 case C_THUMBSTATFUNC:
938 if (cs->c_name[0] == '.')
939 {
940 if (strcmp (cs->c_name, ".text") == 0)
941 {
942 /* FIXME: don't wire in ".text" as section name or
943 symbol name! */
944 /* Check for in_source_file deals with case of a
945 file with debugging symbols followed by a later
946 file with no symbols. */
947 if (in_source_file)
948 complete_symtab (filestring,
949 cs->c_value + ANOFFSET (objfile->section_offsets,
950 SECT_OFF_TEXT (objfile)),
951 main_aux.x_scn.x_scnlen);
952 in_source_file = 0;
953 }
954 /* Flush rest of '.' symbols. */
955 break;
956 }
957 else if (!SDB_TYPE (cs->c_type)
958 && cs->c_name[0] == 'L'
959 && (startswith (cs->c_name, "LI%")
960 || startswith (cs->c_name, "LF%")
961 || startswith (cs->c_name, "LC%")
962 || startswith (cs->c_name, "LP%")
963 || startswith (cs->c_name, "LPB%")
964 || startswith (cs->c_name, "LBB%")
965 || startswith (cs->c_name, "LBE%")
966 || startswith (cs->c_name, "LPBX%")))
967 /* At least on a 3b1, gcc generates swbeg and string labels
968 that look like this. Ignore them. */
969 break;
970 /* Fall in for static symbols that don't start with '.' */
971 case C_THUMBEXT:
972 case C_THUMBEXTFUNC:
973 case C_EXT:
974 {
975 /* Record it in the minimal symbols regardless of
976 SDB_TYPE. This parallels what we do for other debug
977 formats, and probably is needed to make
978 print_address_symbolic work right without the (now
979 gone) "set fast-symbolic-addr off" kludge. */
980
981 enum minimal_symbol_type ms_type;
982 int sec;
983 CORE_ADDR offset = 0;
984
985 if (cs->c_secnum == N_UNDEF)
986 {
987 /* This is a common symbol. We used to rely on
988 the target to tell us whether it knows where
989 the symbol has been relocated to, but none of
990 the target implementations actually provided
991 that operation. So we just ignore the symbol,
992 the same way we would do if we had a target-side
993 symbol lookup which returned no match. */
994 break;
995 }
996 else if (cs->c_secnum == N_ABS)
997 {
998 /* Use the correct minimal symbol type (and don't
999 relocate) for absolute values. */
1000 ms_type = mst_abs;
1001 sec = cs_to_section (cs, objfile);
1002 tmpaddr = cs->c_value;
1003 }
1004 else
1005 {
1006 asection *bfd_section = cs_to_bfd_section (cs, objfile);
1007
1008 sec = cs_to_section (cs, objfile);
1009 tmpaddr = cs->c_value;
1010 /* Statics in a PE file also get relocated. */
1011 if (cs->c_sclass == C_EXT
1012 || cs->c_sclass == C_THUMBEXTFUNC
1013 || cs->c_sclass == C_THUMBEXT
1014 || (pe_file && (cs->c_sclass == C_STAT)))
1015 offset = ANOFFSET (objfile->section_offsets, sec);
1016
1017 if (bfd_section->flags & SEC_CODE)
1018 {
1019 ms_type =
1020 cs->c_sclass == C_EXT || cs->c_sclass == C_THUMBEXTFUNC
1021 || cs->c_sclass == C_THUMBEXT ?
1022 mst_text : mst_file_text;
1023 tmpaddr = gdbarch_addr_bits_remove (gdbarch, tmpaddr);
1024 }
1025 else if (bfd_section->flags & SEC_ALLOC
1026 && bfd_section->flags & SEC_LOAD)
1027 {
1028 ms_type =
1029 cs->c_sclass == C_EXT || cs->c_sclass == C_THUMBEXT
1030 ? mst_data : mst_file_data;
1031 }
1032 else if (bfd_section->flags & SEC_ALLOC)
1033 {
1034 ms_type =
1035 cs->c_sclass == C_EXT || cs->c_sclass == C_THUMBEXT
1036 ? mst_bss : mst_file_bss;
1037 }
1038 else
1039 ms_type = mst_unknown;
1040 }
1041
1042 msym = record_minimal_symbol (reader, cs, tmpaddr, ms_type,
1043 sec, objfile);
1044 if (msym)
1045 gdbarch_coff_make_msymbol_special (gdbarch,
1046 cs->c_sclass, msym);
1047
1048 if (SDB_TYPE (cs->c_type))
1049 {
1050 struct symbol *sym;
1051
1052 sym = process_coff_symbol
1053 (cs, &main_aux, objfile);
1054 SYMBOL_VALUE (sym) = tmpaddr + offset;
1055 SYMBOL_SECTION (sym) = sec;
1056 }
1057 }
1058 break;
1059
1060 case C_FCN:
1061 if (strcmp (cs->c_name, ".bf") == 0)
1062 {
1063 within_function = 1;
1064
1065 /* Value contains address of first non-init type
1066 code. */
1067 /* main_aux.x_sym.x_misc.x_lnsz.x_lnno
1068 contains line number of '{' }. */
1069 if (cs->c_naux != 1)
1070 complaint (&symfile_complaints,
1071 _("`.bf' symbol %d has no aux entry"),
1072 cs->c_symnum);
1073 fcn_first_line = main_aux.x_sym.x_misc.x_lnsz.x_lnno;
1074 fcn_first_line_addr = cs->c_value;
1075
1076 /* Might want to check that locals are 0 and
1077 context_stack_depth is zero, and complain if not. */
1078
1079 depth = 0;
1080 newobj = push_context (depth, fcn_start_addr);
1081 fcn_cs_saved.c_name = getsymname (&fcn_sym_saved);
1082 newobj->name =
1083 process_coff_symbol (&fcn_cs_saved,
1084 &fcn_aux_saved, objfile);
1085 }
1086 else if (strcmp (cs->c_name, ".ef") == 0)
1087 {
1088 if (!within_function)
1089 error (_("Bad coff function information."));
1090 /* The value of .ef is the address of epilogue code;
1091 not useful for gdb. */
1092 /* { main_aux.x_sym.x_misc.x_lnsz.x_lnno
1093 contains number of lines to '}' */
1094
1095 if (context_stack_depth <= 0)
1096 { /* We attempted to pop an empty context stack. */
1097 complaint (&symfile_complaints,
1098 _("`.ef' symbol without matching `.bf' "
1099 "symbol ignored starting at symnum %d"),
1100 cs->c_symnum);
1101 within_function = 0;
1102 break;
1103 }
1104
1105 newobj = pop_context ();
1106 /* Stack must be empty now. */
1107 if (context_stack_depth > 0 || newobj == NULL)
1108 {
1109 complaint (&symfile_complaints,
1110 _("Unmatched .ef symbol(s) ignored "
1111 "starting at symnum %d"),
1112 cs->c_symnum);
1113 within_function = 0;
1114 break;
1115 }
1116 if (cs->c_naux != 1)
1117 {
1118 complaint (&symfile_complaints,
1119 _("`.ef' symbol %d has no aux entry"),
1120 cs->c_symnum);
1121 fcn_last_line = 0x7FFFFFFF;
1122 }
1123 else
1124 {
1125 fcn_last_line = main_aux.x_sym.x_misc.x_lnsz.x_lnno;
1126 }
1127 /* fcn_first_line is the line number of the opening '{'.
1128 Do not record it - because it would affect gdb's idea
1129 of the line number of the first statement of the
1130 function - except for one-line functions, for which
1131 it is also the line number of all the statements and
1132 of the closing '}', and for which we do not have any
1133 other statement-line-number. */
1134 if (fcn_last_line == 1)
1135 record_line (current_subfile, fcn_first_line,
1136 gdbarch_addr_bits_remove (gdbarch,
1137 fcn_first_line_addr));
1138 else
1139 enter_linenos (fcn_line_ptr, fcn_first_line,
1140 fcn_last_line, objfile);
1141
1142 finish_block (newobj->name, &local_symbols, newobj->old_blocks,
1143 NULL, newobj->start_addr,
1144 fcn_cs_saved.c_value
1145 + fcn_aux_saved.x_sym.x_misc.x_fsize
1146 + ANOFFSET (objfile->section_offsets,
1147 SECT_OFF_TEXT (objfile)));
1148 within_function = 0;
1149 }
1150 break;
1151
1152 case C_BLOCK:
1153 if (strcmp (cs->c_name, ".bb") == 0)
1154 {
1155 tmpaddr = cs->c_value;
1156 tmpaddr += ANOFFSET (objfile->section_offsets,
1157 SECT_OFF_TEXT (objfile));
1158 push_context (++depth, tmpaddr);
1159 }
1160 else if (strcmp (cs->c_name, ".eb") == 0)
1161 {
1162 if (context_stack_depth <= 0)
1163 { /* We attempted to pop an empty context stack. */
1164 complaint (&symfile_complaints,
1165 _("`.eb' symbol without matching `.bb' "
1166 "symbol ignored starting at symnum %d"),
1167 cs->c_symnum);
1168 break;
1169 }
1170
1171 newobj = pop_context ();
1172 if (depth-- != newobj->depth)
1173 {
1174 complaint (&symfile_complaints,
1175 _("Mismatched .eb symbol ignored "
1176 "starting at symnum %d"),
1177 symnum);
1178 break;
1179 }
1180 if (local_symbols && context_stack_depth > 0)
1181 {
1182 tmpaddr =
1183 cs->c_value + ANOFFSET (objfile->section_offsets,
1184 SECT_OFF_TEXT (objfile));
1185 /* Make a block for the local symbols within. */
1186 finish_block (0, &local_symbols, newobj->old_blocks, NULL,
1187 newobj->start_addr, tmpaddr);
1188 }
1189 /* Now pop locals of block just finished. */
1190 local_symbols = newobj->locals;
1191 }
1192 break;
1193
1194 default:
1195 process_coff_symbol (cs, &main_aux, objfile);
1196 break;
1197 }
1198 }
1199
1200 if ((nsyms == 0) && (pe_file))
1201 {
1202 /* We've got no debugging symbols, but it's a portable
1203 executable, so try to read the export table. */
1204 read_pe_exported_syms (reader, objfile);
1205 }
1206
1207 if (get_last_source_file ())
1208 coff_end_symtab (objfile);
1209
1210 /* Patch up any opaque types (references to types that are not defined
1211 in the file where they are referenced, e.g. "struct foo *bar"). */
1212 {
1213 struct compunit_symtab *cu;
1214 struct symtab *s;
1215
1216 ALL_OBJFILE_FILETABS (objfile, cu, s)
1217 patch_opaque_types (s);
1218 }
1219
1220 coffread_objfile = NULL;
1221 }
1222
1223 /* Routines for reading headers and symbols from executable. */
1224
1225 /* Read the next symbol, swap it, and return it in both
1226 internal_syment form, and coff_symbol form. Also return its first
1227 auxent, if any, in internal_auxent form, and skip any other
1228 auxents. */
1229
1230 static void
1231 read_one_sym (struct coff_symbol *cs,
1232 struct internal_syment *sym,
1233 union internal_auxent *aux)
1234 {
1235 int i;
1236 bfd_size_type bytes;
1237
1238 cs->c_symnum = symnum;
1239 bytes = bfd_bread (temp_sym, local_symesz, nlist_bfd_global);
1240 if (bytes != local_symesz)
1241 error (_("%s: error reading symbols"), objfile_name (coffread_objfile));
1242 bfd_coff_swap_sym_in (symfile_bfd, temp_sym, (char *) sym);
1243 cs->c_naux = sym->n_numaux & 0xff;
1244 if (cs->c_naux >= 1)
1245 {
1246 bytes = bfd_bread (temp_aux, local_auxesz, nlist_bfd_global);
1247 if (bytes != local_auxesz)
1248 error (_("%s: error reading symbols"), objfile_name (coffread_objfile));
1249 bfd_coff_swap_aux_in (symfile_bfd, temp_aux,
1250 sym->n_type, sym->n_sclass,
1251 0, cs->c_naux, (char *) aux);
1252 /* If more than one aux entry, read past it (only the first aux
1253 is important). */
1254 for (i = 1; i < cs->c_naux; i++)
1255 {
1256 bytes = bfd_bread (temp_aux, local_auxesz, nlist_bfd_global);
1257 if (bytes != local_auxesz)
1258 error (_("%s: error reading symbols"),
1259 objfile_name (coffread_objfile));
1260 }
1261 }
1262 cs->c_name = getsymname (sym);
1263 cs->c_value = sym->n_value;
1264 cs->c_sclass = (sym->n_sclass & 0xff);
1265 cs->c_secnum = sym->n_scnum;
1266 cs->c_type = (unsigned) sym->n_type;
1267 if (!SDB_TYPE (cs->c_type))
1268 cs->c_type = 0;
1269
1270 #if 0
1271 if (cs->c_sclass & 128)
1272 printf (_("thumb symbol %s, class 0x%x\n"), cs->c_name, cs->c_sclass);
1273 #endif
1274
1275 symnum += 1 + cs->c_naux;
1276
1277 /* The PE file format stores symbol values as offsets within the
1278 section, rather than as absolute addresses. We correct that
1279 here, if the symbol has an appropriate storage class. FIXME: We
1280 should use BFD to read the symbols, rather than duplicating the
1281 work here. */
1282 if (pe_file)
1283 {
1284 switch (cs->c_sclass)
1285 {
1286 case C_EXT:
1287 case C_THUMBEXT:
1288 case C_THUMBEXTFUNC:
1289 case C_SECTION:
1290 case C_NT_WEAK:
1291 case C_STAT:
1292 case C_THUMBSTAT:
1293 case C_THUMBSTATFUNC:
1294 case C_LABEL:
1295 case C_THUMBLABEL:
1296 case C_BLOCK:
1297 case C_FCN:
1298 case C_EFCN:
1299 if (cs->c_secnum != 0)
1300 cs->c_value += cs_section_address (cs, symfile_bfd);
1301 break;
1302 }
1303 }
1304 }
1305
1306 /* Support for string table handling. */
1307
1308 static char *stringtab = NULL;
1309
1310 static int
1311 init_stringtab (bfd *abfd, long offset)
1312 {
1313 long length;
1314 int val;
1315 unsigned char lengthbuf[4];
1316
1317 free_stringtab ();
1318
1319 /* If the file is stripped, the offset might be zero, indicating no
1320 string table. Just return with `stringtab' set to null. */
1321 if (offset == 0)
1322 return 0;
1323
1324 if (bfd_seek (abfd, offset, 0) < 0)
1325 return -1;
1326
1327 val = bfd_bread ((char *) lengthbuf, sizeof lengthbuf, abfd);
1328 length = bfd_h_get_32 (symfile_bfd, lengthbuf);
1329
1330 /* If no string table is needed, then the file may end immediately
1331 after the symbols. Just return with `stringtab' set to null. */
1332 if (val != sizeof lengthbuf || length < sizeof lengthbuf)
1333 return 0;
1334
1335 stringtab = (char *) xmalloc (length);
1336 /* This is in target format (probably not very useful, and not
1337 currently used), not host format. */
1338 memcpy (stringtab, lengthbuf, sizeof lengthbuf);
1339 if (length == sizeof length) /* Empty table -- just the count. */
1340 return 0;
1341
1342 val = bfd_bread (stringtab + sizeof lengthbuf,
1343 length - sizeof lengthbuf, abfd);
1344 if (val != length - sizeof lengthbuf || stringtab[length - 1] != '\0')
1345 return -1;
1346
1347 return 0;
1348 }
1349
1350 static void
1351 free_stringtab (void)
1352 {
1353 if (stringtab)
1354 xfree (stringtab);
1355 stringtab = NULL;
1356 }
1357
1358 static void
1359 free_stringtab_cleanup (void *ignore)
1360 {
1361 free_stringtab ();
1362 }
1363
1364 static char *
1365 getsymname (struct internal_syment *symbol_entry)
1366 {
1367 static char buffer[SYMNMLEN + 1];
1368 char *result;
1369
1370 if (symbol_entry->_n._n_n._n_zeroes == 0)
1371 {
1372 /* FIXME: Probably should be detecting corrupt symbol files by
1373 seeing whether offset points to within the stringtab. */
1374 result = stringtab + symbol_entry->_n._n_n._n_offset;
1375 }
1376 else
1377 {
1378 strncpy (buffer, symbol_entry->_n._n_name, SYMNMLEN);
1379 buffer[SYMNMLEN] = '\0';
1380 result = buffer;
1381 }
1382 return result;
1383 }
1384
1385 /* Extract the file name from the aux entry of a C_FILE symbol.
1386 Return only the last component of the name. Result is in static
1387 storage and is only good for temporary use. */
1388
1389 static const char *
1390 coff_getfilename (union internal_auxent *aux_entry)
1391 {
1392 static char buffer[BUFSIZ];
1393 const char *result;
1394
1395 if (aux_entry->x_file.x_n.x_zeroes == 0)
1396 {
1397 if (strlen (stringtab + aux_entry->x_file.x_n.x_offset) >= BUFSIZ)
1398 internal_error (__FILE__, __LINE__, _("coff file name too long"));
1399 strcpy (buffer, stringtab + aux_entry->x_file.x_n.x_offset);
1400 }
1401 else
1402 {
1403 strncpy (buffer, aux_entry->x_file.x_fname, FILNMLEN);
1404 buffer[FILNMLEN] = '\0';
1405 }
1406 result = buffer;
1407
1408 /* FIXME: We should not be throwing away the information about what
1409 directory. It should go into dirname of the symtab, or some such
1410 place. */
1411 result = lbasename (result);
1412 return (result);
1413 }
1414
1415 /* Support for line number handling. */
1416
1417 static char *linetab = NULL;
1418 static long linetab_offset;
1419 static unsigned long linetab_size;
1420
1421 /* Read in all the line numbers for fast lookups later. Leave them in
1422 external (unswapped) format in memory; we'll swap them as we enter
1423 them into GDB's data structures. */
1424
1425 static int
1426 init_lineno (bfd *abfd, long offset, int size)
1427 {
1428 int val;
1429
1430 linetab_offset = offset;
1431 linetab_size = size;
1432
1433 free_linetab ();
1434
1435 if (size == 0)
1436 return 0;
1437
1438 if (bfd_seek (abfd, offset, 0) < 0)
1439 return -1;
1440
1441 /* Allocate the desired table, plus a sentinel. */
1442 linetab = (char *) xmalloc (size + local_linesz);
1443
1444 val = bfd_bread (linetab, size, abfd);
1445 if (val != size)
1446 return -1;
1447
1448 /* Terminate it with an all-zero sentinel record. */
1449 memset (linetab + size, 0, local_linesz);
1450
1451 return 0;
1452 }
1453
1454 static void
1455 free_linetab (void)
1456 {
1457 if (linetab)
1458 xfree (linetab);
1459 linetab = NULL;
1460 }
1461
1462 static void
1463 free_linetab_cleanup (void *ignore)
1464 {
1465 free_linetab ();
1466 }
1467
1468 #if !defined (L_LNNO32)
1469 #define L_LNNO32(lp) ((lp)->l_lnno)
1470 #endif
1471
1472 static void
1473 enter_linenos (long file_offset, int first_line,
1474 int last_line, struct objfile *objfile)
1475 {
1476 struct gdbarch *gdbarch = get_objfile_arch (objfile);
1477 char *rawptr;
1478 struct internal_lineno lptr;
1479
1480 if (!linetab)
1481 return;
1482 if (file_offset < linetab_offset)
1483 {
1484 complaint (&symfile_complaints,
1485 _("Line number pointer %ld lower than start of line numbers"),
1486 file_offset);
1487 if (file_offset > linetab_size) /* Too big to be an offset? */
1488 return;
1489 file_offset += linetab_offset; /* Try reading at that linetab
1490 offset. */
1491 }
1492
1493 rawptr = &linetab[file_offset - linetab_offset];
1494
1495 /* Skip first line entry for each function. */
1496 rawptr += local_linesz;
1497 /* Line numbers start at one for the first line of the function. */
1498 first_line--;
1499
1500 /* If the line number table is full (e.g. 64K lines in COFF debug
1501 info), the next function's L_LNNO32 might not be zero, so don't
1502 overstep the table's end in any case. */
1503 while (rawptr <= &linetab[0] + linetab_size)
1504 {
1505 bfd_coff_swap_lineno_in (symfile_bfd, rawptr, &lptr);
1506 rawptr += local_linesz;
1507 /* The next function, or the sentinel, will have L_LNNO32 zero;
1508 we exit. */
1509 if (L_LNNO32 (&lptr) && L_LNNO32 (&lptr) <= last_line)
1510 {
1511 CORE_ADDR addr = lptr.l_addr.l_paddr;
1512 addr += ANOFFSET (objfile->section_offsets,
1513 SECT_OFF_TEXT (objfile));
1514 record_line (current_subfile,
1515 first_line + L_LNNO32 (&lptr),
1516 gdbarch_addr_bits_remove (gdbarch, addr));
1517 }
1518 else
1519 break;
1520 }
1521 }
1522
1523 static void
1524 patch_type (struct type *type, struct type *real_type)
1525 {
1526 struct type *target = TYPE_TARGET_TYPE (type);
1527 struct type *real_target = TYPE_TARGET_TYPE (real_type);
1528 int field_size = TYPE_NFIELDS (real_target) * sizeof (struct field);
1529
1530 TYPE_LENGTH (target) = TYPE_LENGTH (real_target);
1531 TYPE_NFIELDS (target) = TYPE_NFIELDS (real_target);
1532 TYPE_FIELDS (target) = (struct field *) TYPE_ALLOC (target,
1533 field_size);
1534
1535 memcpy (TYPE_FIELDS (target),
1536 TYPE_FIELDS (real_target),
1537 field_size);
1538
1539 if (TYPE_NAME (real_target))
1540 {
1541 /* The previous copy of TYPE_NAME is allocated by
1542 process_coff_symbol. */
1543 if (TYPE_NAME (target))
1544 xfree ((char*) TYPE_NAME (target));
1545 TYPE_NAME (target) = xstrdup (TYPE_NAME (real_target));
1546 }
1547 }
1548
1549 /* Patch up all appropriate typedef symbols in the opaque_type_chains
1550 so that they can be used to print out opaque data structures
1551 properly. */
1552
1553 static void
1554 patch_opaque_types (struct symtab *s)
1555 {
1556 struct block *b;
1557 struct block_iterator iter;
1558 struct symbol *real_sym;
1559
1560 /* Go through the per-file symbols only. */
1561 b = BLOCKVECTOR_BLOCK (SYMTAB_BLOCKVECTOR (s), STATIC_BLOCK);
1562 ALL_BLOCK_SYMBOLS (b, iter, real_sym)
1563 {
1564 /* Find completed typedefs to use to fix opaque ones.
1565 Remove syms from the chain when their types are stored,
1566 but search the whole chain, as there may be several syms
1567 from different files with the same name. */
1568 if (SYMBOL_CLASS (real_sym) == LOC_TYPEDEF
1569 && SYMBOL_DOMAIN (real_sym) == VAR_DOMAIN
1570 && TYPE_CODE (SYMBOL_TYPE (real_sym)) == TYPE_CODE_PTR
1571 && TYPE_LENGTH (TYPE_TARGET_TYPE (SYMBOL_TYPE (real_sym))) != 0)
1572 {
1573 const char *name = SYMBOL_LINKAGE_NAME (real_sym);
1574 int hash = hashname (name);
1575 struct symbol *sym, *prev;
1576
1577 prev = 0;
1578 for (sym = opaque_type_chain[hash]; sym;)
1579 {
1580 if (name[0] == SYMBOL_LINKAGE_NAME (sym)[0]
1581 && strcmp (name + 1, SYMBOL_LINKAGE_NAME (sym) + 1) == 0)
1582 {
1583 if (prev)
1584 {
1585 SYMBOL_VALUE_CHAIN (prev) = SYMBOL_VALUE_CHAIN (sym);
1586 }
1587 else
1588 {
1589 opaque_type_chain[hash] = SYMBOL_VALUE_CHAIN (sym);
1590 }
1591
1592 patch_type (SYMBOL_TYPE (sym), SYMBOL_TYPE (real_sym));
1593
1594 if (prev)
1595 {
1596 sym = SYMBOL_VALUE_CHAIN (prev);
1597 }
1598 else
1599 {
1600 sym = opaque_type_chain[hash];
1601 }
1602 }
1603 else
1604 {
1605 prev = sym;
1606 sym = SYMBOL_VALUE_CHAIN (sym);
1607 }
1608 }
1609 }
1610 }
1611 }
1612
1613 static int
1614 coff_reg_to_regnum (struct symbol *sym, struct gdbarch *gdbarch)
1615 {
1616 return gdbarch_sdb_reg_to_regnum (gdbarch, SYMBOL_VALUE (sym));
1617 }
1618
1619 static const struct symbol_register_ops coff_register_funcs = {
1620 coff_reg_to_regnum
1621 };
1622
1623 /* The "aclass" index for computed COFF symbols. */
1624
1625 static int coff_register_index;
1626
1627 static struct symbol *
1628 process_coff_symbol (struct coff_symbol *cs,
1629 union internal_auxent *aux,
1630 struct objfile *objfile)
1631 {
1632 struct symbol *sym = allocate_symbol (objfile);
1633 char *name;
1634
1635 name = cs->c_name;
1636 name = EXTERNAL_NAME (name, objfile->obfd);
1637 SYMBOL_SET_LANGUAGE (sym, current_subfile->language,
1638 &objfile->objfile_obstack);
1639 SYMBOL_SET_NAMES (sym, name, strlen (name), 1, objfile);
1640
1641 /* default assumptions */
1642 SYMBOL_VALUE (sym) = cs->c_value;
1643 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
1644 SYMBOL_SECTION (sym) = cs_to_section (cs, objfile);
1645
1646 if (ISFCN (cs->c_type))
1647 {
1648 SYMBOL_VALUE (sym) += ANOFFSET (objfile->section_offsets,
1649 SECT_OFF_TEXT (objfile));
1650 SYMBOL_TYPE (sym) =
1651 lookup_function_type (decode_function_type (cs, cs->c_type,
1652 aux, objfile));
1653
1654 SYMBOL_ACLASS_INDEX (sym) = LOC_BLOCK;
1655 if (cs->c_sclass == C_STAT || cs->c_sclass == C_THUMBSTAT
1656 || cs->c_sclass == C_THUMBSTATFUNC)
1657 add_symbol_to_list (sym, &file_symbols);
1658 else if (cs->c_sclass == C_EXT || cs->c_sclass == C_THUMBEXT
1659 || cs->c_sclass == C_THUMBEXTFUNC)
1660 add_symbol_to_list (sym, &global_symbols);
1661 }
1662 else
1663 {
1664 SYMBOL_TYPE (sym) = decode_type (cs, cs->c_type, aux, objfile);
1665 switch (cs->c_sclass)
1666 {
1667 case C_NULL:
1668 break;
1669
1670 case C_AUTO:
1671 SYMBOL_ACLASS_INDEX (sym) = LOC_LOCAL;
1672 add_symbol_to_list (sym, &local_symbols);
1673 break;
1674
1675 case C_THUMBEXT:
1676 case C_THUMBEXTFUNC:
1677 case C_EXT:
1678 SYMBOL_ACLASS_INDEX (sym) = LOC_STATIC;
1679 SYMBOL_VALUE_ADDRESS (sym) = (CORE_ADDR) cs->c_value;
1680 SYMBOL_VALUE_ADDRESS (sym) += ANOFFSET (objfile->section_offsets,
1681 SECT_OFF_TEXT (objfile));
1682 add_symbol_to_list (sym, &global_symbols);
1683 break;
1684
1685 case C_THUMBSTAT:
1686 case C_THUMBSTATFUNC:
1687 case C_STAT:
1688 SYMBOL_ACLASS_INDEX (sym) = LOC_STATIC;
1689 SYMBOL_VALUE_ADDRESS (sym) = (CORE_ADDR) cs->c_value;
1690 SYMBOL_VALUE_ADDRESS (sym) += ANOFFSET (objfile->section_offsets,
1691 SECT_OFF_TEXT (objfile));
1692 if (within_function)
1693 {
1694 /* Static symbol of local scope. */
1695 add_symbol_to_list (sym, &local_symbols);
1696 }
1697 else
1698 {
1699 /* Static symbol at top level of file. */
1700 add_symbol_to_list (sym, &file_symbols);
1701 }
1702 break;
1703
1704 #ifdef C_GLBLREG /* AMD coff */
1705 case C_GLBLREG:
1706 #endif
1707 case C_REG:
1708 SYMBOL_ACLASS_INDEX (sym) = coff_register_index;
1709 SYMBOL_VALUE (sym) = cs->c_value;
1710 add_symbol_to_list (sym, &local_symbols);
1711 break;
1712
1713 case C_THUMBLABEL:
1714 case C_LABEL:
1715 break;
1716
1717 case C_ARG:
1718 SYMBOL_ACLASS_INDEX (sym) = LOC_ARG;
1719 SYMBOL_IS_ARGUMENT (sym) = 1;
1720 add_symbol_to_list (sym, &local_symbols);
1721 break;
1722
1723 case C_REGPARM:
1724 SYMBOL_ACLASS_INDEX (sym) = coff_register_index;
1725 SYMBOL_IS_ARGUMENT (sym) = 1;
1726 SYMBOL_VALUE (sym) = cs->c_value;
1727 add_symbol_to_list (sym, &local_symbols);
1728 break;
1729
1730 case C_TPDEF:
1731 SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
1732 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
1733
1734 /* If type has no name, give it one. */
1735 if (TYPE_NAME (SYMBOL_TYPE (sym)) == 0)
1736 {
1737 if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_PTR
1738 || TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_FUNC)
1739 {
1740 /* If we are giving a name to a type such as
1741 "pointer to foo" or "function returning foo", we
1742 better not set the TYPE_NAME. If the program
1743 contains "typedef char *caddr_t;", we don't want
1744 all variables of type char * to print as caddr_t.
1745 This is not just a consequence of GDB's type
1746 management; CC and GCC (at least through version
1747 2.4) both output variables of either type char *
1748 or caddr_t with the type refering to the C_TPDEF
1749 symbol for caddr_t. If a future compiler cleans
1750 this up it GDB is not ready for it yet, but if it
1751 becomes ready we somehow need to disable this
1752 check (without breaking the PCC/GCC2.4 case).
1753
1754 Sigh.
1755
1756 Fortunately, this check seems not to be necessary
1757 for anything except pointers or functions. */
1758 ;
1759 }
1760 else
1761 TYPE_NAME (SYMBOL_TYPE (sym)) =
1762 xstrdup (SYMBOL_LINKAGE_NAME (sym));
1763 }
1764
1765 /* Keep track of any type which points to empty structured
1766 type, so it can be filled from a definition from another
1767 file. A simple forward reference (TYPE_CODE_UNDEF) is
1768 not an empty structured type, though; the forward
1769 references work themselves out via the magic of
1770 coff_lookup_type. */
1771 if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_PTR
1772 && TYPE_LENGTH (TYPE_TARGET_TYPE (SYMBOL_TYPE (sym))) == 0
1773 && TYPE_CODE (TYPE_TARGET_TYPE (SYMBOL_TYPE (sym)))
1774 != TYPE_CODE_UNDEF)
1775 {
1776 int i = hashname (SYMBOL_LINKAGE_NAME (sym));
1777
1778 SYMBOL_VALUE_CHAIN (sym) = opaque_type_chain[i];
1779 opaque_type_chain[i] = sym;
1780 }
1781 add_symbol_to_list (sym, &file_symbols);
1782 break;
1783
1784 case C_STRTAG:
1785 case C_UNTAG:
1786 case C_ENTAG:
1787 SYMBOL_ACLASS_INDEX (sym) = LOC_TYPEDEF;
1788 SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN;
1789
1790 /* Some compilers try to be helpful by inventing "fake"
1791 names for anonymous enums, structures, and unions, like
1792 "~0fake" or ".0fake". Thanks, but no thanks... */
1793 if (TYPE_TAG_NAME (SYMBOL_TYPE (sym)) == 0)
1794 if (SYMBOL_LINKAGE_NAME (sym) != NULL
1795 && *SYMBOL_LINKAGE_NAME (sym) != '~'
1796 && *SYMBOL_LINKAGE_NAME (sym) != '.')
1797 TYPE_TAG_NAME (SYMBOL_TYPE (sym)) =
1798 concat (SYMBOL_LINKAGE_NAME (sym), (char *)NULL);
1799
1800 add_symbol_to_list (sym, &file_symbols);
1801 break;
1802
1803 default:
1804 break;
1805 }
1806 }
1807 return sym;
1808 }
1809
1810 /* Decode a coff type specifier; return the type that is meant. */
1811
1812 static struct type *
1813 decode_type (struct coff_symbol *cs, unsigned int c_type,
1814 union internal_auxent *aux, struct objfile *objfile)
1815 {
1816 struct type *type = 0;
1817 unsigned int new_c_type;
1818
1819 if (c_type & ~N_BTMASK)
1820 {
1821 new_c_type = DECREF (c_type);
1822 if (ISPTR (c_type))
1823 {
1824 type = decode_type (cs, new_c_type, aux, objfile);
1825 type = lookup_pointer_type (type);
1826 }
1827 else if (ISFCN (c_type))
1828 {
1829 type = decode_type (cs, new_c_type, aux, objfile);
1830 type = lookup_function_type (type);
1831 }
1832 else if (ISARY (c_type))
1833 {
1834 int i, n;
1835 unsigned short *dim;
1836 struct type *base_type, *index_type, *range_type;
1837
1838 /* Define an array type. */
1839 /* auxent refers to array, not base type. */
1840 if (aux->x_sym.x_tagndx.l == 0)
1841 cs->c_naux = 0;
1842
1843 /* Shift the indices down. */
1844 dim = &aux->x_sym.x_fcnary.x_ary.x_dimen[0];
1845 i = 1;
1846 n = dim[0];
1847 for (i = 0; *dim && i < DIMNUM - 1; i++, dim++)
1848 *dim = *(dim + 1);
1849 *dim = 0;
1850
1851 base_type = decode_type (cs, new_c_type, aux, objfile);
1852 index_type = objfile_type (objfile)->builtin_int;
1853 range_type
1854 = create_static_range_type ((struct type *) NULL,
1855 index_type, 0, n - 1);
1856 type =
1857 create_array_type ((struct type *) NULL,
1858 base_type, range_type);
1859 }
1860 return type;
1861 }
1862
1863 /* Reference to existing type. This only occurs with the struct,
1864 union, and enum types. EPI a29k coff fakes us out by producing
1865 aux entries with a nonzero x_tagndx for definitions of structs,
1866 unions, and enums, so we have to check the c_sclass field. SCO
1867 3.2v4 cc gets confused with pointers to pointers to defined
1868 structs, and generates negative x_tagndx fields. */
1869 if (cs->c_naux > 0 && aux->x_sym.x_tagndx.l != 0)
1870 {
1871 if (cs->c_sclass != C_STRTAG
1872 && cs->c_sclass != C_UNTAG
1873 && cs->c_sclass != C_ENTAG
1874 && aux->x_sym.x_tagndx.l >= 0)
1875 {
1876 type = coff_alloc_type (aux->x_sym.x_tagndx.l);
1877 return type;
1878 }
1879 else
1880 {
1881 complaint (&symfile_complaints,
1882 _("Symbol table entry for %s has bad tagndx value"),
1883 cs->c_name);
1884 /* And fall through to decode_base_type... */
1885 }
1886 }
1887
1888 return decode_base_type (cs, BTYPE (c_type), aux, objfile);
1889 }
1890
1891 /* Decode a coff type specifier for function definition;
1892 return the type that the function returns. */
1893
1894 static struct type *
1895 decode_function_type (struct coff_symbol *cs,
1896 unsigned int c_type,
1897 union internal_auxent *aux,
1898 struct objfile *objfile)
1899 {
1900 if (aux->x_sym.x_tagndx.l == 0)
1901 cs->c_naux = 0; /* auxent refers to function, not base
1902 type. */
1903
1904 return decode_type (cs, DECREF (c_type), aux, objfile);
1905 }
1906
1907 /* Basic C types. */
1908
1909 static struct type *
1910 decode_base_type (struct coff_symbol *cs,
1911 unsigned int c_type,
1912 union internal_auxent *aux,
1913 struct objfile *objfile)
1914 {
1915 struct gdbarch *gdbarch = get_objfile_arch (objfile);
1916 struct type *type;
1917
1918 switch (c_type)
1919 {
1920 case T_NULL:
1921 /* Shows up with "void (*foo)();" structure members. */
1922 return objfile_type (objfile)->builtin_void;
1923
1924 #ifdef T_VOID
1925 case T_VOID:
1926 /* Intel 960 COFF has this symbol and meaning. */
1927 return objfile_type (objfile)->builtin_void;
1928 #endif
1929
1930 case T_CHAR:
1931 return objfile_type (objfile)->builtin_char;
1932
1933 case T_SHORT:
1934 return objfile_type (objfile)->builtin_short;
1935
1936 case T_INT:
1937 return objfile_type (objfile)->builtin_int;
1938
1939 case T_LONG:
1940 if (cs->c_sclass == C_FIELD
1941 && aux->x_sym.x_misc.x_lnsz.x_size
1942 > gdbarch_long_bit (gdbarch))
1943 return objfile_type (objfile)->builtin_long_long;
1944 else
1945 return objfile_type (objfile)->builtin_long;
1946
1947 case T_FLOAT:
1948 return objfile_type (objfile)->builtin_float;
1949
1950 case T_DOUBLE:
1951 return objfile_type (objfile)->builtin_double;
1952
1953 case T_LNGDBL:
1954 return objfile_type (objfile)->builtin_long_double;
1955
1956 case T_STRUCT:
1957 if (cs->c_naux != 1)
1958 {
1959 /* Anonymous structure type. */
1960 type = coff_alloc_type (cs->c_symnum);
1961 TYPE_CODE (type) = TYPE_CODE_STRUCT;
1962 TYPE_NAME (type) = NULL;
1963 /* This used to set the tag to "<opaque>". But I think
1964 setting it to NULL is right, and the printing code can
1965 print it as "struct {...}". */
1966 TYPE_TAG_NAME (type) = NULL;
1967 INIT_CPLUS_SPECIFIC (type);
1968 TYPE_LENGTH (type) = 0;
1969 TYPE_FIELDS (type) = 0;
1970 TYPE_NFIELDS (type) = 0;
1971 }
1972 else
1973 {
1974 type = coff_read_struct_type (cs->c_symnum,
1975 aux->x_sym.x_misc.x_lnsz.x_size,
1976 aux->x_sym.x_fcnary.x_fcn.x_endndx.l,
1977 objfile);
1978 }
1979 return type;
1980
1981 case T_UNION:
1982 if (cs->c_naux != 1)
1983 {
1984 /* Anonymous union type. */
1985 type = coff_alloc_type (cs->c_symnum);
1986 TYPE_NAME (type) = NULL;
1987 /* This used to set the tag to "<opaque>". But I think
1988 setting it to NULL is right, and the printing code can
1989 print it as "union {...}". */
1990 TYPE_TAG_NAME (type) = NULL;
1991 INIT_CPLUS_SPECIFIC (type);
1992 TYPE_LENGTH (type) = 0;
1993 TYPE_FIELDS (type) = 0;
1994 TYPE_NFIELDS (type) = 0;
1995 }
1996 else
1997 {
1998 type = coff_read_struct_type (cs->c_symnum,
1999 aux->x_sym.x_misc.x_lnsz.x_size,
2000 aux->x_sym.x_fcnary.x_fcn.x_endndx.l,
2001 objfile);
2002 }
2003 TYPE_CODE (type) = TYPE_CODE_UNION;
2004 return type;
2005
2006 case T_ENUM:
2007 if (cs->c_naux != 1)
2008 {
2009 /* Anonymous enum type. */
2010 type = coff_alloc_type (cs->c_symnum);
2011 TYPE_CODE (type) = TYPE_CODE_ENUM;
2012 TYPE_NAME (type) = NULL;
2013 /* This used to set the tag to "<opaque>". But I think
2014 setting it to NULL is right, and the printing code can
2015 print it as "enum {...}". */
2016 TYPE_TAG_NAME (type) = NULL;
2017 TYPE_LENGTH (type) = 0;
2018 TYPE_FIELDS (type) = 0;
2019 TYPE_NFIELDS (type) = 0;
2020 }
2021 else
2022 {
2023 type = coff_read_enum_type (cs->c_symnum,
2024 aux->x_sym.x_misc.x_lnsz.x_size,
2025 aux->x_sym.x_fcnary.x_fcn.x_endndx.l,
2026 objfile);
2027 }
2028 return type;
2029
2030 case T_MOE:
2031 /* Shouldn't show up here. */
2032 break;
2033
2034 case T_UCHAR:
2035 return objfile_type (objfile)->builtin_unsigned_char;
2036
2037 case T_USHORT:
2038 return objfile_type (objfile)->builtin_unsigned_short;
2039
2040 case T_UINT:
2041 return objfile_type (objfile)->builtin_unsigned_int;
2042
2043 case T_ULONG:
2044 if (cs->c_sclass == C_FIELD
2045 && aux->x_sym.x_misc.x_lnsz.x_size
2046 > gdbarch_long_bit (gdbarch))
2047 return objfile_type (objfile)->builtin_unsigned_long_long;
2048 else
2049 return objfile_type (objfile)->builtin_unsigned_long;
2050 }
2051 complaint (&symfile_complaints,
2052 _("Unexpected type for symbol %s"), cs->c_name);
2053 return objfile_type (objfile)->builtin_void;
2054 }
2055
2056 /* This page contains subroutines of read_type. */
2057
2058 /* Read the description of a structure (or union type) and return an
2059 object describing the type. */
2060
2061 static struct type *
2062 coff_read_struct_type (int index, int length, int lastsym,
2063 struct objfile *objfile)
2064 {
2065 struct nextfield
2066 {
2067 struct nextfield *next;
2068 struct field field;
2069 };
2070
2071 struct type *type;
2072 struct nextfield *list = 0;
2073 struct nextfield *newobj;
2074 int nfields = 0;
2075 int n;
2076 char *name;
2077 struct coff_symbol member_sym;
2078 struct coff_symbol *ms = &member_sym;
2079 struct internal_syment sub_sym;
2080 union internal_auxent sub_aux;
2081 int done = 0;
2082
2083 type = coff_alloc_type (index);
2084 TYPE_CODE (type) = TYPE_CODE_STRUCT;
2085 INIT_CPLUS_SPECIFIC (type);
2086 TYPE_LENGTH (type) = length;
2087
2088 while (!done && symnum < lastsym && symnum < nlist_nsyms_global)
2089 {
2090 read_one_sym (ms, &sub_sym, &sub_aux);
2091 name = ms->c_name;
2092 name = EXTERNAL_NAME (name, objfile->obfd);
2093
2094 switch (ms->c_sclass)
2095 {
2096 case C_MOS:
2097 case C_MOU:
2098
2099 /* Get space to record the next field's data. */
2100 newobj = XALLOCA (struct nextfield);
2101 newobj->next = list;
2102 list = newobj;
2103
2104 /* Save the data. */
2105 list->field.name
2106 = (const char *) obstack_copy0 (&objfile->objfile_obstack,
2107 name, strlen (name));
2108 FIELD_TYPE (list->field) = decode_type (ms, ms->c_type,
2109 &sub_aux, objfile);
2110 SET_FIELD_BITPOS (list->field, 8 * ms->c_value);
2111 FIELD_BITSIZE (list->field) = 0;
2112 nfields++;
2113 break;
2114
2115 case C_FIELD:
2116
2117 /* Get space to record the next field's data. */
2118 newobj = XALLOCA (struct nextfield);
2119 newobj->next = list;
2120 list = newobj;
2121
2122 /* Save the data. */
2123 list->field.name
2124 = (const char *) obstack_copy0 (&objfile->objfile_obstack,
2125 name, strlen (name));
2126 FIELD_TYPE (list->field) = decode_type (ms, ms->c_type,
2127 &sub_aux, objfile);
2128 SET_FIELD_BITPOS (list->field, ms->c_value);
2129 FIELD_BITSIZE (list->field) = sub_aux.x_sym.x_misc.x_lnsz.x_size;
2130 nfields++;
2131 break;
2132
2133 case C_EOS:
2134 done = 1;
2135 break;
2136 }
2137 }
2138 /* Now create the vector of fields, and record how big it is. */
2139
2140 TYPE_NFIELDS (type) = nfields;
2141 TYPE_FIELDS (type) = (struct field *)
2142 TYPE_ALLOC (type, sizeof (struct field) * nfields);
2143
2144 /* Copy the saved-up fields into the field vector. */
2145
2146 for (n = nfields; list; list = list->next)
2147 TYPE_FIELD (type, --n) = list->field;
2148
2149 return type;
2150 }
2151
2152 /* Read a definition of an enumeration type,
2153 and create and return a suitable type object.
2154 Also defines the symbols that represent the values of the type. */
2155
2156 static struct type *
2157 coff_read_enum_type (int index, int length, int lastsym,
2158 struct objfile *objfile)
2159 {
2160 struct gdbarch *gdbarch = get_objfile_arch (objfile);
2161 struct symbol *sym;
2162 struct type *type;
2163 int nsyms = 0;
2164 int done = 0;
2165 struct pending **symlist;
2166 struct coff_symbol member_sym;
2167 struct coff_symbol *ms = &member_sym;
2168 struct internal_syment sub_sym;
2169 union internal_auxent sub_aux;
2170 struct pending *osyms, *syms;
2171 int o_nsyms;
2172 int n;
2173 char *name;
2174 int unsigned_enum = 1;
2175
2176 type = coff_alloc_type (index);
2177 if (within_function)
2178 symlist = &local_symbols;
2179 else
2180 symlist = &file_symbols;
2181 osyms = *symlist;
2182 o_nsyms = osyms ? osyms->nsyms : 0;
2183
2184 while (!done && symnum < lastsym && symnum < nlist_nsyms_global)
2185 {
2186 read_one_sym (ms, &sub_sym, &sub_aux);
2187 name = ms->c_name;
2188 name = EXTERNAL_NAME (name, objfile->obfd);
2189
2190 switch (ms->c_sclass)
2191 {
2192 case C_MOE:
2193 sym = allocate_symbol (objfile);
2194
2195 name = (char *) obstack_copy0 (&objfile->objfile_obstack, name,
2196 strlen (name));
2197 SYMBOL_SET_LINKAGE_NAME (sym, name);
2198 SYMBOL_ACLASS_INDEX (sym) = LOC_CONST;
2199 SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
2200 SYMBOL_VALUE (sym) = ms->c_value;
2201 add_symbol_to_list (sym, symlist);
2202 nsyms++;
2203 break;
2204
2205 case C_EOS:
2206 /* Sometimes the linker (on 386/ix 2.0.2 at least) screws
2207 up the count of how many symbols to read. So stop
2208 on .eos. */
2209 done = 1;
2210 break;
2211 }
2212 }
2213
2214 /* Now fill in the fields of the type-structure. */
2215
2216 if (length > 0)
2217 TYPE_LENGTH (type) = length;
2218 else /* Assume ints. */
2219 TYPE_LENGTH (type) = gdbarch_int_bit (gdbarch) / TARGET_CHAR_BIT;
2220 TYPE_CODE (type) = TYPE_CODE_ENUM;
2221 TYPE_NFIELDS (type) = nsyms;
2222 TYPE_FIELDS (type) = (struct field *)
2223 TYPE_ALLOC (type, sizeof (struct field) * nsyms);
2224
2225 /* Find the symbols for the values and put them into the type.
2226 The symbols can be found in the symlist that we put them on
2227 to cause them to be defined. osyms contains the old value
2228 of that symlist; everything up to there was defined by us. */
2229 /* Note that we preserve the order of the enum constants, so
2230 that in something like "enum {FOO, LAST_THING=FOO}" we print
2231 FOO, not LAST_THING. */
2232
2233 for (syms = *symlist, n = 0; syms; syms = syms->next)
2234 {
2235 int j = 0;
2236
2237 if (syms == osyms)
2238 j = o_nsyms;
2239 for (; j < syms->nsyms; j++, n++)
2240 {
2241 struct symbol *xsym = syms->symbol[j];
2242
2243 SYMBOL_TYPE (xsym) = type;
2244 TYPE_FIELD_NAME (type, n) = SYMBOL_LINKAGE_NAME (xsym);
2245 SET_FIELD_ENUMVAL (TYPE_FIELD (type, n), SYMBOL_VALUE (xsym));
2246 if (SYMBOL_VALUE (xsym) < 0)
2247 unsigned_enum = 0;
2248 TYPE_FIELD_BITSIZE (type, n) = 0;
2249 }
2250 if (syms == osyms)
2251 break;
2252 }
2253
2254 if (unsigned_enum)
2255 TYPE_UNSIGNED (type) = 1;
2256
2257 return type;
2258 }
2259
2260 /* Register our ability to parse symbols for coff BFD files. */
2261
2262 static const struct sym_fns coff_sym_fns =
2263 {
2264 coff_new_init, /* sym_new_init: init anything gbl to
2265 entire symtab */
2266 coff_symfile_init, /* sym_init: read initial info, setup
2267 for sym_read() */
2268 coff_symfile_read, /* sym_read: read a symbol file into
2269 symtab */
2270 NULL, /* sym_read_psymbols */
2271 coff_symfile_finish, /* sym_finish: finished with file,
2272 cleanup */
2273 default_symfile_offsets, /* sym_offsets: xlate external to
2274 internal form */
2275 default_symfile_segments, /* sym_segments: Get segment
2276 information from a file */
2277 NULL, /* sym_read_linetable */
2278
2279 default_symfile_relocate, /* sym_relocate: Relocate a debug
2280 section. */
2281 NULL, /* sym_probe_fns */
2282 &psym_functions
2283 };
2284
2285 /* Free the per-objfile COFF data. */
2286
2287 static void
2288 coff_free_info (struct objfile *objfile, void *arg)
2289 {
2290 xfree (arg);
2291 }
2292
2293 void
2294 _initialize_coffread (void)
2295 {
2296 add_symtab_fns (bfd_target_coff_flavour, &coff_sym_fns);
2297
2298 coff_objfile_data_key = register_objfile_data_with_cleanup (NULL,
2299 coff_free_info);
2300
2301 coff_register_index
2302 = register_symbol_register_impl (LOC_REGISTER, &coff_register_funcs);
2303 }
gdbarch
Definition: gdbarch.c:127
minimal_symbol_reader::install
void install()
Definition: minsyms.c:1346
type::length
unsigned int length
Definition: gdbtypes.h:803
coff_symbol::c_secnum
int c_secnum
Definition: coffread.c:141
objfile::flags
objfile_flags flags
Definition: objfiles.h:311
OBJF_READNEVER
Definition: objfile-flags.h:70
local_n_tmask
static unsigned local_n_tmask
Definition: coffread.c:105
gdb-stabs.h
gdb_obstack.h
dwarf2_has_info
int dwarf2_has_info(struct objfile *objfile, const struct dwarf2_debug_sections *names)
Definition: dwarf2read.c:2424
nextfield::field
struct field field
Definition: dwarf2read.c:1611
TYPE_CODE_ENUM
Definition: gdbtypes.h:108
SECT_OFF_TEXT
#define SECT_OFF_TEXT(objfile)
Definition: objfiles.h:686
objfile::obfd
bfd * obfd
Definition: objfiles.h:342
ALL_OBJFILE_FILETABS
#define ALL_OBJFILE_FILETABS(objfile, cu, s)
Definition: objfiles.h:594
finish_block
struct block * finish_block(struct symbol *symbol, struct pending **listhead, struct pending_block *old_blocks, const struct dynamic_prop *static_link, CORE_ADDR start, CORE_ADDR end)
Definition: buildsym.c:528
current_source_start_addr
static CORE_ADDR current_source_start_addr
Definition: coffread.c:81
create_static_range_type
struct type * create_static_range_type(struct type *result_type, struct type *index_type, LONGEST low_bound, LONGEST high_bound)
Definition: gdbtypes.c:945
decode_type
static struct type * decode_type(struct coff_symbol *, unsigned int, union internal_auxent *, struct objfile *)
Definition: coffread.c:1813
enter_linenos
static void enter_linenos(long, int, int, struct objfile *)
Definition: coffread.c:1473
dwarf2_build_frame_info
void dwarf2_build_frame_info(struct objfile *objfile)
Definition: dwarf2-frame.c:2193
MSYMBOL_LINKAGE_NAME
#define MSYMBOL_LINKAGE_NAME(symbol)
Definition: symtab.h:707
objfile_type::builtin_void
struct type * builtin_void
Definition: gdbtypes.h:1591
CORE_ADDR
bfd_vma CORE_ADDR
Definition: common-types.h:41
coff_symfile_info::textsize
unsigned int textsize
Definition: coffread.c:60
TYPE_FIELD_NAME
#define TYPE_FIELD_NAME(thistype, n)
Definition: gdbtypes.h:1372
mst_bss
Definition: symtab.h:587
free_stringtab_cleanup
static void free_stringtab_cleanup(void *ignore)
Definition: coffread.c:1359
find_separate_debug_file_by_buildid
char * find_separate_debug_file_by_buildid(struct objfile *objfile)
Definition: build-id.c:146
gdb_bfd_section_index
int gdb_bfd_section_index(bfd *abfd, asection *section)
Definition: gdb_bfd.c:888
coff_symfile_finish
static void coff_symfile_finish(struct objfile *objfile)
Definition: coffread.c:768
xfree
void xfree(void *)
hashname
int hashname(const char *name)
Definition: buildsym.c:1671
LOC_BLOCK
Definition: symtab.h:854
coffstab_build_psymtabs
void coffstab_build_psymtabs(struct objfile *objfile, CORE_ADDR textaddr, unsigned int textsize, struct stab_section_list *stabsects, file_ptr stabstroffset, unsigned int stabstrsize)
Definition: dbxread.c:3066
add_symbol_to_list
void add_symbol_to_list(struct symbol *symbol, struct pending **listhead)
Definition: buildsym.c:216
gdbarch_int_bit
int gdbarch_int_bit(struct gdbarch *gdbarch)
Definition: gdbarch.c:1579
if
if(!(yy_init))
Definition: ada-lex.c:1075
objfile_type::builtin_double
struct type * builtin_double
Definition: gdbtypes.h:1604
coff_symfile_info
Definition: coffread.c:54
create_array_type
struct type * create_array_type(struct type *result_type, struct type *element_type, struct type *range_type)
Definition: gdbtypes.c:1223
objfile_type::builtin_long_double
struct type * builtin_long_double
Definition: gdbtypes.h:1605
coff_start_symtab
static void coff_start_symtab(struct objfile *objfile, const char *name)
Definition: coffread.c:384
TYPE_NAME
#define TYPE_NAME(thistype)
Definition: gdbtypes.h:1224
coff_lookup_type
static struct type ** coff_lookup_type(int index)
Definition: coffread.c:339
INIT_CPLUS_SPECIFIC
#define INIT_CPLUS_SPECIFIC(type)
Definition: gdbtypes.h:1192
getsymname
static char * getsymname(struct internal_syment *)
Definition: coffread.c:1365
init_stringtab
static int init_stringtab(bfd *, long)
Definition: coffread.c:1311
_initialize_coffread
void _initialize_coffread(void)
Definition: coffread.c:2294
set_last_source_file
void set_last_source_file(const char *name)
Definition: buildsym.c:1727
coff_symfile_read
static void coff_symfile_read(struct objfile *objfile, symfile_add_flags symfile_flags)
Definition: coffread.c:562
SYMBOL_SET_LINKAGE_NAME
#define SYMBOL_SET_LINKAGE_NAME(symbol, linkage_name)
Definition: symtab.h:489
patch_opaque_types
static void patch_opaque_types(struct symtab *)
Definition: coffread.c:1554
objfile_type
const struct objfile_type * objfile_type(struct objfile *objfile)
Definition: gdbtypes.c:5363
end_symtab
struct compunit_symtab * end_symtab(CORE_ADDR end_addr, int section)
Definition: buildsym.c:1536
local_n_btmask
static unsigned local_n_btmask
Definition: coffread.c:103
SYMBOL_CLASS
#define SYMBOL_CLASS(symbol)
Definition: symtab.h:1155
memset
void * memset(T *s, int c, size_t n)=delete
internal_error
void internal_error(const char *file, int line, const char *fmt,...)
Definition: errors.c:50
add_symtab_fns
void add_symtab_fns(enum bfd_flavour flavour, const struct sym_fns *sf)
Definition: symfile.c:1790
file_symbols
EXTERN struct pending * file_symbols
Definition: buildsym.h:112
objfile_type::builtin_float
struct type * builtin_float
Definition: gdbtypes.h:1603
current_source_end_addr
static CORE_ADDR current_source_end_addr
Definition: coffread.c:82
default_symfile_segments
struct symfile_segment_data * default_symfile_segments(bfd *abfd)
Definition: symfile.c:785
psymtab.h
pending::symbol
struct symbol * symbol[PENDINGSIZE]
Definition: buildsym.h:105
gdbarch_long_bit
int gdbarch_long_bit(struct gdbarch *gdbarch)
Definition: gdbarch.c:1596
build-id.h
mst_abs
Definition: symtab.h:588
compunit_symtab
Definition: symtab.h:1380
TYPE_CODE_UNDEF
Definition: gdbtypes.h:83
symbol_register_ops
Definition: symtab.h:1010
symfile_bfd_open
gdb_bfd_ref_ptr symfile_bfd_open(const char *name)
Definition: symfile.c:1719
dwarf2_build_psymtabs
void dwarf2_build_psymtabs(struct objfile *objfile)
Definition: dwarf2read.c:6519
LOC_TYPEDEF
Definition: symtab.h:844
BLOCKVECTOR_BLOCK
#define BLOCKVECTOR_BLOCK(blocklist, n)
Definition: block.h:125
coff_read_enum_type
static struct type * coff_read_enum_type(int, int, int, struct objfile *)
Definition: coffread.c:2157
pe_file
static int pe_file
Definition: coffread.c:124
opaque_type_chain
static struct symbol * opaque_type_chain[HASHSIZE]
Definition: coffread.c:129
cleanup
Definition: cleanups.c:38
objfile_type::builtin_short
struct type * builtin_short
Definition: gdbtypes.h:1593
STRUCT_DOMAIN
Definition: symtab.h:745
_
#define _(String)
Definition: gdb_locale.h:35
coff_free_info
static void coff_free_info(struct objfile *objfile, void *arg)
Definition: coffread.c:2288
mst_file_data
Definition: symtab.h:601
objfile_type::builtin_long_long
struct type * builtin_long_long
Definition: gdbtypes.h:1596
context_stack_depth
EXTERN int context_stack_depth
Definition: buildsym.h:174
type_vector_length
static int type_vector_length
Definition: coffread.c:151
SET_FIELD_BITPOS
#define SET_FIELD_BITPOS(thisfld, bitpos)
Definition: gdbtypes.h:1352
defs.h
objfile_type::builtin_long
struct type * builtin_long
Definition: gdbtypes.h:1595
TYPE_FIELD
#define TYPE_FIELD(thistype, n)
Definition: gdbtypes.h:1370
LOC_ARG
Definition: symtab.h:823
decode_function_type
static struct type * decode_function_type(struct coff_symbol *, unsigned int, union internal_auxent *, struct objfile *)
Definition: coffread.c:1895
coff_getfilename
static const char * coff_getfilename(union internal_auxent *)
Definition: coffread.c:1390
LOC_LOCAL
Definition: symtab.h:839
objfiles.h
INITIAL_TYPE_VECTOR_LENGTH
#define INITIAL_TYPE_VECTOR_LENGTH
Definition: coffread.c:156
XNEW
#define XNEW(T)
Definition: poison.h:109
LOC_REGISTER
Definition: symtab.h:819
current_subfile
EXTERN struct subfile * current_subfile
Definition: buildsym.h:76
read_pe_exported_syms
void read_pe_exported_syms(minimal_symbol_reader &reader, struct objfile *objfile)
Definition: coff-pe-read.c:333
XCNEWVEC
#define XCNEWVEC(T, N)
Definition: poison.h:157
symtab.h
free_stringtab
static void free_stringtab(void)
Definition: coffread.c:1351
objfile_has_partial_symbols
int objfile_has_partial_symbols(struct objfile *objfile)
Definition: objfiles.c:979
name
const char *const name
Definition: aarch64-tdep.c:76
free_linetab
static void free_linetab(void)
Definition: coffread.c:1455
SYMTAB_BLOCKVECTOR
#define SYMTAB_BLOCKVECTOR(symtab)
Definition: symtab.h:1334
coff_symbol
Definition: coffread.c:133
default_symfile_relocate
bfd_byte * default_symfile_relocate(struct objfile *objfile, asection *sectp, bfd_byte *buf)
Definition: symfile.c:3625
OBJF_REORDERED
Definition: objfile-flags.h:36
stab_section_list::section
asection * section
Definition: stabsread.h:158
symnum
EXTERN unsigned int symnum
Definition: buildsym.h:93
SYMBOL_ACLASS_INDEX
#define SYMBOL_ACLASS_INDEX(symbol)
Definition: symtab.h:1154
gdb::ref_ptr
Definition: gdb_ref_ptr.h:49
SYMBOL_VALUE_ADDRESS
#define SYMBOL_VALUE_ADDRESS(symbol)
Definition: symtab.h:464
objfile_type::builtin_unsigned_long_long
struct type * builtin_unsigned_long_long
Definition: gdbtypes.h:1602
pending::nsyms
int nsyms
Definition: buildsym.h:104
SDB_TYPE
#define SDB_TYPE(type)
Definition: coffread.c:76
coff_locate_sections
static void coff_locate_sections(bfd *abfd, asection *sectp, void *csip)
Definition: coffread.c:222
dwarf2_free_objfile
void dwarf2_free_objfile(struct objfile *objfile)
Definition: dwarf2read.c:25113
gdbarch_addr_bits_remove
CORE_ADDR gdbarch_addr_bits_remove(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition: gdbarch.c:3208
SYMBOL_DOMAIN
#define SYMBOL_DOMAIN(symbol)
Definition: symtab.h:1152
global_symbols
EXTERN struct pending * global_symbols
Definition: buildsym.h:116
sym_fns
Definition: symfile.h:302
pending::next
struct pending * next
Definition: buildsym.h:103
context_stack::old_blocks
struct pending_block * old_blocks
Definition: buildsym.h:145
mst_data
Definition: symtab.h:586
local_linesz
static unsigned local_linesz
Definition: coffread.c:118
symfile_bfd
static bfd * symfile_bfd
Definition: coffread.c:557
N_BTMASK
#define N_BTMASK
Definition: coffread.c:108
stab_section_list::next
struct stab_section_list * next
Definition: stabsread.h:155
SYMBOL_SET_LANGUAGE
#define SYMBOL_SET_LANGUAGE(symbol, language, obstack)
Definition: symtab.h:478
linetab
static char * linetab
Definition: coffread.c:1417
buildsym.h
bound_minimal_symbol
Definition: minsyms.h:29
find_targ_sec_arg
Definition: coffread.c:273
objfile_type::builtin_char
struct type * builtin_char
Definition: gdbtypes.h:1592
coff_end_symtab
static void coff_end_symtab(struct objfile *objfile)
Definition: coffread.c:421
nlist_nsyms_global
static int nlist_nsyms_global
Definition: coffread.c:88
free_current_contents
void free_current_contents(void *ptr)
Definition: utils.c:199
local_n_tshift
static unsigned local_n_tshift
Definition: coffread.c:106
objfile_type::builtin_unsigned_long
struct type * builtin_unsigned_long
Definition: gdbtypes.h:1601
linetab_offset
static long linetab_offset
Definition: coffread.c:1418
make_cleanup
struct cleanup * make_cleanup(make_cleanup_ftype *function, void *arg)
Definition: cleanups.c:116
nextfield
Definition: dwarf2read.c:1606
ANOFFSET
#define ANOFFSET(secoff, whichone)
Definition: symtab.h:1276
TYPE_CODE_UNION
Definition: gdbtypes.h:107
get_objfile_arch
struct gdbarch * get_objfile_arch(const struct objfile *objfile)
Definition: objfiles.c:445
local_symbols
EXTERN struct pending * local_symbols
Definition: buildsym.h:120
TARGET_CHAR_BIT
#define TARGET_CHAR_BIT
Definition: host-defs.h:29
type
Definition: gdbtypes.h:749
pending
Definition: buildsym.h:101
find_targ_sec_arg::resultp
asection ** resultp
Definition: coffread.c:276
LOC_CONST
Definition: symtab.h:801
temp_sym
static char * temp_sym
Definition: coffread.c:94
pop_context
struct context_stack * pop_context(void)
Definition: buildsym.c:1660
L_LNNO32
#define L_LNNO32(lp)
Definition: coffread.c:1469
alloc_type
struct type * alloc_type(struct objfile *objfile)
Definition: gdbtypes.c:167
coff_symbol::c_sclass
int c_sclass
Definition: coffread.c:140
type
static const char * type
Definition: language.c:113
get_last_source_file
const char * get_last_source_file(void)
Definition: buildsym.c:1736
stringtab
static char * stringtab
Definition: coffread.c:1308
find_separate_debug_file_by_debuglink
char * find_separate_debug_file_by_debuglink(struct objfile *objfile)
Definition: symfile.c:1551
cs_to_bfd_section
static struct bfd_section * cs_to_bfd_section(struct coff_symbol *cs, struct objfile *objfile)
Definition: coffread.c:290
field
Definition: gdbtypes.h:517
SYMBOL_LINKAGE_NAME
#define SYMBOL_LINKAGE_NAME(symbol)
Definition: symtab.h:523
complaint
#define complaint(COMPLAINTS, FMT,...)
Definition: complaints.h:40
startswith
static int startswith(const char *string, const char *pattern)
Definition: common-utils.h:107
SET_FIELD_ENUMVAL
#define SET_FIELD_ENUMVAL(thisfld, enumval)
Definition: gdbtypes.h:1355
LOC_STATIC
Definition: symtab.h:805
coff_register_funcs
static const struct symbol_register_ops coff_register_funcs
Definition: coffread.c:1619
cs_section_address
static CORE_ADDR cs_section_address(struct coff_symbol *, bfd *)
Definition: coffread.c:317
breakpoint.h
TYPE_FIELDS
#define TYPE_FIELDS(thistype)
Definition: gdbtypes.h:1240
gdbarch_coff_make_msymbol_special
void gdbarch_coff_make_msymbol_special(struct gdbarch *gdbarch, int val, struct minimal_symbol *msym)
Definition: gdbarch.c:3398
symtab
Definition: symtab.h:1291
complete_symtab
static void complete_symtab(const char *name, CORE_ADDR start_addr, unsigned int size)
Definition: coffread.c:408
objfile_name
const char * objfile_name(const struct objfile *objfile)
Definition: objfiles.c:1557
FIELD_BITSIZE
#define FIELD_BITSIZE(thisfld)
Definition: gdbtypes.h:1368
xmalloc
void * xmalloc(YYSIZE_T)
TYPE_CODE_STRUCT
Definition: gdbtypes.h:106
process_coff_symbol
static struct symbol * process_coff_symbol(struct coff_symbol *, union internal_auxent *, struct objfile *)
Definition: coffread.c:1628
TYPE_FIELD_BITSIZE
#define TYPE_FIELD_BITSIZE(thistype, n)
Definition: gdbtypes.h:1380
complaints.h
coff_read_struct_type
static struct type * coff_read_struct_type(int, int, int, struct objfile *)
Definition: coffread.c:2062
language_minimal
Definition: defs.h:218
TYPE_CODE_FUNC
Definition: gdbtypes.h:110
objfile_type::builtin_unsigned_short
struct type * builtin_unsigned_short
Definition: gdbtypes.h:1599
coff_symfile_info::textaddr
CORE_ADDR textaddr
Definition: coffread.c:59
EXTERNAL_NAME
#define EXTERNAL_NAME(string, abfd)
Definition: coffread.c:67
coff_register_index
static int coff_register_index
Definition: coffread.c:1625
TYPE_UNSIGNED
#define TYPE_UNSIGNED(t)
Definition: gdbtypes.h:205
SYMBOL_VALUE
#define SYMBOL_VALUE(symbol)
Definition: symtab.h:463
linetab_size
static unsigned long linetab_size
Definition: coffread.c:1419
SYMBOL_VALUE_CHAIN
#define SYMBOL_VALUE_CHAIN(symbol)
Definition: symtab.h:468
block
Definition: block.h:60
coff_symfile_info::max_lineno_offset
file_ptr max_lineno_offset
Definition: coffread.c:57
objfile_type::builtin_int
struct type * builtin_int
Definition: gdbtypes.h:1594
hash
unsigned long hash(const void *addr, int length)
Definition: bcache.c:98
local_symesz
static unsigned local_symesz
Definition: coffread.c:119
context_stack
Definition: buildsym.h:133
xrealloc
PTR xrealloc(PTR ptr, size_t size)
Definition: common-utils.c:52
coff_symbol::c_naux
int c_naux
Definition: coffread.c:137
objfile
Definition: objfiles.h:286
find_linenos
static void find_linenos(bfd *abfd, struct bfd_section *asect, void *vpinfo)
Definition: coffread.c:526
TYPE_CODE_PTR
Definition: gdbtypes.h:84
fcn_cs_saved
static struct coff_symbol fcn_cs_saved
Definition: xcoffread.c:103
coff_symfile_info::stabstrdata
char * stabstrdata
Definition: coffread.c:63
coffread_objfile
static struct objfile * coffread_objfile
Definition: coffread.c:52
temp_aux
static char * temp_aux
Definition: coffread.c:95
SYMBOL_SET_NAMES
#define SYMBOL_SET_NAMES(symbol, linkage_name, len, copy_name, objfile)
Definition: symtab.h:494
nextfield::next
struct nextfield * next
Definition: dwarf2read.c:1608
coff_symfile_info::stabsects
struct stab_section_list * stabsects
Definition: coffread.c:61
MSYMBOL_TYPE
#define MSYMBOL_TYPE(msymbol)
Definition: symtab.h:680
read_one_sym
static void read_one_sym(struct coff_symbol *, struct internal_syment *, union internal_auxent *)
Definition: coffread.c:1231
TYPE_TARGET_TYPE
#define TYPE_TARGET_TYPE(thistype)
Definition: gdbtypes.h:1226
perror_with_name
void void void void void void void void void perror_with_name(const char *string) ATTRIBUTE_NORETURN
Definition: utils.c:692
context_stack::locals
struct pending * locals
Definition: buildsym.h:137
allocate_symbol
struct symbol * allocate_symbol(struct objfile *objfile)
Definition: symtab.c:5757
free_linetab_cleanup
static void free_linetab_cleanup(void *ignore)
Definition: coffread.c:1463
coff_objfile_data_key
static const struct objfile_data * coff_objfile_data_key
Definition: coffread.c:48
coff_symbol::c_name
char * c_name
Definition: coffread.c:135
XCNEW
#define XCNEW(T)
Definition: poison.h:121
minimal_symbol_reader::record_with_info
struct minimal_symbol * record_with_info(const char *name, CORE_ADDR address, enum minimal_symbol_type ms_type, int section)
Definition: minsyms.h:121
TYPE_CODE
#define TYPE_CODE(thistype)
Definition: gdbtypes.h:1238
stabsread.h
record_debugformat
void record_debugformat(const char *format)
Definition: buildsym.c:1678
symfile_complaints
struct complaints * symfile_complaints
Definition: complaints.c:96
bound_minimal_symbol::minsym
struct minimal_symbol * minsym
Definition: minsyms.h:34
field::name
const char * name
Definition: gdbtypes.h:550
coff_symfile_info::min_lineno_offset
file_ptr min_lineno_offset
Definition: coffread.c:56
patch_type
static void patch_type(struct type *type, struct type *real_type)
Definition: coffread.c:1524
psym_functions
const struct quick_symbol_functions psym_functions
Definition: psymtab.c:1541
nlist_bfd_global
static bfd * nlist_bfd_global
Definition: coffread.c:87
find_targ_sec
static void find_targ_sec(bfd *abfd, asection *sect, void *obj)
Definition: coffread.c:280
context_stack::depth
int depth
Definition: buildsym.h:166
mst_unknown
Definition: symtab.h:581
coff_sym_fns
static const struct sym_fns coff_sym_fns
Definition: coffread.c:2262
offset
int offset
Definition: agent.c:65
register_symbol_register_impl
int register_symbol_register_impl(enum address_class aclass, const struct symbol_register_ops *ops)
Definition: symtab.c:5707
TYPE_NFIELDS
#define TYPE_NFIELDS(thistype)
Definition: gdbtypes.h:1239
record_line
record_line_ftype record_line
buffer
Definition: buffer.h:23
context_stack::start_addr
CORE_ADDR start_addr
Definition: buildsym.h:158
last_source_start_addr
EXTERN CORE_ADDR last_source_start_addr
Definition: buildsym.h:56
mst_text
Definition: symtab.h:582
default_symfile_offsets
void default_symfile_offsets(struct objfile *objfile, const struct section_addr_info *addrs)
Definition: symfile.c:695
type_vector
static struct type ** type_vector
Definition: coffread.c:147
gdbarch_sdb_reg_to_regnum
int gdbarch_sdb_reg_to_regnum(struct gdbarch *gdbarch, int sdb_regnr)
Definition: gdbarch.c:2248
target.h
find_targ_sec_arg::targ_index
int targ_index
Definition: coffread.c:275
gdb::ref_ptr::get
T * get() const
Definition: gdb_ref_ptr.h:130
VAR_DOMAIN
Definition: symtab.h:739
mst_solib_trampoline
Definition: symtab.h:597
coff_symfile_init
static void coff_symfile_init(struct objfile *objfile)
Definition: coffread.c:502
block_iterator
Definition: block.h:197
TYPE_TAG_NAME
#define TYPE_TAG_NAME(type)
Definition: gdbtypes.h:1225
coff_new_init
static void coff_new_init(struct objfile *ignore)
Definition: coffread.c:757
HASHSIZE
#define HASHSIZE
Definition: buildsym.h:49
init_lineno
static int init_lineno(bfd *, long, int)
Definition: coffread.c:1426
ALL_OBJFILE_MSYMBOLS
#define ALL_OBJFILE_MSYMBOLS(objfile, m)
Definition: objfiles.h:605
coff_symbol::c_symnum
int c_symnum
Definition: coffread.c:136
gdbtypes.h
context_stack::name
struct symbol * name
Definition: buildsym.h:149
STATIC_BLOCK
Definition: defs.h:687
ignore
static int ignore(struct target_ops *ops, struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
Definition: corelow.c:879
objfile_type::builtin_unsigned_int
struct type * builtin_unsigned_int
Definition: gdbtypes.h:1600
dbx_symfile_info
Definition: gdb-stabs.h:37
TYPE_ALLOC
#define TYPE_ALLOC(t, size)
Definition: gdbtypes.h:1652
subfile::language
enum language language
Definition: buildsym.h:72
range_type
range_type
Definition: expression.h:161
SYMBOL_TYPE
#define SYMBOL_TYPE(symbol)
Definition: symtab.h:1161
dbx_objfile_data_key
const struct objfile_data * dbx_objfile_data_key
Definition: dbxread.c:64
symbol
Definition: symtab.h:1049
coff_alloc_type
static struct type * coff_alloc_type(int index)
Definition: coffread.c:363
push_context
struct context_stack * push_context(int desc, CORE_ADDR valu)
Definition: buildsym.c:1630
coff-pe-read.h
local_auxesz
static unsigned local_auxesz
Definition: coffread.c:120
TYPE_LENGTH
#define TYPE_LENGTH(thistype)
Definition: gdbtypes.h:1235
minimal_symbol
Definition: symtab.h:623
bound_minimal_symbol::objfile
struct objfile * objfile
Definition: minsyms.h:39
SYMBOL_SECTION
#define SYMBOL_SECTION(symbol)
Definition: symtab.h:470
objfile::section_offsets
struct section_offsets * section_offsets
Definition: objfiles.h:396
mst_file_bss
Definition: symtab.h:602
objfile::objfile_obstack
Definition: objfiles.h:357
minimal_symbol_type
minimal_symbol_type
Definition: symtab.h:579
language_unknown
Definition: defs.h:205
QUIT
#define QUIT
Definition: defs.h:179
minimal_symbol_reader
Definition: minsyms.h:62
record_minimal_symbol
static struct minimal_symbol * record_minimal_symbol(minimal_symbol_reader &reader, struct coff_symbol *cs, CORE_ADDR address, enum minimal_symbol_type type, int section, struct objfile *objfile)
Definition: coffread.c:465
start_symtab
struct compunit_symtab * start_symtab(struct objfile *objfile, const char *name, const char *comp_dir, CORE_ADDR start_addr, enum language language)
Definition: buildsym.c:1055
within_function
EXTERN int within_function
Definition: buildsym.h:186
lookup_minimal_symbol
struct bound_minimal_symbol lookup_minimal_symbol(const char *name, const char *sfile, struct objfile *objf)
Definition: minsyms.c:311
is_import_fixup_symbol
static int is_import_fixup_symbol(struct coff_symbol *cs, enum minimal_symbol_type type)
Definition: coffread.c:436
coff_reg_to_regnum
static int coff_reg_to_regnum(struct symbol *sym, struct gdbarch *gdbarch)
Definition: coffread.c:1614
error
void error(const char *fmt,...)
Definition: errors.c:38
size
size_t size
Definition: go32-nat.c:242
local_n_btshft
static unsigned local_n_btshft
Definition: coffread.c:104
cs_to_section
static int cs_to_section(struct coff_symbol *, struct objfile *)
Definition: coffread.c:303
lookup_pointer_type
struct type * lookup_pointer_type(struct type *type)
Definition: gdbtypes.c:381
ALL_BLOCK_SYMBOLS
#define ALL_BLOCK_SYMBOLS(block, iter, sym)
Definition: block.h:310
dictionary.h
decode_base_type
static struct type * decode_base_type(struct coff_symbol *, unsigned int, union internal_auxent *, struct objfile *)
Definition: coffread.c:1910
block.h
do_cleanups
void do_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:174
FIELD_TYPE
#define FIELD_TYPE(thisfld)
Definition: gdbtypes.h:1342
coff_symbol::c_type
unsigned int c_type
Definition: coffread.c:142
objfile_type::builtin_unsigned_char
struct type * builtin_unsigned_char
Definition: gdbtypes.h:1598
mst_file_text
Definition: symtab.h:600
coff_symbol::c_value
CORE_ADDR c_value
Definition: coffread.c:139
lookup_function_type
struct type * lookup_function_type(struct type *type)
Definition: gdbtypes.c:519
SYMBOL_IS_ARGUMENT
#define SYMBOL_IS_ARGUMENT(symbol)
Definition: symtab.h:1157
stab_section_list
Definition: stabsread.h:152
coff_symfile_info::stabstrsect
asection * stabstrsect
Definition: coffread.c:62
coff_symtab_read
static void coff_symtab_read(minimal_symbol_reader &, long, unsigned int, struct objfile *)
Definition: coffread.c:783
stabsread_clear_cache
void stabsread_clear_cache(void)
Definition: stabsread.c:521
symbol_file_add_separate
void symbol_file_add_separate(bfd *bfd, const char *name, symfile_add_flags symfile_flags, struct objfile *objfile)
Definition: symfile.c:1230