Bug Summary

File:src/gnu/usr.bin/binutils/gdb/coffread.c
Warning:line 1487, column 22
Assigned value is garbage or undefined

Annotated Source Code

Press '?' to see keyboard shortcuts

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