[PATCH 186/203] Remove now-unused Fortran evaluator code

Tom Tromey
2021-01-01T21:49:59Z

Now that the Fortran parser has switched to the new style, there is no
need for the old Fortran evaluation code.

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

* f-lang.h (class f_language) <expresssion_ops>: Remove.
<exp_descriptor_tab>: Remove.
* f-lang.c (fortran_value_subarray, evaluate_subexp_f)
(operator_length_f, print_unop_subexp_f, print_binop_subexp_f)
(print_subexp_f, dump_subexp_body_f, operator_check_f)
(f_language::exp_descriptor_tab): Remove.
---
gdb/ChangeLog | 9 +
gdb/f-lang.c | 735 --------------------------------------------------
gdb/f-lang.h | 10 -
3 files changed, 9 insertions(+), 745 deletions(-)

diff --git a/gdb/f-lang.c b/gdb/f-lang.c
index 207c2ecefd7..e5b66c7fa3b 100644
--- a/gdb/f-lang.c
+++ b/gdb/f-lang.c
@@ -292,417 +292,6 @@ class fortran_array_repacker_impl
struct value *m_val;
};

-/* Called from evaluate_subexp_standard to perform array indexing, and
- sub-range extraction, for Fortran. As well as arrays this function
- also handles strings as they can be treated like arrays of characters.
- ARRAY is the array or string being accessed. EXP, POS, and NOSIDE are
- as for evaluate_subexp_standard, and NARGS is the number of arguments
- in this access (e.g. 'array (1,2,3)' would be NARGS 3). */
-
-static struct value *
-fortran_value_subarray (struct value *array, struct expression *exp,
- int *pos, int nargs, enum noside noside)
-{
- type *original_array_type = check_typedef (value_type (array));
- bool is_string_p = original_array_type->code () == TYPE_CODE_STRING;
-
- /* Perform checks for ARRAY not being available. The somewhat overly
- complex logic here is just to keep backward compatibility with the
- errors that we used to get before FORTRAN_VALUE_SUBARRAY was
- rewritten. Maybe a future task would streamline the error messages we
- get here, and update all the expected test results. */
- if (exp->elts[*pos].opcode != OP_RANGE)
- {
- if (type_not_associated (original_array_type))
- error (_("no such vector element (vector not associated)"));
- else if (type_not_allocated (original_array_type))
- error (_("no such vector element (vector not allocated)"));
- }
- else
- {
- if (type_not_associated (original_array_type))
- error (_("array not associated"));
- else if (type_not_allocated (original_array_type))
- error (_("array not allocated"));
- }
-
- /* First check that the number of dimensions in the type we are slicing
- matches the number of arguments we were passed. */
- int ndimensions = calc_f77_array_dims (original_array_type);
- if (nargs != ndimensions)
- error (_("Wrong number of subscripts"));
-
- /* This will be initialised below with the type of the elements held in
- ARRAY. */
- struct type *inner_element_type;
-
- /* Extract the types of each array dimension from the original array
- type. We need these available so we can fill in the default upper and
- lower bounds if the user requested slice doesn't provide that
- information. Additionally unpacking the dimensions like this gives us
- the inner element type. */
- std::vector<struct type *> dim_types;
- {
- dim_types.reserve (ndimensions);
- struct type *type = original_array_type;
- for (int i = 0; i < ndimensions; ++i)
- {
- dim_types.push_back (type);
- type = TYPE_TARGET_TYPE (type);
- }
- /* TYPE is now the inner element type of the array, we start the new
- array slice off as this type, then as we process the requested slice
- (from the user) we wrap new types around this to build up the final
- slice type. */
- inner_element_type = type;
- }
-
- /* As we analyse the new slice type we need to understand if the data
- being referenced is contiguous. Do decide this we must track the size
- of an element at each dimension of the new slice array. Initially the
- elements of the inner most dimension of the array are the same inner
- most elements as the original ARRAY. */
- LONGEST slice_element_size = TYPE_LENGTH (inner_element_type);
-
- /* Start off assuming all data is contiguous, this will be set to false
- if access to any dimension results in non-contiguous data. */
- bool is_all_contiguous = true;
-
- /* The TOTAL_OFFSET is the distance in bytes from the start of the
- original ARRAY to the start of the new slice. This is calculated as
- we process the information from the user. */
- LONGEST total_offset = 0;
-
- /* A structure representing information about each dimension of the
- resulting slice. */
- struct slice_dim
- {
- /* Constructor. */
- slice_dim (LONGEST l, LONGEST h, LONGEST s, struct type *idx)
- : low (l),
- high (h),
- stride (s),
- index (idx)
- { /* Nothing. */ }
-
- /* The low bound for this dimension of the slice. */
- LONGEST low;
-
- /* The high bound for this dimension of the slice. */
- LONGEST high;
-
- /* The byte stride for this dimension of the slice. */
- LONGEST stride;
-
- struct type *index;
- };
-
- /* The dimensions of the resulting slice. */
- std::vector<slice_dim> slice_dims;
-
- /* Process the incoming arguments. These arguments are in the reverse
- order to the array dimensions, that is the first argument refers to
- the last array dimension. */
- if (fortran_array_slicing_debug)
- debug_printf ("Processing array access:\n");
- for (int i = 0; i < nargs; ++i)
- {
- /* For each dimension of the array the user will have either provided
- a ranged access with optional lower bound, upper bound, and
- stride, or the user will have supplied a single index. */
- struct type *dim_type = dim_types[ndimensions - (i + 1)];
- if (exp->elts[*pos].opcode == OP_RANGE)
- {
- int pc = (*pos) + 1;
- enum range_flag range_flag = (enum range_flag) exp->elts[pc].longconst;
- *pos += 3;
-
- LONGEST low, high, stride;
- low = high = stride = 0;
-
- if ((range_flag & RANGE_LOW_BOUND_DEFAULT) == 0)
- low = value_as_long (evaluate_subexp (nullptr, exp, pos, noside));
- else
- low = f77_get_lowerbound (dim_type);
- if ((range_flag & RANGE_HIGH_BOUND_DEFAULT) == 0)
- high = value_as_long (evaluate_subexp (nullptr, exp, pos, noside));
- else
- high = f77_get_upperbound (dim_type);
- if ((range_flag & RANGE_HAS_STRIDE) == RANGE_HAS_STRIDE)
- stride = value_as_long (evaluate_subexp (nullptr, exp, pos, noside));
- else
- stride = 1;
-
- if (stride == 0)
- error (_("stride must not be 0"));
-
- /* Get information about this dimension in the original ARRAY. */
- struct type *target_type = TYPE_TARGET_TYPE (dim_type);
- struct type *index_type = dim_type->index_type ();
- LONGEST lb = f77_get_lowerbound (dim_type);
- LONGEST ub = f77_get_upperbound (dim_type);
- LONGEST sd = index_type->bit_stride ();
- if (sd == 0)
- sd = TYPE_LENGTH (target_type) * 8;
-
- if (fortran_array_slicing_debug)
- {
- debug_printf ("|-> Range access\n");
- std::string str = type_to_string (dim_type);
- debug_printf ("| |-> Type: %s\n", str.c_str ());
- debug_printf ("| |-> Array:\n");
- debug_printf ("| | |-> Low bound: %s\n", plongest (lb));
- debug_printf ("| | |-> High bound: %s\n", plongest (ub));
- debug_printf ("| | |-> Bit stride: %s\n", plongest (sd));
- debug_printf ("| | |-> Byte stride: %s\n", plongest (sd / 8));
- debug_printf ("| | |-> Type size: %s\n",
- pulongest (TYPE_LENGTH (dim_type)));
- debug_printf ("| | '-> Target type size: %s\n",
- pulongest (TYPE_LENGTH (target_type)));
- debug_printf ("| |-> Accessing:\n");
- debug_printf ("| | |-> Low bound: %s\n",
- plongest (low));
- debug_printf ("| | |-> High bound: %s\n",
- plongest (high));
- debug_printf ("| | '-> Element stride: %s\n",
- plongest (stride));
- }
-
- /* Check the user hasn't asked for something invalid. */
- if (high > ub || low < lb)
- error (_("array subscript out of bounds"));
-
- /* Calculate what this dimension of the new slice array will look
- like. OFFSET is the byte offset from the start of the
- previous (more outer) dimension to the start of this
- dimension. E_COUNT is the number of elements in this
- dimension. REMAINDER is the number of elements remaining
- between the last included element and the upper bound. For
- example an access '1:6:2' will include elements 1, 3, 5 and
- have a remainder of 1 (element #6). */
- LONGEST lowest = std::min (low, high);
- LONGEST offset = (sd / 8) * (lowest - lb);
- LONGEST e_count = std::abs (high - low) + 1;
- e_count = (e_count + (std::abs (stride) - 1)) / std::abs (stride);
- LONGEST new_low = 1;
- LONGEST new_high = new_low + e_count - 1;
- LONGEST new_stride = (sd * stride) / 8;
- LONGEST last_elem = low + ((e_count - 1) * stride);
- LONGEST remainder = high - last_elem;
- if (low > high)
- {
- offset += std::abs (remainder) * TYPE_LENGTH (target_type);
- if (stride > 0)
- error (_("incorrect stride and boundary combination"));
- }
- else if (stride < 0)
- error (_("incorrect stride and boundary combination"));
-
- /* Is the data within this dimension contiguous? It is if the
- newly computed stride is the same size as a single element of
- this dimension. */
- bool is_dim_contiguous = (new_stride == slice_element_size);
- is_all_contiguous &= is_dim_contiguous;
-
- if (fortran_array_slicing_debug)
- {
- debug_printf ("| '-> Results:\n");
- debug_printf ("| |-> Offset = %s\n", plongest (offset));
- debug_printf ("| |-> Elements = %s\n", plongest (e_count));
- debug_printf ("| |-> Low bound = %s\n", plongest (new_low));
- debug_printf ("| |-> High bound = %s\n",
- plongest (new_high));
- debug_printf ("| |-> Byte stride = %s\n",
- plongest (new_stride));
- debug_printf ("| |-> Last element = %s\n",
- plongest (last_elem));
- debug_printf ("| |-> Remainder = %s\n",
- plongest (remainder));
- debug_printf ("| '-> Contiguous = %s\n",
- (is_dim_contiguous ? "Yes" : "No"));
- }
-
- /* Figure out how big (in bytes) an element of this dimension of
- the new array slice will be. */
- slice_element_size = std::abs (new_stride * e_count);
-
- slice_dims.emplace_back (new_low, new_high, new_stride,
- index_type);
-
- /* Update the total offset. */
- total_offset += offset;
- }
- else
- {
- /* There is a single index for this dimension. */
- LONGEST index
- = value_as_long (evaluate_subexp_with_coercion (exp, pos, noside));
-
- /* Get information about this dimension in the original ARRAY. */
- struct type *target_type = TYPE_TARGET_TYPE (dim_type);
- struct type *index_type = dim_type->index_type ();
- LONGEST lb = f77_get_lowerbound (dim_type);
- LONGEST ub = f77_get_upperbound (dim_type);
- LONGEST sd = index_type->bit_stride () / 8;
- if (sd == 0)
- sd = TYPE_LENGTH (target_type);
-
- if (fortran_array_slicing_debug)
- {
- debug_printf ("|-> Index access\n");
- std::string str = type_to_string (dim_type);
- debug_printf ("| |-> Type: %s\n", str.c_str ());
- debug_printf ("| |-> Array:\n");
- debug_printf ("| | |-> Low bound: %s\n", plongest (lb));
- debug_printf ("| | |-> High bound: %s\n", plongest (ub));
- debug_printf ("| | |-> Byte stride: %s\n", plongest (sd));
- debug_printf ("| | |-> Type size: %s\n",
- pulongest (TYPE_LENGTH (dim_type)));
- debug_printf ("| | '-> Target type size: %s\n",
- pulongest (TYPE_LENGTH (target_type)));
- debug_printf ("| '-> Accessing:\n");
- debug_printf ("| '-> Index: %s\n",
- plongest (index));
- }
-
- /* If the array has actual content then check the index is in
- bounds. An array without content (an unbound array) doesn't
- have a known upper bound, so don't error check in that
- situation. */
- if (index < lb
- || (dim_type->index_type ()->bounds ()->high.kind () != PROP_UNDEFINED
- && index > ub)
- || (VALUE_LVAL (array) != lval_memory
- && dim_type->index_type ()->bounds ()->high.kind () == PROP_UNDEFINED))
- {
- if (type_not_associated (dim_type))
- error (_("no such vector element (vector not associated)"));
- else if (type_not_allocated (dim_type))
- error (_("no such vector element (vector not allocated)"));
- else
- error (_("no such vector element"));
- }
-
- /* Calculate using the type stride, not the target type size. */
- LONGEST offset = sd * (index - lb);
- total_offset += offset;
- }
- }
-
- if (noside == EVAL_SKIP)
- return array;
-
- /* Build a type that represents the new array slice in the target memory
- of the original ARRAY, this type makes use of strides to correctly
- find only those elements that are part of the new slice. */
- struct type *array_slice_type = inner_element_type;
- for (const auto &d : slice_dims)
- {
- /* Create the range. */
- dynamic_prop p_low, p_high, p_stride;
-
- p_low.set_const_val (d.low);
- p_high.set_const_val (d.high);
- p_stride.set_const_val (d.stride);
-
- struct type *new_range
- = create_range_type_with_stride ((struct type *) NULL,
- TYPE_TARGET_TYPE (d.index),
- &p_low, &p_high, 0, &p_stride,
- true);
- array_slice_type
- = create_array_type (nullptr, array_slice_type, new_range);
- }
-
- if (fortran_array_slicing_debug)
- {
- debug_printf ("'-> Final result:\n");
- debug_printf (" |-> Type: %s\n",
- type_to_string (array_slice_type).c_str ());
- debug_printf (" |-> Total offset: %s\n",
- plongest (total_offset));
- debug_printf (" |-> Base address: %s\n",
- core_addr_to_string (value_address (array)));
- debug_printf (" '-> Contiguous = %s\n",
- (is_all_contiguous ? "Yes" : "No"));
- }
-
- /* Should we repack this array slice? */
- if (!is_all_contiguous && (repack_array_slices || is_string_p))
- {
- /* Build a type for the repacked slice. */
- struct type *repacked_array_type = inner_element_type;
- for (const auto &d : slice_dims)
- {
- /* Create the range. */
- dynamic_prop p_low, p_high, p_stride;
-
- p_low.set_const_val (d.low);
- p_high.set_const_val (d.high);
- p_stride.set_const_val (TYPE_LENGTH (repacked_array_type));
-
- struct type *new_range
- = create_range_type_with_stride ((struct type *) NULL,
- TYPE_TARGET_TYPE (d.index),
- &p_low, &p_high, 0, &p_stride,
- true);
- repacked_array_type
- = create_array_type (nullptr, repacked_array_type, new_range);
- }
-
- /* Now copy the elements from the original ARRAY into the packed
- array value DEST. */
- struct value *dest = allocate_value (repacked_array_type);
- if (value_lazy (array)
- || (total_offset + TYPE_LENGTH (array_slice_type)
- > TYPE_LENGTH (check_typedef (value_type (array)))))
- {
- fortran_array_walker<fortran_lazy_array_repacker_impl> p
- (array_slice_type, value_address (array) + total_offset, dest);
- p.walk ();
- }
- else
- {
- fortran_array_walker<fortran_array_repacker_impl> p
- (array_slice_type, value_address (array) + total_offset,
- total_offset, array, dest);
- p.walk ();
- }
- array = dest;
- }
- else
- {
- if (VALUE_LVAL (array) == lval_memory)
- {
- /* If the value we're taking a slice from is not yet loaded, or
- the requested slice is outside the values content range then
- just create a new lazy value pointing at the memory where the
- contents we're looking for exist. */
- if (value_lazy (array)
- || (total_offset + TYPE_LENGTH (array_slice_type)
- > TYPE_LENGTH (check_typedef (value_type (array)))))
- array = value_at_lazy (array_slice_type,
- value_address (array) + total_offset);
- else
- array = value_from_contents_and_address (array_slice_type,
- (value_contents (array)
- + total_offset),
- (value_address (array)
- + total_offset));
- }
- else if (!value_lazy (array))
- {
- const void *valaddr = value_contents (array) + total_offset;
- array = allocate_value (array_slice_type);
- memcpy (value_contents_raw (array), valaddr, TYPE_LENGTH (array_slice_type));
- }
- else
- error (_("cannot subscript arrays that are not in memory"));
- }
-
- return array;
-}
-
/* A helper function for UNOP_ABS. */

struct value *
@@ -894,145 +483,6 @@ eval_op_f_kind (struct type *expect_type, struct expression *exp,
TYPE_LENGTH (TYPE_TARGET_TYPE (type)));
}

-/* Special expression evaluation cases for Fortran. */
-
-static struct value *
-evaluate_subexp_f (struct type *expect_type, struct expression *exp,
- int *pos, enum noside noside)
-{
- struct value *arg1 = NULL, *arg2 = NULL;
- enum exp_opcode op;
- int pc;
- struct type *type;
-
- pc = *pos;
- *pos += 1;
- op = exp->elts[pc].opcode;
-
- switch (op)
- {
- default:
- *pos -= 1;
- return evaluate_subexp_standard (expect_type, exp, pos, noside);
-
- case UNOP_ABS:
- arg1 = evaluate_subexp (nullptr, exp, pos, noside);
- return eval_op_f_abs (expect_type, exp, noside, op, arg1);
-
- case BINOP_MOD:
- arg1 = evaluate_subexp (nullptr, exp, pos, noside);
- arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
- return eval_op_f_mod (expect_type, exp, noside, op, arg1, arg2);
-
- case UNOP_FORTRAN_CEILING:
- arg1 = evaluate_subexp (nullptr, exp, pos, noside);
- return eval_op_f_ceil (expect_type, exp, noside, op, arg1);
-
- case UNOP_FORTRAN_FLOOR:
- arg1 = evaluate_subexp (nullptr, exp, pos, noside);
- return eval_op_f_floor (expect_type, exp, noside, op, arg1);
-
- case BINOP_FORTRAN_MODULO:
- arg1 = evaluate_subexp (nullptr, exp, pos, noside);
- arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
- return eval_op_f_modulo (expect_type, exp, noside, op, arg1, arg2);
-
- case BINOP_FORTRAN_CMPLX:
- arg1 = evaluate_subexp (nullptr, exp, pos, noside);
- arg2 = evaluate_subexp (value_type (arg1), exp, pos, noside);
- return eval_op_f_cmplx (expect_type, exp, noside, op, arg1, arg2);
-
- case UNOP_FORTRAN_KIND:
- arg1 = evaluate_subexp (NULL, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
- return eval_op_f_kind (expect_type, exp, noside, op, arg1);
-
- case OP_F77_UNDETERMINED_ARGLIST:
- /* Remember that in F77, functions, substring ops and array subscript
- operations cannot be disambiguated at parse time. We have made
- all array subscript operations, substring operations as well as
- function calls come here and we now have to discover what the heck
- this thing actually was. If it is a function, we process just as
- if we got an OP_FUNCALL. */
- int nargs = longest_to_int (exp->elts[pc + 1].longconst);
- (*pos) += 2;
-
- /* First determine the type code we are dealing with. */
- arg1 = evaluate_subexp (nullptr, exp, pos, noside);
- type = check_typedef (value_type (arg1));
- enum type_code code = type->code ();
-
- if (code == TYPE_CODE_PTR)
- {
- /* Fortran always passes variable to subroutines as pointer.
- So we need to look into its target type to see if it is
- array, string or function. If it is, we need to switch
- to the target value the original one points to. */
- struct type *target_type = check_typedef (TYPE_TARGET_TYPE (type));
-
- if (target_type->code () == TYPE_CODE_ARRAY
- || target_type->code () == TYPE_CODE_STRING
- || target_type->code () == TYPE_CODE_FUNC)
- {
- arg1 = value_ind (arg1);
- type = check_typedef (value_type (arg1));
- code = type->code ();
- }
- }
-
- switch (code)
- {
- case TYPE_CODE_ARRAY:
- case TYPE_CODE_STRING:
- return fortran_value_subarray (arg1, exp, pos, nargs, noside);
-
- case TYPE_CODE_PTR:
- case TYPE_CODE_FUNC:
- case TYPE_CODE_INTERNAL_FUNCTION:
- {
- /* It's a function call. Allocate arg vector, including
- space for the function to be called in argvec[0] and a
- termination NULL. */
- struct value **argvec = (struct value **)
- alloca (sizeof (struct value *) * (nargs + 2));
- argvec[0] = arg1;
- int tem = 1;
- for (; tem <= nargs; tem++)
- {
- argvec[tem] = evaluate_subexp_with_coercion (exp, pos, noside);
- /* Arguments in Fortran are passed by address. Coerce the
- arguments here rather than in value_arg_coerce as
- otherwise the call to malloc to place the non-lvalue
- parameters in target memory is hit by this Fortran
- specific logic. This results in malloc being called
- with a pointer to an integer followed by an attempt to
- malloc the arguments to malloc in target memory.
- Infinite recursion ensues. */
- if (code == TYPE_CODE_PTR || code == TYPE_CODE_FUNC)
- {
- bool is_artificial
- = TYPE_FIELD_ARTIFICIAL (value_type (arg1), tem - 1);
- argvec[tem] = fortran_argument_convert (argvec[tem],
- is_artificial);
- }
- }
- argvec[tem] = 0; /* signal end of arglist */
- if (noside == EVAL_SKIP)
- return eval_skip_value (exp);
- return evaluate_subexp_do_call (exp, noside, argvec[0],
- gdb::make_array_view (argvec + 1,
- nargs),
- NULL, expect_type);
- }
-
- default:
- error (_("Cannot perform substring on this type"));
- }
- }
-
- /* Should be unreachable. */
- return nullptr;
-}
-
namespace expr
{

@@ -1519,191 +969,6 @@ fortran_undetermined::evaluate (struct type *expect_type,

} /* namespace expr */

-/* Special expression lengths for Fortran. */
-
-static void
-operator_length_f (const struct expression *exp, int pc, int *oplenp,
- int *argsp)
-{
- int oplen = 1;
- int args = 0;
-
- switch (exp->elts[pc - 1].opcode)
- {
- default:
- operator_length_standard (exp, pc, oplenp, argsp);
- return;
-
- case UNOP_FORTRAN_KIND:
- case UNOP_FORTRAN_FLOOR:
- case UNOP_FORTRAN_CEILING:
- oplen = 1;
- args = 1;
- break;
-
- case BINOP_FORTRAN_CMPLX:
- case BINOP_FORTRAN_MODULO:
- oplen = 1;
- args = 2;
- break;
-
- case OP_F77_UNDETERMINED_ARGLIST:
- oplen = 3;
- args = 1 + longest_to_int (exp->elts[pc - 2].longconst);
- break;
- }
-
- *oplenp = oplen;
- *argsp = args;
-}
-
-/* Helper for PRINT_SUBEXP_F. Arguments are as for PRINT_SUBEXP_F, except
- the extra argument NAME which is the text that should be printed as the
- name of this operation. */
-
-static void
-print_unop_subexp_f (struct expression *exp, int *pos,
- struct ui_file *stream, enum precedence prec,
- const char *name)
-{
- (*pos)++;
- fprintf_filtered (stream, "%s(", name);
- print_subexp (exp, pos, stream, PREC_SUFFIX);
- fputs_filtered (")", stream);
-}
-
-/* Helper for PRINT_SUBEXP_F. Arguments are as for PRINT_SUBEXP_F, except
- the extra argument NAME which is the text that should be printed as the
- name of this operation. */
-
-static void
-print_binop_subexp_f (struct expression *exp, int *pos,
- struct ui_file *stream, enum precedence prec,
- const char *name)
-{
- (*pos)++;
- fprintf_filtered (stream, "%s(", name);
- print_subexp (exp, pos, stream, PREC_SUFFIX);
- fputs_filtered (",", stream);
- print_subexp (exp, pos, stream, PREC_SUFFIX);
- fputs_filtered (")", stream);
-}
-
-/* Special expression printing for Fortran. */
-
-static void
-print_subexp_f (struct expression *exp, int *pos,
- struct ui_file *stream, enum precedence prec)
-{
- int pc = *pos;
- enum exp_opcode op = exp->elts[pc].opcode;
-
- switch (op)
- {
- default:
- print_subexp_standard (exp, pos, stream, prec);
- return;
-
- case UNOP_FORTRAN_KIND:
- print_unop_subexp_f (exp, pos, stream, prec, "KIND");
- return;
-
- case UNOP_FORTRAN_FLOOR:
- print_unop_subexp_f (exp, pos, stream, prec, "FLOOR");
- return;
-
- case UNOP_FORTRAN_CEILING:
- print_unop_subexp_f (exp, pos, stream, prec, "CEILING");
- return;
-
- case BINOP_FORTRAN_CMPLX:
- print_binop_subexp_f (exp, pos, stream, prec, "CMPLX");
- return;
-
- case BINOP_FORTRAN_MODULO:
- print_binop_subexp_f (exp, pos, stream, prec, "MODULO");
- return;
-
- case OP_F77_UNDETERMINED_ARGLIST:
- (*pos)++;
- print_subexp_funcall (exp, pos, stream);
- return;
- }
-}
-
-/* Special expression dumping for Fortran. */
-
-static int
-dump_subexp_body_f (struct expression *exp,
- struct ui_file *stream, int elt)
-{
- int opcode = exp->elts[elt].opcode;
- int oplen, nargs, i;
-
- switch (opcode)
- {
- default:
- return dump_subexp_body_standard (exp, stream, elt);
-
- case UNOP_FORTRAN_KIND:
- case UNOP_FORTRAN_FLOOR:
- case UNOP_FORTRAN_CEILING:
- case BINOP_FORTRAN_CMPLX:
- case BINOP_FORTRAN_MODULO:
- operator_length_f (exp, (elt + 1), &oplen, &nargs);
- break;
-
- case OP_F77_UNDETERMINED_ARGLIST:
- return dump_subexp_body_funcall (exp, stream, elt + 1);
- }
-
- elt += oplen;
- for (i = 0; i < nargs; i += 1)
- elt = dump_subexp (exp, stream, elt);
-
- return elt;
-}
-
-/* Special expression checking for Fortran. */
-
-static int
-operator_check_f (struct expression *exp, int pos,
- int (*objfile_func) (struct objfile *objfile,
- void *data),
- void *data)
-{
- const union exp_element *const elts = exp->elts;
-
- switch (elts[pos].opcode)
- {
- case UNOP_FORTRAN_KIND:
- case UNOP_FORTRAN_FLOOR:
- case UNOP_FORTRAN_CEILING:
- case BINOP_FORTRAN_CMPLX:
- case BINOP_FORTRAN_MODULO:
- /* Any references to objfiles are held in the arguments to this
- expression, not within the expression itself, so no additional
- checking is required here, the outer expression iteration code
- will take care of checking each argument. */
- break;
-
- default:
- return operator_check_standard (exp, pos, objfile_func, data);
- }
-
- return 0;
-}
-
-/* Expression processing for Fortran. */
-const struct exp_descriptor f_language::exp_descriptor_tab =
-{
- print_subexp_f,
- operator_length_f,
- operator_check_f,
- dump_subexp_body_f,
- evaluate_subexp_f
-};
-
/* See language.h. */

void
diff --git a/gdb/f-lang.h b/gdb/f-lang.h
index 9174d8df899..03b59102139 100644
--- a/gdb/f-lang.h
+++ b/gdb/f-lang.h
@@ -220,11 +220,6 @@ class f_language : public language_defn

/* See language.h. */

- const struct exp_descriptor *expression_ops () const override
- { return &exp_descriptor_tab; }
-
- /* See language.h. */
-
const struct op_print *opcode_print_table () const override
{ return op_print_tab; }

@@ -236,11 +231,6 @@ class f_language : public language_defn
(const lookup_name_info &lookup_name) const override;

private:
- /* Table of expression handling functions for use by EXPRESSION_OPS
- member function. */
-
- static const struct exp_descriptor exp_descriptor_tab;
-
/* Table of opcode data for use by OPCODE_PRINT_TABLE member function. */

static const struct op_print op_print_tab[];
--
2.26.2