#include "stabsread.h"
#include "complaints.h"
+#include "gdb-stabs.h"
+
/* For interface with stabsread.c. */
#include "aout/stab_gnu.h"
static void
add_stab_to_list PARAMS ((char *, struct pending_stabs **));
+\f
+#ifdef STATIC_NODEBUG_VARS
+/* Return the section_offsets* that CS points to. */
+static int cs_to_section PARAMS ((struct coff_symbol *, struct objfile *));
+
+struct find_targ_sec_arg {
+ int targ_index;
+ int *resultp;
+};
+
+static void find_targ_sec PARAMS ((bfd *, asection *, void *));
+
+static void find_targ_sec (abfd, sect, obj)
+ bfd *abfd;
+ asection *sect;
+ PTR obj;
+{
+ struct find_targ_sec_arg *args = (struct find_targ_sec_arg *)obj;
+ if (sect->target_index == args->targ_index)
+ {
+ /* This is the section. Figure out what SECT_OFF_* code it is. */
+ if (bfd_get_section_flags (abfd, sect) & SEC_CODE)
+ *args->resultp = SECT_OFF_TEXT;
+ else if (bfd_get_section_flags (abfd, sect) & SEC_LOAD)
+ *args->resultp = SECT_OFF_DATA;
+ else
+ *args->resultp = SECT_OFF_BSS;
+ }
+}
+
+/* Return the section number (SECT_OFF_*) that CS points to. */
+static int
+cs_to_section (cs, objfile)
+ struct coff_symbol *cs;
+ struct objfile *objfile;
+{
+ int off = SECT_OFF_TEXT;
+ struct find_targ_sec_arg args;
+ args.targ_index = cs->c_secnum;
+ args.resultp = &off;
+ bfd_map_over_sections (objfile->obfd, find_targ_sec, &args);
+ return off;
+}
+#endif /* STATIC_NODEBUG_VARS */
+\f
/* add a given stab string into given stab vector. */
static void
#define RECORD_MINIMAL_SYMBOL(NAME, ADDR, TYPE, ALLOCED, SECTION, OBJFILE) \
{ \
char *namestr; \
- if (ALLOCED) \
- namestr = (NAME) + 1; \
- else { \
+ namestr = (NAME); \
+ if (namestr[0] == '.') ++namestr; \
+ if (!(ALLOCED)) { \
(NAME) = namestr = \
- obstack_copy0 (&objfile->symbol_obstack, (NAME) + 1, strlen ((NAME)+1)); \
+ obstack_copy0 (&objfile->symbol_obstack, namestr, strlen (namestr)); \
(ALLOCED) = 1; \
} \
prim_record_minimal_symbol_and_info (namestr, (ADDR), (TYPE), \
current_objfile = objfile;
- /* Get the appropriate COFF "constants" related to the file we're handling. */
+ /* Get the appropriate COFF "constants" related to the file we're
+ handling. */
N_TMASK = coff_data (abfd)->local_n_tmask;
N_BTSHFT = coff_data (abfd)->local_n_btshft;
local_symesz = coff_data (abfd)->local_symesz;
raw_symbol = symtbl;
textsec = bfd_get_section_by_name (abfd, ".text");
- if (!textsec) {
- printf_unfiltered ("Unable to locate text section!\n");
- }
+ if (!textsec)
+ {
+ printf_unfiltered ("Unable to locate text section!\n");
+ }
next_symbol_text_func = xcoff_next_symbol_text;
- while (symnum < nsyms) {
+ while (symnum < nsyms)
+ {
- QUIT; /* make this command interruptable. */
+ QUIT; /* make this command interruptable. */
- /* READ_ONE_SYMBOL (symbol, cs, symname_alloced); */
- /* read one symbol into `cs' structure. After processing the whole symbol
- table, only string table will be kept in memory, symbol table and debug
- section of xcoff will be freed. Thus we can mark symbols with names
- in string table as `alloced'. */
- {
- int ii;
-
- /* Swap and align the symbol into a reasonable C structure. */
- bfd_coff_swap_sym_in (abfd, raw_symbol, symbol);
-
- cs->c_symnum = symnum;
- cs->c_naux = symbol->n_numaux;
- if (symbol->n_zeroes) {
- symname_alloced = 0;
- /* We must use the original, unswapped, name here so the name field
- pointed to by cs->c_name will persist throughout xcoffread. If
- we use the new field, it gets overwritten for each symbol. */
- cs->c_name = ((struct external_syment *)raw_symbol)->e.e_name;
- /* If it's exactly E_SYMNMLEN characters long it isn't
- '\0'-terminated. */
- if (cs->c_name[E_SYMNMLEN - 1] != '\0')
+ /* READ_ONE_SYMBOL (symbol, cs, symname_alloced); */
+ /* read one symbol into `cs' structure. After processing the
+ whole symbol table, only string table will be kept in memory,
+ symbol table and debug section of xcoff will be freed. Thus
+ we can mark symbols with names in string table as
+ `alloced'. */
+ {
+ int ii;
+
+ /* Swap and align the symbol into a reasonable C structure. */
+ bfd_coff_swap_sym_in (abfd, raw_symbol, symbol);
+
+ cs->c_symnum = symnum;
+ cs->c_naux = symbol->n_numaux;
+ if (symbol->n_zeroes)
{
- char *p;
- p = obstack_alloc (&objfile->symbol_obstack, E_SYMNMLEN + 1);
- strncpy (p, cs->c_name, E_SYMNMLEN);
- p[E_SYMNMLEN] = '\0';
- cs->c_name = p;
+ symname_alloced = 0;
+ /* We must use the original, unswapped, name here so the name field
+ pointed to by cs->c_name will persist throughout xcoffread. If
+ we use the new field, it gets overwritten for each symbol. */
+ cs->c_name = ((struct external_syment *)raw_symbol)->e.e_name;
+ /* If it's exactly E_SYMNMLEN characters long it isn't
+ '\0'-terminated. */
+ if (cs->c_name[E_SYMNMLEN - 1] != '\0')
+ {
+ char *p;
+ p = obstack_alloc (&objfile->symbol_obstack, E_SYMNMLEN + 1);
+ strncpy (p, cs->c_name, E_SYMNMLEN);
+ p[E_SYMNMLEN] = '\0';
+ cs->c_name = p;
+ symname_alloced = 1;
+ }
+ }
+ else if (symbol->n_sclass & 0x80)
+ {
+ cs->c_name = debugsec + symbol->n_offset;
+ symname_alloced = 0;
+ }
+ else
+ {
+ /* in string table */
+ cs->c_name = strtbl + (int)symbol->n_offset;
symname_alloced = 1;
}
- } else if (symbol->n_sclass & 0x80) {
- cs->c_name = debugsec + symbol->n_offset;
- symname_alloced = 0;
- } else { /* in string table */
- cs->c_name = strtbl + (int)symbol->n_offset;
- symname_alloced = 1;
- }
- cs->c_value = symbol->n_value;
- cs->c_sclass = symbol->n_sclass;
- cs->c_secnum = symbol->n_scnum;
- cs->c_type = (unsigned)symbol->n_type;
+ cs->c_value = symbol->n_value;
+ cs->c_sclass = symbol->n_sclass;
+ cs->c_secnum = symbol->n_scnum;
+ cs->c_type = (unsigned)symbol->n_type;
- raw_symbol += coff_data (abfd)->local_symesz;
- ++symnum;
+ raw_symbol += coff_data (abfd)->local_symesz;
+ ++symnum;
- raw_auxptr = raw_symbol; /* Save addr of first aux entry */
+ /* Save addr of first aux entry. */
+ raw_auxptr = raw_symbol;
- /* Skip all the auxents associated with this symbol. */
- for (ii = symbol->n_numaux; ii; --ii ) {
- raw_symbol += coff_data (abfd)->local_auxesz;
- ++symnum;
+ /* Skip all the auxents associated with this symbol. */
+ for (ii = symbol->n_numaux; ii; --ii)
+ {
+ raw_symbol += coff_data (abfd)->local_auxesz;
+ ++symnum;
+ }
}
- }
- /* if symbol name starts with ".$" or "$", ignore it. */
- if (cs->c_name[0] == '$' || (cs->c_name[1] == '$' && cs->c_name[0] == '.'))
- continue;
+ /* if symbol name starts with ".$" or "$", ignore it. */
+ if (cs->c_name[0] == '$'
+ || (cs->c_name[1] == '$' && cs->c_name[0] == '.'))
+ continue;
- if (cs->c_symnum == next_file_symnum && cs->c_sclass != C_FILE) {
- if (last_source_file)
+ if (cs->c_symnum == next_file_symnum && cs->c_sclass != C_FILE)
{
- end_symtab (cur_src_end_addr, 1, 0, objfile, textsec->target_index);
- end_stabs ();
- }
-
- start_stabs ();
- start_symtab ("_globals_", (char *)NULL, (CORE_ADDR)0);
- cur_src_end_addr = first_object_file_end;
- /* done with all files, everything from here on is globals */
- }
+ if (last_source_file)
+ {
+ end_symtab (cur_src_end_addr, 1, 0, objfile,
+ textsec->target_index);
+ end_stabs ();
+ }
- /* if explicitly specified as a function, treat is as one. */
- if (ISFCN(cs->c_type) && cs->c_sclass != C_TPDEF) {
- bfd_coff_swap_aux_in (abfd, raw_auxptr, cs->c_type, cs->c_sclass,
- 0, cs->c_naux, &main_aux);
- goto function_entry_point;
- }
+ start_stabs ();
+ start_symtab ("_globals_", (char *)NULL, (CORE_ADDR)0);
+ cur_src_end_addr = first_object_file_end;
+ /* done with all files, everything from here on is globals */
+ }
- if ((cs->c_sclass == C_EXT || cs->c_sclass == C_HIDEXT) && cs->c_naux == 1)
- {
- /* dealing with a symbol with a csect entry. */
+ /* if explicitly specified as a function, treat is as one. */
+ if (ISFCN(cs->c_type) && cs->c_sclass != C_TPDEF)
+ {
+ bfd_coff_swap_aux_in (abfd, raw_auxptr, cs->c_type, cs->c_sclass,
+ 0, cs->c_naux, &main_aux);
+ goto function_entry_point;
+ }
-# define CSECT(PP) ((PP)->x_csect)
-# define CSECT_LEN(PP) (CSECT(PP).x_scnlen.l)
-# define CSECT_ALIGN(PP) (SMTYP_ALIGN(CSECT(PP).x_smtyp))
-# define CSECT_SMTYP(PP) (SMTYP_SMTYP(CSECT(PP).x_smtyp))
-# define CSECT_SCLAS(PP) (CSECT(PP).x_smclas)
+ if ((cs->c_sclass == C_EXT || cs->c_sclass == C_HIDEXT)
+ && cs->c_naux == 1)
+ {
+ /* Dealing with a symbol with a csect entry. */
- /* Convert the auxent to something we can access. */
- bfd_coff_swap_aux_in (abfd, raw_auxptr, cs->c_type, cs->c_sclass,
- 0, cs->c_naux, &main_aux);
+#define CSECT(PP) ((PP)->x_csect)
+#define CSECT_LEN(PP) (CSECT(PP).x_scnlen.l)
+#define CSECT_ALIGN(PP) (SMTYP_ALIGN(CSECT(PP).x_smtyp))
+#define CSECT_SMTYP(PP) (SMTYP_SMTYP(CSECT(PP).x_smtyp))
+#define CSECT_SCLAS(PP) (CSECT(PP).x_smclas)
- switch (CSECT_SMTYP (&main_aux)) {
+ /* Convert the auxent to something we can access. */
+ bfd_coff_swap_aux_in (abfd, raw_auxptr, cs->c_type, cs->c_sclass,
+ 0, cs->c_naux, &main_aux);
- case XTY_ER :
- continue; /* ignore all external references. */
+ switch (CSECT_SMTYP (&main_aux))
+ {
- case XTY_SD : /* a section description. */
- {
- switch (CSECT_SCLAS (&main_aux)) {
+ case XTY_ER:
+ /* Ignore all external references. */
+ continue;
- case XMC_PR : /* a `.text' csect. */
+ case XTY_SD:
+ /* A section description. */
{
+ switch (CSECT_SCLAS (&main_aux))
+ {
+
+ case XMC_PR:
+ {
+
+ /* A program csect is seen. We have to allocate one
+ symbol table for each program csect. Normally gdb
+ prefers one symtab for each source file. In case
+ of AIX, one source file might include more than one
+ [PR] csect, and they don't have to be adjacent in
+ terms of the space they occupy in memory. Thus, one
+ single source file might get fragmented in the
+ memory and gdb's file start and end address
+ approach does not work! GCC (and I think xlc) seem
+ to put all the code in the unnamed program csect. */
+
+ if (last_csect_name)
+ {
+
+ /* If no misc. function recorded in the last
+ seen csect, enter it as a function. This
+ will take care of functions like strcmp()
+ compiled by xlc. */
+
+ if (!misc_func_recorded)
+ {
+ int alloced = 0;
+ RECORD_MINIMAL_SYMBOL
+ (last_csect_name, last_csect_val,
+ mst_text, alloced, last_csect_sec,
+ objfile);
+ }
+
+ complete_symtab (filestring, file_start_addr);
+ cur_src_end_addr = file_end_addr;
+ end_symtab (file_end_addr, 1, 0, objfile,
+ textsec->target_index);
+ end_stabs ();
+ start_stabs ();
+ /* Give all csects for this source file the same
+ name. */
+ start_symtab (filestring, NULL, (CORE_ADDR)0);
+ }
+
+ /* If this is the very first csect seen,
+ basically `__start'. */
+ if (just_started)
+ {
+ first_object_file_end
+ = cs->c_value + CSECT_LEN (&main_aux);
+ just_started = 0;
+ }
+
+ file_start_addr = cs->c_value;
+ file_end_addr = cs->c_value + CSECT_LEN (&main_aux);
+
+ if (cs->c_name && cs->c_name[0] == '.')
+ {
+ last_csect_name = cs->c_name;
+ last_csect_val = cs->c_value;
+ last_csect_sec = cs->c_secnum;
+ }
+ }
+ misc_func_recorded = 0;
+ continue;
+
+ case XMC_RW :
+ break;
+
+ /* If the section is not a data description,
+ ignore it. Note that uninitialized data will
+ show up as XTY_CM/XMC_RW pair. */
+
+ case XMC_TC0:
+ if (toc_offset)
+ warning ("More than one xmc_tc0 symbol found.");
+ toc_offset = cs->c_value;
+ continue;
+
+ case XMC_TC:
+#ifdef STATIC_NODEBUG_VARS
+ /* We need to process these symbols if they are C_HIDEXT,
+ for static variables in files compiled without -g. */
+ if (cs->c_sclass == C_HIDEXT)
+ break;
+ else
+#endif
+ continue;
- /* A program csect is seen. We have to allocate one
- symbol table for each program csect. Normally gdb
- prefers one symtab for each source file. In case
- of AIX, one source file might include more than one
- [PR] csect, and they don't have to be adjacent in
- terms of the space they occupy in memory. Thus, one
- single source file might get fragmented in the
- memory and gdb's file start and end address
- approach does not work! GCC (and I think xlc) seem
- to put all the code in the unnamed program csect. */
-
- if (last_csect_name) {
-
- /* if no misc. function recorded in the last seen csect, enter
- it as a function. This will take care of functions like
- strcmp() compiled by xlc. */
-
- if (!misc_func_recorded) {
- int alloced = 0;
- RECORD_MINIMAL_SYMBOL (last_csect_name, last_csect_val,
- mst_text, alloced, last_csect_sec,
- objfile);
+ default:
+ /* Ignore the symbol. */
+ continue;
}
-
-
- complete_symtab (filestring, file_start_addr);
- cur_src_end_addr = file_end_addr;
- end_symtab (file_end_addr, 1, 0, objfile,
- textsec->target_index);
- end_stabs ();
- start_stabs ();
- /* Give all csects for this source file the same
- name. */
- start_symtab (filestring, (char *)NULL, (CORE_ADDR)0);
- }
-
- /* If this is the very first csect seen, basically `__start'. */
- if (just_started) {
- first_object_file_end = cs->c_value + CSECT_LEN (&main_aux);
- just_started = 0;
- }
-
- file_start_addr = cs->c_value;
- file_end_addr = cs->c_value + CSECT_LEN (&main_aux);
-
- if (cs->c_name && cs->c_name[0] == '.') {
- last_csect_name = cs->c_name;
- last_csect_val = cs->c_value;
- last_csect_sec = cs->c_secnum;
- }
}
- misc_func_recorded = 0;
- continue;
-
- case XMC_RW :
break;
- /* If the section is not a data description, ignore it. Note that
- uninitialized data will show up as XTY_CM/XMC_RW pair. */
-
- case XMC_TC0:
- if (toc_offset)
- warning ("More than one xmc_tc0 symbol found.");
- toc_offset = cs->c_value;
- continue;
+ case XTY_LD:
+
+ switch (CSECT_SCLAS (&main_aux))
+ {
+ case XMC_PR:
+ /* a function entry point. */
+ function_entry_point:
+ RECORD_MINIMAL_SYMBOL (cs->c_name, cs->c_value, mst_text,
+ symname_alloced, cs->c_secnum,
+ objfile);
+
+ fcn_line_offset = main_aux.x_sym.x_fcnary.x_fcn.x_lnnoptr;
+ fcn_start_addr = cs->c_value;
+
+ /* save the function header info, which will be used
+ when `.bf' is seen. */
+ fcn_cs_saved = *cs;
+ fcn_aux_saved = main_aux;
+
+ ptb = NULL;
+
+ /* If function has two auxent, then debugging information is
+ already available for it. Process traceback table for
+ functions with only one auxent. */
+
+ if (cs->c_naux == 1)
+ ptb = retrieve_tracebackinfo (abfd, textsec, cs);
+
+ else if (cs->c_naux != 2)
+ {
+ static struct complaint msg =
+ {"Expected one or two auxents for function", 0, 0};
+ complain (&msg);
+ }
+
+ /* If there is traceback info, create and add parameters
+ for it. */
+
+ if (ptb && (ptb->fixedparms || ptb->floatparms))
+ {
+
+ int parmcnt = ptb->fixedparms + ptb->floatparms;
+ char *parmcode = (char*) &ptb->parminfo;
+
+ /* The link area is 0x18 bytes. */
+ int parmvalue = ptb->framesize + 0x18;
+ unsigned int ii, mask;
+
+ for (ii=0, mask = 0x80000000; ii <parmcnt; ++ii)
+ {
+ struct symbol *parm;
+
+ if (ptb->parminfo & mask)
+ {
+ /* float or double */
+ mask = mask >> 1;
+ if (ptb->parminfo & mask)
+ {
+ /* double parm */
+ ADD_PARM_TO_PENDING
+ (parm, parmvalue, builtin_type_double,
+ local_symbols);
+ parmvalue += sizeof (double);
+ }
+ else
+ {
+ /* float parm */
+ ADD_PARM_TO_PENDING
+ (parm, parmvalue, builtin_type_float,
+ local_symbols);
+ parmvalue += sizeof (float);
+ }
+ }
+ else
+ {
+ /* fixed parm, use (int*) for hex rep. */
+ ADD_PARM_TO_PENDING
+ (parm, parmvalue,
+ lookup_pointer_type (builtin_type_int),
+ local_symbols);
+ parmvalue += sizeof (int);
+ }
+ mask = mask >> 1;
+ }
+
+ /* Fake this as a function. Needed in
+ process_xcoff_symbol(). */
+ cs->c_type = 32;
+
+ finish_block
+ (process_xcoff_symbol (cs, objfile), &local_symbols,
+ pending_blocks, cs->c_value,
+ cs->c_value + ptb->fsize, objfile);
+ }
+ continue;
+
+ case XMC_GL:
+ /* shared library function trampoline code entry point. */
+
+ /* record trampoline code entries as
+ mst_solib_trampoline symbol. When we lookup mst
+ symbols, we will choose mst_text over
+ mst_solib_trampoline. */
+ RECORD_MINIMAL_SYMBOL
+ (cs->c_name, cs->c_value,
+ mst_solib_trampoline,
+ symname_alloced, cs->c_secnum, objfile);
+ continue;
+
+ case XMC_DS:
+ /* The symbols often have the same names as debug symbols for
+ functions, and confuse lookup_symbol. */
+ continue;
+
+ default:
+ /* xlc puts each variable in a separate csect, so we get
+ an XTY_SD for each variable. But gcc puts several
+ variables in a csect, so that each variable only gets
+ an XTY_LD. We still need to record them. This will
+ typically be XMC_RW; I suspect XMC_RO and XMC_BS might
+ be possible too. */
+ break;
+ }
- case XMC_TC : /* ignore toc entries */
- default : /* any other XMC_XXX */
- continue;
+ default:
+ break;
}
- }
- break; /* switch CSECT_SCLAS() */
-
- case XTY_LD :
-
- switch (CSECT_SCLAS (&main_aux))
- {
- case XMC_PR:
- /* a function entry point. */
- function_entry_point:
- RECORD_MINIMAL_SYMBOL (cs->c_name, cs->c_value, mst_text,
- symname_alloced, cs->c_secnum, objfile);
+ }
- fcn_line_offset = main_aux.x_sym.x_fcnary.x_fcn.x_lnnoptr;
- fcn_start_addr = cs->c_value;
+ switch (cs->c_sclass)
+ {
- /* save the function header info, which will be used
- when `.bf' is seen. */
- fcn_cs_saved = *cs;
- fcn_aux_saved = main_aux;
+ case C_FILE:
+ /* see if the last csect needs to be recorded. */
- ptb = NULL;
+ if (last_csect_name && !misc_func_recorded)
+ {
- /* If function has two auxent, then debugging information is
- already available for it. Process traceback table for
- functions with only one auxent. */
+ /* If no misc. function recorded in the last seen csect, enter
+ it as a function. This will take care of functions like
+ strcmp() compiled by xlc. */
- if (cs->c_naux == 1)
- ptb = retrieve_tracebackinfo (abfd, textsec, cs);
+ int alloced = 0;
+ RECORD_MINIMAL_SYMBOL
+ (last_csect_name, last_csect_val,
+ mst_text, alloced, last_csect_sec, objfile);
+ }
- else if (cs->c_naux != 2)
- {
- static struct complaint msg =
- {"Expected one or two auxents for function", 0, 0};
- complain (&msg);
- }
+ /* c_value field contains symnum of next .file entry in table
+ or symnum of first global after last .file. */
- /* If there is traceback info, create and add parameters for it. */
+ next_file_symnum = cs->c_value;
- if (ptb && (ptb->fixedparms || ptb->floatparms)) {
+ /* Complete symbol table for last object file containing
+ debugging information. */
- int parmcnt = ptb->fixedparms + ptb->floatparms;
- char *parmcode = (char*) &ptb->parminfo;
- int parmvalue = ptb->framesize + 0x18; /* sizeof(LINK AREA) == 0x18 */
- unsigned int ii, mask;
+ /* Whether or not there was a csect in the previous file, we
+ have to call `end_stabs' and `start_stabs' to reset
+ type_vector, line_vector, etc. structures. */
- for (ii=0, mask = 0x80000000; ii <parmcnt; ++ii) {
- struct symbol *parm;
+ complete_symtab (filestring, file_start_addr);
+ cur_src_end_addr = file_end_addr;
+ end_symtab (file_end_addr, 1, 0, objfile, textsec->target_index);
+ end_stabs ();
- if (ptb->parminfo & mask) { /* float or double */
- mask = mask >> 1;
- if (ptb->parminfo & mask) { /* double parm */
- ADD_PARM_TO_PENDING
- (parm, parmvalue, builtin_type_double, local_symbols);
- parmvalue += sizeof (double);
- }
- else { /* float parm */
- ADD_PARM_TO_PENDING
- (parm, parmvalue, builtin_type_float, local_symbols);
- parmvalue += sizeof (float);
- }
- }
- else { /* fixed parm, use (int*) for hex rep. */
- ADD_PARM_TO_PENDING (parm, parmvalue,
- lookup_pointer_type (builtin_type_int),
- local_symbols);
- parmvalue += sizeof (int);
- }
- mask = mask >> 1;
- }
-
- /* Fake this as a function. Needed in process_xcoff_symbol() */
- cs->c_type = 32;
-
- finish_block(process_xcoff_symbol (cs, objfile), &local_symbols,
- pending_blocks, cs->c_value,
- cs->c_value + ptb->fsize, objfile);
+ /* XCOFF, according to the AIX 3.2 documentation, puts the filename
+ in cs->c_name. But xlc 1.3.0.2 has decided to do things the
+ standard COFF way and put it in the auxent. We use the auxent if
+ the symbol is ".file" and an auxent exists, otherwise use the symbol
+ itself. Simple enough. */
+ if (!strcmp (cs->c_name, ".file") && cs->c_naux > 0)
+ {
+ bfd_coff_swap_aux_in (abfd, raw_auxptr, cs->c_type, cs->c_sclass,
+ 0, cs->c_naux, &main_aux);
+ filestring = coff_getfilename (&main_aux);
}
- continue;
+ else
+ filestring = cs->c_name;
- case XMC_GL:
- /* shared library function trampoline code entry point. */
+ start_stabs ();
+ start_symtab (filestring, (char *)NULL, (CORE_ADDR)0);
+ last_csect_name = 0;
- /* record trampoline code entries as mst_solib_trampoline symbol.
- When we lookup mst symbols, we will choose mst_text over
- mst_solib_trampoline. */
- RECORD_MINIMAL_SYMBOL (cs->c_name, cs->c_value,
- mst_solib_trampoline,
- symname_alloced, cs->c_secnum, objfile);
- continue;
-
- case XMC_DS:
- /* The symbols often have the same names as debug symbols for
- functions, and confuse lookup_symbol. */
- continue;
-
- default:
- /* xlc puts each variable in a separate csect, so we get
- an XTY_SD for each variable. But gcc puts several
- variables in a csect, so that each variable only gets
- an XTY_LD. We still need to record them. This will
- typically be XMC_RW; I suspect XMC_RO and XMC_BS might
- be possible too. */
- break;
- }
-
- default : /* all other XTY_XXXs */
+ /* reset file start and end addresses. A compilation unit with no text
+ (only data) should have zero file boundaries. */
+ file_start_addr = file_end_addr = 0;
break;
- } /* switch CSECT_SMTYP() */ }
-
- switch (cs->c_sclass) {
- case C_FILE:
+ case C_FUN:
+ fcn_stab_saved = *cs;
+ break;
- /* see if the last csect needs to be recorded. */
+ case C_FCN:
+ if (STREQ (cs->c_name, ".bf"))
+ {
- if (last_csect_name && !misc_func_recorded) {
+ bfd_coff_swap_aux_in (abfd, raw_auxptr, cs->c_type, cs->c_sclass,
+ 0, cs->c_naux, &main_aux);
- /* if no misc. function recorded in the last seen csect, enter
- it as a function. This will take care of functions like
- strcmp() compiled by xlc. */
+ within_function = 1;
- int alloced = 0;
- RECORD_MINIMAL_SYMBOL (last_csect_name, last_csect_val,
- mst_text, alloced, last_csect_sec, objfile);
- }
+ mark_first_line (fcn_line_offset, cs->c_symnum);
- /* c_value field contains symnum of next .file entry in table
- or symnum of first global after last .file. */
+ new = push_context (0, fcn_start_addr);
- next_file_symnum = cs->c_value;
-
- /* complete symbol table for last object file containing
- debugging information. */
+ new->name = define_symbol
+ (fcn_cs_saved.c_value, fcn_stab_saved.c_name, 0, 0, objfile);
+ if (new->name != NULL)
+ SYMBOL_SECTION (new->name) = cs->c_secnum;
+ }
+ else if (STREQ (cs->c_name, ".ef"))
+ {
- /* Whether or not there was a csect in the previous file, we have to call
- `end_stabs' and `start_stabs' to reset type_vector,
- line_vector, etc. structures. */
+ bfd_coff_swap_aux_in (abfd, raw_auxptr, cs->c_type, cs->c_sclass,
+ 0, cs->c_naux, &main_aux);
+
+ /* The value of .ef is the address of epilogue code;
+ not useful for gdb. */
+ /* { main_aux.x_sym.x_misc.x_lnsz.x_lnno
+ contains number of lines to '}' */
+
+ fcn_last_line = main_aux.x_sym.x_misc.x_lnsz.x_lnno;
+ new = pop_context ();
+ if (context_stack_depth != 0)
+ error ("\
+ invalid symbol data; .bf/.ef/.bb/.eb symbol mismatch, at symbol %d.",
+ symnum);
+
+ finish_block (new->name, &local_symbols, new->old_blocks,
+ new->start_addr,
+ fcn_cs_saved.c_value +
+ fcn_aux_saved.x_sym.x_misc.x_fsize, objfile);
+ within_function = 0;
+ }
+ break;
- complete_symtab (filestring, file_start_addr);
- cur_src_end_addr = file_end_addr;
- end_symtab (file_end_addr, 1, 0, objfile, textsec->target_index);
- end_stabs ();
+ case C_BSTAT:
+ /* Begin static block. */
+ {
+ struct internal_syment symbol;
- /* XCOFF, according to the AIX 3.2 documentation, puts the filename
- in cs->c_name. But xlc 1.3.0.2 has decided to do things the
- standard COFF way and put it in the auxent. We use the auxent if
- the symbol is ".file" and an auxent exists, otherwise use the symbol
- itself. Simple enough. */
- if (!strcmp (cs->c_name, ".file") && cs->c_naux > 0)
- {
- bfd_coff_swap_aux_in (abfd, raw_auxptr, cs->c_type, cs->c_sclass,
- 0, cs->c_naux, &main_aux);
- filestring = coff_getfilename (&main_aux);
- }
- else
- filestring = cs->c_name;
+ read_symbol (&symbol, cs->c_value);
+ static_block_base = symbol.n_value;
+ static_block_section = symbol.n_scnum;
+ }
+ break;
- start_stabs ();
- start_symtab (filestring, (char *)NULL, (CORE_ADDR)0);
- last_csect_name = 0;
+ case C_ESTAT:
+ /* End of static block. */
+ static_block_base = 0;
+ static_block_section = -1;
+ break;
- /* reset file start and end addresses. A compilation unit with no text
- (only data) should have zero file boundaries. */
- file_start_addr = file_end_addr = 0;
- break;
+ case C_ARG:
+ case C_REGPARM:
+ case C_TPDEF:
+ case C_STRTAG:
+ case C_UNTAG:
+ case C_ENTAG:
+ printf_unfiltered
+ ("ERROR: Unimplemented storage class: %d.\n", cs->c_sclass);
+ break;
+ case C_LABEL:
+ case C_NULL:
+ /* Ignore these. */
+ break;
- case C_FUN:
- fcn_stab_saved = *cs;
- break;
-
+#ifdef STATIC_NODEBUG_VARS
+ /* This is wrong. These symbols are XMC_TC, which means that
+ the value of the symbol is the address of the TOC entry, not
+ the address of the variable itself. */
+ case C_HIDEXT:
+ {
+ /* This is the only place that static variables show up in files
+ compiled without -g. External variables also have a C_EXT,
+ so that is why we record everything as mst_file_* here. */
+ enum minimal_symbol_type ms_type;
+ CORE_ADDR tmpaddr;
+ int sec;
- case C_FCN:
- if (STREQ (cs->c_name, ".bf")) {
+ sec = cs_to_section (cs, objfile);
+ tmpaddr = cs->c_value;
- bfd_coff_swap_aux_in (abfd, raw_auxptr, cs->c_type, cs->c_sclass,
- 0, cs->c_naux, &main_aux);
+ switch (sec)
+ {
+ case SECT_OFF_TEXT:
+ case SECT_OFF_RODATA:
+ ms_type = mst_file_text;
+ break;
+ case SECT_OFF_DATA:
+ ms_type = mst_file_data;
+ break;
+ case SECT_OFF_BSS:
+ ms_type = mst_file_bss;
+ break;
+ default:
+ ms_type = mst_unknown;
+ break;
+ }
+ RECORD_MINIMAL_SYMBOL (cs->c_name, cs->c_value, ms_type,
+ symname_alloced, cs->c_secnum, objfile);
+ }
+#endif /* STATIC_NODEBUG_VARS */
+ break;
- within_function = 1;
+ case C_BINCL:
+ /* beginning of include file */
+ /* In xlc output, C_BINCL/C_EINCL pair doesn't show up in sorted
+ order. Thus, when wee see them, we might not know enough info
+ to process them. Thus, we'll be saving them into a table
+ (inclTable) and postpone their processing. */
- mark_first_line (fcn_line_offset, cs->c_symnum);
+ record_include_begin (cs);
+ break;
- new = push_context (0, fcn_start_addr);
+ case C_EINCL:
+ /* End of include file. */
+ /* See the comment after case C_BINCL. */
+ record_include_end (cs);
+ break;
- new->name = define_symbol
- (fcn_cs_saved.c_value, fcn_stab_saved.c_name, 0, 0, objfile);
- if (new->name != NULL)
- SYMBOL_SECTION (new->name) = cs->c_secnum;
- }
- else if (STREQ (cs->c_name, ".ef")) {
-
- bfd_coff_swap_aux_in (abfd, raw_auxptr, cs->c_type, cs->c_sclass,
- 0, cs->c_naux, &main_aux);
-
- /* the value of .ef is the address of epilogue code;
- not useful for gdb */
- /* { main_aux.x_sym.x_misc.x_lnsz.x_lnno
- contains number of lines to '}' */
-
- fcn_last_line = main_aux.x_sym.x_misc.x_lnsz.x_lnno;
- new = pop_context ();
- if (context_stack_depth != 0)
- error ("invalid symbol data; .bf/.ef/.bb/.eb symbol mismatch, at symbol %d.",
- symnum);
-
- finish_block (new->name, &local_symbols, new->old_blocks,
- new->start_addr,
- fcn_cs_saved.c_value +
- fcn_aux_saved.x_sym.x_misc.x_fsize, objfile);
- within_function = 0;
- }
- break;
+ case C_BLOCK:
+ if (STREQ (cs->c_name, ".bb"))
+ {
+ depth++;
+ new = push_context (depth, cs->c_value);
+ }
+ else if (STREQ (cs->c_name, ".eb"))
+ {
+ new = pop_context ();
+ if (depth != new->depth)
+ error ("\
+ Invalid symbol data: .bb/.eb symbol mismatch at symbol %d.",
+ symnum);
+
+ depth--;
+ if (local_symbols && context_stack_depth > 0)
+ {
+ /* Make a block for the local symbols within. */
+ finish_block (new->name, &local_symbols, new->old_blocks,
+ new->start_addr, cs->c_value, objfile);
+ }
+ local_symbols = new->locals;
+ }
+ break;
- case C_BSTAT : /* begin static block */
- {
- struct internal_syment symbol;
-
- read_symbol (&symbol, cs->c_value);
- static_block_base = symbol.n_value;
- static_block_section = symbol.n_scnum;
- }
- break;
-
- case C_ESTAT : /* end of static block */
- static_block_base = 0;
- static_block_section = -1;
- break;
-
- case C_ARG : /* These are not implemented. */
- case C_REGPARM :
- case C_TPDEF :
- case C_STRTAG :
- case C_UNTAG :
- case C_ENTAG :
- printf_unfiltered ("ERROR: Unimplemented storage class: %d.\n", cs->c_sclass);
- break;
-
- case C_HIDEXT : /* ignore these.. */
- case C_LABEL :
- case C_NULL :
- break;
-
- case C_BINCL : /* beginning of include file */
-
- /* In xlc output, C_BINCL/C_EINCL pair doesn't show up in sorted
- order. Thus, when wee see them, we might not know enough info
- to process them. Thus, we'll be saving them into a table
- (inclTable) and postpone their processing. */
-
- record_include_begin (cs);
- break;
-
- case C_EINCL : /* end of include file */
- /* see the comment after case C_BINCL. */
- record_include_end (cs);
- break;
-
- case C_BLOCK :
- if (STREQ (cs->c_name, ".bb")) {
- depth++;
- new = push_context (depth, cs->c_value);
- }
- else if (STREQ (cs->c_name, ".eb")) {
- new = pop_context ();
- if (depth != new->depth)
- error ("Invalid symbol data: .bb/.eb symbol mismatch at symbol %d.",
- symnum);
-
- depth--;
- if (local_symbols && context_stack_depth > 0) {
- /* Make a block for the local symbols within. */
- finish_block (new->name, &local_symbols, new->old_blocks,
- new->start_addr, cs->c_value, objfile);
+ default:
+ process_xcoff_symbol (cs, objfile);
+ break;
}
- local_symbols = new->locals;
- }
- break;
-
- default :
- process_xcoff_symbol (cs, objfile);
- break;
}
- } /* while */
-
if (last_source_file)
{
end_symtab (cur_src_end_addr, 1, 0, objfile, textsec->target_index);
(ALLOCED) ? (NAME) : obstack_copy0 (&objfile->symbol_obstack, (NAME), strlen (NAME));
+static struct type *func_symbol_type;
+static struct type *var_symbol_type;
+
/* process one xcoff symbol. */
static struct symbol *
SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
SYMBOL_SECTION (sym) = cs->c_secnum;
- if (ISFCN (cs->c_type)) {
-
- /* At this point, we don't know the type of the function and assume it
- is int. This will be patched with the type from its stab entry later
- on in patch_block_stabs () */
-
- SYMBOL_NAME (sym) = SYMNAME_ALLOC (name, symname_alloced);
- SYMBOL_TYPE (sym) = lookup_function_type (lookup_fundamental_type (objfile, FT_INTEGER));
-
- SYMBOL_CLASS (sym) = LOC_BLOCK;
- SYMBOL_DUP (sym, sym2);
-
- if (cs->c_sclass == C_EXT)
- add_symbol_to_list (sym2, &global_symbols);
- else if (cs->c_sclass == C_HIDEXT || cs->c_sclass == C_STAT)
- add_symbol_to_list (sym2, &file_symbols);
- }
+ if (ISFCN (cs->c_type))
+ {
+ /* At this point, we don't know the type of the function. This
+ will be patched with the type from its stab entry later on in
+ patch_block_stabs (), unless the file was compiled without -g. */
- else {
+ SYMBOL_NAME (sym) = SYMNAME_ALLOC (name, symname_alloced);
+ SYMBOL_TYPE (sym) = func_symbol_type;
- /* in case we can't figure out the type, default is `int'. */
- SYMBOL_TYPE (sym) = lookup_fundamental_type (objfile, FT_INTEGER);
+ SYMBOL_CLASS (sym) = LOC_BLOCK;
+ SYMBOL_DUP (sym, sym2);
- switch (cs->c_sclass)
+ if (cs->c_sclass == C_EXT)
+ add_symbol_to_list (sym2, &global_symbols);
+ else if (cs->c_sclass == C_HIDEXT || cs->c_sclass == C_STAT)
+ add_symbol_to_list (sym2, &file_symbols);
+ }
+ else
{
+ /* In case we can't figure out the type, provide default. */
+ SYMBOL_TYPE (sym) = var_symbol_type;
+
+ switch (cs->c_sclass)
+ {
#if 0
- case C_FUN:
- if (fcn_cs_saved.c_sclass == C_EXT)
- add_stab_to_list (name, &global_stabs);
- else
- add_stab_to_list (name, &file_stabs);
- break;
+ case C_FUN:
+ if (fcn_cs_saved.c_sclass == C_EXT)
+ add_stab_to_list (name, &global_stabs);
+ else
+ add_stab_to_list (name, &file_stabs);
+ break;
#endif
- case C_GSYM:
- add_stab_to_list (name, &global_stabs);
- break;
+ case C_GSYM:
+ add_stab_to_list (name, &global_stabs);
+ break;
- case C_BCOMM:
- common_block_start (cs->c_name, objfile);
- break;
+ case C_BCOMM:
+ common_block_start (cs->c_name, objfile);
+ break;
- case C_ECOMM:
- common_block_end (objfile);
- break;
+ case C_ECOMM:
+ common_block_end (objfile);
+ break;
- default:
- complain (&storclass_complaint, cs->c_sclass);
- /* FALLTHROUGH */
+ default:
+ complain (&storclass_complaint, cs->c_sclass);
+ /* FALLTHROUGH */
- case C_DECL:
- case C_PSYM:
- case C_RPSYM:
- case C_ECOML:
+ case C_DECL:
+ case C_PSYM:
+ case C_RPSYM:
+ case C_ECOML:
- sym = define_symbol (cs->c_value, cs->c_name, 0, 0, objfile);
- if (sym != NULL)
- {
- SYMBOL_SECTION (sym) = cs->c_secnum;
- }
- return sym;
+ sym = define_symbol (cs->c_value, cs->c_name, 0, 0, objfile);
+ if (sym != NULL)
+ {
+ SYMBOL_SECTION (sym) = cs->c_secnum;
+ }
+ return sym;
- case C_STSYM:
+ case C_STSYM:
- /* For xlc (not GCC), the 'V' symbol descriptor is used for all
- statics and we need to distinguish file-scope versus function-scope
- using within_function. We do this by changing the string we pass
- to define_symbol to use 'S' where we need to, which is not necessarily
- super-clean, but seems workable enough. */
+ /* For xlc (not GCC), the 'V' symbol descriptor is used for
+ all statics and we need to distinguish file-scope versus
+ function-scope using within_function. We do this by
+ changing the string we pass to define_symbol to use 'S'
+ where we need to, which is not necessarily super-clean,
+ but seems workable enough. */
- if (*name == ':' || (pp = (char *) strchr(name, ':')) == NULL)
- return NULL;
+ if (*name == ':' || (pp = (char *) strchr(name, ':')) == NULL)
+ return NULL;
- ++pp;
- if (*pp == 'V' && !within_function)
- *pp = 'S';
- sym = define_symbol (cs->c_value, cs->c_name, 0, 0, objfile);
- if (sym != NULL)
- {
- SYMBOL_VALUE (sym) += static_block_base;
- SYMBOL_SECTION (sym) = static_block_section;
- }
- return sym;
+ ++pp;
+ if (*pp == 'V' && !within_function)
+ *pp = 'S';
+ sym = define_symbol (cs->c_value, cs->c_name, 0, 0, objfile);
+ if (sym != NULL)
+ {
+ SYMBOL_VALUE (sym) += static_block_base;
+ SYMBOL_SECTION (sym) = static_block_section;
+ }
+ return sym;
- case C_LSYM:
- sym = define_symbol (cs->c_value, cs->c_name, 0, N_LSYM, objfile);
- if (sym != NULL)
- {
- SYMBOL_SECTION (sym) = cs->c_secnum;
- }
- return sym;
+ case C_LSYM:
+ sym = define_symbol (cs->c_value, cs->c_name, 0, N_LSYM, objfile);
+ if (sym != NULL)
+ {
+ SYMBOL_SECTION (sym) = cs->c_secnum;
+ }
+ return sym;
- case C_AUTO:
- SYMBOL_CLASS (sym) = LOC_LOCAL;
- SYMBOL_NAME (sym) = SYMNAME_ALLOC (name, symname_alloced);
- SYMBOL_SECTION (sym) = cs->c_secnum;
- SYMBOL_DUP (sym, sym2);
- add_symbol_to_list (sym2, &local_symbols);
- break;
+ case C_AUTO:
+ SYMBOL_CLASS (sym) = LOC_LOCAL;
+ SYMBOL_NAME (sym) = SYMNAME_ALLOC (name, symname_alloced);
+ SYMBOL_SECTION (sym) = cs->c_secnum;
+ SYMBOL_DUP (sym, sym2);
+ add_symbol_to_list (sym2, &local_symbols);
+ break;
- case C_EXT:
- SYMBOL_CLASS (sym) = LOC_STATIC;
- SYMBOL_NAME (sym) = SYMNAME_ALLOC (name, symname_alloced);
- SYMBOL_SECTION (sym) = cs->c_secnum;
- SYMBOL_DUP (sym, sym2);
- add_symbol_to_list (sym2, &global_symbols);
- break;
+ case C_EXT:
+ SYMBOL_CLASS (sym) = LOC_STATIC;
+ SYMBOL_NAME (sym) = SYMNAME_ALLOC (name, symname_alloced);
+ SYMBOL_SECTION (sym) = cs->c_secnum;
+ SYMBOL_DUP (sym, sym2);
+ add_symbol_to_list (sym2, &global_symbols);
+ break;
- case C_STAT:
- SYMBOL_CLASS (sym) = LOC_STATIC;
- SYMBOL_NAME (sym) = SYMNAME_ALLOC (name, symname_alloced);
- SYMBOL_SECTION (sym) = cs->c_secnum;
- SYMBOL_DUP (sym, sym2);
- add_symbol_to_list
- (sym2, within_function ? &local_symbols : &file_symbols);
- break;
+ case C_STAT:
+ SYMBOL_CLASS (sym) = LOC_STATIC;
+ SYMBOL_NAME (sym) = SYMNAME_ALLOC (name, symname_alloced);
+ SYMBOL_SECTION (sym) = cs->c_secnum;
+ SYMBOL_DUP (sym, sym2);
+ add_symbol_to_list
+ (sym2, within_function ? &local_symbols : &file_symbols);
+ break;
- case C_REG:
- printf_unfiltered ("ERROR! C_REG is not fully implemented!\n");
- SYMBOL_CLASS (sym) = LOC_REGISTER;
- SYMBOL_NAME (sym) = SYMNAME_ALLOC (name, symname_alloced);
- SYMBOL_SECTION (sym) = cs->c_secnum;
- SYMBOL_DUP (sym, sym2);
- add_symbol_to_list (sym2, &local_symbols);
- break;
+ case C_REG:
+ printf_unfiltered ("ERROR! C_REG is not fully implemented!\n");
+ SYMBOL_CLASS (sym) = LOC_REGISTER;
+ SYMBOL_NAME (sym) = SYMNAME_ALLOC (name, symname_alloced);
+ SYMBOL_SECTION (sym) = cs->c_secnum;
+ SYMBOL_DUP (sym, sym2);
+ add_symbol_to_list (sym2, &local_symbols);
+ break;
- case C_RSYM:
- pp = (char*) strchr (name, ':');
- if (pp) {
- sym = define_symbol (cs->c_value, cs->c_name, 0, 0, objfile);
- if (sym != NULL)
- SYMBOL_SECTION (sym) = cs->c_secnum;
- return sym;
- }
- else {
- complain (&rsym_complaint, name);
- return NULL;
+ case C_RSYM:
+ pp = (char*) strchr (name, ':');
+ if (pp)
+ {
+ sym = define_symbol (cs->c_value, cs->c_name, 0, 0, objfile);
+ if (sym != NULL)
+ SYMBOL_SECTION (sym) = cs->c_secnum;
+ return sym;
+ }
+ else
+ {
+ complain (&rsym_complaint, name);
+ return NULL;
+ }
}
}
- }
return sym2;
}
{
add_symtab_fns(&xcoff_sym_fns);
- /* Initialize symbol template later used for arguments. */
+ /* Initialize symbol template later used for arguments. Its other
+ fields are zero, or are filled in later. */
SYMBOL_NAME (&parmsym) = "";
SYMBOL_INIT_LANGUAGE_SPECIFIC (&parmsym, language_c);
SYMBOL_NAMESPACE (&parmsym) = VAR_NAMESPACE;
SYMBOL_CLASS (&parmsym) = LOC_ARG;
- /* Its other fields are zero, or are filled in later. */
+
+ func_symbol_type = init_type (TYPE_CODE_FUNC, 1, 0,
+ "<function, no debug info>", NULL);
+ TYPE_TARGET_TYPE (func_symbol_type) = builtin_type_int;
+ var_symbol_type =
+ init_type (TYPE_CODE_INT, TARGET_INT_BIT / HOST_CHAR_BIT, 0,
+ "<variable, no debug info>", NULL);
}
projects / binutils-gdb.git / commitdiff