From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 23006 invoked by alias); 15 Dec 2009 19:43:17 -0000 Received: (qmail 22994 invoked by uid 22791); 15 Dec 2009 19:43:15 -0000 X-SWARE-Spam-Status: No, hits=-2.5 required=5.0 tests=AWL,BAYES_00 X-Spam-Check-By: sourceware.org Received: from smtp-outbound-1.vmware.com (HELO smtp-outbound-1.vmware.com) (65.115.85.69) by sourceware.org (qpsmtpd/0.43rc1) with ESMTP; Tue, 15 Dec 2009 19:43:11 +0000 Received: from mailhost3.vmware.com (mailhost3.vmware.com [10.16.27.45]) by smtp-outbound-1.vmware.com (Postfix) with ESMTP id 711DC13D65; Tue, 15 Dec 2009 11:43:10 -0800 (PST) Received: from [10.20.94.141] (msnyder-server.eng.vmware.com [10.20.94.141]) by mailhost3.vmware.com (Postfix) with ESMTP id 697CDCD921; Tue, 15 Dec 2009 11:43:10 -0800 (PST) Message-ID: <4B27E65D.3050706@vmware.com> Date: Tue, 15 Dec 2009 19:43:00 -0000 From: Michael Snyder User-Agent: Thunderbird 1.5.0.12 (X11/20090624) MIME-Version: 1.0 To: Jakob Engblom CC: 'Vladimir Prus' , "gdb-patches@sources.redhat.com" Subject: Re: GDB MI Reverse Commands added [3 of 3] References: <00d001ca265a$ddd0c800$99725800$@com> <018401ca2cc6$7c2581a0$747084e0$@com> In-Reply-To: <018401ca2cc6$7c2581a0$747084e0$@com> Content-Type: multipart/mixed; boundary="------------010508090100080708070007" X-IsSubscribed: yes Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org X-SW-Source: 2009-12/txt/msg00199.txt.bz2 This is a multi-part message in MIME format. --------------010508090100080708070007 Content-Type: text/plain; charset=ISO-8859-1; format=flowed Content-Transfer-Encoding: 7bit Content-length: 1303 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 --------------010508090100080708070007 Content-Type: text/plain; name="mi-reverse.exp" Content-Transfer-Encoding: 7bit Content-Disposition: inline; filename="mi-reverse.exp" Content-length: 5927 # 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 . # 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 --------------010508090100080708070007--