1 # This testcase is part of GDB, the GNU debugger.
3 # Copyright 2002-2004, 2007-2012 Free Software Foundation, Inc.
5 # This program is free software; you can redistribute it and/or modify
6 # it under the terms of the GNU General Public License as published by
7 # the Free Software Foundation; either version 3 of the License, or
8 # (at your option) any later version.
10 # This program is distributed in the hope that it will be useful,
11 # but WITHOUT ANY WARRANTY; without even the implied warranty of
12 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 # GNU General Public License for more details.
15 # You should have received a copy of the GNU General Public License
16 # along with this program. If not, see <http://www.gnu.org/licenses/>.
19 # test running programs
23 set srcfile ${testfile}.c
24 set binfile ${objdir}/${subdir}/${testfile}
25 if { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}] != "" } {
30 if [get_compiler_info] {
36 gdb_reinitialize_dir $srcdir/$subdir
40 # set it up at a breakpoint so we can play with the variable values
43 if ![runto_main] then {
44 perror "couldn't run to breakpoint"
50 proc check_set { t l r new add } {
53 set prefix "var ${t} l"
54 gdb_test "tbreak wack_${t}"
56 set test "continue to wack_${t}"
57 gdb_test_multiple "continue" $test {
58 -re "register ${t} l = u, r = v;\r\n$gdb_prompt $" {
59 # See GCC PR debug/53948.
63 -re "l = add_${t} .l, r.;\r\n$gdb_prompt $" {
68 gdb_test "print l" " = ${l}" \
69 "${prefix}; print old l, expecting ${l}"
70 gdb_test "print r" " = ${r}" \
71 "${prefix}; print old r, expecting ${r}"
72 gdb_test_no_output "set variable l = 4" \
73 "${prefix}; setting l to 4"
74 gdb_test "print l" " = ${new}" \
75 "${prefix}; print new l, expecting ${new}"
76 gdb_test "next" "return l \\+ r;" \
77 "${prefix}; next over add call"
78 gdb_test "print l" " = ${add}" \
79 "${prefix}; print incremented l, expecting ${add}"
82 check_set "charest" "-1 .*" "-2 .*" "4 ..004." "2 ..002."
83 check_set "short" "-1" "-2" "4" "2"
84 check_set "int" "-1" "-2" "4" "2"
85 check_set "long" "-1" "-2" "4" "2"
86 check_set "longest" "-1" "-2" "4" "2"
87 check_set "float" "-1" "-2" "4" "2"
88 check_set "double" "-1" "-2" "4" "2"
89 check_set "doublest" "-1" "-2" "4" "2"
93 proc up_set { t l r new } {
94 set prefix "upvar ${t} l"
95 gdb_test "tbreak add_${t}"
96 gdb_test "continue" "return u . v;" \
97 "continue to add_${t}"
98 gdb_test "up" "l = add_${t} .l, r.;" \
100 gdb_test "print l" " = ${l}" \
101 "${prefix}; print old l, expecting ${l}"
102 gdb_test "print r" " = ${r}" \
103 "${prefix}; print old r, expecting ${r}"
104 gdb_test_no_output "set variable l = 4" \
105 "${prefix}; set l to 4"
106 gdb_test "print l" " = ${new}" \
107 "${prefix}; print new l, expecting ${new}"
110 up_set "charest" "-1 .*" "-2 .*" "4 ..004."
111 up_set "short" "-1" "-2" "4"
112 up_set "int" "-1" "-2" "4"
113 up_set "long" "-1" "-2" "4"
114 up_set "longest" "-1" "-2" "4"
115 up_set "float" "-1" "-2" "4"
116 up_set "double" "-1" "-2" "4"
117 up_set "doublest" "-1" "-2" "4"
121 proc check_struct { t old new } {
122 set prefix "var struct ${t} u"
123 gdb_test "tbreak wack_struct_${t}"
124 gdb_test "continue" "int i; register struct s_${t} u = z_${t};" \
125 "continue to wack_struct_${t}"
126 gdb_test "next 2" "add_struct_${t} .u.;" \
127 "${prefix}; next to add_struct_${t} call"
128 gdb_test "print u" " = ${old}" \
129 "${prefix}; print old u, expecting ${old}"
130 gdb_test_no_output "set variable u = s_${t}" \
131 "${prefix}; set u to s_${t}"
132 gdb_test "print u" " = ${new}" \
133 "${prefix}; print new u, expecting ${new}"
136 check_struct "1" "{s = \\{0}}" "{s = \\{1}}"
137 check_struct "2" "{s = \\{0, 0}}" "{s = \\{1, 2}}"
138 check_struct "3" "{s = \\{0, 0, 0}}" "{s = \\{1, 2, 3}}"
139 check_struct "4" "{s = \\{0, 0, 0, 0}}" "{s = \\{1, 2, 3, 4}}"
141 proc up_struct { t old new } {
142 set prefix "up struct ${t} u"
143 gdb_test "tbreak add_struct_${t}"
144 gdb_test "continue" "for .i = 0; i < sizeof .s. / sizeof .s.s.0..; i..." \
145 "continue to add_struct_${t}"
146 gdb_test "up" "u = add_struct_${t} .u.;" \
148 gdb_test "print u" " = ${old}" \
149 "${prefix}; print old u, expecting ${old}"
150 gdb_test_no_output "set variable u = s_${t}" \
151 "${prefix}; set u to s_${t}"
152 gdb_test "print u" " = ${new}" \
153 "${prefix}; print new u, expecting ${new}"
156 up_struct "1" "{s = \\{0}}" "{s = \\{1}}"
157 up_struct "2" "{s = \\{0, 0}}" "{s = \\{1, 2}}"
158 up_struct "3" "{s = \\{0, 0, 0}}" "{s = \\{1, 2, 3}}"
159 up_struct "4" "{s = \\{0, 0, 0, 0}}" "{s = \\{1, 2, 3, 4}}"
163 proc check_field { t } {
165 gdb_test "tbreak wack_field_${t}"
166 gdb_test "continue" "register struct f_${t} u = f_${t};" \
167 "continue field ${t}"
169 # Match either the return statement, or the line immediatly after
170 # it. The compiler can end up merging the return statement into
171 # the return instruction.
172 gdb_test "next" "(return u;|\})" "next field ${t}"
174 gdb_test "print u" " = {i = 1, j = 1, k = 1}" "old field ${t}"
175 gdb_test_no_output "set variable u = F_${t}"
176 gdb_test "print u" " = {i = 0, j = 0, k = 0}" "new field ${t}"
178 gdb_test_no_output "set variable u = F_${t}, u.i = f_${t}.i"
179 gdb_test "print u" " = {i = 1, j = 0, k = 0}" "f_${t}.i"
181 gdb_test_no_output "set variable u = F_${t}, u.j = f_${t}.j"
182 gdb_test "print u" " = {i = 0, j = 1, k = 0}" "f_${t}.j"
184 gdb_test_no_output "set variable u = F_${t}, u.k = f_${t}.k"
185 gdb_test "print u" " = {i = 0, j = 0, k = 1}" "f_${t}.k"
187 gdb_test_no_output "set variable u = f_${t}, u.i = F_${t}.i"
188 gdb_test "print u" " = {i = 0, j = 1, k = 1}" "F_${t}.i"
190 gdb_test_no_output "set variable u = f_${t}, u.j = F_${t}.j"
191 gdb_test "print u" " = {i = 1, j = 0, k = 1}" "F_${t}.j"
193 gdb_test_no_output "set variable u = f_${t}, u.k = F_${t}.k"
194 gdb_test "print u" " = {i = 1, j = 1, k = 0}" "F_${t}.k"
205 # WANTED: A fairly portable way of convincing the compiler to split a
206 # value across memory and registers.