From: Tom Tromey <tom@tromey.com>
To: gdb-patches@sourceware.org
Subject: [PATCH v3 145/206] Introduce fortran_undetermined
Date: Sat, 20 Feb 2021 13:15:08 -0700 [thread overview]
Message-ID: <20210220201609.838264-146-tom@tromey.com> (raw)
In-Reply-To: <20210220201609.838264-1-tom@tromey.com>
This adds class fortran_undetermined, which implements
OP_F77_UNDETERMINED_ARGLIST. fortran_range_operation is also added
here, as it is needed by fortran_undetermined.
gdb/ChangeLog
2021-02-20 Tom Tromey <tom@tromey.com>
* f-lang.c (fortran_undetermined::value_subarray)
(fortran_undetermined::evaluate): New methods.
* f-exp.h (class fortran_range_operation)
(class fortran_undetermined): New classes.
---
gdb/ChangeLog | 7 +
gdb/f-exp.h | 63 +++++++
gdb/f-lang.c | 482 ++++++++++++++++++++++++++++++++++++++++++++++++++
3 files changed, 552 insertions(+)
diff --git a/gdb/f-exp.h b/gdb/f-exp.h
index 4b3fdd4a53e..b569c33ad9c 100644
--- a/gdb/f-exp.h
+++ b/gdb/f-exp.h
@@ -96,6 +96,69 @@ class fortran_cmplx_operation
{ return BINOP_FORTRAN_CMPLX; }
};
+/* OP_RANGE for Fortran. */
+class fortran_range_operation
+ : public tuple_holding_operation<enum range_flag, operation_up, operation_up,
+ operation_up>
+{
+public:
+
+ using tuple_holding_operation::tuple_holding_operation;
+
+ value *evaluate (struct type *expect_type,
+ struct expression *exp,
+ enum noside noside) override
+ {
+ error (_("ranges not allowed in this context"));
+ }
+
+ range_flag get_flags () const
+ {
+ return std::get<0> (m_storage);
+ }
+
+ value *evaluate0 (struct expression *exp, enum noside noside) const
+ {
+ return std::get<1> (m_storage)->evaluate (nullptr, exp, noside);
+ }
+
+ value *evaluate1 (struct expression *exp, enum noside noside) const
+ {
+ return std::get<2> (m_storage)->evaluate (nullptr, exp, noside);
+ }
+
+ value *evaluate2 (struct expression *exp, enum noside noside) const
+ {
+ return std::get<3> (m_storage)->evaluate (nullptr, exp, noside);
+ }
+
+ enum exp_opcode opcode () const override
+ { return OP_RANGE; }
+};
+
+/* In F77, functions, substring ops and array subscript operations
+ cannot be disambiguated at parse time. This operation handles
+ both, deciding which do to at evaluation time. */
+class fortran_undetermined
+ : public tuple_holding_operation<operation_up, std::vector<operation_up>>
+{
+public:
+
+ using tuple_holding_operation::tuple_holding_operation;
+
+ value *evaluate (struct type *expect_type,
+ struct expression *exp,
+ enum noside noside) override;
+
+ enum exp_opcode opcode () const override
+ { return OP_F77_UNDETERMINED_ARGLIST; }
+
+private:
+
+ value *value_subarray (value *array, struct expression *exp,
+ enum noside noside);
+};
+
} /* namespace expr */
#endif /* FORTRAN_EXP_H */
diff --git a/gdb/f-lang.c b/gdb/f-lang.c
index 89e5f4ea092..bdf0bee2ccb 100644
--- a/gdb/f-lang.c
+++ b/gdb/f-lang.c
@@ -1205,6 +1205,488 @@ evaluate_subexp_f (struct type *expect_type, struct expression *exp,
return nullptr;
}
+namespace expr
+{
+
+/* Called from evaluate 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 and NOSIDE are as
+ for evaluate. */
+
+value *
+fortran_undetermined::value_subarray (value *array,
+ struct expression *exp,
+ enum noside noside)
+{
+ type *original_array_type = check_typedef (value_type (array));
+ bool is_string_p = original_array_type->code () == TYPE_CODE_STRING;
+ const std::vector<operation_up> &ops = std::get<1> (m_storage);
+ int nargs = ops.size ();
+
+ /* 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 (ops[0]->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)];
+ fortran_range_operation *range_op
+ = dynamic_cast<fortran_range_operation *> (ops[i].get ());
+ if (range_op != nullptr)
+ {
+ enum range_flag range_flag = range_op->get_flags ();
+
+ LONGEST low, high, stride;
+ low = high = stride = 0;
+
+ if ((range_flag & RANGE_LOW_BOUND_DEFAULT) == 0)
+ low = value_as_long (range_op->evaluate0 (exp, noside));
+ else
+ low = f77_get_lowerbound (dim_type);
+ if ((range_flag & RANGE_HIGH_BOUND_DEFAULT) == 0)
+ high = value_as_long (range_op->evaluate1 (exp, noside));
+ else
+ high = f77_get_upperbound (dim_type);
+ if ((range_flag & RANGE_HAS_STRIDE) == RANGE_HAS_STRIDE)
+ stride = value_as_long (range_op->evaluate2 (exp, 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 (ops[i]->evaluate_with_coercion (exp, 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;
+ }
+ }
+
+ /* 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))
+ array = value_from_component (array, array_slice_type, total_offset);
+ else
+ error (_("cannot subscript arrays that are not in memory"));
+ }
+
+ return array;
+}
+
+value *
+fortran_undetermined::evaluate (struct type *expect_type,
+ struct expression *exp,
+ enum noside noside)
+{
+ value *callee = std::get<0> (m_storage)->evaluate (nullptr, exp, noside);
+ struct type *type = check_typedef (value_type (callee));
+ 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)
+ {
+ callee = value_ind (callee);
+ type = check_typedef (value_type (callee));
+ code = type->code ();
+ }
+ }
+
+ switch (code)
+ {
+ case TYPE_CODE_ARRAY:
+ case TYPE_CODE_STRING:
+ return value_subarray (callee, exp, 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. */
+ std::vector<value *> argvec (std::get<1> (m_storage).size ());
+ for (int tem = 0; tem < argvec.size (); tem++)
+ {
+ argvec[tem]
+ = std::get<1> (m_storage)[tem]->evaluate_with_coercion (exp,
+ 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 (callee), tem);
+ argvec[tem] = fortran_argument_convert (argvec[tem],
+ is_artificial);
+ }
+ }
+ return evaluate_subexp_do_call (exp, noside, callee, argvec,
+ nullptr, expect_type);
+ }
+
+ default:
+ error (_("Cannot perform substring on this type"));
+ }
+}
+
+} /* namespace expr */
+
/* Special expression lengths for Fortran. */
static void
--
2.26.2
next prev parent reply other threads:[~2021-02-20 20:16 UTC|newest]
Thread overview: 208+ messages / expand[flat|nested] mbox.gz Atom feed top
2021-02-20 20:12 [PATCH v3 000/206] Refactor expressions Tom Tromey
2021-02-20 20:12 ` [PATCH v3 001/206] Split out eval_op_scope Tom Tromey
2021-02-20 20:12 ` [PATCH v3 002/206] Split out eval_op_var_entry_value Tom Tromey
2021-02-20 20:12 ` [PATCH v3 003/206] Split out eval_op_var_msym_value Tom Tromey
2021-02-20 20:12 ` [PATCH v3 004/206] Split out eval_op_func_static_var Tom Tromey
2021-02-20 20:12 ` [PATCH v3 005/206] Split out eval_op_register Tom Tromey
2021-02-20 20:12 ` [PATCH v3 006/206] Split out eval_op_string Tom Tromey
2021-02-20 20:12 ` [PATCH v3 007/206] Split out eval_op_objc_selector Tom Tromey
2021-02-20 20:12 ` [PATCH v3 008/206] Split out eval_op_concat Tom Tromey
2021-02-20 20:12 ` [PATCH v3 009/206] Split out eval_op_ternop Tom Tromey
2021-02-20 20:12 ` [PATCH v3 010/206] Split out eval_op_structop_struct Tom Tromey
2021-02-20 20:12 ` [PATCH v3 011/206] Split out eval_op_structop_ptr Tom Tromey
2021-02-20 20:12 ` [PATCH v3 012/206] Split out eval_op_member Tom Tromey
2021-02-20 20:12 ` [PATCH v3 013/206] Split out eval_op_add Tom Tromey
2021-02-20 20:12 ` [PATCH v3 014/206] Split out eval_op_sub Tom Tromey
2021-02-20 20:12 ` [PATCH v3 015/206] Split out eval_op_binary Tom Tromey
2021-02-20 20:12 ` [PATCH v3 016/206] Split out eval_op_subscript Tom Tromey
2021-02-20 20:13 ` [PATCH v3 017/206] Split out eval_op_equal Tom Tromey
2021-02-20 20:13 ` [PATCH v3 018/206] Split out eval_op_notequal Tom Tromey
2021-02-20 20:13 ` [PATCH v3 019/206] Split out eval_op_less Tom Tromey
2021-02-20 20:13 ` [PATCH v3 020/206] Split out eval_op_gtr Tom Tromey
2021-02-20 20:13 ` [PATCH v3 021/206] Split out eval_op_geq Tom Tromey
2021-02-20 20:13 ` [PATCH v3 022/206] Split out eval_op_leq Tom Tromey
2021-02-20 20:13 ` [PATCH v3 023/206] Split out eval_op_repeat Tom Tromey
2021-02-20 20:13 ` [PATCH v3 024/206] Split out eval_op_plus Tom Tromey
2021-02-20 20:13 ` [PATCH v3 025/206] Split out eval_op_neg Tom Tromey
2021-02-20 20:13 ` [PATCH v3 026/206] Split out eval_op_complement Tom Tromey
2021-02-20 20:13 ` [PATCH v3 027/206] Split out eval_op_lognot Tom Tromey
2021-02-20 20:13 ` [PATCH v3 028/206] Split out eval_op_ind Tom Tromey
2021-02-20 20:13 ` [PATCH v3 029/206] Split out eval_op_alignof Tom Tromey
2021-02-20 20:13 ` [PATCH v3 030/206] Split out eval_op_memval Tom Tromey
2021-02-20 20:13 ` [PATCH v3 031/206] Split out eval_op_preinc Tom Tromey
2021-02-20 20:13 ` [PATCH v3 032/206] Split out eval_op_predec Tom Tromey
2021-02-20 20:13 ` [PATCH v3 033/206] Split out eval_op_postinc Tom Tromey
2021-02-20 20:13 ` [PATCH v3 034/206] Split out eval_op_postdec Tom Tromey
2021-02-20 20:13 ` [PATCH v3 035/206] Split out eval_op_type Tom Tromey
2021-02-20 20:13 ` [PATCH v3 036/206] Split out eval_op_f_abs Tom Tromey
2021-02-20 20:13 ` [PATCH v3 037/206] Split out eval_op_f_mod Tom Tromey
2021-02-20 20:13 ` [PATCH v3 038/206] Split out eval_op_f_ceil Tom Tromey
2021-02-20 20:13 ` [PATCH v3 039/206] Split out eval_op_f_floor Tom Tromey
2021-02-20 20:13 ` [PATCH v3 040/206] Split out eval_op_f_modulo Tom Tromey
2021-02-20 20:13 ` [PATCH v3 041/206] Split out eval_op_f_cmplx Tom Tromey
2021-02-20 20:13 ` [PATCH v3 042/206] Split out eval_op_f_kind Tom Tromey
2021-02-20 20:13 ` [PATCH v3 043/206] Split ot fortran_require_array Tom Tromey
2021-02-20 20:13 ` [PATCH v3 044/206] Split out eval_op_f_allocated Tom Tromey
2021-02-20 20:13 ` [PATCH v3 045/206] Change parameters to rust_range Tom Tromey
2021-02-20 20:13 ` [PATCH v3 046/206] Change parameters to rust_subscript Tom Tromey
2021-02-20 20:13 ` [PATCH v3 047/206] Split out eval_op_rust_ind Tom Tromey
2021-02-20 20:13 ` [PATCH v3 048/206] Split out eval_op_rust_complement Tom Tromey
2021-02-20 20:13 ` [PATCH v3 049/206] Split out eval_op_rust_array Tom Tromey
2021-02-20 20:13 ` [PATCH v3 050/206] Split out eval_op_rust_struct_anon Tom Tromey
2021-02-20 20:13 ` [PATCH v3 051/206] Split out eval_op_rust_structop Tom Tromey
2021-02-20 20:13 ` [PATCH v3 052/206] Split helper functions Tom Tromey
2021-02-20 20:13 ` [PATCH v3 053/206] Split out eval_op_m2_high Tom Tromey
2021-02-20 20:13 ` [PATCH v3 054/206] Split out eval_op_m2_subscript Tom Tromey
2021-02-20 20:13 ` [PATCH v3 055/206] Split out eval_binop_assign_modify Tom Tromey
2021-02-20 20:13 ` [PATCH v3 056/206] Split out eval_op_objc_msgcall Tom Tromey
2021-02-20 20:13 ` [PATCH v3 057/206] Split out eval_opencl_assign Tom Tromey
2021-02-20 20:13 ` [PATCH v3 058/206] Split out eval_ternop_in_range Tom Tromey
2021-02-20 20:13 ` [PATCH v3 059/206] Split out ada_unop_neg Tom Tromey
2021-02-20 20:13 ` [PATCH v3 060/206] Split out ada_unop_in_range Tom Tromey
2021-02-20 20:13 ` [PATCH v3 061/206] Split out ada_atr_tag Tom Tromey
2021-02-20 20:13 ` [PATCH v3 062/206] Split out ada_atr_size Tom Tromey
2021-02-20 20:13 ` [PATCH v3 063/206] Split out ada_abs Tom Tromey
2021-02-20 20:13 ` [PATCH v3 064/206] Split out ada_mult_binop Tom Tromey
2021-02-20 20:13 ` [PATCH v3 065/206] Split out ada_equal_binop Tom Tromey
2021-02-20 20:13 ` [PATCH v3 066/206] Split out ada_ternop_slice Tom Tromey
2021-02-20 20:13 ` [PATCH v3 067/206] Split out ada_binop_in_bounds Tom Tromey
2021-02-20 20:13 ` [PATCH v3 068/206] Split out ada_unop_atr Tom Tromey
2021-02-20 20:13 ` [PATCH v3 069/206] Split out ada_binop_minmax Tom Tromey
2021-02-20 20:13 ` [PATCH v3 070/206] Change value_val_atr to ada_val_atr Tom Tromey
2021-02-20 20:13 ` [PATCH v3 071/206] Split out ada_binop_exp Tom Tromey
2021-02-20 20:13 ` [PATCH v3 072/206] Split out eval_multi_subscript Tom Tromey
2021-02-20 20:13 ` [PATCH v3 073/206] Split gen_expr_binop_rest Tom Tromey
2021-02-20 20:13 ` [PATCH v3 074/206] Introduce class operation Tom Tromey
2021-02-20 20:13 ` [PATCH v3 075/206] Implement dumping Tom Tromey
2021-02-20 20:13 ` [PATCH v3 076/206] Add two agent expression helper functions Tom Tromey
2021-02-20 20:14 ` [PATCH v3 077/206] Introduce float_const_operation Tom Tromey
2021-02-20 20:14 ` [PATCH v3 078/206] Introduce scope_operation Tom Tromey
2021-02-20 20:14 ` [PATCH v3 079/206] Introduce long_const_operation Tom Tromey
2021-02-20 20:14 ` [PATCH v3 080/206] Introduce var_msym_value_operation Tom Tromey
2021-02-20 20:14 ` [PATCH v3 081/206] Introduce var_entry_value_operation Tom Tromey
2021-02-20 20:14 ` [PATCH v3 082/206] Introduce func_static_var_operation Tom Tromey
2021-02-20 20:14 ` [PATCH v3 083/206] Introduce last_operation Tom Tromey
2021-02-20 20:14 ` [PATCH v3 084/206] Introduce register_operation Tom Tromey
2021-02-20 20:14 ` [PATCH v3 085/206] Introduce bool_operation Tom Tromey
2021-02-20 20:14 ` [PATCH v3 086/206] Introduce internalvar_operation Tom Tromey
2021-02-20 20:14 ` [PATCH v3 087/206] Introduce string_operation Tom Tromey
2021-02-20 20:14 ` [PATCH v3 088/206] Introduce ternop_slice_operation Tom Tromey
2021-02-20 20:14 ` [PATCH v3 089/206] Introduce ternop_cond_operation Tom Tromey
2021-02-20 20:14 ` [PATCH v3 090/206] Add c-exp.h and c_string_operation Tom Tromey
2021-02-20 20:14 ` [PATCH v3 091/206] Introduce objc_nsstring_operation Tom Tromey
2021-02-20 20:14 ` [PATCH v3 092/206] Introduce objc_selector_operation Tom Tromey
2021-02-20 20:14 ` [PATCH v3 093/206] Introduce complex_operation Tom Tromey
2021-02-20 20:14 ` [PATCH v3 094/206] Introduce structop_operation Tom Tromey
2021-02-20 20:14 ` [PATCH v3 095/206] Introduce structop_ptr_operation Tom Tromey
2021-02-20 20:14 ` [PATCH v3 096/206] Introduce structop_member_operation and structop_mptr_operation Tom Tromey
2021-02-20 20:14 ` [PATCH v3 097/206] Introduce concat_operation Tom Tromey
2021-02-20 20:14 ` [PATCH v3 098/206] Introduce add_operation Tom Tromey
2021-02-20 20:14 ` [PATCH v3 099/206] Introduce sub_operation Tom Tromey
2021-02-20 20:14 ` [PATCH v3 100/206] Introduce binop_operation Tom Tromey
2021-02-20 20:14 ` [PATCH v3 101/206] Introduce subscript_operation Tom Tromey
2021-02-20 20:14 ` [PATCH v3 102/206] Implement binary comparison operations Tom Tromey
2021-02-20 20:14 ` [PATCH v3 103/206] Introduce repeat_operation Tom Tromey
2021-02-20 20:14 ` [PATCH v3 104/206] Introduce comma_operation Tom Tromey
2021-02-20 20:14 ` [PATCH v3 105/206] Implement some unary operations Tom Tromey
2021-02-20 20:14 ` [PATCH v3 106/206] Implement unary increment and decrement operations Tom Tromey
2021-02-20 20:14 ` [PATCH v3 107/206] Introduce unop_ind_operation Tom Tromey
2021-02-20 20:14 ` [PATCH v3 108/206] Introduce type_operation Tom Tromey
2021-02-20 20:14 ` [PATCH v3 109/206] Introduce typeof_operation Tom Tromey
2021-02-20 20:14 ` [PATCH v3 110/206] Introduce decltype_operation Tom Tromey
2021-02-20 20:14 ` [PATCH v3 111/206] Introduce typeid_operation Tom Tromey
2021-02-20 20:14 ` [PATCH v3 112/206] Introduce unop_addr_operation Tom Tromey
2021-02-20 20:14 ` [PATCH v3 113/206] Introduce unop_sizeof_operation Tom Tromey
2021-02-20 20:14 ` [PATCH v3 114/206] Introduce unop_alignof_operation Tom Tromey
2021-02-20 20:14 ` [PATCH v3 115/206] Implement UNOP_MEMVAL and UNOP_MEMVAL_TYPE Tom Tromey
2021-02-20 20:14 ` [PATCH v3 116/206] Introduce op_this_operation Tom Tromey
2021-02-20 20:14 ` [PATCH v3 117/206] Introduce type_instance_operation Tom Tromey
2021-02-20 20:14 ` [PATCH v3 118/206] Introduce assign_operation Tom Tromey
2021-02-20 20:14 ` [PATCH v3 119/206] Introduce assign_modify_operation Tom Tromey
2021-02-20 20:14 ` [PATCH v3 120/206] Introduce unop_cast_operation Tom Tromey
2021-02-20 20:14 ` [PATCH v3 121/206] Introduce unop_cast_type_operation Tom Tromey
2021-02-20 20:14 ` [PATCH v3 122/206] Implement C++ cast operations Tom Tromey
2021-02-20 20:14 ` [PATCH v3 123/206] Introduce var_value_operation Tom Tromey
2021-02-20 20:14 ` [PATCH v3 124/206] Introduce objc_msgcall_operation Tom Tromey
2021-02-20 20:14 ` [PATCH v3 125/206] Introduce multi_subscript_operation Tom Tromey
2021-02-20 20:14 ` [PATCH v3 126/206] Introduce ada_wrapped_operation Tom Tromey
2021-02-20 20:14 ` [PATCH v3 127/206] Introduce ada_string_operation Tom Tromey
2021-02-20 20:14 ` [PATCH v3 128/206] Introduce ada_qual_operation Tom Tromey
2021-02-20 20:14 ` [PATCH v3 129/206] Introduce ada_ternop_range_operation Tom Tromey
2021-02-20 20:14 ` [PATCH v3 130/206] Implement several Fortran operations Tom Tromey
2021-02-20 20:14 ` [PATCH v3 131/206] Implement some Rust operations Tom Tromey
2021-02-20 20:14 ` [PATCH v3 132/206] Introduce rust_unop_ind_operation Tom Tromey
2021-02-20 20:14 ` [PATCH v3 133/206] Introduce rust_subscript_operation Tom Tromey
2021-02-20 20:14 ` [PATCH v3 134/206] Introduce rust_range_operation Tom Tromey
2021-02-20 20:14 ` [PATCH v3 135/206] Implement Rust field operations Tom Tromey
2021-02-20 20:14 ` [PATCH v3 136/206] Introduce rust_aggregate_operation Tom Tromey
2021-02-20 20:15 ` [PATCH v3 137/206] Add two simple Modula-2 operations Tom Tromey
2021-02-20 20:15 ` [PATCH v3 138/206] Implement the "&&" and "||" operators Tom Tromey
2021-02-20 20:15 ` [PATCH v3 139/206] Implement some Ada unary operations Tom Tromey
2021-02-20 20:15 ` [PATCH v3 140/206] Introduce ada_unop_range_operation Tom Tromey
2021-02-20 20:15 ` [PATCH v3 141/206] Introduce class adl_func_operation Tom Tromey
2021-02-20 20:15 ` [PATCH v3 142/206] Introduce array_operation Tom Tromey
2021-02-20 20:15 ` [PATCH v3 143/206] Implement function call operations Tom Tromey
2021-02-20 20:15 ` [PATCH v3 144/206] Implement Rust funcall operation Tom Tromey
2021-02-20 20:15 ` Tom Tromey [this message]
2021-02-20 20:15 ` [PATCH v3 146/206] Introduce classes for Fortran bound intrinsics Tom Tromey
2021-02-20 20:15 ` [PATCH v3 147/206] Implement fortran_allocated_operation Tom Tromey
2021-02-20 20:15 ` [PATCH v3 148/206] Introduce opencl_cast_type_operation Tom Tromey
2021-02-20 20:15 ` [PATCH v3 149/206] Implement OpenCL binary operations Tom Tromey
2021-02-20 20:15 ` [PATCH v3 150/206] Introduce opencl_notequal_operation Tom Tromey
2021-02-20 20:15 ` [PATCH v3 151/206] Introduce opencl_structop_operation Tom Tromey
2021-02-20 20:15 ` [PATCH v3 152/206] Implement OpenCL logical binary operations Tom Tromey
2021-02-20 20:15 ` [PATCH v3 153/206] Implement OpenCL ternary conditional operator Tom Tromey
2021-02-20 20:15 ` [PATCH v3 154/206] Split out some Ada type resolution code Tom Tromey
2021-02-20 20:15 ` [PATCH v3 155/206] Introduce ada_binop_addsub_operation Tom Tromey
2021-02-20 20:15 ` [PATCH v3 156/206] Implement Ada multiplicative operators Tom Tromey
2021-02-20 20:15 ` [PATCH v3 157/206] Implement Ada equality operators Tom Tromey
2021-02-20 20:15 ` [PATCH v3 158/206] Introduce ada_bitwise_operation Tom Tromey
2021-02-20 20:15 ` [PATCH v3 159/206] Introduce ada_ternop_slice Tom Tromey
2021-02-20 20:15 ` [PATCH v3 160/206] Introduce ada_binop_in_bounds Tom Tromey
2021-02-20 20:15 ` [PATCH v3 161/206] Implement some Ada OP_ATR_ operations Tom Tromey
2021-02-20 20:15 ` [PATCH v3 162/206] Introduce ada_var_value_operation Tom Tromey
2021-02-20 20:15 ` [PATCH v3 163/206] Introduce ada_var_msym_value_operation Tom Tromey
2021-02-20 20:15 ` [PATCH v3 164/206] Implement Ada min and max operations Tom Tromey
2021-02-20 20:15 ` [PATCH v3 165/206] Refactor value_pos_atr Tom Tromey
2021-02-20 20:15 ` [PATCH v3 166/206] Introduce ada_pos_operation Tom Tromey
2021-02-20 20:15 ` [PATCH v3 167/206] Introduce ada_atr_val_operation Tom Tromey
2021-02-20 20:15 ` [PATCH v3 168/206] Introduce ada_binop_exp_operation Tom Tromey
2021-02-20 20:15 ` [PATCH v3 169/206] Introduce ada_unop_ind_operation Tom Tromey
2021-02-20 20:15 ` [PATCH v3 170/206] Introduce ada_structop_operation Tom Tromey
2021-02-20 20:15 ` [PATCH v3 171/206] Implement function calls for Ada Tom Tromey
2021-02-20 20:15 ` [PATCH v3 172/206] Implement Ada resolution Tom Tromey
2021-02-20 20:15 ` [PATCH v3 173/206] Implement Ada assignment Tom Tromey
2021-02-20 20:15 ` [PATCH v3 174/206] Remove use of op_string Tom Tromey
2021-02-20 20:15 ` [PATCH v3 175/206] Add an expr::operation_up to struct expression Tom Tromey
2021-02-20 20:15 ` [PATCH v3 176/206] Add completion for operations Tom Tromey
2021-02-20 20:15 ` [PATCH v3 177/206] Add operation-related methods to parser_state Tom Tromey
2021-02-20 20:15 ` [PATCH v3 178/206] Convert dtrace probes to use operations Tom Tromey
2021-02-20 20:15 ` [PATCH v3 179/206] Convert stap probes to create operations Tom Tromey
2021-02-20 20:15 ` [PATCH v3 180/206] Convert rust-exp.y to use operations Tom Tromey
2021-02-20 20:15 ` [PATCH v3 181/206] Convert c-exp.y " Tom Tromey
2021-02-20 20:15 ` [PATCH v3 182/206] Convert go-exp.y " Tom Tromey
2021-02-20 20:15 ` [PATCH v3 183/206] Convert d-exp.y " Tom Tromey
2021-02-20 20:15 ` [PATCH v3 184/206] Convert p-exp.y " Tom Tromey
2021-02-20 20:15 ` [PATCH v3 185/206] Convert m2-exp.y " Tom Tromey
2021-02-20 20:15 ` [PATCH v3 186/206] Convert f-exp.y " Tom Tromey
2021-02-20 20:15 ` [PATCH v3 187/206] Convert ada-exp.y " Tom Tromey
2021-02-20 20:15 ` [PATCH v3 188/206] Remove now-unused Rust evaluator code Tom Tromey
2021-02-20 20:15 ` [PATCH v3 189/206] Remove now-unused Fortran " Tom Tromey
2021-02-20 20:15 ` [PATCH v3 190/206] Remove now-unused Modula-2 " Tom Tromey
2021-02-20 20:15 ` [PATCH v3 191/206] Remove now-unused Ada " Tom Tromey
2021-02-20 20:15 ` [PATCH v3 192/206] Remove now-unused C " Tom Tromey
2021-02-20 20:15 ` [PATCH v3 193/206] Remove union exp_element Tom Tromey
2021-02-20 20:15 ` [PATCH v3 194/206] Remove two Ada opcodes Tom Tromey
2021-02-20 20:15 ` [PATCH v3 195/206] Remove unused Modula-2 opcodes Tom Tromey
2021-02-20 20:15 ` [PATCH v3 196/206] Remove unused Ada opcodes Tom Tromey
2021-02-20 20:16 ` [PATCH v3 197/206] Remove OP_EXTENDED0 Tom Tromey
2021-02-20 20:16 ` [PATCH v3 198/206] Remove OP_UNUSED_LAST Tom Tromey
2021-02-20 20:16 ` [PATCH v3 199/206] Remove BINOP_END Tom Tromey
2021-02-20 20:16 ` [PATCH v3 200/206] Inline expression constructor Tom Tromey
2021-02-20 20:16 ` [PATCH v3 201/206] Inline expr_builder methods Tom Tromey
2021-02-20 20:16 ` [PATCH v3 202/206] Merge namespace scopes in eval.c Tom Tromey
2021-02-20 20:16 ` [PATCH v3 203/206] Remove EVAL_SKIP Tom Tromey
2021-02-20 20:16 ` [PATCH v3 204/206] Change exp_uses_objfile to return bool Tom Tromey
2021-02-20 20:16 ` [PATCH v3 205/206] Use bound_minimal_symbol in var_msym_value_operation Tom Tromey
2021-02-20 20:16 ` [PATCH v3 206/206] Remove some null checks Tom Tromey
2021-03-02 18:45 ` [PATCH v3 000/206] Refactor expressions Tom Tromey
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=20210220201609.838264-146-tom@tromey.com \
--to=tom@tromey.com \
--cc=gdb-patches@sourceware.org \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).