From 8285870aeb368fe27af00e8be80261fcda320211 Mon Sep 17 00:00:00 2001 From: Jan Kratochvil Date: Tue, 15 Sep 2009 16:09:32 +0000 Subject: [PATCH] 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 ): Remove. (struct attribute ): Reduce the bit width. (struct attribute , DW_STRING_IS_CANONICAL): New. (read_attribute_value ) (read_attribute_value ): Initialize DW_STRING_IS_CANONICAL. (dwarf2_name, dump_die_shallow ) (dump_die_shallow ): Update the code using former GDB_FORM_cached_string. --- gdb/ChangeLog | 21 +++++++++ gdb/Makefile.in | 2 +- gdb/ada-lang.h | 86 ------------------------------------ gdb/ada-operator.inc | 102 +++++++++++++++++++++++++++++++++++++++++++ gdb/dwarf2read.c | 32 +++++++------- gdb/expression.h | 17 +++++--- 6 files changed, 149 insertions(+), 111 deletions(-) create mode 100644 gdb/ada-operator.inc diff --git a/gdb/ChangeLog b/gdb/ChangeLog index c1018455bb2..57caa24a790 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,3 +1,24 @@ +2009-09-15 Jan Kratochvil + + 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 ): Remove. + (struct attribute ): Reduce the bit width. + (struct attribute , DW_STRING_IS_CANONICAL): New. + (read_attribute_value ) + (read_attribute_value ): Initialize + DW_STRING_IS_CANONICAL. + (dwarf2_name, dump_die_shallow ) + (dump_die_shallow ): Update the code using former + GDB_FORM_cached_string. + 2009-09-14 Sergio Durigan Junior * amd64-linux-tdep.c: Include xml-syscall.h header, define the XML diff --git a/gdb/Makefile.in b/gdb/Makefile.in index d42d6fb7271..f5e1ddeff42 100644 --- a/gdb/Makefile.in +++ b/gdb/Makefile.in @@ -750,7 +750,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 xml-syscall.h +gdb_usleep.h jit.h xml-syscall.h ada-operator.inc # Header files that already have srcdir in them, or which are in objdir. diff --git a/gdb/ada-lang.h b/gdb/ada-lang.h index c314867ba1a..8a465d4e95b 100644 --- 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 { diff --git a/gdb/ada-operator.inc b/gdb/ada-operator.inc new file mode 100644 index 00000000000..aba44619bb0 --- /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 . */ + + /* 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, diff --git a/gdb/dwarf2read.c b/gdb/dwarf2read.c index 9be9356b248..4cce36b6f19 100644 --- 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_"; } @@ -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])) diff --git a/gdb/expression.h b/gdb/expression.h index 12163e3949e..effe1f042ed 100644 --- 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 -- 2.30.2