1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
|
# Copyright 2008-2014 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/>.
# This tests the find command.
standard_testfile .c
if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug nowarnings}] != "" } {
untested find.exp
return -1
}
clean_restart ${binfile}
gdb_test "break $srcfile:stop_here" \
"Breakpoint.*at.* file .*$srcfile, line.*" \
"breakpoint function in file"
gdb_run_cmd
gdb_expect {
-re "Breakpoint \[0-9\]+,.*stop_here.* at .*$srcfile:.*$gdb_prompt $" {
pass "run until function breakpoint"
}
-re "$gdb_prompt $" {
fail "run until function breakpoint"
}
timeout {
fail "run until function breakpoint (timeout)"
}
}
# We've now got the target program in a state where we can test "find".
set hex_number {0x[0-9a-fA-F][0-9a-fA-F]*}
set history_prefix {[$][0-9]* = }
set newline "\[\r\n\]*"
set pattern_not_found "${newline}Pattern not found\[.\]"
set one_pattern_found "${newline}1 pattern found\[.\]"
set two_patterns_found "${newline}2 patterns found\[.\]"
# Test string pattern.
gdb_test_no_output "set *(int32_t*) &int8_search_buf\[10\] = 0x61616161" ""
gdb_test "find &int8_search_buf\[0\], +sizeof(int8_search_buf), 'a', 'a', 'a'" \
"${hex_number}.*<int8_search_buf\\+10>${newline}${hex_number}.*<int8_search_buf\\+11>${two_patterns_found}" \
"find string pattern"
# Test not finding pattern because search range too small, with
# potential find at the edge of the range.
gdb_test "find &int8_search_buf\[0\], +10+3, \"aaaa\"" \
"${pattern_not_found}" \
"pattern not found at end of range"
# Increase the search range by 1 and we should find the pattern.
gdb_test "find &int8_search_buf\[0\], +10+3+1, 'a', 'a', 'a', 'a'" \
"${hex_number}.*<int8_search_buf\\+10>${one_pattern_found}" \
"pattern found at end of range"
# Test max-count, $_ and $numfound.
gdb_test "find /1 &int8_search_buf\[0\], +sizeof(int8_search_buf), 'a', 'a', 'a'" \
"${hex_number}.*<int8_search_buf\\+10>${one_pattern_found}" \
"max-count"
gdb_test "print \$_" \
"${history_prefix}.*${hex_number} <int8_search_buf\\+10>" \
"\$_"
gdb_test "print \$numfound" \
"${history_prefix}1" \
"\$numfound"
# Test max-count with size-char.
# They can be specified in either order.
gdb_test "find /1b &int8_search_buf\[0\], +sizeof(int8_search_buf), 0x61, 0x61, 0x61" \
"${hex_number}.*<int8_search_buf\\+10>${one_pattern_found}" \
"size,max-count, /1b"
gdb_test "find /b1 &int8_search_buf\[0\], +sizeof(int8_search_buf), 0x61, 0x61, 0x61" \
"${hex_number}.*<int8_search_buf\\+10>${one_pattern_found}" \
"size,max-count, /b1"
gdb_test "find /b /1 &int8_search_buf\[0\], +sizeof(int8_search_buf), 0x61, 0x61, 0x61" \
"${hex_number}.*<int8_search_buf\\+10>${one_pattern_found}" \
"size,max-count, /b/1"
gdb_test "find /1 /b &int8_search_buf\[0\], +sizeof(int8_search_buf), 0x61, 0x61, 0x61" \
"${hex_number}.*<int8_search_buf\\+10>${one_pattern_found}" \
"size,max-count, /1/b"
# Test specifying end address.
gdb_test "find /b &int8_search_buf\[0\], &int8_search_buf\[0\]+sizeof(int8_search_buf), 0x61, 0x61, 0x61, 0x61" \
"${hex_number}.*<int8_search_buf\\+10>${one_pattern_found}" \
"find byte pattern with end address"
# Test 16-bit pattern.
gdb_test_no_output "set int16_search_buf\[10\] = 0x1234" ""
gdb_test "find /h &int16_search_buf\[0\], +sizeof(int16_search_buf), 0x1234" \
"${hex_number}.*<int16_search_buf\\+20>${one_pattern_found}" \
"find 16-bit pattern"
gdb_test "find &int16_search_buf\[0\], +sizeof(int16_search_buf), (int16_t) 0x1234" \
"${hex_number}.*<int16_search_buf\\+20>${one_pattern_found}" \
"find 16-bit pattern"
# Test 32-bit pattern.
gdb_test_no_output "set int32_search_buf\[10\] = 0x12345678" ""
gdb_test "find &int32_search_buf\[0\], +sizeof(int32_search_buf), (int32_t) 0x12345678" \
"${hex_number}.*<int32_search_buf\\+40>${one_pattern_found}" \
"find 32-bit pattern"
gdb_test "find /w &int32_search_buf\[0\], +sizeof(int32_search_buf), 0x12345678" \
"${hex_number}.*<int32_search_buf\\+40>${one_pattern_found}" \
"find 32-bit pattern"
# Test 64-bit pattern.
gdb_test_no_output "set int64_search_buf\[10\] = 0xfedcba9876543210LL" ""
gdb_test "find &int64_search_buf\[0\], +sizeof(int64_search_buf), (int64_t) 0xfedcba9876543210LL" \
"${hex_number}.*<int64_search_buf\\+80>${one_pattern_found}" \
"find 64-bit pattern"
gdb_test "find /g &int64_search_buf\[0\], +sizeof(int64_search_buf), 0xfedcba9876543210LL" \
"${hex_number}.*<int64_search_buf\\+80>${one_pattern_found}" \
"find 64-bit pattern"
# Test mixed-sized patterns.
gdb_test_no_output "set *(int8_t*) &search_buf\[10\] = 0x62" ""
gdb_test_no_output "set *(int16_t*) &search_buf\[11\] = 0x6363" ""
gdb_test_no_output "set *(int32_t*) &search_buf\[13\] = 0x64646464" ""
gdb_test "find &search_buf\[0\], +100, (int8_t) 0x62, (int16_t) 0x6363, (int32_t) 0x64646464" \
"${hex_number}${one_pattern_found}" \
"find mixed-sized pattern"
# Test search spanning a large range, in the particular case of native
# targets, test the search spanning multiple chunks.
# Remote targets may implement the search differently.
set CHUNK_SIZE 16000 ;# see findcmd.c
gdb_test_no_output "set *(int32_t*) &search_buf\[0*${CHUNK_SIZE}+100\] = 0x12345678" ""
gdb_test_no_output "set *(int32_t*) &search_buf\[1*${CHUNK_SIZE}+100\] = 0x12345678" ""
gdb_test "find /w search_buf, +search_buf_size, 0x12345678" \
"${hex_number}${newline}${hex_number}${two_patterns_found}" \
"search spanning large range"
# For native targets, test a pattern straddling a chunk boundary.
if [isnative] {
gdb_test_no_output "set *(int32_t*) &search_buf\[${CHUNK_SIZE}-1\] = 0xfdb97531" ""
gdb_test "find /w search_buf, +search_buf_size, 0xfdb97531" \
"${hex_number}${one_pattern_found}" \
"find pattern straddling chunk boundary"
}
# Check GDB buffer overflow.
gdb_test "find int64_search_buf, +64/8*100, int64_search_buf" " <int64_search_buf>\r\n1 pattern found\\."
|
GitWeb