[patch] Fix warnings using gcc-4.5 HEAD

[patch] Fix warnings using gcc-4.5 HEAD

[Jan Kratochvil]

Hi,

currently GDB CVS HEAD cannot be built with gcc SVN HEAD
gcc (GCC) 4.5.0 20090711 (experimental)

ada-lang.c: In function ‘ada_attribute_name’:
ada-lang.c:7501:9: error: comparison between ‘enum exp_opcode’ and ‘enum ada_operator’
ada-lang.c: In function ‘assign_component’:
ada-lang.c:8008:30: error: comparison between ‘enum exp_opcode’ and ‘enum ada_operator’
ada-lang.c: In function ‘aggregate_assign_from_choices’:
ada-lang.c:8163:14: error: comparison between ‘enum exp_opcode’ and ‘enum ada_operator’
ada-lang.c: In function ‘ada_evaluate_subexp’:
ada-lang.c:8581:34: error: comparison between ‘enum exp_opcode’ and ‘enum ada_operator’
ada-lang.c:9201:13: error: comparison between ‘enum exp_opcode’ and ‘enum ada_operator’
cp-name-parser.y: In function ‘cp_comp_to_string’:
cp-name-parser.y:1982:20: error: comparison between ‘enum demangle_component_type’ and ‘enum <anonymous>’
cp-name-parser.y:1987:25: error: comparison between ‘enum demangle_component_type’ and ‘enum <anonymous>’
dwarf2read.c: In function ‘dwarf2_name’:
dwarf2read.c:8513:22: error: comparison between ‘enum dwarf_form’ and ‘enum <anonymous>’

Regression tested on x86_64-fedora-linux-gnu using gcc-4.4.0-4/Fedora.

Using gcc-4.5.0-20090711/SVN there are some testsuite regressions due to the
built gcc target testcases - assuming not due to the built host gdb.


Thanks,
Jan


gdb/
2009-07-11  Jan Kratochvil  <jan.kratochvil@redhat.com>

	Fix gcc-4.5 HEAD warnings.
	* ada-lang.h (enum ada_operator): Make the enum anonymous.
	(BINOP_IN_BOUNDS, TERNOP_IN_RANGE, 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, UNOP_QUAL)
	(UNOP_IN_RANGE, OP_AGGREGATE, OP_OTHERS, OP_CHOICES, OP_POSITIONAL)
	(OP_DISCRETE_RANGE): New casted #defines.
	* cp-name-parser.y (GLOBAL_CONSTRUCTORS, GLOBAL_DESTRUCTORS): Replace
	the enum by casted #defines.
	* dwarf2read.c (GDB_FORM_cached_string): Likewise.

--- a/gdb/ada-lang.h
+++ b/gdb/ada-lang.h
@@ -79,7 +79,9 @@ struct ada_opname_map
 /* Defined in ada-lang.c */
 extern const struct ada_opname_map ada_opname_table[];
 
-enum ada_operator 
+/* Extend enum exp_opcode so that its new elements have the same type using
+   #defines below.  */
+enum
   {
     /* 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 
@@ -87,31 +89,46 @@ enum ada_operator
        dimension (1-based) of A.  (A multi-dimensional array
        type is represented as array of array of ...) */
     BINOP_IN_BOUNDS = OP_EXTENDED0,
+#define BINOP_IN_BOUNDS ((enum exp_opcode) BINOP_IN_BOUNDS)
 
     /* X IN L .. U.  True iff L <= X <= U.  */
     TERNOP_IN_RANGE,
+#define TERNOP_IN_RANGE ((enum exp_opcode) TERNOP_IN_RANGE)
 
     /* Ada attributes ('Foo). */
     OP_ATR_FIRST,
+#define OP_ATR_FIRST ((enum exp_opcode) OP_ATR_FIRST)
     OP_ATR_LAST,
+#define OP_ATR_LAST ((enum exp_opcode) OP_ATR_LAST)
     OP_ATR_LENGTH,
+#define OP_ATR_LENGTH ((enum exp_opcode) OP_ATR_LENGTH)
     OP_ATR_IMAGE,
+#define OP_ATR_IMAGE ((enum exp_opcode) OP_ATR_IMAGE)
     OP_ATR_MAX,
+#define OP_ATR_MAX ((enum exp_opcode) OP_ATR_MAX)
     OP_ATR_MIN,
+#define OP_ATR_MIN ((enum exp_opcode) OP_ATR_MIN)
     OP_ATR_MODULUS,
+#define OP_ATR_MODULUS ((enum exp_opcode) OP_ATR_MODULUS)
     OP_ATR_POS,
+#define OP_ATR_POS ((enum exp_opcode) OP_ATR_POS)
     OP_ATR_SIZE,
+#define OP_ATR_SIZE ((enum exp_opcode) OP_ATR_SIZE)
     OP_ATR_TAG,
+#define OP_ATR_TAG ((enum exp_opcode) OP_ATR_TAG)
     OP_ATR_VAL,
+#define OP_ATR_VAL ((enum exp_opcode) OP_ATR_VAL)
 
     /* Ada type qualification.  It is encoded as for UNOP_CAST, above, 
        and denotes the TYPE'(EXPR) construct. */
     UNOP_QUAL,
+#define UNOP_QUAL ((enum exp_opcode) 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,
+#define UNOP_IN_RANGE ((enum exp_opcode) UNOP_IN_RANGE)
 
     /* An aggregate.   A single immediate operand, N>0, gives
        the number of component specifications that follow.  The
@@ -122,9 +139,11 @@ enum ada_operator
        positional aggregates only).  Aggregates currently
        occur only as the right sides of assignments. */
     OP_AGGREGATE,
+#define OP_AGGREGATE ((enum exp_opcode) OP_AGGREGATE)
 
     /* An others clause.  Followed by a single expression. */
     OP_OTHERS,
+#define OP_OTHERS ((enum exp_opcode) OP_OTHERS)
 
     /* An aggregate component association.  A single immediate operand, N, 
        gives the number of choices that follow.  This is followed by a second
@@ -150,16 +169,19 @@ enum ada_operator
        who can work around the problem in any case by putting
        parentheses around X. */
     OP_CHOICES,
+#define OP_CHOICES ((enum exp_opcode) 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,
+#define OP_POSITIONAL ((enum exp_opcode) OP_POSITIONAL)
 
     /* A range of values.  Followed by two expressions giving the
        upper and lower bounds of the range. */
-    OP_DISCRETE_RANGE,       
+    OP_DISCRETE_RANGE,
+#define OP_DISCRETE_RANGE ((enum exp_opcode) OP_DISCRETE_RANGE)
 
     /* End marker */
     OP_ADA_LAST
--- a/gdb/cp-name-parser.y
+++ b/gdb/cp-name-parser.y
@@ -316,10 +316,8 @@ make_name (const char *name, int len)
 %token <typed_val_int> GLOBAL
 
 %{
-enum {
-  GLOBAL_CONSTRUCTORS = DEMANGLE_COMPONENT_LITERAL + 20,
-  GLOBAL_DESTRUCTORS = DEMANGLE_COMPONENT_LITERAL + 21
-};
+#define GLOBAL_CONSTRUCTORS (DEMANGLE_COMPONENT_LITERAL + 20)
+#define GLOBAL_DESTRUCTORS (DEMANGLE_COMPONENT_LITERAL + 21)
 %}
 
 /* Precedence declarations.  */
--- a/gdb/dwarf2read.c
+++ b/gdb/dwarf2read.c
@@ -501,14 +501,11 @@ 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
-  };
+/* Additional GDB-specific attribute form:
+
+   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.  */
+#define GDB_FORM_cached_string ((enum dwarf_form) 0xff)
 
 /* Attributes have a name and a value */
 struct attribute

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

[Mark Kettenis]

> Date: Sat, 11 Jul 2009 10:25:02 +0200
> From: Jan Kratochvil <jan.kratochvil@redhat.com>
> 
> Hi,
> 
> currently GDB CVS HEAD cannot be built with gcc SVN HEAD
> gcc (GCC) 4.5.0 20090711 (experimental)
> 
> gdb/
> 2009-07-11  Jan Kratochvil  <jan.kratochvil@redhat.com>
> 
> 	Fix gcc-4.5 HEAD warnings.
> 	* ada-lang.h (enum ada_operator): Make the enum anonymous.
> 	(BINOP_IN_BOUNDS, TERNOP_IN_RANGE, 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, UNOP_QUAL)
> 	(UNOP_IN_RANGE, OP_AGGREGATE, OP_OTHERS, OP_CHOICES, OP_POSITIONAL)
> 	(OP_DISCRETE_RANGE): New casted #defines.
> 	* cp-name-parser.y (GLOBAL_CONSTRUCTORS, GLOBAL_DESTRUCTORS): Replace
> 	the enum by casted #defines.
> 	* dwarf2read.c (GDB_FORM_cached_string): Likewise.

Yuck, this is beyond ugly.

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

[Jan Kratochvil]

On Sat, 11 Jul 2009 10:36:05 +0200, Mark Kettenis wrote:
> Yuck, this is beyond ugly.

I agree, just I did not want to comment my patch this way myself.

There is no way how to extend 3rd party enum X definition:
error: nested redefinition of ‘enum X’
error: redeclaration of ‘enum X’


Thanks,
Jan

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

[Eli Zaretskii]

> Date: Sat, 11 Jul 2009 10:39:28 +0200
> From: Jan Kratochvil <jan.kratochvil@redhat.com>
> Cc: gdb-patches@sourceware.org
> 
> There is no way how to extend 3rd party enum X definition:
> error: nested redefinition of ‘enum X’
> error: redeclaration of ‘enum X’

Aren't there ways of cleaning this up other than extending existing
enum definitions?

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

[Jan Kratochvil]

On Sat, 11 Jul 2009 11:27:48 +0200, Eli Zaretskii wrote:
> Aren't there ways of cleaning this up other than extending existing
> enum definitions?

The third part is going to be posted separately for libiberty/ demangler to
gcc-patches.

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


Thanks,
Jan


gdb/
2009-07-11  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.

	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
+gdb_usleep.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
@@ -501,20 +501,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;
@@ -567,6 +564,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)
@@ -6523,11 +6521,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:
@@ -8510,12 +8510,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);
     }
@@ -9013,8 +9013,6 @@ dwarf_form_name (unsigned form)
       return "DW_FORM_ref_udata";
     case DW_FORM_indirect:
       return "DW_FORM_indirect";
-    case GDB_FORM_cached_string:
-      return "GDB_FORM_cached_string";
     default:
       return "DW_FORM_<unknown>";
     }
@@ -9560,10 +9558,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
@@ -347,12 +347,18 @@ enum exp_opcode
   
     /* 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

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

[Tom Tromey]

>>>>> "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.

They seem reasonable enough to me.  I was unaware of enum ada_operator,
yikes.

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.

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

This part is ok.

Jan>      /* NOTE: Eventually, we expect to convert to an object-oriented 
Jan>         formulation for expression operators that does away with the
Jan>         need for these extension operators, and indeed for this
Jan>         entire enumeration type.  Therefore, consider the OP_EXTENDED
Jan>         definitions to be a temporary measure. */

This comment is nearly 6 years old :(

Tom

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

[Jan Kratochvil]

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

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

[Joel Brobecker]

> > 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

The Ada part seems fine. I'm left wondering if it really brings much
value to have this in a separate file, rather than added directly to
enum exp_opcode inside expression.h, especially since other languages
are now having visibility on these enumerates.  But the the benefits
are not obvious either way to me, so let's not worry about this for now.

Do you want me to look at the rest of the patch as well, or did someone
(Tom?) look at that already?

-- 
Joel

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

[Jan Kratochvil]

On Thu, 10 Sep 2009 03:48:21 +0200, Joel Brobecker wrote:
> The Ada part seems fine. I'm left wondering if it really brings much
> value to have this in a separate file, rather than added directly to
> enum exp_opcode inside expression.h, especially since other languages
> are now having visibility on these enumerates.  But the the benefits
> are not obvious either way to me, so let's not worry about this for now.

OK, I (also) do not have a strict opinion on it.


> Do you want me to look at the rest of the patch as well, or did someone
> (Tom?) look at that already?

Except for the changed comment for OP_EXTENDED0 the whole patch is now
approved, the other part by Tom:
	http://sourceware.org/ml/gdb-patches/2009-07/msg00721.html

Going to check it in on weekend if nobody replies.


Thanks,
Jan

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

[Jan Kratochvil]

Hi all,

Checked-in:
	http://sourceware.org/ml/gdb-cvs/2009-09/msg00080.html

gdb/
	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.
	
gdb/
	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.


Thanks,
Jan

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

[Eli Zaretskii]

> Date: Sat, 11 Jul 2009 10:36:05 +0200 (CEST)
> From: Mark Kettenis <mark.kettenis@xs4all.nl>
> CC: gdb-patches@sourceware.org
> 
> > Date: Sat, 11 Jul 2009 10:25:02 +0200
> > From: Jan Kratochvil <jan.kratochvil@redhat.com>
> > 
> > Hi,
> > 
> > currently GDB CVS HEAD cannot be built with gcc SVN HEAD
> > gcc (GCC) 4.5.0 20090711 (experimental)
> > 
> > gdb/
> > 2009-07-11  Jan Kratochvil  <jan.kratochvil@redhat.com>
> > 
> > 	Fix gcc-4.5 HEAD warnings.
> > 	* ada-lang.h (enum ada_operator): Make the enum anonymous.
> > 	(BINOP_IN_BOUNDS, TERNOP_IN_RANGE, 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, UNOP_QUAL)
> > 	(UNOP_IN_RANGE, OP_AGGREGATE, OP_OTHERS, OP_CHOICES, OP_POSITIONAL)
> > 	(OP_DISCRETE_RANGE): New casted #defines.
> > 	* cp-name-parser.y (GLOBAL_CONSTRUCTORS, GLOBAL_DESTRUCTORS): Replace
> > 	the enum by casted #defines.
> > 	* dwarf2read.c (GDB_FORM_cached_string): Likewise.
> 
> Yuck, this is beyond ugly.

Agreed.

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

[Daniel Jacobowitz]

On Sat, Jul 11, 2009 at 10:25:02AM +0200, Jan Kratochvil wrote:
> Hi,
> 
> currently GDB CVS HEAD cannot be built with gcc SVN HEAD
> gcc (GCC) 4.5.0 20090711 (experimental)
> 
> ada-lang.c: In function ‘ada_attribute_name’:
> ada-lang.c:7501:9: error: comparison between ‘enum exp_opcode’ and ‘enum ada_operator’

In general, I've been advised that variables affected by this:

> dwarf2read.c: In function ‘dwarf2_name’:
> dwarf2read.c:8513:22: error: comparison between ‘enum dwarf_form’ and ‘enum <anonymous>’

Should actually use int variables since they aren't really of a single
enum's type.

I really don't like this warning, though.

-- 
Daniel Jacobowitz
CodeSourcery