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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-6.8/] [gdb/] [testsuite/] [gdb.base/] [macscp.exp] - Blame information for rev 157

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 24 jeremybenn
# Test macro scoping.
2
# Copyright 2002, 2007, 2008 Free Software Foundation, Inc.
3
 
4
# This program is free software; you can redistribute it and/or modify
5
# it under the terms of the GNU General Public License as published by
6
# the Free Software Foundation; either version 3 of the License, or
7
# (at your option) any later version.
8
#
9
# This program is distributed in the hope that it will be useful,
10
# but WITHOUT ANY WARRANTY; without even the implied warranty of
11
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12
# GNU General Public License for more details.
13
#
14
# You should have received a copy of the GNU General Public License
15
# along with this program.  If not, see .
16
 
17
# Please email any bugs, comments, and/or additions to this file to:
18
# bug-gdb@prep.ai.mit.edu
19
 
20
if $tracelevel then {
21
    strace $tracelevel
22
}
23
 
24
set prms_id 0
25
set bug_id 0
26
 
27
set testfile "macscp"
28
set binfile ${objdir}/${subdir}/${testfile}
29
 
30
if  {[gdb_compile "${srcdir}/${subdir}/macscp1.c" "${binfile}" executable {debug}] != "" } {
31
    untested macscp.exp
32
    return -1
33
}
34
 
35
gdb_exit
36
gdb_start
37
gdb_reinitialize_dir $srcdir/$subdir
38
gdb_load ${binfile}
39
 
40
 
41
# Ask GDB to show the current definition of MACRO, and return a list
42
# describing the result.
43
#
44
# The return value has the form {FILE1 FILE2 ... DEF}, which means
45
# that MACRO has the definition `DEF', and was defined in `FILE1',
46
# which was included from `FILE2', included from ... .
47
#
48
# If GDB says that MACRO has no definition, return the string `undefined'.
49
#
50
# If GDB complains that it doesn't have any information about
51
# preprocessor macro definitions, return the string `no-macro-info'.
52
#
53
# If expect times out waiting for GDB, we return the string `timeout'.
54
#
55
# If GDB's output doesn't otherwise match what we're expecting, we
56
# return the empty string.
57
 
58
proc info_macro {macro} {
59
    global gdb_prompt
60
    global decimal
61
 
62
    set filepat {macscp[0-9]+\.[ch]}
63
    set definition {}
64
    set location {}
65
 
66
    send_gdb "info macro ${macro}\n"
67
 
68
    set debug_me 0
69
 
70
    if {$debug_me} {exp_internal 1}
71
    gdb_expect {
72
        -re "Defined at \[^\r\n\]*(${filepat}):${decimal}\[\r\n\]" {
73
            # `location' and `definition' should be empty when we see
74
            # this message.
75
            if {[llength $location] == 0 && [llength $definition] == 0} {
76
                set location $expect_out(1,string)
77
                exp_continue
78
            } else {
79
                # Exit this expect loop, with a result indicating failure.
80
                set definition {}
81
            }
82
        }
83
        -re "The symbol `${macro}' has no definition as a C/C\\+\\+ preprocessor macro\[^\r\n\]*\[\r\n\]" {
84
            # `location' and `definition' should be empty when we see
85
            # this message.
86
            if {[llength $location] == 0 && [llength $definition] == 0} {
87
                set definition undefined
88
                exp_continue
89
            } else {
90
                # Exit this expect loop, with a result indicating failure.
91
                set definition {}
92
            }
93
        }
94
        -re "^\[\r\n\]*  included at \[^\r\n\]*(${filepat}):${decimal}\[\r\n\]" {
95
            # `location' should *not* be empty when we see this
96
            # message.  It should have recorded at least the initial
97
            # `Defined at ' message (for definitions) or ` at' message
98
            # (for undefined symbols).
99
            if {[llength $location] != 0} {
100
                lappend location $expect_out(1,string)
101
                exp_continue
102
            } else {
103
                # Exit this expect loop, with a result indicating failure.
104
                set definition {}
105
            }
106
        }
107
        -re "^\[\r\n\]*at \[^\r\n\]*(${filepat}):${decimal}\[\r\n\]" {
108
            # This appears after a `has no definition' message.
109
            # `location' should be empty when we see it.
110
            if {[string compare $definition undefined] == 0 \
111
                    && [llength $location] == 0} {
112
                set location $expect_out(1,string)
113
                exp_continue
114
            } else {
115
                # Exit this expect loop, with a result indicating failure.
116
                set definition {}
117
            }
118
        }
119
        -re "#define ${macro} (\[^\r\n\]*)\[\r\n\]" {
120
            # `definition' should be empty when we see this message.
121
            if {[string compare $definition ""] == 0} {
122
                set definition $expect_out(1,string)
123
                exp_continue
124
            } else {
125
                # Exit this expect loop, with a result indicating failure.
126
                set definition {}
127
            }
128
        }
129
        -re "has no preprocessor macro information.*$gdb_prompt $" {
130
            set definition no-macro-info
131
        }
132
        -re "$gdb_prompt $" {
133
            # Exit the expect loop; let the existing value of `definition'
134
            # indicate failure or success.
135
        }
136
        timeout {
137
            set definition timeout
138
        }
139
    }
140
    if {$debug_me} {exp_internal 0}
141
 
142
    switch -exact -- $definition {
143
        no-macro-info { return no-macro-info }
144
        timeout { return timeout }
145
        undefined -
146
        default {
147
            if {[llength $location] >= 1} {
148
                return [concat $location [list $definition]]
149
            } else {
150
                return {}
151
            }
152
        }
153
    }
154
}
155
 
156
 
157
# Call info_macro to show the definition of MACRO.  Expect a result of
158
# EXPECTED.  Use WHERE in pass/fail messages to identify the context.
159
# Return non-zero if we should abort the entire test file, or zero if
160
# we can continue.
161
proc check_macro {macro expected where} {
162
    set func_def [info_macro $macro]
163
    if {[string compare $func_def $expected] == 0} {
164
        pass "info macro $macro $where"
165
    } else {
166
        switch -exact -- $func_def {
167
            no-macro-info {
168
                xfail "executable includes no macro debugging information"
169
                return 1
170
            }
171
            timeout {
172
                fail "info macro $macro $where (timeout)"
173
            }
174
            default {
175
                fail "info macro $macro $where"
176
            }
177
        }
178
    }
179
    return 0
180
}
181
 
182
 
183
# List the function FUNC, and then show the definition of MACRO,
184
# expecting the result EXPECTED.
185
proc list_and_check_macro {func macro expected} {
186
    gdb_test "list $func" ".*${func}.*"
187
    return [check_macro $macro $expected "after `list $func'"]
188
}
189
 
190
 
191
if {[list_and_check_macro main WHERE {macscp1.c {before macscp1_3}}]} {
192
    return 0
193
}
194
list_and_check_macro macscp2_2 WHERE {macscp2.h macscp1.c {before macscp2_2}}
195
list_and_check_macro macscp3_2 WHERE {macscp3.h macscp1.c {before macscp3_2}}
196
 
197
 
198
# Although GDB's macro table structures distinguish between multiple
199
# #inclusions of the same file, GDB's other structures don't.  So the
200
# `list' command here doesn't reliably select one #inclusion or the
201
# other, even though it could.  It would be nice to eventually change
202
# GDB's structures to handle this correctly.
203
gdb_test "list macscp4_2_from_macscp2" ".*macscp4_2_, MACSCP4_INCLUSION.*"
204
switch -exact -- [info_macro WHERE] {
205
    {macscp4.h macscp2.h macscp1.c {before macscp4_2_..., from macscp2.h}} {
206
        pass "info macro WHERE after `list macscp_4_2_from_macscp2'"
207
    }
208
    {macscp4.h macscp3.h macscp1.c {before macscp4_2_..., from macscp3.h}} {
209
        # setup_kfail "gdb/555"
210
        fail "info macro WHERE after `list macscp_4_2_from_macscp2' (gdb/555)"
211
    }
212
    timeout {
213
        fail "info macro WHERE after `list macscp_4_2_from_macscp2' (timeout)"
214
    }
215
    default { fail "info macro WHERE after `list macscp_4_2_from_macscp2'" }
216
}
217
 
218
gdb_test "list macscp4_2_from_macscp3" ".*macscp4_2_, MACSCP4_INCLUSION.*"
219
switch -exact -- [info_macro WHERE] {
220
    {macscp4.h macscp3.h macscp1.c {before macscp4_2_..., from macscp3.h}} {
221
        pass "info macro WHERE after `list macscp_4_2_from_macscp3'"
222
    }
223
    {macscp4.h macscp2.h macscp1.c {before macscp4_2_..., from macscp2.h}} {
224
        # setup_kfail "gdb/555"
225
        fail "info macro WHERE after `list macscp_4_2_from_macscp3' (gdb/555)"
226
    }
227
    timeout {
228
        fail "info macro WHERE after `list macscp_4_2_from_macscp3' (timeout)"
229
    }
230
    default { fail "info macro WHERE after `list macscp_4_2_from_macscp3'" }
231
}
232
 
233
 
234
#### Test the selection of the macro scope by the current frame.
235
 
236
### A table of functions, in the order they will be reached, which is
237
### also the order they appear in the preprocessed output.  Each entry
238
### has the form {FUNCNAME WHERE KFAILWHERE}, where:
239
### - FUNCNAME is the name of the function,
240
### - WHERE is the definition we expect to see for the macro `WHERE', as
241
###   returned by `info_macro', and
242
### - KFAILWHERE is an alternate definition which should be reported
243
###   as a `known failure', due to GDB's inability to distinguish multiple
244
###   #inclusions of the same file.
245
### KFAILWHERE may be omitted.
246
 
247
set funcs {
248
    {
249
        macscp1_1
250
        {macscp1.c {before macscp1_1}}
251
    }
252
    {
253
        macscp2_1
254
        {macscp2.h macscp1.c {before macscp2_1}}
255
    }
256
    {
257
        macscp4_1_from_macscp2
258
        {macscp4.h macscp2.h macscp1.c {before macscp4_1_..., from macscp2.h}}
259
        {macscp4.h macscp3.h macscp1.c {before macscp4_1_..., from macscp3.h}}
260
    }
261
    {
262
        macscp4_2_from_macscp2
263
        {macscp4.h macscp2.h macscp1.c {before macscp4_2_..., from macscp2.h}}
264
        {macscp4.h macscp3.h macscp1.c {before macscp4_2_..., from macscp3.h}}
265
    }
266
    {
267
        macscp2_2
268
        {macscp2.h macscp1.c {before macscp2_2}}
269
    }
270
    {
271
        macscp1_2
272
        {macscp1.c {before macscp1_2}}
273
    }
274
    {
275
        macscp3_1
276
        {macscp3.h macscp1.c {before macscp3_1}}
277
    }
278
    {
279
        macscp4_1_from_macscp3
280
        {macscp4.h macscp3.h macscp1.c {before macscp4_1_..., from macscp3.h}}
281
        {macscp4.h macscp2.h macscp1.c {before macscp4_1_..., from macscp2.h}}
282
    }
283
    {
284
        macscp4_2_from_macscp3
285
        {macscp4.h macscp3.h macscp1.c {before macscp4_2_..., from macscp3.h}}
286
        {macscp4.h macscp2.h macscp1.c {before macscp4_2_..., from macscp2.h}}
287
    }
288
    {
289
        macscp3_2
290
        {macscp3.h macscp1.c {before macscp3_2}}
291
    }
292
    {
293
        macscp1_3
294
        {macscp1.c {before macscp1_3}}
295
    }
296
}
297
 
298
 
299
# Start the program running.
300
if {! [runto_main]} {
301
    fail "macro tests suppressed: couldn't run to main"
302
    return 0
303
}
304
 
305
# Set a breakpoint on each of the functions.
306
foreach func_entry $funcs {
307
    set func [lindex $func_entry 0]
308
    gdb_test "break $func" "Breakpoint.*"
309
}
310
 
311
# Run to each of the breakpoints and check the definition (or lack
312
# thereof) of each macro.
313
for {set i 0} {$i < [llength $funcs]} {incr i} {
314
    set func_entry [lindex $funcs $i]
315
    set func [lindex $func_entry 0]
316
    set expected [lindex $func_entry 1]
317
    set kfail_expected [lindex $func_entry 2]
318
 
319
    # Run to the breakpoint for $func.
320
    gdb_test "continue" "Breakpoint $decimal, $func .*" "continue to $func"
321
 
322
    # Check the macro WHERE.
323
    set result [info_macro WHERE]
324
    if {[string compare $result $expected] == 0} {
325
        pass "info macro WHERE stopped in $func"
326
    } elseif {[string compare $result $kfail_expected] == 0} {
327
        # setup_kfail "gdb/555"
328
        fail "info macro WHERE stopped in $func (gdb/555)"
329
    } elseif {[string compare $result timeout] == 0} {
330
        fail "info macro WHERE stopped in $func (timeout)"
331
    } else {
332
        fail "info macro WHERE stopped in $func"
333
    }
334
 
335
    # Check that the BEFORE_ macros for all prior functions are
336
    # #defined, and that those for all subsequent functions are not.
337
    for {set j 0} {$j < [llength $funcs]} {incr j} {
338
        if {$j != $i} {
339
            set func_j_entry [lindex $funcs $j]
340
            set func_j [lindex $func_j_entry 0]
341
 
342
            set before_macro "BEFORE_[string toupper $func_j]"
343
            set test_name \
344
                    "$before_macro defined/undefined when stopped at $func"
345
            set result [info_macro $before_macro]
346
 
347
            # We can't get the right scope info when we're stopped in
348
            # the macro4_ functions.
349
            if {[string match macscp4_* $func]} {
350
                # setup_kfail "gdb/555"
351
                set test_name "$test_name (gdb/555)"
352
            }
353
            if {$j < $i} {
354
                if {[llength $result] >= 2 && \
355
                        [string compare [lindex $result end] {}] == 0} {
356
                    pass $test_name
357
                } elseif {[string compare $result timeout] == 0} {
358
                    fail "$test_name (timeout)"
359
                } else {
360
                    fail "$test_name"
361
                }
362
            } elseif {$j > $i} {
363
                switch -- [lindex $result end] {
364
                    undefined { pass $test_name }
365
                    timeout { fail "$test_name (timeout)" }
366
                    default {
367
                        fail "$test_name"
368
                    }
369
                }
370
            }
371
 
372
            set until_macro "UNTIL_[string toupper $func_j]"
373
            set test_name \
374
                    "$until_macro defined/undefined when stopped at $func"
375
            set result [info_macro $until_macro]
376
 
377
            # We can't get the right scope info when we're stopped in
378
            # the macro4_ functions.
379
            if {[string match macscp4_* $func]} {
380
                # setup_kfail "gdb/555"
381
                set test_name "$test_name (gdb/555)"
382
            }
383
            if {$j <= $i} {
384
                switch -- [lindex $result end] {
385
                    undefined { pass $test_name }
386
                    timeout { fail "$test_name (timeout)" }
387
                    default {
388
                        fail "$test_name"
389
                    }
390
                }
391
            } elseif {$j > $i} {
392
                if {[llength $result] >= 2 && \
393
                        [string compare [lindex $result end] {}] == 0} {
394
                    pass $test_name
395
                } elseif {[string compare $result timeout] == 0} {
396
                    fail "$test_name (timeout)"
397
                } else {
398
                    fail "$test_name"
399
                }
400
            }
401
        }
402
    }
403
}

powered by: WebSVN 2.1.0

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