OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-7.2/] [gdb/] [testsuite/] [gdb.trace/] [backtrace.exp] - Blame information for rev 330

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 330 jeremybenn
#   Copyright 1998, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
2
#
3
# This program is free software; you can redistribute it and/or modify
4
# it under the terms of the GNU General Public License as published by
5
# the Free Software Foundation; either version 3 of the License, or
6
# (at your option) any later version.
7
#
8
# This program is distributed in the hope that it will be useful,
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
# GNU General Public License for more details.
12
#
13
# You should have received a copy of the GNU General Public License
14
# along with this program.  If not, see .
15
 
16
# This file was written by Michael Snyder (msnyder@cygnus.com)
17
 
18
load_lib "trace-support.exp";
19
 
20
if $tracelevel then {
21
    strace $tracelevel
22
}
23
 
24
 
25
gdb_exit
26
gdb_start
27
 
28
set testfile "actions"
29
set srcfile ${testfile}.c
30
set binfile $objdir/$subdir/backtrace
31
if { [gdb_compile "$srcdir/$subdir/$srcfile" $binfile \
32
          executable {debug nowarnings}] != "" } {
33
    untested backtrace.exp
34
    return -1
35
}
36
gdb_load $binfile
37
gdb_test "tstop"       ".*" ""
38
gdb_test "tfind none"  ".*" ""
39
runto_main
40
gdb_reinitialize_dir $srcdir/$subdir
41
 
42
# We generously give ourselves one "pass" if we successfully
43
# detect that this test cannot be run on this target!
44
if { ![gdb_target_supports_trace] } then {
45
    pass "Current target does not support trace"
46
    return 1;
47
 
48
}
49
 
50
#
51
# test backtraces in trace frames
52
#
53
 
54
set testline1 0
55
set testline2 0
56
set testline3 0
57
set testline4 0
58
set testline5 0
59
set testline6 0
60
 
61
set arg1 1
62
set arg2 2
63
set arg3 3
64
set arg4 4
65
set arg5 5
66
set arg6 6
67
 
68
set baseline [gdb_find_recursion_test_baseline $srcfile];
69
if { $baseline == -1 } {
70
    fail "Could not find gdb_recursion_test function"
71
    return;
72
}
73
 
74
set return_me 0
75
 
76
gdb_test_multiple "list $baseline, +12" "all tests in this module will fail" {
77
    -re "\[\r\n\](\[0-9\]+).*gdbtestline 1 " {
78
        set testline1 $expect_out(1,string)
79
        exp_continue
80
    }
81
    -re "\[\r\n\](\[0-9\]+).*gdbtestline 2 " {
82
        set testline2 $expect_out(1,string)
83
        exp_continue
84
    }
85
    -re "\[\r\n\](\[0-9\]+).*gdbtestline 3 " {
86
        set testline3 $expect_out(1,string)
87
        exp_continue
88
    }
89
    -re "\[\r\n\](\[0-9\]+).*gdbtestline 4 " {
90
        set testline4 $expect_out(1,string)
91
        exp_continue
92
    }
93
    -re "\[\r\n\](\[0-9\]+).*gdbtestline 5 " {
94
        set testline5 $expect_out(1,string)
95
        exp_continue
96
    }
97
    -re "\[\r\n\](\[0-9\]+).*gdbtestline 6 " {
98
        set testline6 $expect_out(1,string)
99
        exp_continue
100
    }
101
    -re ".*$gdb_prompt $" {
102
        if { ($testline1 == 0) || ($testline2 == 0) || ($testline3 == 0) || ($testline4 == 0) || ($testline5 == 0) || ($testline6 == 0) } {
103
            untested backtrace.exp
104
            set return_me 1
105
all tests in this module will fail."
106
        }
107
    }
108
    default {
109
            untested backtrace.exp
110
            set return_me 1
111
all tests in this module will fail."
112
    }
113
}
114
 
115
if { $return_me == 1 } then {
116
    return -1;
117
}
118
 
119
#
120
# Setup backtrace experiment.  This will involve:
121
#   1) a tracepoint where nothing is collected
122
#   2) a tracepoint where only regs are collected
123
#   3) a tracepoint where regs, locals and args are collected
124
#   4) a tracepoint where regs plus some amount of stack are collected.
125
#
126
 
127
gdb_delete_tracepoints
128
set tdp2 [gdb_gettpnum $testline2]
129
set tdp3 [gdb_gettpnum $testline3]
130
set tdp4 [gdb_gettpnum $testline4]
131
set tdp5 [gdb_gettpnum $testline5]
132
set tdp6 [gdb_gettpnum $testline6]
133
if {    $tdp2 <= 0 || $tdp3 <= 0 || \
134
        $tdp4 <= 0 || $tdp5 <= 0 || $tdp6 <= 0 } then {
135
    fail "setting tracepoints failed"
136
    return;
137
}
138
 
139
#gdb_trace_setactions "setup TP to collect FP" \
140
#       "$tdp2" \
141
#       "collect \$fp" ""
142
#
143
 
144
gdb_trace_setactions "8.6: setup TP to collect regs" \
145
        "$tdp3" \
146
        "collect \$regs" "^$"
147
 
148
gdb_trace_setactions "8.6: setup TP to collect regs, args, and locals" \
149
        "$tdp4" \
150
        "collect \$regs, \$args, \$locs" "^$"
151
 
152
if [istarget "x86_64-*"] then {
153
    set fpreg "\$rbp"
154
    set spreg "\$rsp"
155
} elseif [istarget "i?86-*"] then {
156
    set fpreg "\$ebp"
157
    set spreg "\$esp"
158
} else {
159
    set fpreg "\$fp"
160
    set spreg "\$sp"
161
}
162
 
163
gdb_trace_setactions "8.6: setup TP to collect stack mem cast expr" \
164
       "$tdp6" \
165
       "collect $fpreg, \(\*\(void \*\*\) \($spreg\)\) @ 64" "^$"
166
 
167
gdb_test "tstart" ".*" ""
168
 
169
gdb_test "break end" ".*" ""
170
gdb_test "continue" \
171
    "Continuing.*Breakpoint $decimal, end.*" \
172
    "run trace experiment"
173
 
174
gdb_test "tstop" ".*" ""
175
 
176
proc gdb_backtrace_tdp_1 { msg } {
177
    global gdb_prompt
178
 
179
    # We are in a trace frame at which we didn't collect anything
180
    # except $PC.  Therefore we expect to be able to identify stack
181
    # frame #0, but that's about all.  In particular we do not expect
182
    # to be able to display the function's arguments or locals, and we
183
    # do not expect to be able to identify the caller of this function.
184
 
185
    gdb_test "backtrace" \
186
        "#0\[\t \]+gdb_recursion_test.*depth=.*" \
187
        "$msg"
188
}
189
 
190
proc gdb_backtrace_tdp_2 { msg } {
191
    global gdb_prompt
192
 
193
    # We are in a trace frame at which we collected only the registers
194
    # Therefore we expect to be able to identify stack frame #0, but
195
    # we don't expect to be able to display its args unles they are
196
    # passed in registers (which isn't the case for m68k), and we
197
    # don't expect to be able to identify the caller's stack frame.
198
 
199
    gdb_test "backtrace" \
200
        "#0\[\t \]+gdb_recursion_test.*depth=.*" \
201
        "$msg"
202
}
203
 
204
proc gdb_backtrace_tdp_3 { msg } {
205
    global gdb_prompt
206
 
207
    # We are in a trace frame at which we collected all registers, all
208
    # arguments and all locals.  This means that the display of
209
    # stack frame #0 should be complete (including argument values).
210
 
211
    gdb_test_multiple "backtrace" "$msg" {
212
        -re "#0\[\t \]+gdb_recursion_test.*depth=\[0-9\]+.*q1=\[0-9\]+.*q2=\[0-9\]+.*q3=\[0-9\]+.*q4=\[0-9\]+.*q5=\[0-9\]+.*q6=\[0-9\]+.*$gdb_prompt $" {
213
            pass "$msg"
214
        }
215
        -re "#0\[\t \]+gdb_recursion_test.*depth=Cannot access.*$gdb_prompt $" {
216
            fail "$msg (failed to collect arguments)"
217
        }
218
    }
219
}
220
 
221
proc gdb_backtrace_tdp_4 { msg depth } {
222
    global gdb_prompt
223
 
224
    # We are in a trace frame at which we collected all registers,
225
    # plus a sizeable hunk of stack memory.  This should enable us to
226
    # display at least several stack frames worth of backtrace.  We'll
227
    # assume that if we can't display at least "depth" levels (with
228
    # args), it counts as an error.
229
 
230
    gdb_test_multiple "backtrace" "$msg" {
231
        -re "#$depth\[\t \].*gdb_recursion_test.*depth=\[0-9\]+.*q1=\[0-9\]+.*q2=\[0-9\]+.*q3=\[0-9\]+.*q4=\[0-9\]+.*q5=\[0-9\]+.*q6=\[0-9\]+.*$gdb_prompt $" {
232
            pass "$msg"
233
        }
234
        -re "#$depth\[\t \].*gdb_recursion_test.*depth=.*$gdb_prompt $" {
235
            fail "$msg (args missing from #$depth stack frame)"
236
        }
237
        -re "#\[0-9\]+\[\t \].*gdb_recursion_test.*depth=.*$gdb_prompt $" {
238
            fail "$msg (fewer than $depth stack frames found)"
239
        }
240
    }
241
}
242
 
243
#
244
# begin backtrace test
245
#
246
 
247
set timeout 60
248
 
249
gdb_tfind_test "init: make sure not debugging any trace frame" "none" "-1"
250
 
251
gdb_tfind_test "8.6: find start frame" "start" "0"
252
gdb_test "printf \"TDP \%d:\\n\", \$tracepoint" \
253
        "TDP $tdp2:" ""
254
gdb_backtrace_tdp_1 "8.6: Backtrace, depth == 1, collect nothing"
255
 
256
gdb_tfind_test "8.6: find frame 1"     "1" "1"
257
gdb_test "printf \"TDP \%d:\\n\", \$tracepoint" \
258
        "TDP $tdp3:" ""
259
gdb_backtrace_tdp_2 "8.6: Backtrace, depth == 1, collect regs"
260
 
261
gdb_tfind_test "8.6: find frame 2"     "2" "2"
262
gdb_test "printf \"TDP \%d:\\n\", \$tracepoint" \
263
        "TDP $tdp4:" ""
264
gdb_backtrace_tdp_3 "8.6: Backtrace, depth == 1, collect args and locals"
265
 
266
 
267
gdb_tfind_test "8.6: find frame 4"     "4" "4"
268
gdb_test "printf \"TDP \%d:\\n\", \$tracepoint" \
269
        "TDP $tdp6:" ""
270
gdb_backtrace_tdp_4 "8.6: Backtrace, depth == 1, collect stack mem expr" "0"
271
 
272
gdb_tfind_test "8.6: find frame 5"     "5" "5"
273
gdb_test "printf \"TDP \%d:\\n\", \$tracepoint" \
274
        "TDP $tdp2:" ""
275
gdb_backtrace_tdp_1 "8.6: Backtrace, depth == 2, collect nothing"
276
 
277
gdb_tfind_test "8.6: find frame 6"     "6" "6"
278
gdb_test "printf \"TDP \%d:\\n\", \$tracepoint" \
279
        "TDP $tdp3:" ""
280
gdb_backtrace_tdp_2 "8.6: Backtrace, depth == 2, collect regs"
281
 
282
gdb_tfind_test "8.6: find frame 7"     "7" "7"
283
gdb_test "printf \"TDP \%d:\\n\", \$tracepoint" \
284
        "TDP $tdp4:" ""
285
gdb_backtrace_tdp_3 "8.6: Backtrace, depth == 2, collect args and locals"
286
 
287
 
288
gdb_tfind_test "8.6: find frame 9"     "9" "9"
289
gdb_test "printf \"TDP \%d:\\n\", \$tracepoint" \
290
        "TDP $tdp6:" ""
291
gdb_backtrace_tdp_4 "8.6: Backtrace, depth == 1, collect stack mem expr" "0"
292
 
293
gdb_tfind_test "8.6: find frame 10"    "10" "10"
294
gdb_test "printf \"TDP \%d:\\n\", \$tracepoint" \
295
        "TDP $tdp2:" ""
296
gdb_backtrace_tdp_1 "8.6: Backtrace, depth == 3, collect nothing"
297
 
298
gdb_tfind_test "8.6: find frame 11"    "11" "11"
299
gdb_test "printf \"TDP \%d:\\n\", \$tracepoint" \
300
        "TDP $tdp3:" ""
301
gdb_backtrace_tdp_2 "8.6: Backtrace, depth == 3, collect regs"
302
 
303
gdb_tfind_test "8.6: find frame 12"    "12" "12"
304
gdb_test "printf \"TDP \%d:\\n\", \$tracepoint" \
305
        "TDP $tdp4:" ""
306
gdb_backtrace_tdp_3 "8.6: Backtrace, depth == 3, collect args and locals"
307
 
308
 
309
gdb_tfind_test "8.6: find frame 14"    "14" "14"
310
gdb_test "printf \"TDP \%d:\\n\", \$tracepoint" \
311
        "TDP $tdp6:" ""
312
gdb_backtrace_tdp_4 "8.6: Backtrace, depth == 1, collect stack mem expr" "0"
313
 
314
gdb_tfind_test "8.6: find frame 15"    "15" "15"
315
gdb_test "printf \"TDP \%d:\\n\", \$tracepoint" \
316
        "TDP $tdp2:" ""
317
gdb_backtrace_tdp_1 "8.6: Backtrace, depth == 4, collect nothing"
318
 
319
gdb_tfind_test "8.6: find frame 16"    "16" "16"
320
gdb_test "printf \"TDP \%d:\\n\", \$tracepoint" \
321
        "TDP $tdp3:" ""
322
gdb_backtrace_tdp_2 "8.6: Backtrace, depth == 4, collect regs"
323
 
324
gdb_tfind_test "8.6: find frame 17"    "17" "17"
325
gdb_test "printf \"TDP \%d:\\n\", \$tracepoint" \
326
        "TDP $tdp4:" ""
327
gdb_backtrace_tdp_3 "8.6: Backtrace, depth == 4, collect args and locals"
328
 
329
 
330
gdb_tfind_test "8.6: find frame 19"    "19" "19"
331
gdb_test "printf \"TDP \%d:\\n\", \$tracepoint" \
332
        "TDP $tdp6:" ""
333
gdb_backtrace_tdp_4 "8.6: Backtrace, depth == 1, collect stack mem expr" "0"
334
 
335
gdb_test "printf \"x \%d x\\n\", depth == 3" \
336
        "x 0 x" \
337
        "1.13: trace in recursion: depth not equal to 3"
338
 
339
# Finished!
340
gdb_test "tfind none" ".*" ""

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.