@ -123,44 +123,6 @@ static unsigned local_auxesz;
static struct symbol * opaque_type_chain [ HASHSIZE ] ; static struct symbol * opaque_type_chain [ HASHSIZE ] ;
/* Record the symbols defined for each context in a list.
We don ' t create a struct block for the context until we
know how long to make it . */
struct coff_pending
{
struct coff_pending * next ;
struct symbol * symbol ;
} ;
/* Here are the three lists that symbols are put on. */
struct coff_pending * coff_file_symbols ; /* static at top level, and types */
struct coff_pending * coff_global_symbols ; /* global functions and variables */
struct coff_pending * coff_local_symbols ; /* everything local to lexical context */
/* List of unclosed lexical contexts
( that will become blocks , eventually ) . */
struct coff_context_stack
{
struct coff_context_stack * next ;
struct coff_pending * locals ;
struct pending_block * old_blocks ;
struct symbol * name ;
CORE_ADDR start_addr ;
int depth ;
} ;
struct coff_context_stack * coff_context_stack ;
/* Nonzero if within a function (so symbols should be local,
if nothing says specifically ) . */
int within_function ;
#if 0 #if 0
/* The type of the function we are currently reading in. This is
/* The type of the function we are currently reading in. This is
used by define_symbol to record the type of arguments to a function . */ used by define_symbol to record the type of arguments to a function . */
@ -229,9 +191,6 @@ decode_function_type PARAMS ((struct coff_symbol *, unsigned int,
static struct type * static struct type *
coff_read_enum_type PARAMS ( ( int , int , int ) ) ; coff_read_enum_type PARAMS ( ( int , int , int ) ) ;
static struct blockvector *
make_blockvector PARAMS ( ( struct objfile * ) ) ;
static struct symbol * static struct symbol *
process_coff_symbol PARAMS ( ( struct coff_symbol * , union internal_auxent * , process_coff_symbol PARAMS ( ( struct coff_symbol * , union internal_auxent * ,
struct objfile * ) ) ; struct objfile * ) ) ;
@ -300,14 +259,6 @@ coff_start_symtab PARAMS ((void));
static void static void
coff_record_line PARAMS ( ( int , CORE_ADDR ) ) ; coff_record_line PARAMS ( ( int , CORE_ADDR ) ) ;
static void
coff_finish_block PARAMS ( ( struct symbol * , struct coff_pending * * ,
struct pending_block * , CORE_ADDR , CORE_ADDR ,
struct objfile * ) ) ;
static void
coff_add_symbol_to_list PARAMS ( ( struct symbol * , struct coff_pending * * ) ) ;
static struct type * static struct type *
coff_alloc_type PARAMS ( ( int ) ) ; coff_alloc_type PARAMS ( ( int ) ) ;
@ -365,142 +316,6 @@ coff_alloc_type (index)
return type ; return type ;
} }
/* maintain the lists of symbols and blocks */
/* Add a symbol to one of the lists of symbols. */
static void
coff_add_symbol_to_list ( symbol , listhead )
struct symbol * symbol ;
struct coff_pending * * listhead ;
{
register struct coff_pending * link
= ( struct coff_pending * ) xmalloc ( sizeof ( struct coff_pending ) ) ;
link - > next = * listhead ;
link - > symbol = symbol ;
* listhead = link ;
}
/* Take one of the lists of symbols and make a block from it.
Put the block on the list of pending blocks . */
static void
coff_finish_block ( symbol , listhead , old_blocks , start , end , objfile )
struct symbol * symbol ;
struct coff_pending * * listhead ;
struct pending_block * old_blocks ;
CORE_ADDR start , end ;
struct objfile * objfile ;
{
register struct coff_pending * next , * next1 ;
register struct block * block ;
register struct pending_block * pblock ;
struct pending_block * opblock ;
register int i ;
/* Count the length of the list of symbols. */
for ( next = * listhead , i = 0 ; next ; next = next - > next , i + + ) ;
block = ( struct block * )
obstack_alloc ( & objfile - > symbol_obstack , sizeof ( struct block ) + ( i - 1 ) * sizeof ( struct symbol * ) ) ;
/* Copy the symbols into the block. */
BLOCK_NSYMS ( block ) = i ;
for ( next = * listhead ; next ; next = next - > next )
BLOCK_SYM ( block , - - i ) = next - > symbol ;
BLOCK_START ( block ) = start ;
BLOCK_END ( block ) = end ;
BLOCK_SUPERBLOCK ( block ) = 0 ; /* Filled in when containing block is made */
/* Put the block in as the value of the symbol that names it. */
if ( symbol )
{
SYMBOL_BLOCK_VALUE ( symbol ) = block ;
BLOCK_FUNCTION ( block ) = symbol ;
}
else
BLOCK_FUNCTION ( block ) = 0 ;
/* Now free the links of the list, and empty the list. */
for ( next = * listhead ; next ; next = next1 )
{
next1 = next - > next ;
free ( ( PTR ) next ) ;
}
* listhead = 0 ;
/* Install this block as the superblock
of all blocks made since the start of this scope
that don ' t have superblocks yet . */
opblock = 0 ;
for ( pblock = pending_blocks ; pblock ! = old_blocks ; pblock = pblock - > next )
{
if ( BLOCK_SUPERBLOCK ( pblock - > block ) = = 0 )
BLOCK_SUPERBLOCK ( pblock - > block ) = block ;
opblock = pblock ;
}
/* Record this block on the list of all blocks in the file.
Put it after opblock , or at the beginning if opblock is 0.
This puts the block in the list after all its subblocks . */
pblock = ( struct pending_block * ) xmalloc ( sizeof ( struct pending_block ) ) ;
pblock - > block = block ;
if ( opblock )
{
pblock - > next = opblock - > next ;
opblock - > next = pblock ;
}
else
{
pblock - > next = pending_blocks ;
pending_blocks = pblock ;
}
}
static struct blockvector *
make_blockvector ( objfile )
struct objfile * objfile ;
{
register struct pending_block * next , * next1 ;
register struct blockvector * blockvector ;
register int i ;
/* Count the length of the list of blocks. */
for ( next = pending_blocks , i = 0 ; next ; next = next - > next , i + + ) ;
blockvector = ( struct blockvector * )
obstack_alloc ( & objfile - > symbol_obstack , sizeof ( struct blockvector ) + ( i - 1 ) * sizeof ( struct block * ) ) ;
/* Copy the blocks into the blockvector.
This is done in reverse order , which happens to put
the blocks into the proper order ( ascending starting address ) .
coff_finish_block has hair to insert each block into the list
after its subblocks in order to make sure this is true . */
BLOCKVECTOR_NBLOCKS ( blockvector ) = i ;
for ( next = pending_blocks ; next ; next = next - > next )
BLOCKVECTOR_BLOCK ( blockvector , - - i ) = next - > block ;
/* Now free the links of the list, and empty the list. */
for ( next = pending_blocks ; next ; next = next1 )
{
next1 = next - > next ;
free ( ( PTR ) next ) ;
}
pending_blocks = 0 ;
return blockvector ;
}
/* Manage the vector of line numbers. */ /* Manage the vector of line numbers. */
static void static void
@ -531,11 +346,14 @@ coff_record_line (line, pc)
static void static void
coff_start_symtab ( ) coff_start_symtab ( )
{ {
coff_file_symbols = 0 ; start_symtab (
coff_global_symbols = 0 ; /* We fill in the filename later. */
coff_context_stack = 0 ; " " ,
within_function = 0 ; /* We never know the directory name for COFF. */
last_source_file = NULL ; NULL ,
/* The start address is irrelevant, since we set
last_source_start_addr in coff_end_symtab . */
0 ) ;
/* Initialize the source file line number information for this file. */ /* Initialize the source file line number information for this file. */
@ -581,87 +399,24 @@ static void
coff_end_symtab ( objfile ) coff_end_symtab ( objfile )
struct objfile * objfile ; struct objfile * objfile ;
{ {
register struct symtab * symtab ; struct symtab * symtab ;
register struct coff_context_stack * cstk ;
register struct blockvector * blockvector ;
register struct linetable * lv ;
/* Finish the lexical context of the last function in the file. */ last_source_start_addr = cur_src_start_addr ;
if ( coff_context_stack ) /* For COFF, we only have one subfile, so we can just look at
{ subfiles and not worry about there being other elements in the
cstk = coff_context_stack ; chain . We fill in various fields now because we didn ' t know them
coff_context_stack = 0 ; before ( or because doing it now is simply an artifact of how this
/* Make a block for the local symbols within. */ file used to be written ) . */
coff_finish_block ( cstk - > name , & coff_local_symbols , cstk - > old_blocks , subfiles - > line_vector = line_vector ;
cstk - > start_addr , cur_src_end_addr , objfile ) ; subfiles - > name = last_source_file ;
free ( ( PTR ) cstk ) ;
}
/* Ignore a file that has no functions with real debugging info. */ /* sort_pending is needed for amdcoff, at least.
if ( pending_blocks = = 0 & & coff_file_symbols = = 0 & & coff_global_symbols = = 0 ) sort_linevec is needed for the SCO compiler . */
{ symtab = end_symtab ( cur_src_end_addr , 1 , 1 , objfile , 0 ) ;
free ( ( PTR ) line_vector ) ;
line_vector = 0 ;
line_vector_length = - 1 ;
last_source_file = NULL ;
return ;
}
/* It is unfortunate that in amdcoff, pending blocks might not be ordered
in this stage . Especially , blocks for static functions will show up at
the end . We need to sort them , so tools like ` find_pc_function ' and
` find_pc_block ' can work reliably . */
if ( pending_blocks ) {
/* FIXME! Remove this horrid bubble sort and use qsort!!! */
int swapped ;
do {
struct pending_block * pb , * pbnext ;
pb = pending_blocks , pbnext = pb - > next ;
swapped = 0 ;
while ( pbnext ) {
/* swap blocks if unordered! */
if ( BLOCK_START ( pb - > block ) < BLOCK_START ( pbnext - > block ) ) {
struct block * tmp = pb - > block ;
complain ( & misordered_blocks_complaint , BLOCK_START ( pb - > block ) ) ;
pb - > block = pbnext - > block ;
pbnext - > block = tmp ;
swapped = 1 ;
}
pb = pbnext ;
pbnext = pbnext - > next ;
}
} while ( swapped ) ;
}
/* Create the two top-level blocks for this file (STATIC_BLOCK and
GLOBAL_BLOCK ) . */
coff_finish_block ( 0 , & coff_file_symbols , 0 , cur_src_start_addr , cur_src_end_addr , objfile ) ;
coff_finish_block ( 0 , & coff_global_symbols , 0 , cur_src_start_addr , cur_src_end_addr , objfile ) ;
/* Create the blockvector that points to all the file's blocks. */ if ( symtab ! = NULL )
blockvector = make_blockvector ( objfile ) ; free_named_symtabs ( symtab - > filename ) ;
/* Now create the symtab object for this source file. */
symtab = allocate_symtab ( last_source_file , objfile ) ;
/* Fill in its components. */
symtab - > blockvector = blockvector ;
symtab - > free_code = free_linetable ;
symtab - > free_ptr = 0 ;
symtab - > filename = last_source_file ;
symtab - > dirname = NULL ;
lv = line_vector ;
lv - > nitems = line_vector_index ;
symtab - > linetable = ( struct linetable * )
xrealloc ( ( char * ) lv , ( sizeof ( struct linetable )
+ lv - > nitems * sizeof ( struct linetable_entry ) ) ) ;
free_named_symtabs ( symtab - > filename ) ;
/* Reinitialize for beginning of new file. */ /* Reinitialize for beginning of new file. */
line_vector = 0 ; line_vector = 0 ;
@ -888,7 +643,7 @@ read_coff_symtab (symtab_offset, nsyms, objfile)
struct objfile * objfile ; struct objfile * objfile ;
{ {
FILE * stream ; FILE * stream ;
register struct coff_co ntext_stack * new ; register struct context_stack * new ;
struct coff_symbol coff_symbol ; struct coff_symbol coff_symbol ;
register struct coff_symbol * cs = & coff_symbol ; register struct coff_symbol * cs = & coff_symbol ;
static struct internal_syment main_sym ; static struct internal_syment main_sym ;
@ -1098,41 +853,41 @@ read_coff_symtab (symtab_offset, nsyms, objfile)
complain ( & bf_no_aux_complaint , cs - > c_symnum ) ; complain ( & bf_no_aux_complaint , cs - > c_symnum ) ;
fcn_first_line = main_aux . x_sym . x_misc . x_lnsz . x_lnno ; fcn_first_line = main_aux . x_sym . x_misc . x_lnsz . x_lnno ;
new = ( struct coff_context_stack * ) /* Might want to check that locals are 0 and
xmalloc ( sizeof ( struct coff_context_stack ) ) ; context_stack_depth is zero , and complain if not . */
new - > depth = depth = 0 ;
new - > next = 0 ; depth = 0 ;
coff_context_stack = new ; new = push_context ( depth , fcn_start_addr ) ;
new - > locals = 0 ;
new - > old_blocks = pending_blocks ;
new - > start_addr = fcn_start_addr ;
fcn_cs_saved . c_name = getsymname ( & fcn_sym_saved ) ; fcn_cs_saved . c_name = getsymname ( & fcn_sym_saved ) ;
new - > name = process_coff_symbol ( & fcn_cs_saved , new - > name = process_coff_symbol ( & fcn_cs_saved ,
& fcn_aux_saved , objfile ) ; & fcn_aux_saved , objfile ) ;
} }
else if ( STREQ ( cs - > c_name , " .ef " ) ) else if ( STREQ ( cs - > c_name , " .ef " ) )
{ {
/* the value of .ef is the address of epilogue code;
/* the value of .ef is the address of epilogue code;
* not useful for gdb not useful for gdb . */
*/
/* { main_aux.x_sym.x_misc.x_lnsz.x_lnno
/* { main_aux.x_sym.x_misc.x_lnsz.x_lnno
contains number of lines to ' } ' */ contains number of lines to ' } ' */
new = coff_context_stack ; new = pop_context ( ) ;
if ( new = = 0 ) /* Stack must be empty now. */
if ( context_stack_depth > 0 | | new = = NULL )
{ {
complain ( & ef_complaint , cs - > c_symnum ) ; complain ( & ef_complaint , cs - > c_symnum ) ;
within_function = 0 ; within_function = 0 ;
break ; break ;
} }
if ( cs - > c_naux ! = 1 ) { if ( cs - > c_naux ! = 1 )
complain ( & ef_no_aux_complaint , cs - > c_symnum ) ; {
fcn_last_line = 0x7FFFFFFF ; complain ( & ef_no_aux_complaint , cs - > c_symnum ) ;
} else { fcn_last_line = 0x7FFFFFFF ;
fcn_last_line = main_aux . x_sym . x_misc . x_lnsz . x_lnno ; }
} else
{
fcn_last_line = main_aux . x_sym . x_misc . x_lnsz . x_lnno ;
}
enter_linenos ( fcn_line_ptr , fcn_first_line , fcn_last_line ) ; enter_linenos ( fcn_line_ptr , fcn_first_line , fcn_last_line ) ;
coff_finish_block ( new - > name , & coff_local_symbols , new - > old_blocks , finish_block ( new - > name , & local_symbols , new - > old_blocks ,
new - > start_addr , new - > start_addr ,
# if defined (FUNCTION_EPILOGUE_SIZE) # if defined (FUNCTION_EPILOGUE_SIZE)
/* This macro should be defined only on
/* This macro should be defined only on
@ -1149,45 +904,31 @@ read_coff_symtab (symtab_offset, nsyms, objfile)
# endif # endif
objfile objfile
) ; ) ;
coff_context_stack = 0 ;
within_function = 0 ; within_function = 0 ;
free ( ( PTR ) new ) ;
} }
break ; break ;
case C_BLOCK : case C_BLOCK :
if ( STREQ ( cs - > c_name , " .bb " ) ) if ( STREQ ( cs - > c_name , " .bb " ) )
{ {
new = ( struct coff_context_stack * ) push_context ( + + depth , cs - > c_value ) ;
xmalloc ( sizeof ( struct coff_context_stack ) ) ;
depth + + ;
new - > depth = depth ;
new - > next = coff_context_stack ;
coff_context_stack = new ;
new - > locals = coff_local_symbols ;
new - > old_blocks = pending_blocks ;
new - > start_addr = cs - > c_value ;
new - > name = 0 ;
coff_local_symbols = 0 ;
} }
else if ( STREQ ( cs - > c_name , " .eb " ) ) else if ( STREQ ( cs - > c_name , " .eb " ) )
{ {
new = coff_context_stack ; new = pop_context ( ) ;
if ( new = = 0 | | depth ! = new - > depth ) if ( depth - - ! = new - > depth )
{ {
complain ( & eb_complaint , ( char * ) symnum ) ; complain ( & eb_complaint , ( char * ) symnum ) ;
break ; break ;
} }
if ( coff_ local_symbols& & coff_context_stack - > next ) if ( local_symbols & & context_stack_depth > 0 )
{ {
/* Make a block for the local symbols within. */ /* Make a block for the local symbols within. */
coff_ finish_block( 0 , & coff_ local_symbols, new - > old_blocks , finish_block ( 0 , & local_symbols , new - > old_blocks ,
new - > start_addr , cs - > c_value , objfile ) ; new - > start_addr , cs - > c_value , objfile ) ;
} }
depth - - ; /* Now pop locals of block just finished. */
coff_local_symbols = new - > locals ; local_symbols = new - > locals ;
coff_context_stack = new - > next ;
free ( ( PTR ) new ) ;
} }
break ; break ;
@ -1337,9 +1078,6 @@ init_stringtab (chan, offset)
return 0 ; return 0 ;
stringtab = ( char * ) xmalloc ( length ) ; stringtab = ( char * ) xmalloc ( length ) ;
if ( stringtab = = NULL )
return - 1 ;
memcpy ( stringtab , & length , sizeof length ) ; memcpy ( stringtab , & length , sizeof length ) ;
if ( length = = sizeof length ) /* Empty table -- just the count */ if ( length = = sizeof length ) /* Empty table -- just the count */
return 0 ; return 0 ;
@ -1435,9 +1173,6 @@ init_lineno (chan, offset, size)
/* Allocate the desired table, plus a sentinel */ /* Allocate the desired table, plus a sentinel */
linetab = ( char * ) xmalloc ( size + local_linesz ) ; linetab = ( char * ) xmalloc ( size + local_linesz ) ;
if ( linetab = = NULL )
return - 1 ;
val = myread ( chan , linetab , size ) ; val = myread ( chan , linetab , size ) ;
if ( val ! = size ) if ( val ! = size )
return - 1 ; return - 1 ;
@ -1626,9 +1361,9 @@ process_coff_symbol (cs, aux, objfile)
SYMBOL_CLASS ( sym ) = LOC_BLOCK ; SYMBOL_CLASS ( sym ) = LOC_BLOCK ;
if ( cs - > c_sclass = = C_STAT ) if ( cs - > c_sclass = = C_STAT )
coff_ add_symbol_to_list( sym , & coff_ file_symbols) ; add_symbol_to_list ( sym , & file_symbols ) ;
else if ( cs - > c_sclass = = C_EXT ) else if ( cs - > c_sclass = = C_EXT )
coff_ add_symbol_to_list( sym , & coff_ global_symbols) ; add_symbol_to_list ( sym , & global_symbols ) ;
} }
else else
{ {
@ -1640,13 +1375,13 @@ process_coff_symbol (cs, aux, objfile)
case C_AUTO : case C_AUTO :
SYMBOL_CLASS ( sym ) = LOC_LOCAL ; SYMBOL_CLASS ( sym ) = LOC_LOCAL ;
coff_ add_symbol_to_list( sym , & coff_ local_symbols) ; add_symbol_to_list ( sym , & local_symbols ) ;
break ; break ;
case C_EXT : case C_EXT :
SYMBOL_CLASS ( sym ) = LOC_STATIC ; SYMBOL_CLASS ( sym ) = LOC_STATIC ;
SYMBOL_VALUE_ADDRESS ( sym ) = ( CORE_ADDR ) cs - > c_value ; SYMBOL_VALUE_ADDRESS ( sym ) = ( CORE_ADDR ) cs - > c_value ;
coff_ add_symbol_to_list( sym , & coff_ global_symbols) ; add_symbol_to_list ( sym , & global_symbols ) ;
break ; break ;
case C_STAT : case C_STAT :
@ -1654,11 +1389,11 @@ process_coff_symbol (cs, aux, objfile)
SYMBOL_VALUE_ADDRESS ( sym ) = ( CORE_ADDR ) cs - > c_value ; SYMBOL_VALUE_ADDRESS ( sym ) = ( CORE_ADDR ) cs - > c_value ;
if ( within_function ) { if ( within_function ) {
/* Static symbol of local scope */ /* Static symbol of local scope */
coff_ add_symbol_to_list( sym , & coff_ local_symbols) ; add_symbol_to_list ( sym , & local_symbols ) ;
} }
else { else {
/* Static symbol at top level of file */ /* Static symbol at top level of file */
coff_ add_symbol_to_list( sym , & coff_ file_symbols) ; add_symbol_to_list ( sym , & file_symbols ) ;
} }
break ; break ;
@ -1668,7 +1403,7 @@ process_coff_symbol (cs, aux, objfile)
case C_REG : case C_REG :
SYMBOL_CLASS ( sym ) = LOC_REGISTER ; SYMBOL_CLASS ( sym ) = LOC_REGISTER ;
SYMBOL_VALUE ( sym ) = SDB_REG_TO_REGNUM ( cs - > c_value ) ; SYMBOL_VALUE ( sym ) = SDB_REG_TO_REGNUM ( cs - > c_value ) ;
coff_ add_symbol_to_list( sym , & coff_ local_symbols) ; add_symbol_to_list ( sym , & local_symbols ) ;
break ; break ;
case C_LABEL : case C_LABEL :
@ -1681,7 +1416,7 @@ process_coff_symbol (cs, aux, objfile)
/* Add parameter to function. */ /* Add parameter to function. */
add_param_to_type ( & in_function_type , sym ) ; add_param_to_type ( & in_function_type , sym ) ;
# endif # endif
coff_ add_symbol_to_list( sym , & coff_ local_symbols) ; add_symbol_to_list ( sym , & local_symbols ) ;
# if !defined (BELIEVE_PCC_PROMOTION) && (TARGET_BYTE_ORDER == BIG_ENDIAN) # if !defined (BELIEVE_PCC_PROMOTION) && (TARGET_BYTE_ORDER == BIG_ENDIAN)
/* If PCC says a parameter is a short or a char,
/* If PCC says a parameter is a short or a char,
aligned on an int boundary , realign it to the " little end " aligned on an int boundary , realign it to the " little end "
@ -1700,7 +1435,7 @@ process_coff_symbol (cs, aux, objfile)
case C_REGPARM : case C_REGPARM :
SYMBOL_CLASS ( sym ) = LOC_REGPARM ; SYMBOL_CLASS ( sym ) = LOC_REGPARM ;
SYMBOL_VALUE ( sym ) = SDB_REG_TO_REGNUM ( cs - > c_value ) ; SYMBOL_VALUE ( sym ) = SDB_REG_TO_REGNUM ( cs - > c_value ) ;
coff_ add_symbol_to_list( sym , & coff_ local_symbols) ; add_symbol_to_list ( sym , & local_symbols ) ;
# if !defined (BELIEVE_PCC_PROMOTION) # if !defined (BELIEVE_PCC_PROMOTION)
/* FIXME: This should retain the current type, since it's just
/* FIXME: This should retain the current type, since it's just
a register value . gnu @ adobe , 26F eb93 */ a register value . gnu @ adobe , 26F eb93 */
@ -1741,7 +1476,7 @@ process_coff_symbol (cs, aux, objfile)
SYMBOL_VALUE_CHAIN ( sym ) = opaque_type_chain [ i ] ; SYMBOL_VALUE_CHAIN ( sym ) = opaque_type_chain [ i ] ;
opaque_type_chain [ i ] = sym ; opaque_type_chain [ i ] = sym ;
} }
coff_ add_symbol_to_list( sym , & coff_ file_symbols) ; add_symbol_to_list ( sym , & file_symbols ) ;
break ; break ;
case C_STRTAG : case C_STRTAG :
@ -1760,7 +1495,7 @@ process_coff_symbol (cs, aux, objfile)
TYPE_TAG_NAME ( SYMBOL_TYPE ( sym ) ) = TYPE_TAG_NAME ( SYMBOL_TYPE ( sym ) ) =
concat ( SYMBOL_NAME ( sym ) , NULL ) ; concat ( SYMBOL_NAME ( sym ) , NULL ) ;
coff_ add_symbol_to_list( sym , & coff_ file_symbols) ; add_symbol_to_list ( sym , & file_symbols ) ;
break ; break ;
default : default :
@ -2114,21 +1849,23 @@ coff_read_enum_type (index, length, lastsym)
register struct type * type ; register struct type * type ;
int nsyms = 0 ; int nsyms = 0 ;
int done = 0 ; int done = 0 ;
struct coff_ pending* * symlist ; struct pending * * symlist ;
struct coff_symbol member_sym ; struct coff_symbol member_sym ;
register struct coff_symbol * ms = & member_sym ; register struct coff_symbol * ms = & member_sym ;
struct internal_syment sub_sym ; struct internal_syment sub_sym ;
union internal_auxent sub_aux ; union internal_auxent sub_aux ;
struct coff_pending * osyms , * syms ; struct pending * osyms , * syms ;
int o_nsyms ;
register int n ; register int n ;
char * name ; char * name ;
type = coff_alloc_type ( index ) ; type = coff_alloc_type ( index ) ;
if ( within_function ) if ( within_function )
symlist = & coff_ local_symbols; symlist = & local_symbols ;
else else
symlist = & coff_ file_symbols; symlist = & file_symbols ;
osyms = * symlist ; osyms = * symlist ;
o_nsyms = osyms ? osyms - > nsyms : 0 ;
while ( ! done & & symnum < lastsym & & symnum < nlist_nsyms_global ) while ( ! done & & symnum < lastsym & & symnum < nlist_nsyms_global )
{ {
@ -2146,7 +1883,7 @@ coff_read_enum_type (index, length, lastsym)
SYMBOL_CLASS ( sym ) = LOC_CONST ; SYMBOL_CLASS ( sym ) = LOC_CONST ;
SYMBOL_NAMESPACE ( sym ) = VAR_NAMESPACE ; SYMBOL_NAMESPACE ( sym ) = VAR_NAMESPACE ;
SYMBOL_VALUE ( sym ) = ms - > c_value ; SYMBOL_VALUE ( sym ) = ms - > c_value ;
coff_ add_symbol_to_list( sym , symlist ) ; add_symbol_to_list ( sym , symlist ) ;
nsyms + + ; nsyms + + ;
break ; break ;
@ -2174,15 +1911,28 @@ coff_read_enum_type (index, length, lastsym)
The symbols can be found in the symlist that we put them on The symbols can be found in the symlist that we put them on
to cause them to be defined . osyms contains the old value to cause them to be defined . osyms contains the old value
of that symlist ; everything up to there was defined by us . */ of that symlist ; everything up to there was defined by us . */
/* Note that we preserve the order of the enum constants, so
that in something like " enum {FOO, LAST_THING=FOO} " we print
FOO , not LAST_THING . */
for ( syms = * symlist , n = nsyms ; syms ! = osyms ; syms = syms - > next ) for ( syms = * symlist , n = 0 ; syms ; syms = syms - > next )
{ {
SYMBOL_TYPE ( syms - > symbol ) = type ; int j = 0 ;
TYPE_FIELD_NAME ( type , - - n ) = SYMBOL_NAME ( syms - > symbol ) ; if ( syms = = osyms )
TYPE_FIELD_VALUE ( type , n ) = 0 ; j = o_nsyms ;
TYPE_FIELD_BITPOS ( type , n ) = SYMBOL_VALUE ( syms - > symbol ) ; for ( ; j < syms - > nsyms ; j + + , n + + )
TYPE_FIELD_BITSIZE ( type , n ) = 0 ; {
struct symbol * xsym = syms - > symbol [ j ] ;
SYMBOL_TYPE ( xsym ) = type ;
TYPE_FIELD_NAME ( type , n ) = SYMBOL_NAME ( xsym ) ;
TYPE_FIELD_VALUE ( type , n ) = 0 ;
TYPE_FIELD_BITPOS ( type , n ) = SYMBOL_VALUE ( xsym ) ;
TYPE_FIELD_BITSIZE ( type , n ) = 0 ;
}
if ( syms = = osyms )
break ;
} }
#if 0 #if 0
/* This screws up perfectly good C programs with enums. FIXME. */ /* This screws up perfectly good C programs with enums. FIXME. */
/* Is this Modula-2's BOOLEAN type? Flag it as such if so. */ /* Is this Modula-2's BOOLEAN type? Flag it as such if so. */
Jim Kingdon
33 years ago