gdb/testsuite/gdb.threads/tls.exp

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