Re: [patch] Fix warnings using gcc-4.5 HEAD

Jan Kratochvil
2009-09-08T18:52:30Z

On Thu, 30 Jul 2009 00:12:18 +0200, Tom Tromey wrote:
> >>>>> "Jan" == Jan Kratochvil <jan.kratochvil@redhat.com> writes:
>
> Jan> 2009-07-11 Jan Kratochvil <jan.kratochvil@redhat.com>
> Jan> Fix gcc-4.5 HEAD warnings for enum ada_operator.
> Jan> * Makefile.in (HFILES_NO_SRCDIR): Add ada-operator.inc.
> Jan> * ada-lang.h (enum ada_operator): Move it to ...
> Jan> * ada-operator.inc: ... a new file.
> Jan> * expression.h (enum exp_opcode): Include ada-operator.inc.
> Jan> New element OP_UNUSED_LAST.
>
> I'd like Joel to comment on the Ada changes.

Hi Joel, pinging for 7.0, this reply is to:
http://sourceware.org/ml/gdb-patches/2009-07/msg00721.html

> At the very least, the comment above OP_EXTENDED0 needs to be updated.
> It mentions the extension enum approach, which now can't be used.

Thanks for the notice, updated.

Updated minor patch conflict due to HEAD updates.

Regression retested on {x86_64,i686}-fedora11-linux-gnu.

Thanks,
Jan

gdb/
2009-09-08 Jan Kratochvil <jan.kratochvil@redhat.com>

Fix gcc-4.5 HEAD warnings for enum ada_operator.
* Makefile.in (HFILES_NO_SRCDIR): Add ada-operator.inc.
* ada-lang.h (enum ada_operator): Move it to ...
* ada-operator.inc: ... a new file.
* expression.h (enum exp_opcode): Include ada-operator.inc.
New element OP_UNUSED_LAST. Update comment for OP_EXTENDED0.

Fix gcc-4.5 HEAD warnings for GDB_FORM_cached_string.
* dwarf2read.c (GDB_FORM_cached_string)
(dwarf_form_name <GDB_FORM_cached_string>): Remove.
(struct attribute <dwarf_form>): Reduce the bit width.
(struct attribute <string_is_canonical>, DW_STRING_IS_CANONICAL): New.
(read_attribute_value <DW_FORM_string>)
(read_attribute_value <DW_FORM_strp>): Initialize
DW_STRING_IS_CANONICAL.
(dwarf2_name, dump_die_shallow <DW_FORM_string>)
(dump_die_shallow <DW_FORM_strp>): Update the code using former
GDB_FORM_cached_string.

--- a/gdb/Makefile.in
+++ b/gdb/Makefile.in
@@ -746,7 +746,7 @@ config/rs6000/nm-rs6000.h top.h bsd-kvm.h gdb-stabs.h reggroups.h \
annotate.h sim-regno.h dictionary.h dfp.h main.h frame-unwind.h \
remote-fileio.h i386-linux-tdep.h vax-tdep.h objc-lang.h \
sentinel-frame.h bcache.h symfile.h windows-tdep.h linux-tdep.h \
-gdb_usleep.h jit.h
+gdb_usleep.h jit.h ada-operator.inc

# Header files that already have srcdir in them, or which are in objdir.

--- a/gdb/ada-lang.h
+++ b/gdb/ada-lang.h
@@ -79,92 +79,6 @@ struct ada_opname_map
/* Defined in ada-lang.c */
extern const struct ada_opname_map ada_opname_table[];

-enum ada_operator
- {
- /* X IN A'RANGE(N). N is an immediate operand, surrounded by
- BINOP_IN_BOUNDS before and after. A is an array, X an index
- value. Evaluates to true iff X is within range of the Nth
- dimension (1-based) of A. (A multi-dimensional array
- type is represented as array of array of ...) */
- BINOP_IN_BOUNDS = OP_EXTENDED0,
-
- /* X IN L .. U. True iff L <= X <= U. */
- TERNOP_IN_RANGE,
-
- /* Ada attributes ('Foo). */
- OP_ATR_FIRST,
- OP_ATR_LAST,
- OP_ATR_LENGTH,
- OP_ATR_IMAGE,
- OP_ATR_MAX,
- OP_ATR_MIN,
- OP_ATR_MODULUS,
- OP_ATR_POS,
- OP_ATR_SIZE,
- OP_ATR_TAG,
- OP_ATR_VAL,
-
- /* Ada type qualification. It is encoded as for UNOP_CAST, above,
- and denotes the TYPE'(EXPR) construct. */
- UNOP_QUAL,
-
- /* X IN TYPE. The `TYPE' argument is immediate, with
- UNOP_IN_RANGE before and after it. True iff X is a member of
- type TYPE (typically a subrange). */
- UNOP_IN_RANGE,
-
- /* An aggregate. A single immediate operand, N>0, gives
- the number of component specifications that follow. The
- immediate operand is followed by a second OP_AGGREGATE.
- Next come N component specifications. A component
- specification is either an OP_OTHERS (others=>...), an
- OP_CHOICES (for named associations), or other expression (for
- positional aggregates only). Aggregates currently
- occur only as the right sides of assignments. */
- OP_AGGREGATE,
-
- /* An others clause. Followed by a single expression. */
- OP_OTHERS,
-
- /* An aggregate component association. A single immediate operand, N,
- gives the number of choices that follow. This is followed by a second
- OP_CHOICES operator. Next come N operands, each of which is an
- expression, an OP_DISCRETE_RANGE, or an OP_NAME---the latter
- for a simple name that must be a record component name and does
- not correspond to a single existing symbol. After the N choice
- indicators comes an expression giving the value.
-
- In an aggregate such as (X => E1, ...), where X is a simple
- name, X could syntactically be either a component_selector_name
- or an expression used as a discrete_choice, depending on the
- aggregate's type context. Since this is not known at parsing
- time, we don't attempt to disambiguate X if it has multiple
- definitions, but instead supply an OP_NAME. If X has a single
- definition, we represent it with an OP_VAR_VALUE, even though
- it may turn out to be within a record aggregate. Aggregate
- evaluation can use either OP_NAMEs or OP_VAR_VALUEs to get a
- record field name, and can evaluate OP_VAR_VALUE normally to
- get its value as an expression. Unfortunately, we lose out in
- cases where X has multiple meanings and is part of an array
- aggregate. I hope these are not common enough to annoy users,
- who can work around the problem in any case by putting
- parentheses around X. */
- OP_CHOICES,
-
- /* A positional aggregate component association. The operator is
- followed by a single integer indicating the position in the
- aggregate (0-based), followed by a second OP_POSITIONAL. Next
- follows a single expression giving the component value. */
- OP_POSITIONAL,
-
- /* A range of values. Followed by two expressions giving the
- upper and lower bounds of the range. */
- OP_DISCRETE_RANGE,
-
- /* End marker */
- OP_ADA_LAST
- };
-
/* A tuple, (symbol, block), representing one instance of a
* symbol-lookup operation. */
struct ada_symbol_info {
--- /dev/null
+++ b/gdb/ada-operator.inc
@@ -0,0 +1,102 @@
+/* Ada language operator definitions for GDB, the GNU debugger.
+
+ Copyright (C) 1992, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
+ 2007, 2008, 2009 Free Software Foundation, Inc.
+
+ This file is part of GDB.
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
+
+ /* X IN A'RANGE(N). N is an immediate operand, surrounded by
+ BINOP_IN_BOUNDS before and after. A is an array, X an index
+ value. Evaluates to true iff X is within range of the Nth
+ dimension (1-based) of A. (A multi-dimensional array
+ type is represented as array of array of ...) */
+ BINOP_IN_BOUNDS = OP_EXTENDED0,
+
+ /* X IN L .. U. True iff L <= X <= U. */
+ TERNOP_IN_RANGE,
+
+ /* Ada attributes ('Foo). */
+ OP_ATR_FIRST,
+ OP_ATR_LAST,
+ OP_ATR_LENGTH,
+ OP_ATR_IMAGE,
+ OP_ATR_MAX,
+ OP_ATR_MIN,
+ OP_ATR_MODULUS,
+ OP_ATR_POS,
+ OP_ATR_SIZE,
+ OP_ATR_TAG,
+ OP_ATR_VAL,
+
+ /* Ada type qualification. It is encoded as for UNOP_CAST, above,
+ and denotes the TYPE'(EXPR) construct. */
+ UNOP_QUAL,
+
+ /* X IN TYPE. The `TYPE' argument is immediate, with
+ UNOP_IN_RANGE before and after it. True iff X is a member of
+ type TYPE (typically a subrange). */
+ UNOP_IN_RANGE,
+
+ /* An aggregate. A single immediate operand, N>0, gives
+ the number of component specifications that follow. The
+ immediate operand is followed by a second OP_AGGREGATE.
+ Next come N component specifications. A component
+ specification is either an OP_OTHERS (others=>...), an
+ OP_CHOICES (for named associations), or other expression (for
+ positional aggregates only). Aggregates currently
+ occur only as the right sides of assignments. */
+ OP_AGGREGATE,
+
+ /* An others clause. Followed by a single expression. */
+ OP_OTHERS,
+
+ /* An aggregate component association. A single immediate operand, N,
+ gives the number of choices that follow. This is followed by a second
+ OP_CHOICES operator. Next come N operands, each of which is an
+ expression, an OP_DISCRETE_RANGE, or an OP_NAME---the latter
+ for a simple name that must be a record component name and does
+ not correspond to a single existing symbol. After the N choice
+ indicators comes an expression giving the value.
+
+ In an aggregate such as (X => E1, ...), where X is a simple
+ name, X could syntactically be either a component_selector_name
+ or an expression used as a discrete_choice, depending on the
+ aggregate's type context. Since this is not known at parsing
+ time, we don't attempt to disambiguate X if it has multiple
+ definitions, but instead supply an OP_NAME. If X has a single
+ definition, we represent it with an OP_VAR_VALUE, even though
+ it may turn out to be within a record aggregate. Aggregate
+ evaluation can use either OP_NAMEs or OP_VAR_VALUEs to get a
+ record field name, and can evaluate OP_VAR_VALUE normally to
+ get its value as an expression. Unfortunately, we lose out in
+ cases where X has multiple meanings and is part of an array
+ aggregate. I hope these are not common enough to annoy users,
+ who can work around the problem in any case by putting
+ parentheses around X. */
+ OP_CHOICES,
+
+ /* A positional aggregate component association. The operator is
+ followed by a single integer indicating the position in the
+ aggregate (0-based), followed by a second OP_POSITIONAL. Next
+ follows a single expression giving the component value. */
+ OP_POSITIONAL,
+
+ /* A range of values. Followed by two expressions giving the
+ upper and lower bounds of the range. */
+ OP_DISCRETE_RANGE,
+
+ /* End marker */
+ OP_ADA_LAST,
--- a/gdb/dwarf2read.c
+++ b/gdb/dwarf2read.c
@@ -546,20 +546,17 @@ struct attr_abbrev
ENUM_BITFIELD(dwarf_form) form : 16;
};

-/* Additional GDB-specific attribute forms. */
-enum
- {
- /* A string which has been updated to GDB's internal
- representation (e.g. converted to canonical form) and does not
- need to be updated again. */
- GDB_FORM_cached_string = 0xff
- };
-
/* Attributes have a name and a value */
struct attribute
{
ENUM_BITFIELD(dwarf_attribute) name : 16;
- ENUM_BITFIELD(dwarf_form) form : 16;
+ ENUM_BITFIELD(dwarf_form) form : 15;
+
+ /* Has DW_STRING already been updated by dwarf2_canonicalize_name? This
+ field should be in u.str (existing only for DW_STRING) but it is kept
+ here for better struct attribute alignment. */
+ unsigned int string_is_canonical : 1;
+
union
{
char *str;
@@ -613,6 +610,7 @@ struct function_range
/* Get at parts of an attribute structure */

#define DW_STRING(attr) ((attr)->u.str)
+#define DW_STRING_IS_CANONICAL(attr) ((attr)->string_is_canonical)
#define DW_UNSND(attr) ((attr)->u.unsnd)
#define DW_BLOCK(attr) ((attr)->u.blk)
#define DW_SND(attr) ((attr)->u.snd)
@@ -7006,11 +7004,13 @@ read_attribute_value (struct attribute *attr, unsigned form,
break;
case DW_FORM_string:
DW_STRING (attr) = read_string (abfd, info_ptr, &bytes_read);
+ DW_STRING_IS_CANONICAL (attr) = 0;
info_ptr += bytes_read;
break;
case DW_FORM_strp:
DW_STRING (attr) = read_indirect_string (abfd, info_ptr, cu_header,
&bytes_read);
+ DW_STRING_IS_CANONICAL (attr) = 0;
info_ptr += bytes_read;
break;
case DW_FORM_block:
@@ -9020,12 +9020,12 @@ dwarf2_name (struct die_info *die, struct dwarf2_cu *cu)
to canonicalize them. */
return DW_STRING (attr);
default:
- if (attr->form != GDB_FORM_cached_string)
+ if (!DW_STRING_IS_CANONICAL (attr))
{
DW_STRING (attr)
= dwarf2_canonicalize_name (DW_STRING (attr), cu,
&cu->objfile->objfile_obstack);
- attr->form = GDB_FORM_cached_string;
+ DW_STRING_IS_CANONICAL (attr) = 1;
}
return DW_STRING (attr);
}
@@ -9536,8 +9536,6 @@ dwarf_form_name (unsigned form)
return "DW_FORM_flag_present";
case DW_FORM_sig8:
return "DW_FORM_sig8";
- case GDB_FORM_cached_string:
- return "GDB_FORM_cached_string";
default:
return "DW_FORM_<unknown>";
}
@@ -10090,10 +10088,10 @@ dump_die_shallow (struct ui_file *f, int indent, struct die_info *die)
break;
case DW_FORM_string:
case DW_FORM_strp:
- case GDB_FORM_cached_string:
- fprintf_unfiltered (f, "string: \"%s\"",
+ fprintf_unfiltered (f, "string: \"%s\" (%s canonicalized)",
DW_STRING (&die->attrs[i])
- ? DW_STRING (&die->attrs[i]) : "");
+ ? DW_STRING (&die->attrs[i]) : "",
+ DW_STRING_IS_CANONICAL (&die->attrs[i]) ? "is" : "not");
break;
case DW_FORM_flag:
if (DW_UNSND (&die->attrs[i]))
--- a/gdb/expression.h
+++ b/gdb/expression.h
@@ -335,24 +335,27 @@ enum exp_opcode
OP_DECFLOAT,

/* First extension operator. Individual language modules define
- extra operators they need as constants with values
- OP_LANGUAGE_SPECIFIC0 + k, for k >= 0, using a separate
- enumerated type definition:
- enum foo_extension_operator {
+ extra operators in *.inc include files below always starting with
+ numbering at OP_EXTENDED0:
BINOP_MOGRIFY = OP_EXTENDED0,
BINOP_FROB,
- ...
- }; */
+ ... */
OP_EXTENDED0,

/* Last possible extension operator. Defined to provide an
explicit and finite number of extended operators. */
- OP_EXTENDED_LAST = 0xff
+ OP_EXTENDED_LAST = 0xff,
/* NOTE: Eventually, we expect to convert to an object-oriented
formulation for expression operators that does away with the
need for these extension operators, and indeed for this
entire enumeration type. Therefore, consider the OP_EXTENDED
definitions to be a temporary measure. */
+
+ /* Each language specific set of operators starts at OP_EXTENDED0. */
+#include "ada-operator.inc"
+
+ /* Existing only to swallow the last comma (',') from last .inc file. */
+ OP_UNUSED_LAST
};

union exp_element