This is the mail archive of the gcc-patches@gcc.gnu.org mailing list for the GCC project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

Re: [PATCH] Add guality [p]type test.


On Thu, Jul 3, 2014 at 11:53 AM, Mark Wielaard <mjw@redhat.com> wrote:
> Hi,
>
> I pulled out the guality.exp [p]type test extension from the actual
> dwarf2out.c changes (which I will repost soon with some tweaks). I think
> the test extension itself is useful on its own (and will use it to
> add tests for my new patches).
>
> All new tests PASS, except when using -flto, so you'll need the
> "Don't run guality.exp tests with LTO_TORTURE_OPTIONS"
> if you don't want to add new FAILs. But I hope this patch can go in
> even without that because I do think it is useful on its own.

You could add a dg-skip-if "" { *-*-* } { "-flto" } with a comment.
Btw, why doesn't it succeed with LTO?  I suspect it's because
we drop the unused variables - try adding __attribute__((used)) to
them.  Same effect should be observable with -fwhole-program
(which doesn't use LTO).

Richard.

> Add a new type:var variant to the guality.exp testsuite to check that
> gdb gets the correct type for a variable or function. To use it in a
> guality test add something like:
>
> /* { dg-final { gdb-test 50 "type:main" "int (int, char **)" } } */
>
> Which will put a breakpoint at line 50 and check that the type of "main"
> equals "int (int, char **)" according to gdb. The test harness will make
> sure to squash all extra whitespace/newlines that gdb might use to make
> comparisons of large structs easy.
>
> gcc/testsuite/ChangeLog
>
>         * lib/gcc-gdb-test.exp (gdb-test): Handle type:var for gdb ptype
>         matching. Catch '<unknown type in ' to recognize older gdb versions.
>         * gcc.dg/guality/const-volatile.c: New test.
> ---
>  gcc/testsuite/ChangeLog                       |    6 ++
>  gcc/testsuite/gcc.dg/guality/const-volatile.c |   83 +++++++++++++++++++++++++
>  gcc/testsuite/lib/gcc-gdb-test.exp            |   47 +++++++++++++-
>  3 files changed, 132 insertions(+), 4 deletions(-)
>  create mode 100644 gcc/testsuite/gcc.dg/guality/const-volatile.c
>
> diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog
> index 421e006..1abc700 100644
> --- a/gcc/testsuite/ChangeLog
> +++ b/gcc/testsuite/ChangeLog
> @@ -1,3 +1,9 @@
> +2014-07-03  Mark Wielaard  <mjw@redhat.com>
> +
> +       * lib/gcc-gdb-test.exp (gdb-test): Handle type:var for gdb ptype
> +       matching. Catch '<unknown type in ' to recognize older gdb versions.
> +       * gcc.dg/guality/const-volatile.c: New test.
> +
>  2014-07-02  Mark Wielaard  <mjw@redhat.com>
>
>         * gcc.dg/guality/guality.exp: Remove LTO_TORTURE_OPTIONS from
> diff --git a/gcc/testsuite/gcc.dg/guality/const-volatile.c b/gcc/testsuite/gcc.dg/guality/const-volatile.c
> new file mode 100644
> index 0000000..6c2b617
> --- /dev/null
> +++ b/gcc/testsuite/gcc.dg/guality/const-volatile.c
> @@ -0,0 +1,83 @@
> +/* debuginfo tests for combinations of const and volatile type qualifiers. */
> +/* { dg-do run } */
> +/* { dg-options "-g" } */
> +
> +int i;
> +const int ci;
> +volatile int vi;
> +const volatile int cvi;
> +
> +int *pi;
> +const int *pci;
> +volatile int *pvi;
> +const volatile int *pcvi;
> +
> +int * const cip;
> +int * volatile vip;
> +int * const volatile cvip;
> +
> +volatile struct
> +{
> +  const long cli;
> +  const signed char csc;
> +} vs;
> +
> +struct foo
> +{
> +  const long cli;
> +  const signed char csc;
> +};
> +
> +struct foo foo;
> +const struct foo cfoo;
> +volatile struct foo vfoo;
> +const volatile struct foo cvfoo;
> +
> +typedef volatile signed char score;
> +
> +score s;
> +const score cs;
> +
> +static __attribute__((noclone, noinline)) int
> +f (const char *progname, volatile struct foo *dummy, const score s)
> +{
> +  return progname == 0 || dummy == 0 || dummy->csc == s;
> +}
> +
> +int
> +main (int argc, char **argv)
> +{
> +  score as = argc;
> +  struct foo dummy = { 1, 1 };
> +  return f (argv[0], &dummy, as) - 1;
> +}
> +
> +/* { dg-final { gdb-test 50 "type:main" "int (int, char **)" } } */
> +
> +/* { dg-final { gdb-test 50 "type:i" "int" } } */
> +/* { dg-final { gdb-test 50 "type:ci" "const int" } } */
> +/* { dg-final { gdb-test 50 "type:vi" "volatile int" } } */
> +/* { dg-final { gdb-test 50 "type:cvi" "const volatile int" } } */
> +
> +/* { dg-final { gdb-test 50 "type:pi" "int *" } } */
> +/* { dg-final { gdb-test 50 "type:pci" "const int *" } } */
> +/* { dg-final { gdb-test 50 "type:pvi" "volatile int *" } } */
> +/* { dg-final { gdb-test 50 "type:pcvi" "const volatile int *" } } */
> +
> +/* { dg-final { gdb-test 50 "type:cip" "int * const" } } */
> +/* { dg-final { gdb-test 50 "type:vip" "int * volatile" } } */
> +/* { dg-final { gdb-test 50 "type:cvip" "int * const volatile" } } */
> +
> +/* { dg-final { gdb-test 50 "type:vs" "volatile struct { const long cli; const signed char csc; }" } } */
> +
> +/* { dg-final { gdb-test 50 "type:cvip" "int * const volatile" } } */
> +
> +/* { dg-final { gdb-test 50 "type:foo" "struct foo { const long cli; const signed char csc; }" } } */
> +/* { dg-final { gdb-test 50 "type:cfoo" "const struct foo { const long cli; const signed char csc; }" } } */
> +/* { dg-final { gdb-test 50 "type:vfoo" "volatile struct foo { const long cli; const signed char csc; }" } } */
> +/* { dg-final { gdb-test 50 "type:cvfoo" "const volatile struct foo { const long cli; const signed char csc; }" } } */
> +
> +/* { dg-final { gdb-test 58 "type:s" "volatile signed char" } } */
> +/* { dg-final { gdb-test 50 "type:cs" "const volatile signed char" } } */
> +
> +/* { dg-final { gdb-test 50 "type:f" "int (const char *, volatile struct foo *, const score)" } } */
> diff --git a/gcc/testsuite/lib/gcc-gdb-test.exp b/gcc/testsuite/lib/gcc-gdb-test.exp
> index d182d88..c729793 100644
> --- a/gcc/testsuite/lib/gcc-gdb-test.exp
> +++ b/gcc/testsuite/lib/gcc-gdb-test.exp
> @@ -19,7 +19,12 @@
>  #
>  # Argument 0 is the line number on which to put a breakpoint
>  # Argument 1 is the name of the variable to be checked
> -# Argument 2 is the expected value of the variable
> +#   possibly prefixed with type: to get the type of the variable
> +#   instead of the value of the variable (the default).
> +# Argument 2 is the expected value (or type) of the variable
> +#   When asking for the value, the expected value is produced
> +#   calling print on it in gdb. When asking for the type it is
> +#   the literal string with extra whitespace removed.
>  # Argument 3 handles expected failures and the like
>  proc gdb-test { args } {
>      if { ![isnative] || [is_remote target] } { return }
> @@ -39,6 +44,16 @@ proc gdb-test { args } {
>      upvar 2 name testcase
>      upvar 2 prog prog
>
> +    # The command to run on the variable
> +    set arg1 [lindex $args 1]
> +    if { [string equal -length 5 "type:" $arg1] == 1 } {
> +       set command "ptype"
> +       set var [string range $arg1 5 end]
> +    } else {
> +       set command "print"
> +       set var $arg1
> +    }
> +
>      set gdb_name $::env(GUALITY_GDB_NAME)
>      set testname "$testcase line [lindex $args 0] [lindex $args 1] == [lindex $args 2]"
>      set output_file "[file rootname [file tail $prog]].exe"
> @@ -47,8 +62,14 @@ proc gdb-test { args } {
>      set fd [open $cmd_file "w"]
>      puts $fd "break [lindex $args 0]"
>      puts $fd "run"
> -    puts $fd "print [lindex $args 1]"
> -    puts $fd "print [lindex $args 2]"
> +    puts $fd "$command $var"
> +    if { $command == "print" } {
> +       # For values, let gdb interpret them by printing them.
> +       puts $fd "print [lindex $args 2]"
> +    } else {
> +       # Since types can span multiple lines, we need an end marker.
> +       puts $fd "echo TYPE_END\\n"
> +    }
>      puts $fd "quit"
>      close $fd
>
> @@ -62,12 +83,13 @@ proc gdb-test { args } {
>
>      remote_expect target [timeout_value] {
>         # Too old GDB
> -       -re "Unhandled dwarf expression|Error in sourced command file" {
> +       -re "Unhandled dwarf expression|Error in sourced command file|<unknown type in " {
>             unsupported "$testname"
>             remote_close target
>             file delete $cmd_file
>             return
>         }
> +       # print var; print expected
>         -re {[\n\r]\$1 = ([^\n\r]*)[\n\r]+\$2 = ([^\n\r]*)[\n\r]} {
>             set first $expect_out(1,string)
>             set second $expect_out(2,string)
> @@ -83,6 +105,23 @@ proc gdb-test { args } {
>             file delete $cmd_file
>             return
>         }
> +       # ptype var;
> +       -re {[\n\r]type = (.*)[\n\r][\n\r]TYPE_END[\n\r]} {
> +           set type $expect_out(1,string)
> +           # Squash all extra whitespace/newlines that gdb might use for
> +           # "pretty printing" into one so result is just one line.
> +           regsub -all {[\n\r\t ]+} $type " " type
> +           set expected [lindex $args 2]
> +           if { $type == $expected } {
> +               pass "$testname"
> +           } else {
> +               send_log -- "$type != $expected\n"
> +               fail "$testname"
> +           }
> +           remote_close target
> +           file delete $cmd_file
> +           return
> +       }
>         timeout {
>             unsupported "$testname"
>             remote_close target
> --
> 1.7.1
>


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]