espressif/binutils-gdb
1
0
Fork 0
mirror of https://github.com/espressif/binutils-gdb.git synced 2025-10-19 13:53:29 +08:00
Code Issues Packages Projects Releases Wiki Activity

Arrange for enumeration members to be manipulated in source code order,

Browse Source 
since they are stored in the Dwarf info in reverse order.
This commit is contained in:
Fred Fish
1991-12-05 05:09:20 +00:00
parent 3c7cc3b70e
commit 98618bf78a
2 changed files with 21 additions and 3 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
gdb/ChangeLog
View File

@ -1,3 +1,9 @@
Wed Dec 4 21:05:30 1991 Fred Fish (fnf at cygnus.com)
* dwarfread (enum_type): Arrange for the order of enumeration
members to match the source code order; not the order in the
Dwarf information, which is explicitly reverse order.
Wed Dec 4 18:24:39 1991 John Gilmore (gnu at cygnus.com) Wed Dec 4 18:24:39 1991 John Gilmore (gnu at cygnus.com)
* main.c (input_from_terminal_p): Check whether GDB has a * main.c (input_from_terminal_p): Check whether GDB has a

18
gdb/dwarfread.c
View File

@ -1330,6 +1330,16 @@ DESCRIPTION
Given a pointer to a die information structure for the die which Given a pointer to a die information structure for the die which
starts an enumeration, process all the dies that define the members starts an enumeration, process all the dies that define the members
of the enumeration and return a type pointer for the enumeration. of the enumeration and return a type pointer for the enumeration.
Note that the DWARF specification explicitly mandates that enum
constants occur in reverse order from the source program order,
for "consistency" and because this ordering is easier for many
compilers to generate. (Draft 5, sec 3.9.5, Enumeration type
Entries)
Because gdb wants to see the enum members in program source
order, we have to ensure that the order gets reversed while
we are processing them.
*/ */
static struct type * static struct type *
@ -1406,14 +1416,16 @@ DEFUN(enum_type, (dip), struct dieinfo *dip)
nfields++; nfields++;
} }
} }
/* Now create the vector of fields, and record how big it is. */ /* Now create the vector of fields, and record how big it is. This is where
we reverse the order, by pulling the members of the list in reverse order
from how they were inserted. */
TYPE_NFIELDS (type) = nfields; TYPE_NFIELDS (type) = nfields;
TYPE_FIELDS (type) = (struct field *) TYPE_FIELDS (type) = (struct field *)
obstack_alloc (symbol_obstack, sizeof (struct field) * nfields); obstack_alloc (symbol_obstack, sizeof (struct field) * nfields);
/* Copy the saved-up fields into the field vector. */ /* Copy the saved-up fields into the field vector. */
for (n = nfields; list; list = list -> next) for (n = 0; (n < nfields) && (list != NULL); list = list -> next)
{ {
TYPE_FIELD (type, --n) = list -> field; TYPE_FIELD (type, n++) = list -> field;
} }
return (type); return (type);
} }