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/] [call-rt-st.exp] - Blame information for rev 157

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 24 jeremybenn
# Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2007, 2008
2
# 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
# This file was written by Elena Zannoni (ezannoni@cygnus.com)
21
 
22
# this file tests command line calls with functions returning structures
23
# corresponding source file: call_return_struct.c
24
 
25
 
26
 
27
if $tracelevel then {
28
        strace $tracelevel
29
}
30
 
31
set prms_id 0
32
set bug_id 0
33
 
34
set testfile "call-rt-st"
35
set srcfile ${testfile}.c
36
set binfile ${objdir}/${subdir}/${testfile}
37
 
38
 
39
# Test depends on printf, which the sparclet stub doesn't support.
40
if { [istarget "sparclet-*-*"] } {
41
    return 0;
42
}
43
 
44
if  { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug nowarnings}] != "" } {
45
    untested "couldn't compile ${srcdir}/${subdir}/${srcfile}"
46
    return -1
47
}
48
 
49
 
50
 
51
# Create and source the file that provides information about the compiler
52
# used to compile the test case.
53
 
54
if [get_compiler_info ${binfile}] {
55
    return -1;
56
}
57
 
58
# Some targets can't do function calls, so don't even bother with this
59
# test.
60
if [target_info exists gdb,cannot_call_functions] {
61
    setup_xfail "*-*-*" 2416
62
    fail "This target can not call functions"
63
    continue
64
}
65
 
66
# Set the current language to C.  This counts as a test.  If it
67
# fails, then we skip the other tests.
68
 
69
proc set_lang_c {} {
70
    global gdb_prompt
71
 
72
    send_gdb "set language c\n"
73
    gdb_expect {
74
        -re ".*$gdb_prompt $" {}
75
        timeout { fail "set language c (timeout)" ; return 0; }
76
    }
77
 
78
    send_gdb "show language\n"
79
    gdb_expect {
80
        -re ".* source language is \"c\".*$gdb_prompt $" {
81
            pass "set language to \"c\""
82
            return 1
83
        }
84
        -re ".*$gdb_prompt $" {
85
            fail "setting language to \"c\""
86
            return 0
87
        }
88
        timeout {
89
            fail "can't show language (timeout)"
90
            return 0
91
        }
92
    }
93
}
94
 
95
# Start with a fresh gdb.
96
 
97
gdb_exit
98
gdb_start
99
gdb_reinitialize_dir $srcdir/$subdir
100
gdb_load ${binfile}
101
send_gdb "set print sevenbit-strings\n" ; gdb_expect -re "$gdb_prompt $"
102
send_gdb "set print address off\n" ; gdb_expect -re "$gdb_prompt $"
103
send_gdb "set width 0\n" ; gdb_expect -re "$gdb_prompt $"
104
 
105
 
106
if ![runto_main] then {
107
    perror "couldn't run to breakpoint"
108
    continue
109
}
110
 
111
 
112
gdb_test "break loop_count" \
113
    "Breakpoint.* file .*call-rt-st.c, line 128\\." \
114
    "breakpoint loop_count"
115
 
116
 
117
send_gdb "continue\n"
118
gdb_expect {
119
 -re  "Continuing\\..*Breakpoint.*loop_count \\(\\) at.*call-rt-st.c:128\[ \t\r\n\]+128\[\t \]+for \\(index=0; index.4; index..\\);\[\r\n \]+$gdb_prompt $" {
120
                 pass "continue to loop_count"}
121
      -re ".*$gdb_prompt $" { fail "continue to loop_count"}
122
      timeout           { fail "(timeout) continue to loop_count"}
123
}
124
 
125
send_gdb "finish\n"
126
gdb_expect {
127
    -re  "Run till exit from .0  loop_count \\(\\) at.*call-rt-st.c:128\[ \t\r\n\]+main \\(\\) at.*call-rt-st.c:777\[ \t\r\n\]+777\[\t \]+return 0;.*$gdb_prompt $" {
128
        pass "finish out from loop_count (line 777)"
129
    }
130
    -re  "Run till exit from .0  loop_count \\(\\) at.*call-rt-st.c:128\[ \t\r\n\]+main \\(\\) at.*call-rt-st.c:775\[ \t\r\n\]+775\[\t \]+loop_count.*$gdb_prompt $" {
131
        pass "finish out from loop_count (line 775)"
132
    }
133
    -re ".*$gdb_prompt $" {
134
        fail "finish out from loop_count"
135
    }
136
    timeout {
137
        fail "finish out from loop_count (timeout)"
138
    }
139
}
140
 
141
# Ask GDB to print the value of EXPR, and expect to see the regexp
142
# RESULT in the output.  If we get back the error message "Function
143
# return value unknown", call that an `unsupported' test; on some
144
# architectures, it's impossible to find structs returned by value
145
# reliably.
146
proc print_struct_call { expr result } {
147
    global gdb_prompt
148
 
149
    set command "print $expr"
150
    send_gdb "${command}\n"
151
    gdb_expect {
152
        -re "$result\[\r\n\]+$gdb_prompt $" {
153
            pass "$command"
154
        }
155
        -re "Function return value unknown.\[\r\n\]+$gdb_prompt $" {
156
            unsupported "$command"
157
        }
158
        -re "$gdb_prompt $" {
159
            fail "$command"
160
        }
161
        timeout {
162
            fail "$command (timeout)"
163
        }
164
    }
165
}
166
 
167
 
168
if ![gdb_skip_stdio_test "print print_struct_rep(*struct1)"] {
169
    print_struct_call "print_struct_rep(*struct1)" \
170
            ".*Contents of struct1:\[ \t\n\r\]+22\[ \t\]+0\[ \t\n\r\]+.\[0-9\]+ = \\{value = 5, head = 0\\}"
171
}
172
 
173
if ![gdb_skip_stdio_test "print print_one_large_struct(...)"] {
174
    print_struct_call "print_one_large_struct(*list1)" \
175
            ".*\[ \t\]+4\[ \t\]+1\[ \r\n\]+.\[0-9\]+ = \\{next_index = \\{1, 2, 3, 4, 5, 6, 7, 8, 9, 10\\}, values = \\{4, 6, 8, 10, 12, 14, 16, 18, 20, 22\\}, head = 0\\}"
176
}
177
 
178
if {![gdb_skip_float_test "print print_one_double(*d1)"] && \
179
        ![gdb_skip_stdio_test "print print_one_double(*d1)"] } {
180
    print_struct_call "print_one_double(*d1)" \
181
            ".*Contents of one_double_t:\[ \r\n\]+1\\.111110\[ \r\n\]+.\[0-9\]+ = \\{double1 = 1\\.111\[0-9\]*\\}"
182
}
183
 
184
if {![gdb_skip_float_test "print print_two_floats(*f3)"] && \
185
        ![gdb_skip_stdio_test "print print_two_floats(*f3)"] } {
186
    print_struct_call "print_two_floats(*f3)" \
187
            ".*Contents of two_floats_t:\[ \r\n\]+-2\\.345000\[ \t]+1\\.000000\[ \r\n\]+.\[0-9\]+ = \\{float1 = -2\\.34500003, float2 = 1\\}"
188
}
189
 
190
if ![gdb_skip_stdio_test "print print_bit_flags_char(*cflags)"] {
191
    print_struct_call "print_bit_flags_char(*cflags)" \
192
            ".*alpha\[ \r\n\]+gamma\[ \r\n\]+epsilon\[ \r\n\]+.\[0-9\]+ = \\{alpha = 1 '\\\\001', beta = 0 '\\\\0', gamma = 1 '\\\\001', delta = 0 '\\\\0', epsilon = 1 '\\\\001', omega = 0 '\\\\0'\\}"
193
}
194
 
195
if ![gdb_skip_stdio_test "print print_bit_flags_short(*sflags)"] {
196
    print_struct_call "print_bit_flags_short(*sflags)" \
197
            ".*alpha\[ \r\n\]+gamma\[ \r\n\]+epsilon\[ \r\n\]+.\[0-9\]+ = \\{alpha = 1, beta = 0, gamma = 1, delta = 0, epsilon = 1, omega = 0\\}"
198
}
199
 
200
if ![gdb_skip_stdio_test "print print_bit_flags(*flags)"] {
201
    print_struct_call "print_bit_flags(*flags)" \
202
            ".*alpha\[ \r\n\]+gamma\[ \r\n\]+epsilon\[ \r\n\]+.\[0-9\]+ = \\{alpha = 1, beta = 0, gamma = 1, delta = 0, epsilon = 1, omega = 0\\}"
203
}
204
 
205
if ![gdb_skip_stdio_test "print print_bit_flags_combo(*flags_combo)"] {
206
    print_struct_call "print_bit_flags_combo(*flags_combo)" \
207
            ".*alpha\[ \r\n\]+gamma\[ \r\n\]+epsilon\[ \r\n\]+ch1: y\[ \t\]+ch2: n\[ \r\n\]+.\[0-9\]+ = \\{alpha = 1, beta = 0, ch1 = 121 'y', gamma = 1, delta = 0, ch2 = 110 'n', epsilon = 1, omega = 0\\}"
208
}
209
 
210
if ![gdb_skip_stdio_test "print print_three_chars(*three_chars)"] {
211
    print_struct_call "print_three_chars(*three_char)" \
212
            ".*Contents of three_char_t:\[ \r\n\]+x\[ \t\]+y\[ \t\]+z\[ \r\n\]+.\[0-9\]+ = \\{ch1 = 120 'x', ch2 = 121 'y', ch3 = 122 'z'\\}"
213
}
214
 
215
if ![gdb_skip_stdio_test "print print_five_chars(*five_chars)"] {
216
    print_struct_call "print_five_chars(*five_char)" \
217
            ".*Contents of five_char_t:\[ \r\n\]+h\[ \t\]+e\[ \t\]+l\[ \t\]+l\[ \t\]+o\[ \r\n\]+.\[0-9\]+ = \\{ch1 = 104 'h', ch2 = 101 'e', ch3 = 108 'l', ch4 = 108 'l', ch5 = 111 'o'\\}"
218
}
219
 
220
if ![gdb_skip_stdio_test "print print_int_char_combo(*int_char_combo)"] {
221
    print_struct_call "print_int_char_combo(*int_char_combo)" \
222
            ".*Contents of int_char_combo_t:\[ \r\n\]+13\[ \t\]+!\[ \r\n\]+.\[0-9\]+ = \\{int1 = 13, ch1 = 33 '!'\\}"
223
}
224
 
225
return

powered by: WebSVN 2.1.0

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