forked from Imagelibrary/binutils-gdb
6b9efd5c1a
PR dap/32090 points out that gdb's DAP "launch" sequencing is
incorrect. The current approach (which is itself a 2nd
implementation...) was based on a misreading of the spec. The spec
has since been clarified here:
https://github.com/microsoft/debug-adapter-protocol/issues/497
The clarification here is that a client is free to send the "launch"
(or "attach") request at any point after the "initialized" event has
been sent by gdb. However, the "launch" does not cause any action to
be taken -- and does not send a response -- until after
"configurationDone" has been seen.
This patch implements this by arranging for the launch and attach
commands to return a DeferredRequest object.
All the tests needed updates. I've also added a new test that checks
that the deferred "launch" request can be cancelled. (Note that the
cancellation is lazy -- it also waits until configurationDone is seen.
This could be fixed, but I was not sure whether it is important to do
so.)
Finally, the "launch" command has a somewhat funny sequencing now.
Simply sending the command and waiting for a response yielded strange
results if the inferior did not stop -- in this case, the repsonse was
never sent. So now, the command is split into two parts, with some
setup being done synchronously (for better error propagation) and the
actual "run" being done async.
Bug: https://sourceware.org/bugzilla/show_bug.cgi?id=32090
Reviewed-by: Kévin Le Gouguec <legouguec@adacore.com>
107 lines
3.2 KiB
Plaintext
107 lines
3.2 KiB
Plaintext
# Copyright 2024 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 DAP disassembly.
|
|
|
|
require allow_dap_tests
|
|
|
|
load_lib dap-support.exp
|
|
|
|
standard_testfile
|
|
|
|
if {[build_executable ${testfile}.exp $testfile] == -1} {
|
|
return
|
|
}
|
|
|
|
if {[dap_initialize] == ""} {
|
|
return
|
|
}
|
|
|
|
set launch_id [dap_launch $testfile]
|
|
|
|
set obj [dap_check_request_and_response "set breakpoint" \
|
|
setFunctionBreakpoints \
|
|
{o breakpoints [a [o name [s main]]]}]
|
|
set fn_bpno [dap_get_breakpoint_number $obj]
|
|
|
|
dap_check_request_and_response "configurationDone" configurationDone
|
|
|
|
dap_check_response "launch response" launch $launch_id
|
|
|
|
dap_wait_for_event_and_check "inferior started" thread "body reason" started
|
|
|
|
dap_wait_for_event_and_check "stopped at line breakpoint" stopped \
|
|
"body reason" breakpoint \
|
|
"body hitBreakpointIds" $fn_bpno
|
|
|
|
# Find out how many lines of disassembly we should request. This is
|
|
# kind of lame but DAP doesn't really provide tools to do this, and
|
|
# gdb's DAP implementation doesn't try to figure out what memory might
|
|
# not really be part of a function.
|
|
set obj [dap_check_request_and_response "disassemble using CLI" \
|
|
evaluate {o expression [s {disassemble &return_value}] \
|
|
context [s repl]}]
|
|
set output [dict get [lindex $obj 0] body result]
|
|
# The result will have literal "\" "n" sequences, turn these into
|
|
# newlines.
|
|
set with_nl [string map [list "\\n" "\n"] $output]
|
|
# The value we want is the number of lines starting with an address.
|
|
set insn_count 0
|
|
foreach line [split $with_nl "\n"] {
|
|
if {[regexp "^ *0x" $line]} {
|
|
incr insn_count
|
|
}
|
|
}
|
|
|
|
set obj [dap_check_request_and_response "find function address" \
|
|
evaluate {o expression [s "&return_value"]}]
|
|
set pc [dict get [lindex $obj 0] body memoryReference]
|
|
|
|
set obj [dap_check_request_and_response "disassemble the function" \
|
|
disassemble \
|
|
[format {o memoryReference [s %s] instructionCount [i %d]} \
|
|
$pc $insn_count]]
|
|
set response [lindex $obj 0]
|
|
|
|
set seen_labels(_) _
|
|
set insn_no 1
|
|
foreach insn [dict get $response body instructions] {
|
|
with_test_prefix $insn_no {
|
|
gdb_assert {[dict exists $insn line]} \
|
|
"line in disassemble output"
|
|
gdb_assert {[dict exists $insn location]} \
|
|
"location in disassemble output"
|
|
if {[dict exists $insn symbol]} {
|
|
set seen_labels([dict get $insn symbol]) 1
|
|
}
|
|
}
|
|
incr insn_no
|
|
}
|
|
|
|
proc require_label {name} {
|
|
global seen_labels
|
|
if {[info exists seen_labels($name)]} {
|
|
pass "saw label $name"
|
|
} else {
|
|
fail "saw label $name"
|
|
}
|
|
}
|
|
|
|
require_label return_value
|
|
require_label compute
|
|
require_label out_label
|
|
|
|
dap_shutdown
|