From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.129.124]) by sourceware.org (Postfix) with ESMTPS id B6C973858D28 for ; Wed, 15 Dec 2021 15:18:58 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org B6C973858D28 Received: from mail-wm1-f69.google.com (mail-wm1-f69.google.com [209.85.128.69]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id us-mta-557-XvhWh5FAOIWzOCkZfh6rlw-1; Wed, 15 Dec 2021 10:18:55 -0500 X-MC-Unique: XvhWh5FAOIWzOCkZfh6rlw-1 Received: by mail-wm1-f69.google.com with SMTP id bg20-20020a05600c3c9400b0033a9300b44bso9155674wmb.2 for ; Wed, 15 Dec 2021 07:18:55 -0800 (PST) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:date:from:to:cc:subject:message-id:references :mime-version:content-disposition:in-reply-to; bh=4ImM66NYkzBAxVXfTBLJ6IXz1rqIPOZZFBkL6pj9dRI=; b=dFM08lykCkkiT29RYEx6wMGWOmKhBY378Sh6CkFfyN0BP+o3tj2mxNJpe1rZ8QU2MJ xMk/7P6CLoBSzq5u6m0Kv0jO6mS2RPcAbww/ID/gKmiVvuuY4sbK5FHhYb1iL9C4ionx xQLTARRXrrJ1RF00kfC1nT3p8zxzCILTyk+IyFAGDvWUPZs6ygHf/CQuEPu80k4DmHoR M/nutUH2H6IiOuChFdYk8R6eNOephT1yNchWJTaHltEexspnvtvXRYWn1zkJun+uZk/p RAbrnSiKe66WoIZxshtE3AqVr+VlCIK79VIJYjQuXm6DRmkMmBkBSq61RpqPgbKocGPf K4cg== X-Gm-Message-State: AOAM530Rn6HyM5TtgRiMTKq4KCwEeKWiPDOGLJN9oXjpIUxtnOEdtb/H WACkety4Dv2dO60lbVo41ey+Uw2O5R02+x21OnO73W4H+mNdW1r4HO2XZubsSL/WwINPHeih2Jj 2olBquUhYA0GKXrJwwkEthA== X-Received: by 2002:a1c:1fd4:: with SMTP id f203mr253982wmf.192.1639581533980; Wed, 15 Dec 2021 07:18:53 -0800 (PST) X-Google-Smtp-Source: ABdhPJwKN5+wUwqEbTrGfArT9bPFz+vzyW+ePuXwad+ib8ji0LL8v1FvSzt/2jEBxgw5pdro9TdPEA== X-Received: by 2002:a1c:1fd4:: with SMTP id f203mr253922wmf.192.1639581533337; Wed, 15 Dec 2021 07:18:53 -0800 (PST) Received: from localhost (host86-134-238-138.range86-134.btcentralplus.com. [86.134.238.138]) by smtp.gmail.com with ESMTPSA id j18sm7017153wmq.44.2021.12.15.07.18.52 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 15 Dec 2021 07:18:52 -0800 (PST) Date: Wed, 15 Dec 2021 15:18:52 +0000 From: Andrew Burgess To: "Maciej W. Rozycki" Cc: gdb-patches@sourceware.org Subject: Re: [PATCH 3/6] Respect `set print repeats' with Fortran arrays Message-ID: <20211215151852.GK175541@redhat.com> References: MIME-Version: 1.0 In-Reply-To: X-Operating-System: Linux/5.8.18-100.fc31.x86_64 (x86_64) X-Uptime: 15:02:12 up 3 days, 1:19, X-Editor: GNU Emacs [ http://www.gnu.org/software/emacs ] X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Content-Type: text/plain; charset=us-ascii Content-Disposition: inline X-Spam-Status: No, score=-2.3 required=5.0 tests=BAYES_00, DKIMWL_WL_HIGH, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, KAM_ASCII_DIVIDERS, KAM_SHORT, RCVD_IN_BARRACUDACENTRAL, RCVD_IN_DNSWL_LOW, RCVD_IN_MSPIKE_H3, RCVD_IN_MSPIKE_WL, SPF_HELO_NONE, SPF_NONE, TXREP autolearn=no autolearn_force=no version=3.4.4 X-Spam-Checker-Version: SpamAssassin 3.4.4 (2020-01-24) on server2.sourceware.org X-BeenThere: gdb-patches@sourceware.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gdb-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Wed, 15 Dec 2021 15:19:02 -0000 * Maciej W. Rozycki [2021-12-11 11:47:25 +0000]: > Implement `set print repeats' handling for Fortran arrays. Currently > the setting is ignored and always treated as if no limit was set. > > Unlike the generic array walker implemented decades ago the Fortran one > is a proper C++ class. Rather than trying to mimic the old walker then, > which turned out a bit of a challenge where interacting with the `set > print elements' setting, write it entirely from scratch, by adding an > extra specialization handler method for processing dimensions other than > the innermost one and letting the specialization class call the `walk_1' > method from the handler as it sees fit. This way repeats can be tracked > and the next inner dimension recursed into as a need arises only, or > unconditionally in the base class. > > Keep track of the dimension number being handled in the class rather as > an argument to the walker so that it does not have to be passed across > by the specialization class. > > Use per-dimension element count tracking, needed to terminate processing > early when the limit set by `set print elements' is hit. This requires > extra care too where the limit triggers exactly where another element > that is a subarray begins. In that case rather than recursing we need > to terminate processing or lone `(...)' would be printed. Additionally > if the skipped element is the last one in the current dimension we need > to print `...' by hand, because `continue_walking' won't print it at the > upper level, because it can see the last element has already been taken > care of. > > Preserve the existing semantics of `set print elements' where the total > count of the elements handled is matched against the trigger level which > is unlike with the C/C++ array printer where the per-dimension element > count is used instead. > > Output now looks like: > > (gdb) set print repeats 4 > (gdb) print array_2d > $1 = ((2, ) ) > (gdb) set print elements 12 > (gdb) print array_2d > $2 = ((2, ) (2, ) (2, 2, ...) ...) > (gdb) > > for a 5 by 5 array filled with the value of 2. > > Amend existing test cases accordingly that rely on the current incorrect > behavior and explicitly request that there be no limit for printing > repeated elements there. > > Add suitable test cases as well covering sliced arrays in particular. Thanks for working on this, this looks awesome now. > > Co-Authored-By: Andrew Burgess That's a little generous, this work is ~99% yours I think :) I have some feedback, and a couple of pretty minor questions... > --- > gdb/f-array-walker.h | 43 ++- > gdb/f-valprint.c | 236 ++++++++++++++++++++- > gdb/testsuite/gdb.fortran/array-repeat.exp | 167 ++++++++++++++ > gdb/testsuite/gdb.fortran/array-repeat.f90 | 50 ++++ > gdb/testsuite/gdb.fortran/array-slices-repeat.f90 | 99 ++++++++ > gdb/testsuite/gdb.fortran/vla-value-sub-finish.exp | 2 > gdb/testsuite/gdb.fortran/vla-value-sub.exp | 2 > 7 files changed, 581 insertions(+), 18 deletions(-) > > gdb-fortran-set-print-repeats.diff > Index: src/gdb/f-array-walker.h > =================================================================== > --- src.orig/gdb/f-array-walker.h > +++ src/gdb/f-array-walker.h > @@ -131,6 +131,18 @@ struct fortran_array_walker_base_impl > void finish_dimension (bool inner_p, bool last_p) > { /* Nothing. */ } > > + /* Called when processing dimensions of the array other than the > + innermost one. WALK_1 is the walker to normally call, ELT_TYPE is > + the type of the element being extracted, and ELT_OFF is the offset > + of the element from the start of array being walked, and LAST_P is > + true only when this is the last element that will be processed in > + this dimension. */ > + void process_dimension (std::function walk_1, I think you should be using gdb::function_view here as the lambda only needs to live for the lifetime of the function call. > + struct type *elt_type, LONGEST elt_off, bool last_p) > + { > + walk_1 (elt_type, elt_off, last_p); > + } > + > /* Called when processing the inner most dimension of the array, for > every element in the array. ELT_TYPE is the type of the element being > extracted, and ELT_OFF is the offset of the element from the start of > @@ -177,22 +189,23 @@ class fortran_array_walker > : m_type (type), > m_address (address), > m_impl (type, address, args...), > - m_ndimensions (calc_f77_array_dims (m_type)) > + m_ndimensions (calc_f77_array_dims (m_type)), > + m_nss (0) > { /* Nothing. */ } > > /* Walk the array. */ > void > walk () > { > - walk_1 (1, m_type, 0, false); > + walk_1 (m_type, 0, false); > } > > private: > - /* The core of the array walking algorithm. NSS is the current > - dimension number being processed, TYPE is the type of this dimension, > - and OFFSET is the offset (in bytes) for the start of this dimension. */ > + /* The core of the array walking algorithm. TYPE is the type of > + the current dimension being processed and OFFSET is the offset > + (in bytes) for the start of this dimension. */ > void > - walk_1 (int nss, struct type *type, int offset, bool last_p) > + walk_1 (struct type *type, int offset, bool last_p) > { > /* Extract the range, and get lower and upper bounds. */ > struct type *range_type = check_typedef (type)->index_type (); > @@ -204,9 +217,10 @@ class fortran_array_walker > dimension. */ > fortran_array_offset_calculator calc (type); > > - m_impl.start_dimension (nss == m_ndimensions); > + m_nss++; > + m_impl.start_dimension (m_nss == m_ndimensions); > > - if (nss != m_ndimensions) > + if (m_nss != m_ndimensions) > { > struct type *subarray_type = TYPE_TARGET_TYPE (check_typedef (type)); > > @@ -220,7 +234,12 @@ class fortran_array_walker > LONGEST new_offset = offset + calc.index_offset (i); > > /* Now print the lower dimension. */ > - walk_1 (nss + 1, subarray_type, new_offset, (i == upperbound)); > + m_impl.process_dimension > + ([this] (struct type *w_type, int w_offset, bool w_last_p) -> void > + { > + this->walk_1 (w_type, w_offset, w_last_p); > + }, > + subarray_type, new_offset, i == upperbound); > } > } > else > @@ -245,7 +264,8 @@ class fortran_array_walker > } > } > > - m_impl.finish_dimension (nss == m_ndimensions, last_p || nss == 1); > + m_impl.finish_dimension (m_nss == m_ndimensions, last_p || m_nss == 1); > + m_nss--; > } > > /* The array type being processed. */ > @@ -260,6 +280,9 @@ class fortran_array_walker > > /* The total number of dimensions in M_TYPE. */ > int m_ndimensions; > + > + /* The current dimension number being processed. */ > + int m_nss; > }; > > #endif /* F_ARRAY_WALKER_H */ > Index: src/gdb/f-valprint.c > =================================================================== > --- src.orig/gdb/f-valprint.c > +++ src/gdb/f-valprint.c > @@ -21,6 +21,7 @@ > along with this program. If not, see . */ > > #include "defs.h" > +#include "annotate.h" > #include "symtab.h" > #include "gdbtypes.h" > #include "expression.h" > @@ -96,6 +97,15 @@ f77_get_dynamic_length_of_aggregate (str > * TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type))); > } > > +/* Per-dimension statistics. */ > + > +struct dimension_stats > +{ > + /* Element counter. */ > + int nelts; > + bool elts_counted; > +}; The comments here seem to just be repeating the variable names. Could we give more information. e.g. "Element counter", what elements is it counting, it's per dimension, but, is it counting every element? The number of repeated elements in a series? What does the bool mean? Does it mean we've counted everything? Just started counting? I also wondered about whether we could replace this with, or otherwise make use of a gdb::optional here? I see there's one place where we set elts_counted without appearing to set nelts, I'm guessing we're picking up the default value of 0 in that case? > + > /* A class used by FORTRAN_PRINT_ARRAY as a specialisation of the array > walking template. This specialisation prints Fortran arrays. */ > > @@ -117,7 +127,10 @@ class fortran_array_printer_impl : publi > m_val (val), > m_stream (stream), > m_recurse (recurse), > - m_options (options) > + m_options (options), > + m_dimension (0), > + m_nrepeats (0), > + m_stats (0) > { /* Nothing. */ } > > /* Called while iterating over the array bounds. When SHOULD_CONTINUE is > @@ -128,8 +141,18 @@ class fortran_array_printer_impl : publi > bool continue_walking (bool should_continue) > { > bool cont = should_continue && (m_elts < m_options->print_max); > + > if (!cont && should_continue) > - fputs_filtered ("...", m_stream); > + { > + if (m_nrepeats) The GDB style is to not treat integers as booleans, so this should be written as: if (m_nrepeats > 0) > + { > + process_outstanding_elements (m_elt_type_prev, m_elt_off_prev); > + fputs_filtered (", ", m_stream); > + m_nrepeats = 0; > + } > + > + fputs_filtered ("...", m_stream); > + } > return cont; > } > > @@ -137,6 +160,12 @@ class fortran_array_printer_impl : publi > inner most dimension then print an opening '(' character. */ > void start_dimension (bool inner_p) > { > + m_dimension++; > + > + m_elt_type_prev = nullptr; > + if (m_stats.size () < m_dimension) > + m_stats.resize (m_dimension); > + > fputs_filtered ("(", m_stream); > } > > @@ -149,22 +178,200 @@ class fortran_array_printer_impl : publi > fputs_filtered (")", m_stream); > if (!last_p) > fputs_filtered (" ", m_stream); > + > + m_dimension--; > + } > + > + /* Called when processing dimensions of the array other than the > + innermost one. WALK_1 is the walker to normally call, ELT_TYPE is > + the type of the element being extracted, and ELT_OFF is the offset > + of the element from the start of array being walked, and LAST_P is > + true only when this is the last element that will be processed in > + this dimension. */ > + void process_dimension (std::function walk_1, > + struct type *elt_type, LONGEST elt_off, bool last_p) > + { > + size_t dim_indx = m_dimension - 1; > + struct type *elt_type_prev = m_elt_type_prev; > + LONGEST elt_off_prev = m_elt_off_prev; > + bool repeated = (m_options->repeat_count_threshold < UINT_MAX > + && elt_type_prev != nullptr > + && (m_elts + ((m_nrepeats + 1) > + * m_stats[dim_indx + 1].nelts) > + <= m_options->print_max) > + && dimension_contents_eq (m_val, elt_type, > + elt_off_prev, elt_off)); > + > + if (repeated) > + m_nrepeats++; > + if (!repeated || last_p) > + { > + LONGEST nrepeats = m_nrepeats; > + > + m_nrepeats = 0; > + if (nrepeats >= m_options->repeat_count_threshold) > + { > + annotate_elt_rep (nrepeats + 1); > + fprintf_filtered (m_stream, "%p[%p]", > + metadata_style.style ().ptr (), > + plongest (nrepeats + 1), > + nullptr); > + annotate_elt_rep_end (); > + if (!repeated) > + fputs_filtered (" ", m_stream); > + m_elts += nrepeats * m_stats[dim_indx + 1].nelts; > + } > + else > + for (LONGEST i = nrepeats; i > 0; i--) > + walk_1 (elt_type_prev, elt_off_prev, repeated && i == 1); > + > + if (!repeated) > + { > + /* We need to specially handle the case of hitting `print_max' > + exactly as recursing would cause lone `(...)' to be printed. > + And we need to print `...' by hand if the skipped element > + would be the last one processed, because the subsequent call > + to `continue_walking' from our caller won't do that. */ > + if (m_elts < m_options->print_max) > + { > + walk_1 (elt_type, elt_off, last_p); > + nrepeats++; > + } > + else if (last_p) > + fputs_filtered ("...", m_stream); > + } > + > + if (!m_stats[dim_indx].elts_counted) > + m_stats[dim_indx].nelts += nrepeats * m_stats[dim_indx + 1].nelts; > + } > + > + m_elt_type_prev = elt_type; > + m_elt_off_prev = elt_off; > + > + if (last_p) > + m_stats[dim_indx].elts_counted = true; > } > > /* Called to process an element of ELT_TYPE at offset ELT_OFF from the > start of the parent object. */ > void process_element (struct type *elt_type, LONGEST elt_off, bool last_p) > { > - /* Extract the element value from the parent value. */ > - struct value *e_val > - = value_from_component (m_val, elt_type, elt_off); > - common_val_print (e_val, m_stream, m_recurse, m_options, current_language); > - if (!last_p) > - fputs_filtered (", ", m_stream); > + size_t dim_indx = m_dimension - 1; > + struct type *elt_type_prev = m_elt_type_prev; > + LONGEST elt_off_prev = m_elt_off_prev; > + bool repeated = (m_options->repeat_count_threshold < UINT_MAX > + && elt_type_prev != nullptr > + && value_contents_eq (m_val, elt_off_prev, m_val, elt_off, > + TYPE_LENGTH (elt_type))); > + > + if (repeated) > + m_nrepeats++; > + if (!repeated || last_p) > + { > + bool printed = false; I noticed that `printed` isn't actually needed, as we could say: bool printed = m_nrepeats; so you could just use m_nrepeats instead. > + > + if (m_nrepeats) Missing '> 0' again. > + { > + process_outstanding_elements (elt_type, elt_off_prev); > + printed = true; > + } > + > + if (!repeated) > + { > + /* Extract the element value from the parent value. */ > + struct value *e_val > + = value_from_component (m_val, elt_type, elt_off); > + > + if (printed) > + fputs_filtered (", ", m_stream); > + common_val_print (e_val, m_stream, m_recurse, m_options, > + current_language); > + } > + if (!last_p) > + fputs_filtered (", ", m_stream); > + } > + > + m_elt_type_prev = elt_type; > + m_elt_off_prev = elt_off; > ++m_elts; > + > + if (last_p && !m_stats[dim_indx].elts_counted) > + { > + m_stats[dim_indx].nelts = m_elts; > + m_stats[dim_indx].elts_counted = true; > + } > } > > private: > + /* Called to print outstanding repeated elements of ELT_TYPE starting > + at offset ELT_OFF from the start of the parent object. */ > + void process_outstanding_elements (struct type *elt_type, LONGEST elt_off) > + { > + LONGEST nrepeats = m_nrepeats; > + > + m_nrepeats = 0; > + if (nrepeats >= m_options->repeat_count_threshold) > + { > + annotate_elt_rep (nrepeats + 1); > + fprintf_filtered (m_stream, "%p[%p]", > + metadata_style.style ().ptr (), > + plongest (nrepeats + 1), > + nullptr); > + annotate_elt_rep_end (); > + } > + else > + { > + /* Extract the element value from the parent value. */ > + struct value *e_val = value_from_component (m_val, elt_type, elt_off); > + > + for (LONGEST i = nrepeats; i > 0; i--) > + { > + common_val_print (e_val, m_stream, m_recurse, m_options, > + current_language); > + if (i > 1) > + fputs_filtered (", ", m_stream); > + } > + } > + } > + > + /* Called to compare two VAL elements of ELT_TYPE at offsets OFFSET1 > + and OFFSET2 each. Handle subarrays recursively, because they may > + have been sliced and we do not want to compare any memory contents > + present between the slices requested. */ > + bool > + dimension_contents_eq (const struct value *val, struct type *type, > + LONGEST offset1, LONGEST offset2) > + { > + if (type->code () == TYPE_CODE_ARRAY > + && TYPE_TARGET_TYPE (type)->code () != TYPE_CODE_CHAR) > + { > + /* Extract the range, and get lower and upper bounds. */ You have a space before tab here. > + struct type *range_type = check_typedef (type)->index_type (); > + LONGEST lowerbound, upperbound; > + if (!get_discrete_bounds (range_type, &lowerbound, &upperbound)) > + error ("failed to get range bounds"); > + > + /* CALC is used to calculate the offsets for each element. */ > + fortran_array_offset_calculator calc (type); > + > + struct type *subarray_type = check_typedef (TYPE_TARGET_TYPE (type)); > + for (LONGEST i = lowerbound; i < upperbound + 1; i++) > + { > + /* Use the index and the stride to work out a new offset. */ > + LONGEST index_offset = calc.index_offset (i); > + > + if (!dimension_contents_eq (val, subarray_type, > + offset1 + index_offset, > + offset2 + index_offset)) > + return false; > + } > + return true; > + } > + else > + return value_contents_eq (val, offset1, val, offset2, > + TYPE_LENGTH (type)); > + } > + > /* The number of elements printed so far. */ > int m_elts; > > @@ -180,6 +387,19 @@ class fortran_array_printer_impl : publi > /* The print control options. Gives us the maximum number of elements to > print, and is passed through to each element that we print. */ > const struct value_print_options *m_options = nullptr; > + > + /* Dimension tracker. */ > + LONGEST m_dimension; > + > + /* Repetition tracker. */ > + LONGEST m_nrepeats; > + > + /* Element tracker. */ > + struct type *m_elt_type_prev; > + LONGEST m_elt_off_prev; > + > + /* Per-dimension stats. */ > + std::vector m_stats; I'd like to see some of these comments expanded slightly to give more information about how they are used. > }; > > /* This function gets called to print a Fortran array. */ > Index: src/gdb/testsuite/gdb.fortran/array-repeat.exp > =================================================================== > --- /dev/null > +++ src/gdb/testsuite/gdb.fortran/array-repeat.exp > @@ -0,0 +1,167 @@ > +# Copyright 2021 Free Software Foundation, Inc. > + > +# 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 . > + > +# Test the detection and printing of repeated elements in Fortran arrays. > + > +if {[skip_fortran_tests]} { return -1 } > + > +load_lib fortran.exp > + > +# Build up the expected output for each array. > +set a9p9o "(9, 9, 9, 9, 9, 9)" > +set a1p "(1, 1, 1, 1, 1)" > +set a1p9 "(1, 1, 1, 1, 1, 9)" > +set a2po "(2, 2, 2, 2, 2)" > +set a2p "(${a2po} ${a2po} ${a2po} ${a2po} ${a2po})" > +set a2p9o "(2, 2, 2, 2, 2, 9)" > +set a2p9 "(${a2p9o} ${a2p9o} ${a2p9o} ${a2p9o} ${a2p9o} ${a9p9o})" > +set a3po "(3, 3, 3, 3, 3)" > +set a3p "(${a3po} ${a3po} ${a3po} ${a3po} ${a3po})" > +set a3p "(${a3p} ${a3p} ${a3p} ${a3p} ${a3p})" > +set a3p9o "(3, 3, 3, 3, 3, 9)" > +set a3p9 "(${a3p9o} ${a3p9o} ${a3p9o} ${a3p9o} ${a3p9o} ${a9p9o})" > +set a9p9 "(${a9p9o} ${a9p9o} ${a9p9o} ${a9p9o} ${a9p9o} ${a9p9o})" > +set a3p9 "(${a3p9} ${a3p9} ${a3p9} ${a3p9} ${a3p9} ${a9p9})" > + > +# Convert the output into a regexp. > +set r1p [string_to_regexp $a1p] > +set r1p9 [string_to_regexp $a1p9] > +set r2po [string_to_regexp $a2po] > +set r2p9o [string_to_regexp $a2p9o] > +set r2p [string_to_regexp $a2p] > +set r2p9 [string_to_regexp $a2p9] > +set r3po [string_to_regexp $a3po] > +set r3p9o [string_to_regexp $a3p9o] > +set r3p [string_to_regexp $a3p] > +set r3p9 [string_to_regexp $a3p9] > + > +set rep5 "" > +set rep6 "" > + > +proc array_repeat { variant } { > + global testfile srcfile binfile > + upvar r1p r1p r1p9 r1p9 r2po r2po r2p9o r2p9o r2p r2p r2p9 r2p9 > + upvar r3po r3po r3p9o r3p9o r3p r3p r3p9 r3p9 > + upvar a2po a2po a2p9o a2p9o a3po a3po a3p9o a3p9o > + upvar rep5 rep5 rep6 rep6 > + > + standard_testfile "${variant}.f90" > + > + if {[prepare_for_testing ${testfile}.exp ${variant} ${srcfile} \ > + {debug f90}]} { > + return -1 > + } > + > + if {![fortran_runto_main]} { > + perror "Could not run to main." > + continue > + } > + > + gdb_breakpoint [gdb_get_line_number "Break here"] > + gdb_continue_to_breakpoint "${variant}" > + > + with_test_prefix "${variant}: repeats=unlimited, elements=unlimited" { > + # Check the arrays print as expected. > + gdb_test_no_output "set print repeats unlimited" > + gdb_test_no_output "set print elements unlimited" > + > + gdb_test "print array_1d" "${r1p}" > + gdb_test "print array_1d9" "${r1p9}" > + gdb_test "print array_2d" "${r2p}" > + gdb_test "print array_2d9" "${r2p9}" > + gdb_test "print array_3d" "${r3p}" > + gdb_test "print array_3d9" "${r3p9}" > + } > + > + with_test_prefix "${variant}: repeats=4, elements=unlimited" { > + # Now set the repeat limit. > + gdb_test_no_output "set print repeats 4" > + gdb_test_no_output "set print elements unlimited" > + > + gdb_test "print array_1d" \ > + [string_to_regexp "(1, ${rep5})"] > + gdb_test "print array_1d9" \ > + [string_to_regexp "(1, ${rep5}, 9)"] > + gdb_test "print array_2d" \ > + [string_to_regexp "((2, ${rep5}) ${rep5})"] > + gdb_test "print array_2d9" \ > + [string_to_regexp "((2, ${rep5}, 9) ${rep5} (9, ${rep6}))"] > + gdb_test "print array_3d" \ > + [string_to_regexp "(((3, ${rep5}) ${rep5}) ${rep5})"] > + gdb_test "print array_3d9" \ > + [string_to_regexp "(((3, ${rep5}, 9) ${rep5} (9, ${rep6})) ${rep5}\ > + ((9, ${rep6}) ${rep6}))"] > + } > + > + with_test_prefix "${variant}: repeats=unlimited, elements=12" { > + # Now set the element limit. > + gdb_test_no_output "set print repeats unlimited" > + gdb_test_no_output "set print elements 12" > + > + gdb_test "print array_1d" "${r1p}" > + gdb_test "print array_1d9" "${r1p9}" > + gdb_test "print array_2d" \ > + [string_to_regexp "(${a2po} ${a2po} (2, 2, ...) ...)"] > + gdb_test "print array_2d9" \ > + [string_to_regexp "(${a2p9o} ${a2p9o} ...)"] > + gdb_test "print array_3d" \ > + [string_to_regexp "((${a3po} ${a3po} (3, 3, ...) ...) ...)"] > + gdb_test "print array_3d9" \ > + [string_to_regexp "((${a3p9o} ${a3p9o} ...) ...)"] > + } > + > + with_test_prefix "${variant}: repeats=4, elements=12" { > + # Now set both limits. > + gdb_test_no_output "set print repeats 4" > + gdb_test_no_output "set print elements 12" > + > + gdb_test "print array_1d" \ > + [string_to_regexp "(1, ${rep5})"] > + gdb_test "print array_1d9" \ > + [string_to_regexp "(1, ${rep5}, 9)"] > + gdb_test "print array_2d" \ > + [string_to_regexp "((2, ${rep5}) (2, ${rep5}) (2, 2, ...) ...)"] > + gdb_test "print array_2d9" \ > + [string_to_regexp "((2, ${rep5}, 9) (2, ${rep5}, 9) ...)"] > + gdb_test "print array_3d" \ > + [string_to_regexp "(((3, ${rep5}) (3, ${rep5}) (3, 3, ...) ...)\ > + ...)"] > + gdb_test "print array_3d9" \ > + [string_to_regexp "(((3, ${rep5}, 9) (3, ${rep5}, 9) ...) ...)"] > + } > + > + with_test_prefix "${variant}: repeats=4, elements=30" { > + # Now set both limits. > + gdb_test_no_output "set print repeats 4" > + gdb_test_no_output "set print elements 30" > + > + gdb_test "print array_1d" \ > + [string_to_regexp "(1, ${rep5})"] > + gdb_test "print array_1d9" \ > + [string_to_regexp "(1, ${rep5}, 9)"] > + gdb_test "print array_2d" \ > + [string_to_regexp "((2, ${rep5}) ${rep5})"] > + gdb_test "print array_2d9" \ > + [string_to_regexp "((2, ${rep5}, 9) ${rep5} ...)"] > + gdb_test "print array_3d" \ > + [string_to_regexp "(((3, ${rep5}) ${rep5}) ((3, ${rep5}) ...)\ > + ...)"] > + gdb_test "print array_3d9" \ > + [string_to_regexp "(((3, ${rep5}, 9) ${rep5} ...) ...)"] > + } > +} > + > +array_repeat "array-repeat" > +array_repeat "array-slices-repeat" > Index: src/gdb/testsuite/gdb.fortran/array-repeat.f90 > =================================================================== > --- /dev/null > +++ src/gdb/testsuite/gdb.fortran/array-repeat.f90 > @@ -0,0 +1,50 @@ > +! Copyright 2021 Free Software Foundation, Inc. > +! > +! 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 . > + > +! > +! Start of test program. > +! > +program test > + > + ! Declare variables used in this test. > + integer, dimension (-2:2) :: array_1d > + integer, dimension (-2:3) :: array_1d9 > + integer, dimension (-2:2, -2:2) :: array_2d > + integer, dimension (-2:3, -2:3) :: array_2d9 > + integer, dimension (-2:2, -2:2, -2:2) :: array_3d > + integer, dimension (-2:3, -2:3, -2:3) :: array_3d9 > + > + array_1d = 1 > + array_1d9 = 1 > + array_1d9 (3) = 9 > + array_2d = 2 > + array_2d9 = 2 > + array_2d9 (3, :) = 9 > + array_2d9 (:, 3) = 9 > + array_3d = 3 > + array_3d9 = 3 > + array_3d9 (3, :, :) = 9 > + array_3d9 (:, 3, :) = 9 > + array_3d9 (:, :, 3) = 9 > + > + print *, "" ! Break here > + print *, array_1d > + print *, array_1d9 > + print *, array_2d > + print *, array_2d9 > + print *, array_3d > + print *, array_3d9 > + > +end program test > Index: src/gdb/testsuite/gdb.fortran/array-slices-repeat.f90 > =================================================================== > --- /dev/null > +++ src/gdb/testsuite/gdb.fortran/array-slices-repeat.f90 > @@ -0,0 +1,99 @@ > +! Copyright 2021 Free Software Foundation, Inc. > +! > +! 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 . > + > +subroutine show (array_1d, array_1d9, array_2d, array_2d9, array_3d, array_3d9) > + integer, dimension (-2:) :: array_1d > + integer, dimension (-2:) :: array_1d9 > + integer, dimension (-2:, -2:) :: array_2d > + integer, dimension (-2:, -2:) :: array_2d9 > + integer, dimension (-2:, -2:, -2:) :: array_3d > + integer, dimension (-2:, -2:, -2:) :: array_3d9 > + > + print *, "" ! Break here > + print *, array_1d > + print *, array_1d9 > + print *, array_2d > + print *, array_2d9 > + print *, array_3d > + print *, array_3d9 > +end subroutine show > + > +! > +! Start of test program. > +! > +program test > + interface > + subroutine show (array_1d, array_1d9, array_2d, array_2d9, & > + array_3d, array_3d9) > + integer, dimension (:) :: array_1d > + integer, dimension (:) :: array_1d9 > + integer, dimension (:, :) :: array_2d > + integer, dimension (:, :) :: array_2d9 > + integer, dimension (:, :, :) :: array_3d > + integer, dimension (:, :, :) :: array_3d9 > + end subroutine show > + end interface > + > + ! Declare variables used in this test. > + integer, dimension (-8:6) :: array_1d > + integer, dimension (-8:9) :: array_1d9 > + integer, dimension (-8:6, -8:6) :: array_2d > + integer, dimension (-8:9, -8:9) :: array_2d9 > + integer, dimension (-8:6, -8:6, -8:6) :: array_3d > + integer, dimension (-8:9, -8:9, -8:9) :: array_3d9 > + > + integer, parameter :: v6 (6) = [-5, -4, -3, 1, 2, 3] > + integer, parameter :: v9 (9) = [-5, -4, -3, 1, 2, 3, 7, 8, 9] > + > + ! Intersperse slices selected with varying data to make sure it is > + ! correctly ignored for the purpose of repeated element recognition > + ! in the slices. > + array_1d = 7 > + array_1d (::3) = 1 > + array_1d9 = 7 > + array_1d9 (::3) = 1 > + array_1d9 (7) = 9 > + array_2d = 7 > + array_2d (:, v6) = 6 > + array_2d (::3, ::3) = 2 > + array_2d9 = 7 > + array_2d9 (:, v9) = 6 > + array_2d9 (::3, ::3) = 2 > + array_2d9 (7, ::3) = 9 > + array_2d9 (::3, 7) = 9 > + array_3d = 7 > + array_3d (:, v6, :) = 6 > + array_3d (:, v6, v6) = 5 > + array_3d (::3, ::3, ::3) = 3 > + array_3d9 = 7 > + array_3d9 (:, v9, :) = 6 > + array_3d9 (:, v9, v9) = 5 > + array_3d9 (::3, ::3, ::3) = 3 > + array_3d9 (7, ::3, ::3) = 9 > + array_3d9 (::3, 7, ::3) = 9 > + array_3d9 (::3, ::3, 7) = 9 > + > + call show (array_1d (::3), array_1d9 (::3), & > + array_2d (::3, ::3), array_2d9 (::3, ::3), & > + array_3d (::3, ::3, ::3), array_3d9 (::3, ::3, ::3)) > + > + print *, array_1d > + print *, array_1d9 > + print *, array_2d > + print *, array_2d9 > + print *, array_3d > + print *, array_3d9 > + > +end program test > Index: src/gdb/testsuite/gdb.fortran/vla-value-sub-finish.exp > =================================================================== > --- src.orig/gdb/testsuite/gdb.fortran/vla-value-sub-finish.exp > +++ src/gdb/testsuite/gdb.fortran/vla-value-sub-finish.exp > @@ -32,6 +32,8 @@ if ![fortran_runto_main] { > # We need both variants as depending on the arch we optionally may still be > # executing the caller line or not after `finish'. > > +gdb_test_no_output "set print repeats unlimited" > + > gdb_breakpoint [gdb_get_line_number "array2-almost-filled"] > gdb_continue_to_breakpoint "array2-almost-filled" > # array2 size is 296352 bytes. > Index: src/gdb/testsuite/gdb.fortran/vla-value-sub.exp > =================================================================== > --- src.orig/gdb/testsuite/gdb.fortran/vla-value-sub.exp > +++ src/gdb/testsuite/gdb.fortran/vla-value-sub.exp > @@ -29,6 +29,8 @@ if ![fortran_runto_main] { > > # Check the values of VLA's in subroutine can be evaluated correctly > > +gdb_test_no_output "set print repeats unlimited" > + > # Try to access values from a fixed array handled as VLA in subroutine. > gdb_breakpoint [gdb_get_line_number "not-filled"] > gdb_continue_to_breakpoint "not-filled (1st)" >