From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail-wr1-x42d.google.com (mail-wr1-x42d.google.com [IPv6:2a00:1450:4864:20::42d]) by sourceware.org (Postfix) with ESMTPS id 96BFA3857C7A for ; Sat, 11 Dec 2021 11:47:28 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org 96BFA3857C7A Authentication-Results: sourceware.org; dmarc=none (p=none dis=none) header.from=embecosm.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=embecosm.com Received: by mail-wr1-x42d.google.com with SMTP id a9so19101026wrr.8 for ; Sat, 11 Dec 2021 03:47:28 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=embecosm.com; s=google; h=date:from:to:cc:subject:in-reply-to:message-id:references :user-agent:mime-version; bh=i/gc7r1BPIDjh7qxQyRGTx31a9bdRQ+qRndemmzjkjQ=; b=eKxfNwDKSiHEJjRhctS3o9xnltBWqtP8/taLaByr0/oK7E052TOdCQNM3Z6gvQAyUL RYfebapOr6dgd99CJdtVoXlNcgsoYPC4kwpATh2fcBwrJQhw5DYNyGqc3bbHfsmsCr0i zO5ZWU7ykkDtjmAmulDn0u+edm4pa1CrPK0f0aElBdMx2dOPdlt/7EPIi7/iTIoR7jFQ khz5aO2fPD0UhLtz35DQAS+WSzQJO+Y1+tECDvOUMFuISnZGmFyM9w2pz8nIG/6tkogV +26JoDqHboCa3ERxd2d93soN8mImyEcq5mg5Zrxy45ttyWRkzGF3+Z9RzHXH82tR7nFi lNtg== 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:in-reply-to:message-id :references:user-agent:mime-version; bh=i/gc7r1BPIDjh7qxQyRGTx31a9bdRQ+qRndemmzjkjQ=; b=lx4XVcx1qLEaCwJt7ZwZ9gpKluivPftCyiXCUzYpykEmK2h8omtDMdcxOvxIEDnepe toLHfSYUjHR7nbx9xWv29/ctE4N45ZElQRqAsa5/Dv2YgrIzkleLa21E9Do3W4y3xzKj BqiayeBtx3ibaVIDDgBbrEYRjY5QjLVIkT/nENC9HzC3fIOakEz9fK7HvZ5/hWG1wnbg +EYKc5/1Qmgx3aEMYkM64nfg963COVOsgix8baiz4Oo8LsTLvoF8I1toVdACJI2a8Ll5 wdw4106UZ1foNBriphk9YL7QizmcN76ic1Zi8I3CBX0FtBA/6YjVJJYTL0NrLNfUHBoM Vdfw== X-Gm-Message-State: AOAM530IyamqlK/AezvLgtuZ8xBllrWmoRF2vJR2aQT93znIz8bQYq1b Z3tckGcnuQaYKZx161ne8aW2TmtXoAuBUg== X-Google-Smtp-Source: ABdhPJwtU40Uqm/hsi23zeoh5OAa4s3j4cri0oviFJ7hcnYhp010gUOe5IE671i0y0lZHsmAhMJUGg== X-Received: by 2002:a5d:628f:: with SMTP id k15mr20993182wru.363.1639223247464; Sat, 11 Dec 2021 03:47:27 -0800 (PST) Received: from tpp.orcam.me.uk (tpp.orcam.me.uk. [2001:8b0:154:0:ea6a:64ff:fe24:f2fc]) by smtp.gmail.com with ESMTPSA id az4sm1330654wmb.20.2021.12.11.03.47.26 (version=TLS1_2 cipher=ECDHE-ECDSA-AES128-GCM-SHA256 bits=128/128); Sat, 11 Dec 2021 03:47:27 -0800 (PST) Date: Sat, 11 Dec 2021 11:47:25 +0000 (GMT) From: "Maciej W. Rozycki" To: gdb-patches@sourceware.org cc: Andrew Burgess Subject: [PATCH 3/6] Respect `set print repeats' with Fortran arrays In-Reply-To: Message-ID: References: User-Agent: Alpine 2.20 (DEB 67 2015-01-07) MIME-Version: 1.0 Content-Type: text/plain; charset=US-ASCII X-Spam-Status: No, score=-2.5 required=5.0 tests=BAYES_00, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, KAM_ASCII_DIVIDERS, KAM_SHORT, RCVD_IN_DNSWL_NONE, SPF_HELO_NONE, SPF_PASS, 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: Sat, 11 Dec 2021 11:47:32 -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. Co-Authored-By: Andrew Burgess --- 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, + 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; +}; + /* 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) + { + 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; + + if (m_nrepeats) + { + 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. */ + 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; }; /* 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)"