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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-7.2/] [gdb/] [testsuite/] [gdb.threads/] [tls.exp] - Blame information for rev 330

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 330 jeremybenn
# tls.exp -- Expect script to test thread-local storage
2
# Copyright (C) 1992, 2003, 2007, 2008, 2009, 2010
3
# Free Software Foundation, Inc.
4
 
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.
9
#
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.
14
#
15
# You should have received a copy of the GNU General Public License
16
# along with this program.  If not, see .  */
17
 
18
set testfile tls
19
set testfile2 tls2
20
set srcfile ${testfile}.c
21
set srcfile2 ${testfile2}.c
22
set binfile ${objdir}/${subdir}/${testfile}
23
 
24
if [istarget "*-*-linux"] then {
25
    set target_cflags "-D_MIT_POSIX_THREADS"
26
} else {
27
    set target_cflags ""
28
}
29
 
30
if {[gdb_compile_pthreads "${srcdir}/${subdir}/${srcfile} ${srcdir}/${subdir}/${srcfile2}" "${binfile}" executable [list debug "incdir=${objdir}"]] != "" } {
31
    return -1
32
}
33
 
34
### Compute the value of the a_thread_local variable.
35
proc compute_expected_value {value} {
36
    set expected_value 0
37
    set i 0
38
    while { $i <= $value} {
39
        incr expected_value $i
40
        incr i
41
    }
42
    return $expected_value
43
}
44
 
45
### Get the value of the variable 'me' for the current thread.
46
proc get_me_variable {tnum} {
47
    global expect_out
48
    global gdb_prompt
49
    global decimal
50
 
51
    set value_of_me -1
52
    send_gdb "print me\n"
53
    gdb_expect {
54
        -re ".*= ($decimal).*\r\n$gdb_prompt $" {
55
            set value_of_me $expect_out(1,string)
56
            pass "$tnum thread print me"
57
        }
58
        -re "$gdb_prompt $" {
59
            fail "$tnum thread print me"
60
        }
61
        timeout {
62
            fail "$tnum thread print me (timeout)"
63
        }
64
    }
65
    return ${value_of_me}
66
}
67
 
68
### Check the values of the thread local variables in the thread.
69
### Also check that info address print the right things.
70
proc check_thread_local {number} {
71
    set me_variable [get_me_variable $number]
72
    set expected_value [compute_expected_value ${me_variable}]
73
 
74
    gdb_test "p a_thread_local" \
75
            "= $expected_value" \
76
            "${number} thread local storage"
77
 
78
    gdb_test "p another_thread_local" \
79
            "= $me_variable" \
80
            "${number} another thread local storage"
81
 
82
    gdb_test "info address a_thread_local" \
83
            ".*a_thread_local.*a thread-local variable at offset.*" \
84
            "${number} info address a_thread_local"
85
 
86
    gdb_test "info address another_thread_local" \
87
            ".*another_thread_local.*a thread-local variable at offset.*" \
88
            "${number} info address another_thread_local"
89
}
90
 
91
### Select a particular thread.
92
proc select_thread {thread} {
93
    global gdb_prompt
94
 
95
    send_gdb "thread $thread\n"
96
    gdb_expect {
97
        -re "\\\[Switching to thread .*\\\].*\r\n$gdb_prompt $" {
98
            pass "selected thread: $thread"
99
        }
100
        -re "$gdb_prompt $" {
101
            fail "selected thread: $thread"
102
        }
103
        timeout {
104
            fail "selected thread: $thread (timeout)"
105
        }
106
    }
107
}
108
 
109
### Do a backtrace for the current thread, and check that the 'spin' routine
110
### is in it. This means we have one of the threads we created, rather
111
### than the main thread. Record the thread in the spin_threads
112
### array. Also remember the level of the 'spin' routine in the backtrace, for
113
### later use.
114
proc check_thread_stack {number spin_threads spin_threads_level} {
115
    global gdb_prompt
116
    global expect_out
117
    global decimal
118
    global hex
119
    upvar $spin_threads tarr
120
    upvar $spin_threads_level tarrl
121
 
122
    select_thread $number
123
    send_gdb "where\n"
124
    gdb_expect {
125
        -re ".*(\[0-9\]+)\[ \t\]+$hex in spin \\(vp=(0x\[0-9a-f\]+).*\r\n$gdb_prompt $" {
126
            if {[info exists tarr($number)]} {
127
                fail "backtrace of thread number $number in spin"
128
            } else {
129
                pass "backtrace of thread number $number in spin"
130
                set level $expect_out(1,string)
131
                set tarrl($number) $level
132
                set tarr($number) 1
133
            }
134
        }
135
        -re ".*$gdb_prompt $" {
136
         set tarr($number) 0
137
         set tarrl($number) 0
138
         pass "backtrace of thread number $number not relevant"
139
        }
140
        timeout {
141
            fail "backtrace of thread number $number (timeout)"
142
        }
143
    }
144
}
145
 
146
gdb_exit
147
gdb_start
148
gdb_reinitialize_dir $srcdir/$subdir
149
 
150
gdb_load ${binfile}
151
if ![runto_main] then {
152
   fail "Can't run to main"
153
   return 0
154
}
155
 
156
# Set a breakpoint at the "spin" routine to
157
# test the thread local's value.
158
#
159
gdb_test "b [gdb_get_line_number "here we know tls value"]" \
160
         ".*Breakpoint 2.*tls.*"   "set breakpoint at all threads"
161
 
162
# Set a bp at a point where we know all threads are alive.
163
#
164
gdb_test "b [gdb_get_line_number "still alive"]" \
165
         ".*Breakpoint 3.*tls.*" "set breakpoint at synch point"
166
 
167
# Set a bp at the end to see if all threads are finished.
168
#
169
gdb_test "b [gdb_get_line_number "before exit"]" \
170
         ".*Breakpoint 4.*tls.*" "set breakpoint at exit"
171
 
172
send_gdb "continue\n"
173
gdb_expect {
174
    -re ".*Program received signal SIGSEGV.*a_thread_local = 0;.*$gdb_prompt $" {
175
        # This is the first symptom if the gcc and binutils versions
176
        # in use support TLS, but the system glibc does not.
177
        unsupported "continue to first thread: system does not support TLS"
178
        return -1
179
    }
180
    -re ".*Program exited normally.*$gdb_prompt $" {
181
        fail "continue to first thread: program runaway"
182
    }
183
    -re ".*Pass 0 done.*Pass 1 done.*$gdb_prompt $" {
184
        fail "continue to first thread: program runaway 2"
185
    }
186
    -re ".*Breakpoint 2.*tls value.*$gdb_prompt $" {
187
        pass "continue to first thread: get to thread"
188
    }
189
    -re ".*$gdb_prompt $" {
190
        fail "continue to first thread: no progress?"
191
    }
192
    timeout { fail "continue to first thread (timeout)" }
193
}
194
 
195
gdb_test "info thread" ".*Thread.*spin.*" \
196
        "at least one th in spin while stopped at first th"
197
 
198
check_thread_local "first"
199
 
200
gdb_test "continue" ".*Breakpoint 2.*tls value.*" "continue to second thread"
201
gdb_test "info thread" "Thread.*spin.*" \
202
        "at least one th in spin while stopped at second th"
203
 
204
check_thread_local "second"
205
 
206
gdb_test "continue" ".*Breakpoint 2.*tls value.*" "continue to third thread"
207
gdb_test "info thread" ".*Thread.*spin.*" \
208
        "at least one th in spin while stopped at third th"
209
 
210
check_thread_local "third"
211
 
212
gdb_test "continue" ".*Breakpoint 3.*still alive.*" "continue to synch point"
213
 
214
set no_of_threads 0
215
send_gdb "info thread\n"
216
gdb_expect {
217
        -re "^info thread\[ \t\r\n\]+(\[0-9\]+) Thread.*$gdb_prompt $" {
218
           set no_of_threads $expect_out(1,string)
219
           pass "get number of threads"
220
        }
221
        -re "$gdb_prompt $" {
222
            fail "get number of threads"
223
        }
224
        timeout {
225
            fail "get number of threads (timeout)"
226
        }
227
}
228
 
229
array set spin_threads {}
230
unset spin_threads
231
array set spin_threads_level {}
232
unset spin_threads_level
233
 
234
# For each thread check its backtrace to see if it is stopped at the
235
# spin routine.
236
for {set i 1} {$i <= $no_of_threads} {incr i} {
237
    check_thread_stack $i spin_threads spin_threads_level
238
}
239
 
240
### Loop through the threads and check the values of the tls variables.
241
### keep track of how many threads we find in the spin routine.
242
set thrs_in_spin 0
243
foreach i [array names spin_threads] {
244
    if {$spin_threads($i) == 1} {
245
      incr thrs_in_spin
246
      select_thread $i
247
      set level $spin_threads_level($i)
248
      # We expect to be in sem_wait, but if the thread has not yet
249
      # been scheduled, we might be in sem_post still.  We could be at
250
      # any intermediate point in spin, too, but that is much less
251
      # likely.
252
      gdb_test "up $level" ".*spin.*sem_(wait|post).*" "thread $i up"
253
      check_thread_local $i
254
    }
255
}
256
 
257
if {$thrs_in_spin == 0} {
258
  fail "No thread backtrace reported spin (vsyscall kernel problem?)"
259
}
260
 
261
gdb_test "continue" ".*Breakpoint 4.*before exit.*" "threads exited"
262
 
263
send_gdb "info thread\n"
264
gdb_expect {
265
    -re ".* 1 Thread.*2 Thread.*$gdb_prompt $" {
266
        fail "Too many threads left at end"
267
    }
268
    -re ".*\\\* 1 Thread.*main.*$gdb_prompt $" {
269
        pass "Expect only base thread at end"
270
    }
271
    -re ".*No stack.*$gdb_prompt $" {
272
        fail "runaway at end"
273
    }
274
    -re ".*$gdb_prompt $" {
275
        fail "mess at end"
276
    }
277
    timeout { fail "at end (timeout)" }
278
}
279
 
280
# Start over and do some "info address" stuff
281
#
282
runto spin
283
 
284
gdb_test "info address a_global" \
285
        ".*a_global.*static storage at address.*" "info address a_global"
286
 
287
setup_kfail "gdb/1294" "*-*-*"
288
gdb_test "info address me" ".*me.*is a variable at offset.*" "info address me"
289
 
290
 
291
# Test LOC_UNRESOLVED references resolving for `extern' TLS variables.
292
 
293
gdb_test "p a_thread_local" " = \[0-9\]+"
294
# Here it could crash with: Cannot access memory at address 0x0
295
gdb_test "p file2_thread_local" " = \[0-9\]+"
296
# Depending on the current lookup scope we get LOC_UNRESOLVED or LOC_COMPUTED
297
# both printing:
298
# Symbol "file2_thread_local" is a thread-local variable at offset 8 in the thread-local storage for `.../gdb.threads/tls'.
299
gdb_test "info address file2_thread_local" "Symbol \"file2_thread_local\" is a thread-local variable.*"
300
# Here it could also crash with: Cannot access memory at address 0x0
301
gdb_test "p a_thread_local" " = \[0-9\]+" "p a_thread_local second time"
302
gdb_test "info address a_thread_local" "Symbol \"a_thread_local\" is a thread-local variable.*"
303
 
304
# Done!
305
#
306
gdb_exit
307
 
308
return 0

powered by: WebSVN 2.1.0

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