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
|
# Copyright 2011-2020 Free Software Foundation, Inc.
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
if {[skip_shlib_tests]} {
untested "skipping shared library tests"
return -1
}
if {[get_compiler_info]} {
untested "could not get compiler info"
return 1
}
# The main code that loads and registers JIT objects.
set main_basename jit-elf-main
set main_srcfile ${srcdir}/${subdir}/${main_basename}.c
set main_binfile [standard_output_file ${main_basename}]
# The shared library that gets loaded as JIT objects.
set jit_solib_basename jit-elf-solib
set jit_solib_srcfile ${srcdir}/${subdir}/${jit_solib_basename}.c
# Compile jit-elf-main.c as an executable.
#
# BINSUFFIX is appended to the binary name.
# OPTIONS is passed to gdb_compile when compiling the program.
#
# On success, return 0.
# On failure, return -1.
proc compile_jit_main {binsuffix options} {
global main_binfile main_srcfile main_basename
set binfile ${main_binfile}${binsuffix}
set options [concat $options debug]
if { [gdb_compile ${main_srcfile} ${binfile} \
executable $options] != "" } {
untested "failed to compile ${main_basename}.c"
return -1
}
return 0
}
# Compile jit-elf-solib.c as a shared library in multiple copies and
# upload them to the target.
#
# On success, return a list of target paths to the shared libraries.
# On failure, return -1.
proc compile_and_download_n_jit_so {count} {
global jit_solib_basename jit_solib_srcfile
set binfiles_target {}
for {set i 1} {$i <= $count} {incr i} {
set binfile [standard_output_file ${jit_solib_basename}.$i.so]
# Note: compiling without debug info by default: some test
# do symbol renaming by munging on ELF symbol table, and that
# wouldn't work for .debug sections. Also, output for "info
# function" changes when debug info is present.
if { [gdb_compile_shlib ${jit_solib_srcfile} ${binfile} {}] != "" } {
untested "failed to compile ${jit_solib_basename}.c as a shared library"
return -1
}
set path [gdb_remote_download target ${binfile}]
lappend binfiles_target $path
}
return $binfiles_target
}
# Detach, restart GDB, and re-attach to the program.
proc clean_reattach {} {
global decimal gdb_prompt
global main_binfile main_srcfile
# Get PID of test program.
set testpid -1
set test "get inferior process ID"
gdb_test_multiple "p mypid" $test {
-re ".* = ($decimal).*$gdb_prompt $" {
set testpid $expect_out(1,string)
pass $test
}
}
gdb_test_no_output "set var wait_for_gdb = 1"
gdb_test "detach" "Detaching from .*"
clean_restart ${main_binfile}
set test "attach"
gdb_test_multiple "attach $testpid" "$test" {
-re "Attaching to program.*.*main.*at .*$main_srcfile:.*$gdb_prompt $" {
pass "$test"
}
}
gdb_test_no_output "set var wait_for_gdb = 0"
}
# Continue to LOCATION in the program. If REATTACH, detach and
# re-attach to the program from scratch.
proc continue_to_test_location {location reattach} {
global main_srcfile
gdb_breakpoint [gdb_get_line_number $location $main_srcfile]
gdb_continue_to_breakpoint $location
if {$reattach} {
with_test_prefix "$location" {
clean_reattach
}
}
}
proc one_jit_test {jit_solibs_target match_str reattach} {
set count [llength $jit_solibs_target]
with_test_prefix "one_jit_test-$count" {
global verbose
global main_binfile main_srcfile
clean_restart ${main_binfile}
# This is just to help debugging when things fail
if {$verbose > 0} {
gdb_test "set debug jit 1"
}
if { ![runto_main] } {
fail "can't run to main"
return
}
# Poke desired values directly into inferior instead of using "set args"
# because "set args" does not work under gdbserver.
incr count
gdb_test_no_output "set var argc=$count" "forging argc"
gdb_test_no_output "set var argv=fake_argv" "forging argv"
for {set i 1} {$i < $count} {incr i} {
set jit_solib_target [lindex $jit_solibs_target [expr $i-1]]
gdb_test_no_output "set var argv\[$i\]=\"${jit_solib_target}\"" \
"forging argv\[$i\]"
}
gdb_breakpoint [gdb_get_line_number "break here 0" $main_srcfile]
gdb_continue_to_breakpoint "break here 0"
continue_to_test_location "break here 1" $reattach
gdb_test "info function ^jit_function" "$match_str"
# This is just to help debugging when things fail
if {$verbose > 0} {
gdb_test "maintenance print objfiles"
gdb_test "maintenance info break"
}
continue_to_test_location "break here 2" $reattach
# All jit librares must have been unregistered
gdb_test "info function jit_function" \
"All functions matching regular expression \"jit_function\":"
}
}
# Compile two shared libraries to use as JIT objects.
set jit_solibs_target [compile_and_download_n_jit_so 2]
if { $jit_solibs_target == -1 } {
return
}
# Compile the main code (which loads the JIT objects).
if { [compile_jit_main "" {}] == 0 } {
one_jit_test [lindex $jit_solibs_target 0] "${hex} jit_function_0001" 0
one_jit_test $jit_solibs_target "${hex} jit_function_0001\[\r\n\]+${hex} jit_function_0002" 0
}
# Test attaching to an inferior with some JIT libraries already
# registered. We reuse the normal test, and detach/reattach at
# specific interesting points.
if {[can_spawn_for_attach]} {
if { [compile_jit_main "-attach" {additional_flags=-DATTACH=1}] == 0 } {
with_test_prefix attach {
one_jit_test $jit_solibs_target "${hex} jit_function_0001\[\r\n\]+${hex} jit_function_0002" 1
}
}
}
if { [compile_jit_main "-pie" {additional_flags=-fPIE ldflags=-pie}] == 0 } {
with_test_prefix PIE {
one_jit_test [lindex $jit_solibs_target 0] "${hex} jit_function_0001" 0
}
}
|
