mirror of
https://sourceware.org/git/binutils-gdb.git
synced 2024-11-27 03:51:15 +08:00
a5c641b57b
This commit brings array slice support to GDB.
WARNING: This patch contains a rather big hack which is limited to
Fortran arrays, this can be seen in gdbtypes.c and f-lang.c. More
details on this below.
This patch rewrites two areas of GDB's Fortran support, the code to
extract an array slice, and the code to print an array.
After this commit a user can, from the GDB prompt, ask for a slice of
a Fortran array and should get the correct result back. Slices can
(optionally) have the lower bound, upper bound, and a stride
specified. Slices can also have a negative stride.
Fortran has the concept of repacking array slices. Within a compiled
Fortran program if a user passes a non-contiguous array slice to a
function then the compiler may have to repack the slice, this involves
copying the elements of the slice to a new area of memory before the
call, and copying the elements back to the original array after the
call. Whether repacking occurs will depend on which version of
Fortran is being used, and what type of function is being called.
This commit adds support for both packed, and unpacked array slicing,
with the default being unpacked.
With an unpacked array slice, when the user asks for a slice of an
array GDB creates a new type that accurately describes where the
elements of the slice can be found within the original array, a
value of this type is then returned to the user. The address of an
element within the slice will be equal to the address of an element
within the original array.
A user can choose to select packed array slices instead using:
(gdb) set fortran repack-array-slices on|off
(gdb) show fortran repack-array-slices
With packed array slices GDB creates a new type that reflects how the
elements of the slice would look if they were laid out in contiguous
memory, allocates a value of this type, and then fetches the elements
from the original array and places then into the contents buffer of
the new value.
One benefit of using packed slices over unpacked slices is the memory
usage, taking a small slice of N elements from a large array will
require (in GDB) N * ELEMENT_SIZE bytes of memory, while an unpacked
array will also include all of the "padding" between the
non-contiguous elements. There are new tests added that highlight
this difference.
There is also a new debugging flag added with this commit that
introduces these commands:
(gdb) set debug fortran-array-slicing on|off
(gdb) show debug fortran-array-slicing
This prints information about how the array slices are being built.
As both the repacking, and the array printing requires GDB to walk
through a multi-dimensional Fortran array visiting each element, this
commit adds the file f-array-walk.h, which introduces some
infrastructure to support this process. This means the array printing
code in f-valprint.c is significantly reduced.
The only slight issue with this commit is the "rather big hack" that I
mentioned above. This hack allows us to handle one specific case,
array slices with negative strides. This is something that I don't
believe the current GDB value contents model will allow us to
correctly handle, and rather than rewrite the value contents code
right now, I'm hoping to slip this hack in as a work around.
The problem is that, as I see it, the current value contents model
assumes that an object base address will be the lowest address within
that object, and that the contents of the object start at this base
address and occupy the TYPE_LENGTH bytes after that.
( We do have the embedded_offset, which is used for C++ sub-classes,
such that an object can start at some offset from the content buffer,
however, the assumption that the object then occupies the next
TYPE_LENGTH bytes is still true within GDB. )
The problem is that Fortran arrays with a negative stride don't follow
this pattern. In this case the base address of the object points to
the element with the highest address, the contents of the array then
start at some offset _before_ the base address, and proceed for one
element _past_ the base address.
As the stride for such an array would be negative then, in theory the
TYPE_LENGTH for this type would also be negative. However, in many
places a value in GDB will degrade to a pointer + length, and the
length almost always comes from the TYPE_LENGTH.
It is my belief that in order to correctly model this case the value
content handling of GDB will need to be reworked to split apart the
value's content buffer (which is a block of memory with a length), and
the object's in memory base address and length, which could be
negative.
Things are further complicated because arrays with negative strides
like this are always dynamic types. When a value has a dynamic type
and its base address needs resolving we actually store the address of
the object within the resolved dynamic type, not within the value
object itself.
In short I don't currently see an easy path to cleanly support this
situation within GDB. And so I believe that leaves two options,
either add a work around, or catch cases where the user tries to make
use of a negative stride, or access an array with a negative stride,
and throw an error.
This patch currently goes with adding a work around, which is that
when we resolve a dynamic Fortran array type, if the stride is
negative, then we adjust the base address to point to the lowest
address required by the array. The printing and slicing code is aware
of this adjustment and will correctly slice and print Fortran arrays.
Where this hack will show through to the user is if they ask for the
address of an array in their program with a negative array stride, the
address they get from GDB will not match the address that would be
computed within the Fortran program.
gdb/ChangeLog:
* Makefile.in (HFILES_NO_SRCDIR): Add f-array-walker.h.
* NEWS: Mention new options.
* f-array-walker.h: New file.
* f-lang.c: Include 'gdbcmd.h' and 'f-array-walker.h'.
(repack_array_slices): New static global.
(show_repack_array_slices): New function.
(fortran_array_slicing_debug): New static global.
(show_fortran_array_slicing_debug): New function.
(value_f90_subarray): Delete.
(skip_undetermined_arglist): Delete.
(class fortran_array_repacker_base_impl): New class.
(class fortran_lazy_array_repacker_impl): New class.
(class fortran_array_repacker_impl): New class.
(fortran_value_subarray): Complete rewrite.
(set_fortran_list): New static global.
(show_fortran_list): Likewise.
(_initialize_f_language): Register new commands.
(fortran_adjust_dynamic_array_base_address_hack): New function.
* f-lang.h (fortran_adjust_dynamic_array_base_address_hack):
Declare.
* f-valprint.c: Include 'f-array-walker.h'.
(class fortran_array_printer_impl): New class.
(f77_print_array_1): Delete.
(f77_print_array): Delete.
(fortran_print_array): New.
(f_value_print_inner): Update to call fortran_print_array.
* gdbtypes.c: Include 'f-lang.h'.
(resolve_dynamic_type_internal): Call
fortran_adjust_dynamic_array_base_address_hack.
gdb/testsuite/ChangeLog:
* gdb.fortran/array-slices-bad.exp: New file.
* gdb.fortran/array-slices-bad.f90: New file.
* gdb.fortran/array-slices-sub-slices.exp: New file.
* gdb.fortran/array-slices-sub-slices.f90: New file.
* gdb.fortran/array-slices.exp: Rewrite tests.
* gdb.fortran/array-slices.f90: Rewrite tests.
* gdb.fortran/vla-sizeof.exp: Correct expected results.
gdb/doc/ChangeLog:
* gdb.texinfo (Debugging Output): Document 'set/show debug
fortran-array-slicing'.
(Special Fortran Commands): Document 'set/show fortran
repack-array-slices'.
376 lines
11 KiB
C++
376 lines
11 KiB
C++
/* Fortran language support definitions for GDB, the GNU debugger.
|
|
|
|
Copyright (C) 1992-2020 Free Software Foundation, Inc.
|
|
|
|
Contributed by Motorola. Adapted from the C definitions by Farooq Butt
|
|
(fmbutt@engage.sps.mot.com).
|
|
|
|
This file is part of GDB.
|
|
|
|
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 <http://www.gnu.org/licenses/>. */
|
|
|
|
#ifndef F_LANG_H
|
|
#define F_LANG_H
|
|
|
|
#include "valprint.h"
|
|
|
|
struct type_print_options;
|
|
struct parser_state;
|
|
|
|
/* Class representing the Fortran language. */
|
|
|
|
class f_language : public language_defn
|
|
{
|
|
public:
|
|
f_language ()
|
|
: language_defn (language_fortran)
|
|
{ /* Nothing. */ }
|
|
|
|
/* See language.h. */
|
|
|
|
const char *name () const override
|
|
{ return "fortran"; }
|
|
|
|
/* See language.h. */
|
|
|
|
const char *natural_name () const override
|
|
{ return "Fortran"; }
|
|
|
|
/* See language.h. */
|
|
|
|
const std::vector<const char *> &filename_extensions () const override
|
|
{
|
|
static const std::vector<const char *> extensions = {
|
|
".f", ".F", ".for", ".FOR", ".ftn", ".FTN", ".fpp", ".FPP",
|
|
".f90", ".F90", ".f95", ".F95", ".f03", ".F03", ".f08", ".F08"
|
|
};
|
|
return extensions;
|
|
}
|
|
|
|
/* See language.h. */
|
|
void language_arch_info (struct gdbarch *gdbarch,
|
|
struct language_arch_info *lai) const override;
|
|
|
|
/* See language.h. */
|
|
unsigned int search_name_hash (const char *name) const override;
|
|
|
|
/* See language.h. */
|
|
|
|
char *demangle_symbol (const char *mangled, int options) const override
|
|
{
|
|
/* We could support demangling here to provide module namespaces
|
|
also for inferiors with only minimal symbol table (ELF symbols).
|
|
Just the mangling standard is not standardized across compilers
|
|
and there is no DW_AT_producer available for inferiors with only
|
|
the ELF symbols to check the mangling kind. */
|
|
return nullptr;
|
|
}
|
|
|
|
/* See language.h. */
|
|
|
|
void print_type (struct type *type, const char *varstring,
|
|
struct ui_file *stream, int show, int level,
|
|
const struct type_print_options *flags) const override;
|
|
|
|
/* See language.h. This just returns default set of word break
|
|
characters but with the modules separator `::' removed. */
|
|
|
|
const char *word_break_characters (void) const override
|
|
{
|
|
static char *retval;
|
|
|
|
if (!retval)
|
|
{
|
|
char *s;
|
|
|
|
retval = xstrdup (language_defn::word_break_characters ());
|
|
s = strchr (retval, ':');
|
|
if (s)
|
|
{
|
|
char *last_char = &s[strlen (s) - 1];
|
|
|
|
*s = *last_char;
|
|
*last_char = 0;
|
|
}
|
|
}
|
|
return retval;
|
|
}
|
|
|
|
|
|
/* See language.h. */
|
|
|
|
void collect_symbol_completion_matches (completion_tracker &tracker,
|
|
complete_symbol_mode mode,
|
|
symbol_name_match_type name_match_type,
|
|
const char *text, const char *word,
|
|
enum type_code code) const override
|
|
{
|
|
/* Consider the modules separator :: as a valid symbol name character
|
|
class. */
|
|
default_collect_symbol_completion_matches_break_on (tracker, mode,
|
|
name_match_type,
|
|
text, word, ":",
|
|
code);
|
|
}
|
|
|
|
/* See language.h. */
|
|
|
|
void value_print_inner
|
|
(struct value *val, struct ui_file *stream, int recurse,
|
|
const struct value_print_options *options) const override;
|
|
|
|
/* See language.h. */
|
|
|
|
struct block_symbol lookup_symbol_nonlocal
|
|
(const char *name, const struct block *block,
|
|
const domain_enum domain) const override;
|
|
|
|
/* See language.h. */
|
|
|
|
int parser (struct parser_state *ps) const override;
|
|
|
|
/* See language.h. */
|
|
|
|
void emitchar (int ch, struct type *chtype,
|
|
struct ui_file *stream, int quoter) const override
|
|
{
|
|
const char *encoding = get_encoding (chtype);
|
|
generic_emit_char (ch, chtype, stream, quoter, encoding);
|
|
}
|
|
|
|
/* See language.h. */
|
|
|
|
void printchar (int ch, struct type *chtype,
|
|
struct ui_file *stream) const override
|
|
{
|
|
fputs_filtered ("'", stream);
|
|
LA_EMIT_CHAR (ch, chtype, stream, '\'');
|
|
fputs_filtered ("'", stream);
|
|
}
|
|
|
|
/* See language.h. */
|
|
|
|
void printstr (struct ui_file *stream, struct type *elttype,
|
|
const gdb_byte *string, unsigned int length,
|
|
const char *encoding, int force_ellipses,
|
|
const struct value_print_options *options) const override
|
|
{
|
|
const char *type_encoding = get_encoding (elttype);
|
|
|
|
if (TYPE_LENGTH (elttype) == 4)
|
|
fputs_filtered ("4_", stream);
|
|
|
|
if (!encoding || !*encoding)
|
|
encoding = type_encoding;
|
|
|
|
generic_printstr (stream, elttype, string, length, encoding,
|
|
force_ellipses, '\'', 0, options);
|
|
}
|
|
|
|
/* See language.h. */
|
|
|
|
void print_typedef (struct type *type, struct symbol *new_symbol,
|
|
struct ui_file *stream) const override;
|
|
|
|
/* See language.h. */
|
|
|
|
bool is_string_type_p (struct type *type) const override
|
|
{
|
|
type = check_typedef (type);
|
|
return (type->code () == TYPE_CODE_STRING
|
|
|| (type->code () == TYPE_CODE_ARRAY
|
|
&& TYPE_TARGET_TYPE (type)->code () == TYPE_CODE_CHAR));
|
|
}
|
|
|
|
/* See language.h. */
|
|
|
|
const char *struct_too_deep_ellipsis () const override
|
|
{ return "(...)"; }
|
|
|
|
/* See language.h. */
|
|
|
|
bool c_style_arrays_p () const override
|
|
{ return false; }
|
|
|
|
/* See language.h. */
|
|
|
|
bool range_checking_on_by_default () const override
|
|
{ return true; }
|
|
|
|
/* See language.h. */
|
|
|
|
enum case_sensitivity case_sensitivity () const override
|
|
{ return case_sensitive_off; }
|
|
|
|
/* See language.h. */
|
|
|
|
enum array_ordering array_ordering () const override
|
|
{ return array_column_major; }
|
|
|
|
/* See language.h. */
|
|
|
|
const struct exp_descriptor *expression_ops () const override
|
|
{ return &exp_descriptor_tab; }
|
|
|
|
/* See language.h. */
|
|
|
|
const struct op_print *opcode_print_table () const override
|
|
{ return op_print_tab; }
|
|
|
|
protected:
|
|
|
|
/* See language.h. */
|
|
|
|
symbol_name_matcher_ftype *get_symbol_name_matcher_inner
|
|
(const lookup_name_info &lookup_name) const override;
|
|
|
|
private:
|
|
/* Table of expression handling functions for use by EXPRESSION_OPS
|
|
member function. */
|
|
|
|
static const struct exp_descriptor exp_descriptor_tab;
|
|
|
|
/* Table of opcode data for use by OPCODE_PRINT_TABLE member function. */
|
|
|
|
static const struct op_print op_print_tab[];
|
|
|
|
/* Return the encoding that should be used for the character type
|
|
TYPE. */
|
|
|
|
static const char *get_encoding (struct type *type);
|
|
|
|
/* Print any asterisks or open-parentheses needed before the variable
|
|
name (to describe its type).
|
|
|
|
On outermost call, pass 0 for PASSED_A_PTR.
|
|
On outermost call, SHOW > 0 means should ignore
|
|
any typename for TYPE and show its details.
|
|
SHOW is always zero on recursive calls. */
|
|
|
|
void f_type_print_varspec_prefix (struct type *type,
|
|
struct ui_file * stream,
|
|
int show, int passed_a_ptr) const;
|
|
|
|
/* Print any array sizes, function arguments or close parentheses needed
|
|
after the variable name (to describe its type). Args work like
|
|
c_type_print_varspec_prefix.
|
|
|
|
PRINT_RANK_ONLY is true when TYPE is an array which should be printed
|
|
without the upper and lower bounds being specified, this will occur
|
|
when the array is not allocated or not associated and so there are no
|
|
known upper or lower bounds. */
|
|
|
|
void f_type_print_varspec_suffix (struct type *type,
|
|
struct ui_file *stream,
|
|
int show, int passed_a_ptr,
|
|
int demangled_args,
|
|
int arrayprint_recurse_level,
|
|
bool print_rank_only) const;
|
|
|
|
/* Print the name of the type (or the ultimate pointer target, function
|
|
value or array element), or the description of a structure or union.
|
|
|
|
SHOW nonzero means don't print this type as just its name;
|
|
show its real definition even if it has a name.
|
|
SHOW zero means print just typename or struct tag if there is one
|
|
SHOW negative means abbreviate structure elements.
|
|
SHOW is decremented for printing of structure elements.
|
|
|
|
LEVEL is the depth to indent by. We increase it for some recursive
|
|
calls. */
|
|
|
|
void f_type_print_base (struct type *type, struct ui_file *stream, int show,
|
|
int level) const;
|
|
};
|
|
|
|
/* Language-specific data structures */
|
|
|
|
/* A common block. */
|
|
|
|
struct common_block
|
|
{
|
|
/* The number of entries in the block. */
|
|
size_t n_entries;
|
|
|
|
/* The contents of the block, allocated using the struct hack. All
|
|
pointers in the array are non-NULL. */
|
|
struct symbol *contents[1];
|
|
};
|
|
|
|
extern LONGEST f77_get_upperbound (struct type *);
|
|
|
|
extern LONGEST f77_get_lowerbound (struct type *);
|
|
|
|
extern int calc_f77_array_dims (struct type *);
|
|
|
|
/* Fortran (F77) types */
|
|
|
|
struct builtin_f_type
|
|
{
|
|
struct type *builtin_character;
|
|
struct type *builtin_integer;
|
|
struct type *builtin_integer_s2;
|
|
struct type *builtin_integer_s8;
|
|
struct type *builtin_logical;
|
|
struct type *builtin_logical_s1;
|
|
struct type *builtin_logical_s2;
|
|
struct type *builtin_logical_s8;
|
|
struct type *builtin_real;
|
|
struct type *builtin_real_s8;
|
|
struct type *builtin_real_s16;
|
|
struct type *builtin_complex_s8;
|
|
struct type *builtin_complex_s16;
|
|
struct type *builtin_complex_s32;
|
|
struct type *builtin_void;
|
|
};
|
|
|
|
/* Return the Fortran type table for the specified architecture. */
|
|
extern const struct builtin_f_type *builtin_f_type (struct gdbarch *gdbarch);
|
|
|
|
/* Ensures that function argument TYPE is appropriate to inform the debugger
|
|
that ARG should be passed as a pointer. Returns the potentially updated
|
|
argument type.
|
|
|
|
If ARG is of type pointer then the type of ARG is returned, otherwise
|
|
TYPE is returned untouched.
|
|
|
|
This function exists to augment the types of Fortran function call
|
|
parameters to be pointers to the reported value, when the corresponding ARG
|
|
has also been wrapped in a pointer (by fortran_argument_convert). This
|
|
informs the debugger that these arguments should be passed as a pointer
|
|
rather than as the pointed to type. */
|
|
|
|
extern struct type *fortran_preserve_arg_pointer (struct value *arg,
|
|
struct type *type);
|
|
|
|
/* Fortran arrays can have a negative stride. When this happens it is
|
|
often the case that the base address for an object is not the lowest
|
|
address occupied by that object. For example, an array slice (10:1:-1)
|
|
will be encoded with lower bound 1, upper bound 10, a stride of
|
|
-ELEMENT_SIZE, and have a base address pointer that points at the
|
|
element with the highest address in memory.
|
|
|
|
This really doesn't play well with our current model of value contents,
|
|
but could easily require a significant update in order to be supported
|
|
"correctly".
|
|
|
|
For now, we manually force the base address to be the lowest addressed
|
|
element here. Yes, this will break some things, but it fixes other
|
|
things. The hope is that it fixes more than it breaks. */
|
|
|
|
extern CORE_ADDR fortran_adjust_dynamic_array_base_address_hack
|
|
(struct type *type, CORE_ADDR address);
|
|
|
|
#endif /* F_LANG_H */
|