Re: GDB MI Reverse Commands added [3 of 3]

[Michael Snyder <msnyder@vmware.com>]

[-- Attachment #1: Type: text/plain, Size: 1303 bytes --]

Jakob Engblom wrote:
>> The file should be called mi-reverse.exp, I think, because mi2- files are
>> supposed to test
>> that whatever was once announced as MI2 is not broken. And this is new
>> development. Likewise,

Oops, sorry -- revised part 3 of MI reverse patch.


> Done. 
>  
>>         set MIFLAGS "-i=mi2"
>>
>> should be:
>>
>>         set MIFLAGS "-i=mi"
> 
> Done.
> 
>> Also, I would appreciate if this:
>>
>>     # Test exec-reverse-next
>>     # FIXME: Why does it take 2 next commands to get back to the
>>     #        previous line?
>>
>> were somehow addressed. I am not familiar with details of reverse behaviour,
> so I
>> did not even try to check that the tested commands and locations, etc, are
> right.
> 
> Since this is tested on top of process record, I think I am not the best person
> to answer... but in general, what tends to happen in reverse in my experience is
> this:
> 
> We have lines of code (or instructions)
> 
> A
> B
> 
> And we stop with a breakpoint in line B.
> 
> We are then at the end of B, or in the middle of B, in the execution.
> 
> Then, doing reverse one step/instruction/line will move you to the start of B. 
> 
> And another step/instruction/line moves you to before A was executed. 
> 
> Does that make sense for process record?
> 
> /jakob


[-- Attachment #2: mi-reverse.exp --]
[-- Type: text/plain, Size: 5927 bytes --]

# Copyright 2009
# 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 <http://www.gnu.org/licenses/>.

# Test Machine interface (MI) operations
# Verify that, using the MI, we can run a simple program in both forward
# and reverse directions with the following execution commands:
# - exec-continue
# - exec-finish
# - exec-next
# - exec-step
# - exec-next-instruction
# - exec-step-instruction

# The goal is not to test gdb functionality, which is done by other tests,
# but to verify the correct output response to MI operations.
#

if ![target_info exists gdb,can_reverse] {
    return
}

load_lib mi-support.exp
set MIFLAGS "-i=mi"

gdb_exit
if [mi_gdb_start] {
    continue
}

set testfile "basics"
set srcfile ${testfile}.c
set binfile ${objdir}/${subdir}/mi2-reverse
if  { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug additional_flags=-DFAKEARGV}] != "" } {
     untested mi2-reverse.exp
     return -1
}

mi_run_to_main

if [target_info exists gdb,use_precord] {
    # Activate process record/replay
    if [mi_gdb_test "-interpreter-exec console record" \
	{\^done} "Turn on process record"] {
	warning "Fail to activate process record/replay, tests in this group will not be performed.\n";
	return -1
    }
}

# Locate line numbers in basics.c.
set line_callee4_head  [gdb_get_line_number "callee4 ("]
set line_callee4_body  [expr $line_callee4_head + 2]
set line_callee3_head  [gdb_get_line_number "callee3 ("]
set line_callee3_body  [expr $line_callee3_head + 2]
set line_callee3_close [expr $line_callee3_head + 3]
set line_callee2_head  [gdb_get_line_number "callee2 ("]
set line_callee2_body  [expr $line_callee2_head + 2]
set line_callee2_close [expr $line_callee2_head + 3]
set line_callee1_head  [gdb_get_line_number "callee1 ("]
set line_callee1_body  [expr $line_callee1_head + 2]
set line_callee1_close [expr $line_callee1_head + 3]
set line_callme_head   [gdb_get_line_number "callme"]
set line_callme_body   [expr $line_callme_head + 2]
set line_main_head     [gdb_get_line_number "main ("]
set line_main_body     [expr $line_main_head + 2]
set line_main_hello    [gdb_get_line_number "Hello, World!"]
set line_main_callme_1 [gdb_get_line_number "callme (1"]

# Forward execute to the callme() function, so that we can
# execute backward from there.
mi_continue_to callme
mi_delete_breakpoints

proc test_controlled_execution_reverse {} {
    global mi_gdb_prompt
    global srcfile
    global hex

    global line_callee4_head line_callee4_body
    global line_callee3_head line_callee3_body line_callee3_close
    global line_callee2_head line_callee2_body line_callee2_close
    global line_callee1_head line_callee1_body line_callee1_close
    global line_main_head    line_main_body
    global line_main_hello   line_main_callme_1

    # Test exec-reverse-finish

    mi_execute_to "exec-finish --reverse" \
	"end-stepping-range" "main" "" \
	"basics.c" $line_main_callme_1 "" \
	"reverse finish from callme"

    # Test exec-reverse-next
    #   It takes two steps to get back to the previous line,
    #   as the first step moves us to the start of the current line,
    #   and the one after that moves back to the previous line.

    mi_execute_to "exec-next --reverse 2" \
 	"end-stepping-range" "main" "" \
 	"basics.c" $line_main_hello "" \
 	"reverse next to get over the call to do_nothing"

    # Test exec-reverse-step

    mi_execute_to "exec-step --reverse" \
 	"end-stepping-range" "callee1" \
	"\{name=\"intarg\",value=\"2\"\},\{name=\"strarg\",value=\"$hex \\\\\"A string argument\.\\\\\"\"\},\{name=\"fltarg\",value=\"3.5\"\}" \
 	"basics.c" $line_callee1_close "" \
 	"reverse step to callee1"

    mi_execute_to "exec-step --reverse" \
 	"end-stepping-range" "callee2" \
	"\{name=\"intarg\",value=\"2\"\},\{name=\"strarg\",value=\"$hex \\\\\"A string argument\.\\\\\"\"\}" \
 	"basics.c" $line_callee2_close "" \
 	"reverse step to callee2"

    mi_execute_to "exec-step --reverse" \
 	"end-stepping-range" "callee3" \
	"\{name=\"strarg\",value=\"$hex \\\\\"A string argument\.\\\\\"\"\}" \
 	"basics.c" $line_callee3_close "" \
 	"reverse step to callee3"

    mi_execute_to "exec-step --reverse" \
 	"end-stepping-range" "callee4" "" \
 	"basics.c" "\[0-9\]+" "" \
 	"reverse step to callee4"

    # Test exec-reverse-[step|next]-instruction

    mi_execute_to "exec-step-instruction --reverse" \
        "end-stepping-range" "callee4" "" \
        "basics.c" "\[0-9\]+" "" \
        "reverse-step-instruction at callee4"

    mi_execute_to "exec-next-instruction --reverse" \
        "end-stepping-range" "callee4" "" \
        "basics.c" "\[0-9\]+" "" \
        "reverse-next-instruction at callee4"

    # Test exec-reverse-continue

    mi_create_breakpoint "-t basics.c:$line_callee3_head" \
	3 del callee3 ".*basics.c" $line_callee3_head $hex \
	"insert temp breakpoint at basics.c:$line_callee3_head"

    mi_execute_to "exec-continue --reverse" \
        "breakpoint-hit" "callee3" \
	"\{name=\"strarg\",value=\"$hex \\\\\"A string argument\.\\\\\"\"\}" \
        "basics.c" "\[0-9\]+" \
	{ "" "disp=\"del\""} \
        "reverse-continue at callee3"

    mi_execute_to "exec-continue --reverse" \
        "" "main" "" \
        "basics.c" $line_main_body "" \
        "reverse-continue at main"
}

test_controlled_execution_reverse

mi_gdb_exit
return 0