mirror of
https://sourceware.org/git/binutils-gdb.git
synced 2024-12-27 04:52:05 +08:00
3666a04883
This commits the result of running gdb/copyright.py as per our Start
of New Year procedure...
gdb/ChangeLog
Update copyright year range in copyright header of all GDB files.
407 lines
9.6 KiB
Plaintext
407 lines
9.6 KiB
Plaintext
# Copyright (C) 1998-2021 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/>.
|
|
|
|
|
|
#
|
|
# Support procedures for trace testing
|
|
#
|
|
|
|
|
|
#
|
|
# Program counter / stack pointer / frame pointer for supported targets.
|
|
# Used in many tests, kept here to avoid duplication.
|
|
#
|
|
|
|
if [is_amd64_regs_target] {
|
|
set fpreg "rbp"
|
|
set spreg "rsp"
|
|
set pcreg "rip"
|
|
} elseif [is_x86_like_target] {
|
|
set fpreg "ebp"
|
|
set spreg "esp"
|
|
set pcreg "eip"
|
|
} elseif [is_aarch64_target] {
|
|
set fpreg "x29"
|
|
set spreg "sp"
|
|
set pcreg "pc"
|
|
} elseif [istarget "powerpc*-*-*"] {
|
|
set fpreg "r31"
|
|
set spreg "r1"
|
|
set pcreg "pc"
|
|
} elseif { [istarget "s390*-*-*"] } {
|
|
set fpreg "r11"
|
|
set spreg "r15"
|
|
set pcreg "pc"
|
|
} else {
|
|
set fpreg "fp"
|
|
set spreg "sp"
|
|
set pcreg "pc"
|
|
}
|
|
|
|
#
|
|
# Procedure: gdb_trace_common_supports_arch
|
|
# Returns true if gdb.trace/trace-common.h knows about this target.
|
|
# Allows skipping tests that depend on being able to include this file.
|
|
# Please keep this in sync with the supported targets in the header.
|
|
#
|
|
|
|
proc gdb_trace_common_supports_arch { } {
|
|
if { [istarget "x86_64*-*-*"]
|
|
|| [istarget "i386*-*-*"]
|
|
|| [istarget "aarch64*-*-*"]
|
|
|| [istarget "powerpc*-*-*"]
|
|
|| [istarget "s390*-*-*"] } {
|
|
return 1
|
|
} else {
|
|
return 0
|
|
}
|
|
}
|
|
|
|
#
|
|
# Procedure: gdb_target_supports_trace
|
|
# Returns true if GDB is connected to a target that supports tracing.
|
|
# Allows tests to abort early if not running on a trace-aware target.
|
|
#
|
|
|
|
proc gdb_target_supports_trace { } {
|
|
global gdb_prompt
|
|
|
|
send_gdb "tstatus\n"
|
|
gdb_expect {
|
|
-re "\[Tt\]race can only be run on.*$gdb_prompt $" {
|
|
return 0
|
|
}
|
|
-re "\[Tt\]race can not be run on.*$gdb_prompt $" {
|
|
return 0
|
|
}
|
|
-re "\[Tt\]arget does not support.*$gdb_prompt $" {
|
|
return 0
|
|
}
|
|
-re ".*\[Ee\]rror.*$gdb_prompt $" {
|
|
return 0
|
|
}
|
|
-re ".*\[Ww\]arning.*$gdb_prompt $" {
|
|
return 0
|
|
}
|
|
-re ".*$gdb_prompt $" {
|
|
return 1
|
|
}
|
|
timeout {
|
|
return 0
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
#
|
|
# Procedure: gdb_delete_tracepoints
|
|
# Many of the tests depend on setting tracepoints at various places and
|
|
# running until that tracepoint is reached. At times, we want to start
|
|
# with a clean slate with respect to tracepoints, so this utility proc
|
|
# lets us do this without duplicating this code everywhere.
|
|
#
|
|
|
|
proc gdb_delete_tracepoints {} {
|
|
global gdb_prompt
|
|
|
|
send_gdb "delete tracepoints\n"
|
|
gdb_expect 30 {
|
|
-re "Delete all tracepoints.*y or n.*$" {
|
|
send_gdb "y\n"
|
|
exp_continue
|
|
}
|
|
-re ".*$gdb_prompt $" { # This happens if there were no tracepoints }
|
|
timeout {
|
|
perror "Delete all tracepoints in delete_tracepoints (timeout)"
|
|
return
|
|
}
|
|
}
|
|
send_gdb "info tracepoints\n"
|
|
gdb_expect 30 {
|
|
-re "No tracepoints.*$gdb_prompt $" {}
|
|
-re "$gdb_prompt $" { perror "tracepoints not deleted" ; return }
|
|
timeout { perror "info tracepoints (timeout)" ; return }
|
|
}
|
|
}
|
|
|
|
# Define actions for a tracepoint.
|
|
# Arguments:
|
|
# actions_command -- the command used to create the actions.
|
|
# either "actions" or "commands".
|
|
# testname -- identifying string for pass/fail output
|
|
# tracepoint -- to which tracepoint(s) do these actions apply? (optional)
|
|
# args -- list of actions to be defined.
|
|
# Returns:
|
|
# zero -- success
|
|
# non-zero -- failure
|
|
|
|
proc gdb_trace_setactions_command { actions_command testname tracepoint args } {
|
|
global gdb_prompt
|
|
|
|
set state 0
|
|
set passfail "pass"
|
|
send_gdb "$actions_command $tracepoint\n"
|
|
set expected_result ""
|
|
gdb_expect 5 {
|
|
-re "No tracepoint number .*$gdb_prompt $" {
|
|
fail $testname
|
|
return 1
|
|
}
|
|
-re "Enter actions for tracepoint $tracepoint.*>" {
|
|
if { [llength $args] > 0 } {
|
|
set lastcommand "[lindex $args $state]"
|
|
send_gdb "[lindex $args $state]\n"
|
|
incr state
|
|
set expected_result [lindex $args $state]
|
|
incr state
|
|
} else {
|
|
send_gdb "end\n"
|
|
}
|
|
exp_continue
|
|
}
|
|
-re "\(.*\)\[\r\n\]+\[ \t]*>$" {
|
|
if { $expected_result != "" } {
|
|
regsub "^\[^\r\n\]+\[\r\n\]+" "$expect_out(1,string)" "" out
|
|
if ![regexp $expected_result $out] {
|
|
set passfail "fail"
|
|
}
|
|
set expected_result ""
|
|
}
|
|
if { $state < [llength $args] } {
|
|
send_gdb "[lindex $args $state]\n"
|
|
incr state
|
|
set expected_result [lindex $args $state]
|
|
incr state
|
|
} else {
|
|
send_gdb "end\n"
|
|
set expected_result ""
|
|
}
|
|
exp_continue
|
|
}
|
|
-re "\(.*\)$gdb_prompt $" {
|
|
if { $expected_result != "" } {
|
|
if ![regexp $expected_result $expect_out(1,string)] {
|
|
set passfail "fail"
|
|
}
|
|
set expected_result ""
|
|
}
|
|
if { [llength $args] < $state } {
|
|
set passfail "fail"
|
|
}
|
|
}
|
|
default {
|
|
set passfail "fail"
|
|
}
|
|
}
|
|
if { $testname != "" } {
|
|
$passfail $testname
|
|
}
|
|
if { $passfail == "pass" } then {
|
|
return 0
|
|
} else {
|
|
return 1
|
|
}
|
|
}
|
|
|
|
# Define actions for a tracepoint, using the "actions" command. See
|
|
# gdb_trace_setactions_command.
|
|
#
|
|
proc gdb_trace_setactions { testname tracepoint args } {
|
|
eval gdb_trace_setactions_command "actions" {$testname} {$tracepoint} $args
|
|
}
|
|
|
|
# Define actions for a tracepoint, using the "commands" command. See
|
|
# gdb_trace_setactions_command.
|
|
#
|
|
proc gdb_trace_setcommands { testname tracepoint args } {
|
|
eval gdb_trace_setactions_command "commands" {$testname} {$tracepoint} $args
|
|
}
|
|
|
|
#
|
|
# Procedure: gdb_tfind_test
|
|
# Find a specified trace frame.
|
|
# Arguments:
|
|
# testname -- identifying string for pass/fail output
|
|
# tfind_arg -- frame (line, PC, etc.) identifier
|
|
# exp_res -- Expected result of frame test
|
|
# args -- Test expression
|
|
# Returns:
|
|
# zero -- success
|
|
# non-zero -- failure
|
|
#
|
|
|
|
proc gdb_tfind_test { testname tfind_arg exp_res args } {
|
|
global gdb_prompt
|
|
|
|
if { "$args" != "" } {
|
|
set expr "$exp_res"
|
|
set exp_res "$args"
|
|
} else {
|
|
set expr "(int) \$trace_frame"
|
|
}
|
|
set passfail "fail"
|
|
|
|
gdb_test "tfind $tfind_arg" "" ""
|
|
send_gdb "printf \"x \%d x\\n\", $expr\n"
|
|
gdb_expect 10 {
|
|
-re "x (-*\[0-9\]+) x" {
|
|
if { $expect_out(1,string) == $exp_res } {
|
|
set passfail "pass"
|
|
}
|
|
exp_continue
|
|
}
|
|
-re "$gdb_prompt $" { }
|
|
}
|
|
$passfail "$testname"
|
|
if { $passfail == "pass" } then {
|
|
return 0
|
|
} else {
|
|
return 1
|
|
}
|
|
}
|
|
|
|
#
|
|
# Procedure: gdb_readexpr
|
|
# Arguments:
|
|
# gdb_expr -- the expression whose value is desired
|
|
# Returns:
|
|
# the value of gdb_expr, as evaluated by gdb.
|
|
# [FIXME: returns -1 on error, which is sometimes a legit value]
|
|
#
|
|
|
|
proc gdb_readexpr { gdb_expr } {
|
|
global gdb_prompt
|
|
|
|
set result -1
|
|
send_gdb "print $gdb_expr\n"
|
|
gdb_expect 5 {
|
|
-re "\[$\].*= (\[0-9\]+).*$gdb_prompt $" {
|
|
set result $expect_out(1,string)
|
|
}
|
|
-re "$gdb_prompt $" { }
|
|
default { }
|
|
}
|
|
return $result
|
|
}
|
|
|
|
#
|
|
# Procedure: gdb_gettpnum
|
|
# Arguments:
|
|
# tracepoint (optional): if supplied, set a tracepoint here.
|
|
# Returns:
|
|
# the tracepoint ID of the most recently set tracepoint.
|
|
#
|
|
|
|
proc gdb_gettpnum { tracepoint } {
|
|
global gdb_prompt
|
|
|
|
if { $tracepoint != "" } {
|
|
gdb_test "trace $tracepoint" "" ""
|
|
}
|
|
return [gdb_readexpr "\$tpnum"]
|
|
}
|
|
|
|
|
|
#
|
|
# Procedure: gdb_find_function_baseline
|
|
# Arguments:
|
|
# func_name -- name of source function
|
|
# Returns:
|
|
# Sourcefile line of function definition (open curly brace),
|
|
# or -1 on failure. Caller must check return value.
|
|
# Note:
|
|
# Works only for open curly brace at beginning of source line!
|
|
#
|
|
|
|
proc gdb_find_function_baseline { func_name } {
|
|
global gdb_prompt
|
|
|
|
set baseline -1
|
|
|
|
send_gdb "list $func_name\n"
|
|
# gdb_expect {
|
|
# -re "\[\r\n\]\[\{\].*$gdb_prompt $" {
|
|
# set baseline 1
|
|
# }
|
|
# }
|
|
}
|
|
|
|
#
|
|
# Procedure: gdb_find_function_baseline
|
|
# Arguments:
|
|
# filename: name of source file of desired function.
|
|
# Returns:
|
|
# Sourcefile line of function definition (open curly brace),
|
|
# or -1 on failure. Caller must check return value.
|
|
# Note:
|
|
# Works only for open curly brace at beginning of source line!
|
|
#
|
|
|
|
proc gdb_find_recursion_test_baseline { filename } {
|
|
global gdb_prompt
|
|
|
|
set baseline -1
|
|
|
|
gdb_test "list $filename:1" "" ""
|
|
send_gdb "search gdb_recursion_test line 0\n"
|
|
gdb_expect {
|
|
-re "(\[0-9\]+)\[\t \]+\{.*line 0.*$gdb_prompt $" {
|
|
set baseline $expect_out(1,string)
|
|
}
|
|
-re "$gdb_prompt $" { }
|
|
default { }
|
|
}
|
|
return $baseline
|
|
}
|
|
|
|
# Return the location of the IPA library.
|
|
|
|
proc get_in_proc_agent {} {
|
|
global objdir
|
|
|
|
if [target_info exists in_proc_agent] {
|
|
return [target_info in_proc_agent]
|
|
} else {
|
|
return $objdir/../../gdbserver/libinproctrace.so
|
|
}
|
|
}
|
|
|
|
# Execute BINFILE on target to generate tracefile. Return 1 if
|
|
# tracefile is generated successfully, return 0 otherwise.
|
|
|
|
proc generate_tracefile { binfile } {
|
|
set status [remote_exec target "$binfile"]
|
|
|
|
if { [lindex $status 0] != 0 } {
|
|
# Failed to execute $binfile, for example on bare metal targets.
|
|
# Alternatively, load the binary and run it. If target doesn't
|
|
# have fileio capabilities, tracefile can't be generated. Skip
|
|
# the test.
|
|
if [target_info exists gdb,nofileio] {
|
|
return 0
|
|
}
|
|
|
|
clean_restart $binfile
|
|
|
|
if ![runto_main] then {
|
|
return 0
|
|
}
|
|
gdb_continue_to_end "" continue 1
|
|
gdb_exit
|
|
}
|
|
|
|
return 1
|
|
}
|