[193/203] Remove unused Ada opcodes

Message ID 20210101214723.1784144-194-tom@tromey.com
State Superseded
Headers show
  • Refactor expressions
Related show

Commit Message

Tom Tromey Jan. 1, 2021, 9:47 p.m.
Several Ada expression opcodes are now unused, and can be removed.
Most of these are handled in a different way by the code.
OP_ATR_IMAGE, however, was never implemented.

2021-01-01  Tom Tromey  <tom@tromey.com>

	* std-operator.def (OP_NAME, OP_ATR_IMAGE, OP_ATR_MODULUS)
 gdb/ChangeLog        |  6 ++++++
 gdb/std-operator.def | 43 -------------------------------------------
 2 files changed, 6 insertions(+), 43 deletions(-)



diff --git a/gdb/std-operator.def b/gdb/std-operator.def
index ab94636b83f..dbd920974da 100644
--- a/gdb/std-operator.def
+++ b/gdb/std-operator.def
@@ -299,9 +299,6 @@  OP (OP_FUNC_STATIC_VAR)
    the GDB "::" operator, or the Modula-2 '.' operator.  */
-/* An un-looked-up identifier.  */
 /* An Objective C Foundation Class NSString constant.  */
@@ -349,8 +346,6 @@  OP (TERNOP_IN_RANGE)
@@ -375,44 +370,6 @@  OP (UNOP_IN_RANGE)
    occur only as the right sides of assignments. */
-/* An others clause.  Followed by a single expression. */
-/* 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. */
-/* 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.  */
-/* A range of values.  Followed by two expressions giving the
-   upper and lower bounds of the range. */
 /* ================ Fortran operators ================ */
 /* This is EXACTLY like OP_FUNCALL but is semantically different.