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
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
|
# Test that GDB properly ignores invalid stabs.
# Also test that GDB can debug a .o file, and that it doesn't mind
# a file that's more minimal than what a compiler normally puts out.
if $tracelevel then {
strace $tracelevel
}
set prms_id 0
set bug_id 0
proc do_tests {} {
global binfile
global prompt
# Do this first because the bug only exhibits itself before partial
# symbols have been expanded.
setup_xfail "*-*-*"
# xcoffread.c doesn't (yet) use partial symbol tables.
clear_xfail "rs*-*-aix*"
gdb_test "ptype red" "type = enum \{red, green, blue\}" "ptype unnamed enum"
print_wierd_var var0
print_wierd_var var1
print_wierd_var var2
print_wierd_var var3
print_wierd_var attr32
print_wierd_var attr33
print_wierd_var attr35
print_wierd_var attr36
print_wierd_var attr37
print_wierd_var attr38
print_wierd_var attr39
print_wierd_var attr41
print_wierd_var attr42
print_wierd_var attr43
print_wierd_var attr44
print_wierd_var attr46
print_wierd_var attr47
print_wierd_var attr58
print_wierd_var attr59
print_wierd_var attr60
print_wierd_var attr61
print_wierd_var attr62
print_wierd_var attr63
print_wierd_var attr64
print_wierd_var attr65
print_wierd_var attr66
print_wierd_var attr67
print_wierd_var attr68
print_wierd_var attr69
print_wierd_var attr70
print_wierd_var attr71
print_wierd_var attr72
print_wierd_var attr73
print_wierd_var attr74
print_wierd_var attr75
print_wierd_var attr76
print_wierd_var attr77
print_wierd_var attr78
print_wierd_var attr79
print_wierd_var attr80
print_wierd_var attr81
print_wierd_var attr82
print_wierd_var attr83
print_wierd_var attr84
print_wierd_var attr85
print_wierd_var attr86
print_wierd_var attr87
print_wierd_var attr88
print_wierd_var attr89
print_wierd_var attr90
print_wierd_var attr91
print_wierd_var attr92
print_wierd_var attr93
print_wierd_var attr94
print_wierd_var attr95
print_wierd_var attr96
print_wierd_var attr97
print_wierd_var attr98
print_wierd_var attr99
print_wierd_var attr100
print_wierd_var attr101
print_wierd_var attr102
print_wierd_var attr103
print_wierd_var attr104
print_wierd_var attr105
print_wierd_var attr106
print_wierd_var attr107
print_wierd_var attr108
print_wierd_var attr109
print_wierd_var attr110
print_wierd_var attr111
print_wierd_var attr112
print_wierd_var attr113
print_wierd_var attr114
print_wierd_var attr115
print_wierd_var attr116
print_wierd_var attr117
print_wierd_var attr118
print_wierd_var attr119
print_wierd_var attr120
print_wierd_var attr121
print_wierd_var attr122
print_wierd_var attr123
print_wierd_var attr124
print_wierd_var attr125
print_wierd_var attr126
gdb_test "p const69" " = 69" "'e' constant on non-enum type"
gdb_test "whatis const69" "type = (unsigned int|inttype)" "whatis const69"
# Haven't investigated
setup_xfail "*-*-*"
gdb_test "p sizeof (const70)" " = 2" "'e' constant with embedded type"
# field3 is printing out a bogus value; haven't investigated
setup_xfail "*-*-*"
gdb_test "p bad_neg0" " = \{field0 = 42, field2 =.*field3 = 45\}" "p bad_neg0"
# test that it at least gets field0 right
gdb_test "p bad_neg0" " = \{field0 = 42, field2 =" "p bad_neg0, test 2"
gdb_test "ptype inttype" "type = (unsigned int|inttype)" "ptype on inttype"
gdb_test "p sizeof (float72type)" " = 9" "unrecognized floating point type"
gdb_test "p/x int256var" " = 0x0*2a0000002b0000002c0000002d\
0000002d0000002c0000002b0000002a" "print very big integer"
gdb_test "whatis consth" "type = inttype" "whatis consth"
gdb_test "whatis consth2" "type = inttype" "whatis consth2"
# GDB does not yet understand S constants
setup_xfail "*-*-*"
gdb_test "p/x bad_neg0const" " = \{field0 = 0x11222211, field2 =.*\
field3 = 0x77888877\}" "print struct constant"
gdb_test "ptype bad_type0" "type = " "print bad_type0"
gdb_test "ptype bad_type1" "type = " "print bad_type1"
# GDB does not yet support arrays indexed by anything at all unusual
setup_xfail "*-*-*"
gdb_test "p array0" " = \{42, 43, 44, 45, 46, 47\}" "array0 with strange index"
setup_xfail "*-*-*"
gdb_test "p array1" " = \{42, 43, 44\}" "array1 with strange index"
# GDB does not yet support this feature
setup_xfail "*-*-*"
gdb_test "whatis one_var" "type = inttype_one" "whatis one_var"
# But do make sure that it prints as something reasonable
gdb_test "whatis one_var" "type = inttype(|_one)" "whatis one_var test 2"
setup_xfail "*-*-*"
gdb_test "whatis two_var" "type = inttype_two" "whatis two_var"
gdb_test "whatis two_var" "type = inttype(|_two)" "whatis two_var test 2"
setup_xfail "*-*-*"
gdb_test "whatis pointer_to_int_var" "type = int \*" "whatis p t i v"
setup_xfail "*-*-*"
gdb_test "whatis intp_var" "type = intp" "whatis intp_var"
# xcoffread.c doesn't understand common blocks at all
setup_xfail "rs6*-*-aix*"
gdb_test "p common0var0" "= 42"
# GDB seems to only understand common blocks local to a function.
# These variables never get relocated to be relative to the common
# block.
# I'm not sure whether it is valid to have a common block which
# is not local to a function.
setup_xfail "*-*-*"
gdb_test "p common0var1" "= 24"
setup_xfail "*-*-*"
gdb_test "p common0var2" "= 22"
gdb_test "p v_comb" "{<> = \
{<> = {x = 42}, \[_a-zA-Z$\]* = \[0-9xa-fA-F\]*, a = 43}, \
<> = {\[_a-zA-Z$\]* = \[0-9xa-fA-F\]*, b = 44}, comb = 45}"
}
proc print_wierd_var { var } {
global prompt
# Make sure that the variable gets printed out correctly, without
# any sort of warning message.
send "print $var\n"
expect {
-re "^print $var\r*\n.\[0-9\]* = 42.*$prompt $" {
pass "variable $var printed properly"
}
-re ".*$prompt $" {
fail "variable $var not printed properly"
}
timeout { fail "variable $var not printed (timeout)" }
eof { fail "(eof) variable $var not printed" }
}
# Make sure that the stabs did get loaded in a sensible way.
# If somehow the stabs got skipped, then the above test can
# pass because GDB assumes int for variables without a stab.
gdb_test "whatis $var" "type = (unsigned int|inttype)" "whatis on $var"
}
# Start with a fresh gdb
gdb_exit
gdb_start
gdb_reinitialize_dir $srcdir/$subdir
# Don't use gdb_load; it doesn't bitch if the loading produced some
# error messages during symbol reading.
set binfile $objdir/$subdir/wierd.o
if ![file exists $binfile] then {
warning "$binfile does not exist; tests suppressed"
} else {
# xcoffread.c wrongly bitches about the lack of a text section.
setup_xfail "rs*-*-aix*"
send "file $binfile\n"
expect {
-re "^file $binfile\r*\nReading symbols from $binfile\.\.\.done\.\r*\n$prompt $" {
pass "wierd.o read without error"
}
-re ".*$prompt $" {
fail "Errors reading wierd.o"
}
timeout {
error "couldn't load $binfile into $GDB (timed out)."
return -1
}
eof { fail "(eof) cannot read wierd.o" }
}
do_tests
}
return 0
|
