aix-thread.c revision 1.1
1/* Low level interface for debugging AIX 4.3+ pthreads. 2 3 Copyright (C) 1999-2014 Free Software Foundation, Inc. 4 Written by Nick Duffek <nsd@redhat.com>. 5 6 This file is part of GDB. 7 8 This program is free software; you can redistribute it and/or modify 9 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation; either version 3 of the License, or 11 (at your option) any later version. 12 13 This program is distributed in the hope that it will be useful, 14 but WITHOUT ANY WARRANTY; without even the implied warranty of 15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 GNU General Public License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 20 21 22/* This module uses the libpthdebug.a library provided by AIX 4.3+ for 23 debugging pthread applications. 24 25 Some name prefix conventions: 26 pthdb_ provided by libpthdebug.a 27 pdc_ callbacks that this module provides to libpthdebug.a 28 pd_ variables or functions interfacing with libpthdebug.a 29 30 libpthdebug peculiarities: 31 32 - pthdb_ptid_pthread() is prototyped in <sys/pthdebug.h>, but 33 it's not documented, and after several calls it stops working 34 and causes other libpthdebug functions to fail. 35 36 - pthdb_tid_pthread() doesn't always work after 37 pthdb_session_update(), but it does work after cycling through 38 all threads using pthdb_pthread(). 39 40 */ 41 42#include "defs.h" 43#include "gdb_assert.h" 44#include "gdbthread.h" 45#include "target.h" 46#include "inferior.h" 47#include "regcache.h" 48#include "gdbcmd.h" 49#include "ppc-tdep.h" 50#include <string.h> 51#include "observer.h" 52 53#include <procinfo.h> 54#include <sys/types.h> 55#include <sys/ptrace.h> 56#include <sys/reg.h> 57#include <sched.h> 58#include <sys/pthdebug.h> 59 60#if !HAVE_DECL_GETTHRDS 61extern int getthrds (pid_t, struct thrdsinfo64 *, int, tid_t *, int); 62#endif 63 64/* Whether to emit debugging output. */ 65static int debug_aix_thread; 66 67/* In AIX 5.1, functions use pthdb_tid_t instead of tid_t. */ 68#ifndef PTHDB_VERSION_3 69#define pthdb_tid_t tid_t 70#endif 71 72/* Return whether to treat PID as a debuggable thread id. */ 73 74#define PD_TID(ptid) (pd_active && ptid_get_tid (ptid) != 0) 75 76/* pthdb_user_t value that we pass to pthdb functions. 0 causes 77 PTHDB_BAD_USER errors, so use 1. */ 78 79#define PD_USER 1 80 81/* Success and failure values returned by pthdb callbacks. */ 82 83#define PDC_SUCCESS PTHDB_SUCCESS 84#define PDC_FAILURE PTHDB_CALLBACK 85 86/* Private data attached to each element in GDB's thread list. */ 87 88struct private_thread_info { 89 pthdb_pthread_t pdtid; /* thread's libpthdebug id */ 90 pthdb_tid_t tid; /* kernel thread id */ 91}; 92 93/* Information about a thread of which libpthdebug is aware. */ 94 95struct pd_thread { 96 pthdb_pthread_t pdtid; 97 pthread_t pthid; 98 pthdb_tid_t tid; 99}; 100 101/* This module's target-specific operations, active while pd_able is true. */ 102 103static struct target_ops aix_thread_ops; 104 105/* Address of the function that libpthread will call when libpthdebug 106 is ready to be initialized. */ 107 108static CORE_ADDR pd_brk_addr; 109 110/* Whether the current application is debuggable by pthdb. */ 111 112static int pd_able = 0; 113 114/* Whether a threaded application is being debugged. */ 115 116static int pd_active = 0; 117 118/* Whether the current architecture is 64-bit. 119 Only valid when pd_able is true. */ 120 121static int arch64; 122 123/* Forward declarations for pthdb callbacks. */ 124 125static int pdc_symbol_addrs (pthdb_user_t, pthdb_symbol_t *, int); 126static int pdc_read_data (pthdb_user_t, void *, pthdb_addr_t, size_t); 127static int pdc_write_data (pthdb_user_t, void *, pthdb_addr_t, size_t); 128static int pdc_read_regs (pthdb_user_t user, pthdb_tid_t tid, 129 unsigned long long flags, 130 pthdb_context_t *context); 131static int pdc_write_regs (pthdb_user_t user, pthdb_tid_t tid, 132 unsigned long long flags, 133 pthdb_context_t *context); 134static int pdc_alloc (pthdb_user_t, size_t, void **); 135static int pdc_realloc (pthdb_user_t, void *, size_t, void **); 136static int pdc_dealloc (pthdb_user_t, void *); 137 138/* pthdb callbacks. */ 139 140static pthdb_callbacks_t pd_callbacks = { 141 pdc_symbol_addrs, 142 pdc_read_data, 143 pdc_write_data, 144 pdc_read_regs, 145 pdc_write_regs, 146 pdc_alloc, 147 pdc_realloc, 148 pdc_dealloc, 149 NULL 150}; 151 152/* Current pthdb session. */ 153 154static pthdb_session_t pd_session; 155 156/* Return a printable representation of pthdebug function return 157 STATUS. */ 158 159static char * 160pd_status2str (int status) 161{ 162 switch (status) 163 { 164 case PTHDB_SUCCESS: return "SUCCESS"; 165 case PTHDB_NOSYS: return "NOSYS"; 166 case PTHDB_NOTSUP: return "NOTSUP"; 167 case PTHDB_BAD_VERSION: return "BAD_VERSION"; 168 case PTHDB_BAD_USER: return "BAD_USER"; 169 case PTHDB_BAD_SESSION: return "BAD_SESSION"; 170 case PTHDB_BAD_MODE: return "BAD_MODE"; 171 case PTHDB_BAD_FLAGS: return "BAD_FLAGS"; 172 case PTHDB_BAD_CALLBACK: return "BAD_CALLBACK"; 173 case PTHDB_BAD_POINTER: return "BAD_POINTER"; 174 case PTHDB_BAD_CMD: return "BAD_CMD"; 175 case PTHDB_BAD_PTHREAD: return "BAD_PTHREAD"; 176 case PTHDB_BAD_ATTR: return "BAD_ATTR"; 177 case PTHDB_BAD_MUTEX: return "BAD_MUTEX"; 178 case PTHDB_BAD_MUTEXATTR: return "BAD_MUTEXATTR"; 179 case PTHDB_BAD_COND: return "BAD_COND"; 180 case PTHDB_BAD_CONDATTR: return "BAD_CONDATTR"; 181 case PTHDB_BAD_RWLOCK: return "BAD_RWLOCK"; 182 case PTHDB_BAD_RWLOCKATTR: return "BAD_RWLOCKATTR"; 183 case PTHDB_BAD_KEY: return "BAD_KEY"; 184 case PTHDB_BAD_PTID: return "BAD_PTID"; 185 case PTHDB_BAD_TID: return "BAD_TID"; 186 case PTHDB_CALLBACK: return "CALLBACK"; 187 case PTHDB_CONTEXT: return "CONTEXT"; 188 case PTHDB_HELD: return "HELD"; 189 case PTHDB_NOT_HELD: return "NOT_HELD"; 190 case PTHDB_MEMORY: return "MEMORY"; 191 case PTHDB_NOT_PTHREADED: return "NOT_PTHREADED"; 192 case PTHDB_SYMBOL: return "SYMBOL"; 193 case PTHDB_NOT_AVAIL: return "NOT_AVAIL"; 194 case PTHDB_INTERNAL: return "INTERNAL"; 195 default: return "UNKNOWN"; 196 } 197} 198 199/* A call to ptrace(REQ, ID, ...) just returned RET. Check for 200 exceptional conditions and either return nonlocally or else return 201 1 for success and 0 for failure. */ 202 203static int 204ptrace_check (int req, int id, int ret) 205{ 206 if (ret == 0 && !errno) 207 return 1; 208 209 /* According to ptrace(2), ptrace may fail with EPERM if "the 210 Identifier parameter corresponds to a kernel thread which is 211 stopped in kernel mode and whose computational state cannot be 212 read or written." This happens quite often with register reads. */ 213 214 switch (req) 215 { 216 case PTT_READ_GPRS: 217 case PTT_READ_FPRS: 218 case PTT_READ_SPRS: 219 if (ret == -1 && errno == EPERM) 220 { 221 if (debug_aix_thread) 222 fprintf_unfiltered (gdb_stdlog, 223 "ptrace (%d, %d) = %d (errno = %d)\n", 224 req, id, ret, errno); 225 return ret == -1 ? 0 : 1; 226 } 227 break; 228 } 229 error (_("aix-thread: ptrace (%d, %d) returned %d (errno = %d %s)"), 230 req, id, ret, errno, safe_strerror (errno)); 231 return 0; /* Not reached. */ 232} 233 234/* Call ptracex (REQ, ID, ADDR, DATA, BUF) or 235 ptrace64 (REQ, ID, ADDR, DATA, BUF) if HAVE_PTRACE64. 236 Return success. */ 237 238#ifdef HAVE_PTRACE64 239# define ptracex(request, pid, addr, data, buf) \ 240 ptrace64 (request, pid, addr, data, buf) 241#endif 242 243static int 244ptrace64aix (int req, int id, long long addr, int data, int *buf) 245{ 246 errno = 0; 247 return ptrace_check (req, id, ptracex (req, id, addr, data, buf)); 248} 249 250/* Call ptrace (REQ, ID, ADDR, DATA, BUF) or 251 ptrace64 (REQ, ID, ADDR, DATA, BUF) if HAVE_PTRACE64. 252 Return success. */ 253 254#ifdef HAVE_PTRACE64 255# define ptrace(request, pid, addr, data, buf) \ 256 ptrace64 (request, pid, addr, data, buf) 257# define addr_ptr long long 258#else 259# define addr_ptr int * 260#endif 261 262static int 263ptrace32 (int req, int id, addr_ptr addr, int data, int *buf) 264{ 265 errno = 0; 266 return ptrace_check (req, id, 267 ptrace (req, id, addr, data, buf)); 268} 269 270/* If *PIDP is a composite process/thread id, convert it to a 271 process id. */ 272 273static void 274pid_to_prc (ptid_t *ptidp) 275{ 276 ptid_t ptid; 277 278 ptid = *ptidp; 279 if (PD_TID (ptid)) 280 *ptidp = pid_to_ptid (ptid_get_pid (ptid)); 281} 282 283/* pthdb callback: for <i> from 0 to COUNT, set SYMBOLS[<i>].addr to 284 the address of SYMBOLS[<i>].name. */ 285 286static int 287pdc_symbol_addrs (pthdb_user_t user, pthdb_symbol_t *symbols, int count) 288{ 289 struct minimal_symbol *ms; 290 int i; 291 char *name; 292 293 if (debug_aix_thread) 294 fprintf_unfiltered (gdb_stdlog, 295 "pdc_symbol_addrs (user = %ld, symbols = 0x%lx, count = %d)\n", 296 user, (long) symbols, count); 297 298 for (i = 0; i < count; i++) 299 { 300 name = symbols[i].name; 301 if (debug_aix_thread) 302 fprintf_unfiltered (gdb_stdlog, 303 " symbols[%d].name = \"%s\"\n", i, name); 304 305 if (!*name) 306 symbols[i].addr = 0; 307 else 308 { 309 if (!(ms = lookup_minimal_symbol (name, NULL, NULL))) 310 { 311 if (debug_aix_thread) 312 fprintf_unfiltered (gdb_stdlog, " returning PDC_FAILURE\n"); 313 return PDC_FAILURE; 314 } 315 symbols[i].addr = SYMBOL_VALUE_ADDRESS (ms); 316 } 317 if (debug_aix_thread) 318 fprintf_unfiltered (gdb_stdlog, " symbols[%d].addr = %s\n", 319 i, hex_string (symbols[i].addr)); 320 } 321 if (debug_aix_thread) 322 fprintf_unfiltered (gdb_stdlog, " returning PDC_SUCCESS\n"); 323 return PDC_SUCCESS; 324} 325 326/* Read registers call back function should be able to read the 327 context information of a debuggee kernel thread from an active 328 process or from a core file. The information should be formatted 329 in context64 form for both 32-bit and 64-bit process. 330 If successful return 0, else non-zero is returned. */ 331 332static int 333pdc_read_regs (pthdb_user_t user, 334 pthdb_tid_t tid, 335 unsigned long long flags, 336 pthdb_context_t *context) 337{ 338 /* This function doesn't appear to be used, so we could probably 339 just return 0 here. HOWEVER, if it is not defined, the OS will 340 complain and several thread debug functions will fail. In case 341 this is needed, I have implemented what I think it should do, 342 however this code is untested. */ 343 344 uint64_t gprs64[ppc_num_gprs]; 345 uint32_t gprs32[ppc_num_gprs]; 346 double fprs[ppc_num_fprs]; 347 struct ptxsprs sprs64; 348 struct ptsprs sprs32; 349 350 if (debug_aix_thread) 351 fprintf_unfiltered (gdb_stdlog, "pdc_read_regs tid=%d flags=%s\n", 352 (int) tid, hex_string (flags)); 353 354 /* General-purpose registers. */ 355 if (flags & PTHDB_FLAG_GPRS) 356 { 357 if (arch64) 358 { 359 if (!ptrace64aix (PTT_READ_GPRS, tid, 360 (unsigned long) gprs64, 0, NULL)) 361 memset (gprs64, 0, sizeof (gprs64)); 362 memcpy (context->gpr, gprs64, sizeof(gprs64)); 363 } 364 else 365 { 366 if (!ptrace32 (PTT_READ_GPRS, tid, (uintptr_t) gprs32, 0, NULL)) 367 memset (gprs32, 0, sizeof (gprs32)); 368 memcpy (context->gpr, gprs32, sizeof(gprs32)); 369 } 370 } 371 372 /* Floating-point registers. */ 373 if (flags & PTHDB_FLAG_FPRS) 374 { 375 if (!ptrace32 (PTT_READ_FPRS, tid, (uintptr_t) fprs, 0, NULL)) 376 memset (fprs, 0, sizeof (fprs)); 377 memcpy (context->fpr, fprs, sizeof(fprs)); 378 } 379 380 /* Special-purpose registers. */ 381 if (flags & PTHDB_FLAG_SPRS) 382 { 383 if (arch64) 384 { 385 if (!ptrace64aix (PTT_READ_SPRS, tid, 386 (unsigned long) &sprs64, 0, NULL)) 387 memset (&sprs64, 0, sizeof (sprs64)); 388 memcpy (&context->msr, &sprs64, sizeof(sprs64)); 389 } 390 else 391 { 392 if (!ptrace32 (PTT_READ_SPRS, tid, (uintptr_t) &sprs32, 0, NULL)) 393 memset (&sprs32, 0, sizeof (sprs32)); 394 memcpy (&context->msr, &sprs32, sizeof(sprs32)); 395 } 396 } 397 return 0; 398} 399 400/* Write register function should be able to write requested context 401 information to specified debuggee's kernel thread id. 402 If successful return 0, else non-zero is returned. */ 403 404static int 405pdc_write_regs (pthdb_user_t user, 406 pthdb_tid_t tid, 407 unsigned long long flags, 408 pthdb_context_t *context) 409{ 410 /* This function doesn't appear to be used, so we could probably 411 just return 0 here. HOWEVER, if it is not defined, the OS will 412 complain and several thread debug functions will fail. In case 413 this is needed, I have implemented what I think it should do, 414 however this code is untested. */ 415 416 if (debug_aix_thread) 417 fprintf_unfiltered (gdb_stdlog, "pdc_write_regs tid=%d flags=%s\n", 418 (int) tid, hex_string (flags)); 419 420 /* General-purpose registers. */ 421 if (flags & PTHDB_FLAG_GPRS) 422 { 423 if (arch64) 424 ptrace64aix (PTT_WRITE_GPRS, tid, 425 (unsigned long) context->gpr, 0, NULL); 426 else 427 ptrace32 (PTT_WRITE_GPRS, tid, (uintptr_t) context->gpr, 0, NULL); 428 } 429 430 /* Floating-point registers. */ 431 if (flags & PTHDB_FLAG_FPRS) 432 { 433 ptrace32 (PTT_WRITE_FPRS, tid, (uintptr_t) context->fpr, 0, NULL); 434 } 435 436 /* Special-purpose registers. */ 437 if (flags & PTHDB_FLAG_SPRS) 438 { 439 if (arch64) 440 { 441 ptrace64aix (PTT_WRITE_SPRS, tid, 442 (unsigned long) &context->msr, 0, NULL); 443 } 444 else 445 { 446 ptrace32 (PTT_WRITE_SPRS, tid, (uintptr_t) &context->msr, 0, NULL); 447 } 448 } 449 return 0; 450} 451 452/* pthdb callback: read LEN bytes from process ADDR into BUF. */ 453 454static int 455pdc_read_data (pthdb_user_t user, void *buf, 456 pthdb_addr_t addr, size_t len) 457{ 458 int status, ret; 459 460 if (debug_aix_thread) 461 fprintf_unfiltered (gdb_stdlog, 462 "pdc_read_data (user = %ld, buf = 0x%lx, addr = %s, len = %ld)\n", 463 user, (long) buf, hex_string (addr), len); 464 465 status = target_read_memory (addr, buf, len); 466 ret = status == 0 ? PDC_SUCCESS : PDC_FAILURE; 467 468 if (debug_aix_thread) 469 fprintf_unfiltered (gdb_stdlog, " status=%d, returning %s\n", 470 status, pd_status2str (ret)); 471 return ret; 472} 473 474/* pthdb callback: write LEN bytes from BUF to process ADDR. */ 475 476static int 477pdc_write_data (pthdb_user_t user, void *buf, 478 pthdb_addr_t addr, size_t len) 479{ 480 int status, ret; 481 482 if (debug_aix_thread) 483 fprintf_unfiltered (gdb_stdlog, 484 "pdc_write_data (user = %ld, buf = 0x%lx, addr = %s, len = %ld)\n", 485 user, (long) buf, hex_string (addr), len); 486 487 status = target_write_memory (addr, buf, len); 488 ret = status == 0 ? PDC_SUCCESS : PDC_FAILURE; 489 490 if (debug_aix_thread) 491 fprintf_unfiltered (gdb_stdlog, " status=%d, returning %s\n", status, 492 pd_status2str (ret)); 493 return ret; 494} 495 496/* pthdb callback: allocate a LEN-byte buffer and store a pointer to it 497 in BUFP. */ 498 499static int 500pdc_alloc (pthdb_user_t user, size_t len, void **bufp) 501{ 502 if (debug_aix_thread) 503 fprintf_unfiltered (gdb_stdlog, 504 "pdc_alloc (user = %ld, len = %ld, bufp = 0x%lx)\n", 505 user, len, (long) bufp); 506 *bufp = xmalloc (len); 507 if (debug_aix_thread) 508 fprintf_unfiltered (gdb_stdlog, 509 " malloc returned 0x%lx\n", (long) *bufp); 510 511 /* Note: xmalloc() can't return 0; therefore PDC_FAILURE will never 512 be returned. */ 513 514 return *bufp ? PDC_SUCCESS : PDC_FAILURE; 515} 516 517/* pthdb callback: reallocate BUF, which was allocated by the alloc or 518 realloc callback, so that it contains LEN bytes, and store a 519 pointer to the result in BUFP. */ 520 521static int 522pdc_realloc (pthdb_user_t user, void *buf, size_t len, void **bufp) 523{ 524 if (debug_aix_thread) 525 fprintf_unfiltered (gdb_stdlog, 526 "pdc_realloc (user = %ld, buf = 0x%lx, len = %ld, bufp = 0x%lx)\n", 527 user, (long) buf, len, (long) bufp); 528 *bufp = xrealloc (buf, len); 529 if (debug_aix_thread) 530 fprintf_unfiltered (gdb_stdlog, 531 " realloc returned 0x%lx\n", (long) *bufp); 532 return *bufp ? PDC_SUCCESS : PDC_FAILURE; 533} 534 535/* pthdb callback: free BUF, which was allocated by the alloc or 536 realloc callback. */ 537 538static int 539pdc_dealloc (pthdb_user_t user, void *buf) 540{ 541 if (debug_aix_thread) 542 fprintf_unfiltered (gdb_stdlog, 543 "pdc_free (user = %ld, buf = 0x%lx)\n", user, 544 (long) buf); 545 xfree (buf); 546 return PDC_SUCCESS; 547} 548 549/* Return a printable representation of pthread STATE. */ 550 551static char * 552state2str (pthdb_state_t state) 553{ 554 switch (state) 555 { 556 case PST_IDLE: 557 /* i18n: Like "Thread-Id %d, [state] idle" */ 558 return _("idle"); /* being created */ 559 case PST_RUN: 560 /* i18n: Like "Thread-Id %d, [state] running" */ 561 return _("running"); /* running */ 562 case PST_SLEEP: 563 /* i18n: Like "Thread-Id %d, [state] sleeping" */ 564 return _("sleeping"); /* awaiting an event */ 565 case PST_READY: 566 /* i18n: Like "Thread-Id %d, [state] ready" */ 567 return _("ready"); /* runnable */ 568 case PST_TERM: 569 /* i18n: Like "Thread-Id %d, [state] finished" */ 570 return _("finished"); /* awaiting a join/detach */ 571 default: 572 /* i18n: Like "Thread-Id %d, [state] unknown" */ 573 return _("unknown"); 574 } 575} 576 577/* qsort() comparison function for sorting pd_thread structs by pthid. */ 578 579static int 580pcmp (const void *p1v, const void *p2v) 581{ 582 struct pd_thread *p1 = (struct pd_thread *) p1v; 583 struct pd_thread *p2 = (struct pd_thread *) p2v; 584 return p1->pthid < p2->pthid ? -1 : p1->pthid > p2->pthid; 585} 586 587/* iterate_over_threads() callback for counting GDB threads. 588 589 Do not count the main thread (whose tid is zero). This matches 590 the list of threads provided by the pthreaddebug library, which 591 does not include that main thread either, and thus allows us 592 to compare the two lists. */ 593 594static int 595giter_count (struct thread_info *thread, void *countp) 596{ 597 if (PD_TID (thread->ptid)) 598 (*(int *) countp)++; 599 return 0; 600} 601 602/* iterate_over_threads() callback for accumulating GDB thread pids. 603 604 Do not include the main thread (whose tid is zero). This matches 605 the list of threads provided by the pthreaddebug library, which 606 does not include that main thread either, and thus allows us 607 to compare the two lists. */ 608 609static int 610giter_accum (struct thread_info *thread, void *bufp) 611{ 612 if (PD_TID (thread->ptid)) 613 { 614 **(struct thread_info ***) bufp = thread; 615 (*(struct thread_info ***) bufp)++; 616 } 617 return 0; 618} 619 620/* ptid comparison function */ 621 622static int 623ptid_cmp (ptid_t ptid1, ptid_t ptid2) 624{ 625 int pid1, pid2; 626 627 if (ptid_get_pid (ptid1) < ptid_get_pid (ptid2)) 628 return -1; 629 else if (ptid_get_pid (ptid1) > ptid_get_pid (ptid2)) 630 return 1; 631 else if (ptid_get_tid (ptid1) < ptid_get_tid (ptid2)) 632 return -1; 633 else if (ptid_get_tid (ptid1) > ptid_get_tid (ptid2)) 634 return 1; 635 else if (ptid_get_lwp (ptid1) < ptid_get_lwp (ptid2)) 636 return -1; 637 else if (ptid_get_lwp (ptid1) > ptid_get_lwp (ptid2)) 638 return 1; 639 else 640 return 0; 641} 642 643/* qsort() comparison function for sorting thread_info structs by pid. */ 644 645static int 646gcmp (const void *t1v, const void *t2v) 647{ 648 struct thread_info *t1 = *(struct thread_info **) t1v; 649 struct thread_info *t2 = *(struct thread_info **) t2v; 650 return ptid_cmp (t1->ptid, t2->ptid); 651} 652 653/* Search through the list of all kernel threads for the thread 654 that has stopped on a SIGTRAP signal, and return its TID. 655 Return 0 if none found. */ 656 657static pthdb_tid_t 658get_signaled_thread (void) 659{ 660 struct thrdsinfo64 thrinf; 661 tid_t ktid = 0; 662 int result = 0; 663 664 while (1) 665 { 666 if (getthrds (ptid_get_pid (inferior_ptid), &thrinf, 667 sizeof (thrinf), &ktid, 1) != 1) 668 break; 669 670 if (thrinf.ti_cursig == SIGTRAP) 671 return thrinf.ti_tid; 672 } 673 674 /* Didn't find any thread stopped on a SIGTRAP signal. */ 675 return 0; 676} 677 678/* Synchronize GDB's thread list with libpthdebug's. 679 680 There are some benefits of doing this every time the inferior stops: 681 682 - allows users to run thread-specific commands without needing to 683 run "info threads" first 684 685 - helps pthdb_tid_pthread() work properly (see "libpthdebug 686 peculiarities" at the top of this module) 687 688 - simplifies the demands placed on libpthdebug, which seems to 689 have difficulty with certain call patterns */ 690 691static void 692sync_threadlists (void) 693{ 694 int cmd, status, infpid; 695 int pcount, psize, pi, gcount, gi; 696 struct pd_thread *pbuf; 697 struct thread_info **gbuf, **g, *thread; 698 pthdb_pthread_t pdtid; 699 pthread_t pthid; 700 pthdb_tid_t tid; 701 702 /* Accumulate an array of libpthdebug threads sorted by pthread id. */ 703 704 pcount = 0; 705 psize = 1; 706 pbuf = (struct pd_thread *) xmalloc (psize * sizeof *pbuf); 707 708 for (cmd = PTHDB_LIST_FIRST;; cmd = PTHDB_LIST_NEXT) 709 { 710 status = pthdb_pthread (pd_session, &pdtid, cmd); 711 if (status != PTHDB_SUCCESS || pdtid == PTHDB_INVALID_PTHREAD) 712 break; 713 714 status = pthdb_pthread_ptid (pd_session, pdtid, &pthid); 715 if (status != PTHDB_SUCCESS || pthid == PTHDB_INVALID_PTID) 716 continue; 717 718 if (pcount == psize) 719 { 720 psize *= 2; 721 pbuf = (struct pd_thread *) xrealloc (pbuf, 722 psize * sizeof *pbuf); 723 } 724 pbuf[pcount].pdtid = pdtid; 725 pbuf[pcount].pthid = pthid; 726 pcount++; 727 } 728 729 for (pi = 0; pi < pcount; pi++) 730 { 731 status = pthdb_pthread_tid (pd_session, pbuf[pi].pdtid, &tid); 732 if (status != PTHDB_SUCCESS) 733 tid = PTHDB_INVALID_TID; 734 pbuf[pi].tid = tid; 735 } 736 737 qsort (pbuf, pcount, sizeof *pbuf, pcmp); 738 739 /* Accumulate an array of GDB threads sorted by pid. */ 740 741 gcount = 0; 742 iterate_over_threads (giter_count, &gcount); 743 g = gbuf = (struct thread_info **) xmalloc (gcount * sizeof *gbuf); 744 iterate_over_threads (giter_accum, &g); 745 qsort (gbuf, gcount, sizeof *gbuf, gcmp); 746 747 /* Apply differences between the two arrays to GDB's thread list. */ 748 749 infpid = ptid_get_pid (inferior_ptid); 750 for (pi = gi = 0; pi < pcount || gi < gcount;) 751 { 752 if (pi == pcount) 753 { 754 delete_thread (gbuf[gi]->ptid); 755 gi++; 756 } 757 else if (gi == gcount) 758 { 759 thread = add_thread (ptid_build (infpid, 0, pbuf[pi].pthid)); 760 thread->private = xmalloc (sizeof (struct private_thread_info)); 761 thread->private->pdtid = pbuf[pi].pdtid; 762 thread->private->tid = pbuf[pi].tid; 763 pi++; 764 } 765 else 766 { 767 ptid_t pptid, gptid; 768 int cmp_result; 769 770 pptid = ptid_build (infpid, 0, pbuf[pi].pthid); 771 gptid = gbuf[gi]->ptid; 772 pdtid = pbuf[pi].pdtid; 773 tid = pbuf[pi].tid; 774 775 cmp_result = ptid_cmp (pptid, gptid); 776 777 if (cmp_result == 0) 778 { 779 gbuf[gi]->private->pdtid = pdtid; 780 gbuf[gi]->private->tid = tid; 781 pi++; 782 gi++; 783 } 784 else if (cmp_result > 0) 785 { 786 delete_thread (gptid); 787 gi++; 788 } 789 else 790 { 791 thread = add_thread (pptid); 792 thread->private = xmalloc (sizeof (struct private_thread_info)); 793 thread->private->pdtid = pdtid; 794 thread->private->tid = tid; 795 pi++; 796 } 797 } 798 } 799 800 xfree (pbuf); 801 xfree (gbuf); 802} 803 804/* Iterate_over_threads() callback for locating a thread, using 805 the TID of its associated kernel thread. */ 806 807static int 808iter_tid (struct thread_info *thread, void *tidp) 809{ 810 const pthdb_tid_t tid = *(pthdb_tid_t *)tidp; 811 812 return (thread->private->tid == tid); 813} 814 815/* Synchronize libpthdebug's state with the inferior and with GDB, 816 generate a composite process/thread <pid> for the current thread, 817 set inferior_ptid to <pid> if SET_INFPID, and return <pid>. */ 818 819static ptid_t 820pd_update (int set_infpid) 821{ 822 int status; 823 ptid_t ptid; 824 pthdb_tid_t tid; 825 struct thread_info *thread = NULL; 826 827 if (!pd_active) 828 return inferior_ptid; 829 830 status = pthdb_session_update (pd_session); 831 if (status != PTHDB_SUCCESS) 832 return inferior_ptid; 833 834 sync_threadlists (); 835 836 /* Define "current thread" as one that just received a trap signal. */ 837 838 tid = get_signaled_thread (); 839 if (tid != 0) 840 thread = iterate_over_threads (iter_tid, &tid); 841 if (!thread) 842 ptid = inferior_ptid; 843 else 844 { 845 ptid = thread->ptid; 846 if (set_infpid) 847 inferior_ptid = ptid; 848 } 849 return ptid; 850} 851 852/* Try to start debugging threads in the current process. 853 If successful and SET_INFPID, set inferior_ptid to reflect the 854 current thread. */ 855 856static ptid_t 857pd_activate (int set_infpid) 858{ 859 int status; 860 861 status = pthdb_session_init (PD_USER, arch64 ? PEM_64BIT : PEM_32BIT, 862 PTHDB_FLAG_REGS, &pd_callbacks, 863 &pd_session); 864 if (status != PTHDB_SUCCESS) 865 { 866 return inferior_ptid; 867 } 868 pd_active = 1; 869 return pd_update (set_infpid); 870} 871 872/* Undo the effects of pd_activate(). */ 873 874static void 875pd_deactivate (void) 876{ 877 if (!pd_active) 878 return; 879 pthdb_session_destroy (pd_session); 880 881 pid_to_prc (&inferior_ptid); 882 pd_active = 0; 883} 884 885/* An object file has just been loaded. Check whether the current 886 application is pthreaded, and if so, prepare for thread debugging. */ 887 888static void 889pd_enable (void) 890{ 891 int status; 892 char *stub_name; 893 struct minimal_symbol *ms; 894 895 /* Don't initialize twice. */ 896 if (pd_able) 897 return; 898 899 /* Check application word size. */ 900 arch64 = register_size (target_gdbarch (), 0) == 8; 901 902 /* Check whether the application is pthreaded. */ 903 stub_name = NULL; 904 status = pthdb_session_pthreaded (PD_USER, PTHDB_FLAG_REGS, 905 &pd_callbacks, &stub_name); 906 if ((status != PTHDB_SUCCESS 907 && status != PTHDB_NOT_PTHREADED) || !stub_name) 908 return; 909 910 /* Set a breakpoint on the returned stub function. */ 911 if (!(ms = lookup_minimal_symbol (stub_name, NULL, NULL))) 912 return; 913 pd_brk_addr = SYMBOL_VALUE_ADDRESS (ms); 914 if (!create_thread_event_breakpoint (target_gdbarch (), pd_brk_addr)) 915 return; 916 917 /* Prepare for thread debugging. */ 918 push_target (&aix_thread_ops); 919 pd_able = 1; 920 921 /* If we're debugging a core file or an attached inferior, the 922 pthread library may already have been initialized, so try to 923 activate thread debugging. */ 924 pd_activate (1); 925} 926 927/* Undo the effects of pd_enable(). */ 928 929static void 930pd_disable (void) 931{ 932 if (!pd_able) 933 return; 934 if (pd_active) 935 pd_deactivate (); 936 pd_able = 0; 937 unpush_target (&aix_thread_ops); 938} 939 940/* new_objfile observer callback. 941 942 If OBJFILE is non-null, check whether a threaded application is 943 being debugged, and if so, prepare for thread debugging. 944 945 If OBJFILE is null, stop debugging threads. */ 946 947static void 948new_objfile (struct objfile *objfile) 949{ 950 if (objfile) 951 pd_enable (); 952 else 953 pd_disable (); 954} 955 956/* Attach to process specified by ARGS. */ 957 958static void 959aix_thread_attach (struct target_ops *ops, char *args, int from_tty) 960{ 961 struct target_ops *beneath = find_target_beneath (ops); 962 963 beneath->to_attach (beneath, args, from_tty); 964 pd_activate (1); 965} 966 967/* Detach from the process attached to by aix_thread_attach(). */ 968 969static void 970aix_thread_detach (struct target_ops *ops, const char *args, int from_tty) 971{ 972 struct target_ops *beneath = find_target_beneath (ops); 973 974 pd_disable (); 975 beneath->to_detach (beneath, args, from_tty); 976} 977 978/* Tell the inferior process to continue running thread PID if != -1 979 and all threads otherwise. */ 980 981static void 982aix_thread_resume (struct target_ops *ops, 983 ptid_t ptid, int step, enum gdb_signal sig) 984{ 985 struct thread_info *thread; 986 pthdb_tid_t tid[2]; 987 988 if (!PD_TID (ptid)) 989 { 990 struct cleanup *cleanup = save_inferior_ptid (); 991 struct target_ops *beneath = find_target_beneath (ops); 992 993 inferior_ptid = pid_to_ptid (ptid_get_pid (inferior_ptid)); 994 beneath->to_resume (beneath, ptid, step, sig); 995 do_cleanups (cleanup); 996 } 997 else 998 { 999 thread = find_thread_ptid (ptid); 1000 if (!thread) 1001 error (_("aix-thread resume: unknown pthread %ld"), 1002 ptid_get_lwp (ptid)); 1003 1004 tid[0] = thread->private->tid; 1005 if (tid[0] == PTHDB_INVALID_TID) 1006 error (_("aix-thread resume: no tid for pthread %ld"), 1007 ptid_get_lwp (ptid)); 1008 tid[1] = 0; 1009 1010 if (arch64) 1011 ptrace64aix (PTT_CONTINUE, tid[0], (long long) 1, 1012 gdb_signal_to_host (sig), (void *) tid); 1013 else 1014 ptrace32 (PTT_CONTINUE, tid[0], (addr_ptr) 1, 1015 gdb_signal_to_host (sig), (void *) tid); 1016 } 1017} 1018 1019/* Wait for thread/process ID if != -1 or for any thread otherwise. 1020 If an error occurs, return -1, else return the pid of the stopped 1021 thread. */ 1022 1023static ptid_t 1024aix_thread_wait (struct target_ops *ops, 1025 ptid_t ptid, struct target_waitstatus *status, int options) 1026{ 1027 struct cleanup *cleanup = save_inferior_ptid (); 1028 struct target_ops *beneath = find_target_beneath (ops); 1029 1030 pid_to_prc (&ptid); 1031 1032 inferior_ptid = pid_to_ptid (ptid_get_pid (inferior_ptid)); 1033 ptid = beneath->to_wait (beneath, ptid, status, options); 1034 do_cleanups (cleanup); 1035 1036 if (ptid_get_pid (ptid) == -1) 1037 return pid_to_ptid (-1); 1038 1039 /* Check whether libpthdebug might be ready to be initialized. */ 1040 if (!pd_active && status->kind == TARGET_WAITKIND_STOPPED 1041 && status->value.sig == GDB_SIGNAL_TRAP) 1042 { 1043 struct regcache *regcache = get_thread_regcache (ptid); 1044 struct gdbarch *gdbarch = get_regcache_arch (regcache); 1045 1046 if (regcache_read_pc (regcache) 1047 - gdbarch_decr_pc_after_break (gdbarch) == pd_brk_addr) 1048 return pd_activate (0); 1049 } 1050 1051 return pd_update (0); 1052} 1053 1054/* Record that the 64-bit general-purpose registers contain VALS. */ 1055 1056static void 1057supply_gprs64 (struct regcache *regcache, uint64_t *vals) 1058{ 1059 struct gdbarch_tdep *tdep = gdbarch_tdep (get_regcache_arch (regcache)); 1060 int regno; 1061 1062 for (regno = 0; regno < ppc_num_gprs; regno++) 1063 regcache_raw_supply (regcache, tdep->ppc_gp0_regnum + regno, 1064 (char *) (vals + regno)); 1065} 1066 1067/* Record that 32-bit register REGNO contains VAL. */ 1068 1069static void 1070supply_reg32 (struct regcache *regcache, int regno, uint32_t val) 1071{ 1072 regcache_raw_supply (regcache, regno, (char *) &val); 1073} 1074 1075/* Record that the floating-point registers contain VALS. */ 1076 1077static void 1078supply_fprs (struct regcache *regcache, double *vals) 1079{ 1080 struct gdbarch *gdbarch = get_regcache_arch (regcache); 1081 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); 1082 int regno; 1083 1084 /* This function should never be called on architectures without 1085 floating-point registers. */ 1086 gdb_assert (ppc_floating_point_unit_p (gdbarch)); 1087 1088 for (regno = tdep->ppc_fp0_regnum; 1089 regno < tdep->ppc_fp0_regnum + ppc_num_fprs; 1090 regno++) 1091 regcache_raw_supply (regcache, regno, 1092 (char *) (vals + regno - tdep->ppc_fp0_regnum)); 1093} 1094 1095/* Predicate to test whether given register number is a "special" register. */ 1096static int 1097special_register_p (struct gdbarch *gdbarch, int regno) 1098{ 1099 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); 1100 1101 return regno == gdbarch_pc_regnum (gdbarch) 1102 || regno == tdep->ppc_ps_regnum 1103 || regno == tdep->ppc_cr_regnum 1104 || regno == tdep->ppc_lr_regnum 1105 || regno == tdep->ppc_ctr_regnum 1106 || regno == tdep->ppc_xer_regnum 1107 || (tdep->ppc_fpscr_regnum >= 0 && regno == tdep->ppc_fpscr_regnum) 1108 || (tdep->ppc_mq_regnum >= 0 && regno == tdep->ppc_mq_regnum); 1109} 1110 1111 1112/* Record that the special registers contain the specified 64-bit and 1113 32-bit values. */ 1114 1115static void 1116supply_sprs64 (struct regcache *regcache, 1117 uint64_t iar, uint64_t msr, uint32_t cr, 1118 uint64_t lr, uint64_t ctr, uint32_t xer, 1119 uint32_t fpscr) 1120{ 1121 struct gdbarch *gdbarch = get_regcache_arch (regcache); 1122 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); 1123 1124 regcache_raw_supply (regcache, gdbarch_pc_regnum (gdbarch), 1125 (char *) &iar); 1126 regcache_raw_supply (regcache, tdep->ppc_ps_regnum, (char *) &msr); 1127 regcache_raw_supply (regcache, tdep->ppc_cr_regnum, (char *) &cr); 1128 regcache_raw_supply (regcache, tdep->ppc_lr_regnum, (char *) &lr); 1129 regcache_raw_supply (regcache, tdep->ppc_ctr_regnum, (char *) &ctr); 1130 regcache_raw_supply (regcache, tdep->ppc_xer_regnum, (char *) &xer); 1131 if (tdep->ppc_fpscr_regnum >= 0) 1132 regcache_raw_supply (regcache, tdep->ppc_fpscr_regnum, 1133 (char *) &fpscr); 1134} 1135 1136/* Record that the special registers contain the specified 32-bit 1137 values. */ 1138 1139static void 1140supply_sprs32 (struct regcache *regcache, 1141 uint32_t iar, uint32_t msr, uint32_t cr, 1142 uint32_t lr, uint32_t ctr, uint32_t xer, 1143 uint32_t fpscr) 1144{ 1145 struct gdbarch *gdbarch = get_regcache_arch (regcache); 1146 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); 1147 1148 regcache_raw_supply (regcache, gdbarch_pc_regnum (gdbarch), 1149 (char *) &iar); 1150 regcache_raw_supply (regcache, tdep->ppc_ps_regnum, (char *) &msr); 1151 regcache_raw_supply (regcache, tdep->ppc_cr_regnum, (char *) &cr); 1152 regcache_raw_supply (regcache, tdep->ppc_lr_regnum, (char *) &lr); 1153 regcache_raw_supply (regcache, tdep->ppc_ctr_regnum, (char *) &ctr); 1154 regcache_raw_supply (regcache, tdep->ppc_xer_regnum, (char *) &xer); 1155 if (tdep->ppc_fpscr_regnum >= 0) 1156 regcache_raw_supply (regcache, tdep->ppc_fpscr_regnum, 1157 (char *) &fpscr); 1158} 1159 1160/* Fetch all registers from pthread PDTID, which doesn't have a kernel 1161 thread. 1162 1163 There's no way to query a single register from a non-kernel 1164 pthread, so there's no need for a single-register version of this 1165 function. */ 1166 1167static void 1168fetch_regs_user_thread (struct regcache *regcache, pthdb_pthread_t pdtid) 1169{ 1170 struct gdbarch *gdbarch = get_regcache_arch (regcache); 1171 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); 1172 int status, i; 1173 pthdb_context_t ctx; 1174 1175 if (debug_aix_thread) 1176 fprintf_unfiltered (gdb_stdlog, 1177 "fetch_regs_user_thread %lx\n", (long) pdtid); 1178 status = pthdb_pthread_context (pd_session, pdtid, &ctx); 1179 if (status != PTHDB_SUCCESS) 1180 error (_("aix-thread: fetch_registers: pthdb_pthread_context returned %s"), 1181 pd_status2str (status)); 1182 1183 /* General-purpose registers. */ 1184 1185 if (arch64) 1186 supply_gprs64 (regcache, ctx.gpr); 1187 else 1188 for (i = 0; i < ppc_num_gprs; i++) 1189 supply_reg32 (regcache, tdep->ppc_gp0_regnum + i, ctx.gpr[i]); 1190 1191 /* Floating-point registers. */ 1192 1193 if (ppc_floating_point_unit_p (gdbarch)) 1194 supply_fprs (regcache, ctx.fpr); 1195 1196 /* Special registers. */ 1197 1198 if (arch64) 1199 supply_sprs64 (regcache, ctx.iar, ctx.msr, ctx.cr, ctx.lr, ctx.ctr, 1200 ctx.xer, ctx.fpscr); 1201 else 1202 supply_sprs32 (regcache, ctx.iar, ctx.msr, ctx.cr, ctx.lr, ctx.ctr, 1203 ctx.xer, ctx.fpscr); 1204} 1205 1206/* Fetch register REGNO if != -1 or all registers otherwise from 1207 kernel thread TID. 1208 1209 AIX provides a way to query all of a kernel thread's GPRs, FPRs, or 1210 SPRs, but there's no way to query individual registers within those 1211 groups. Therefore, if REGNO != -1, this function fetches an entire 1212 group. 1213 1214 Unfortunately, kernel thread register queries often fail with 1215 EPERM, indicating that the thread is in kernel space. This breaks 1216 backtraces of threads other than the current one. To make that 1217 breakage obvious without throwing an error to top level (which is 1218 bad e.g. during "info threads" output), zero registers that can't 1219 be retrieved. */ 1220 1221static void 1222fetch_regs_kernel_thread (struct regcache *regcache, int regno, 1223 pthdb_tid_t tid) 1224{ 1225 struct gdbarch *gdbarch = get_regcache_arch (regcache); 1226 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); 1227 uint64_t gprs64[ppc_num_gprs]; 1228 uint32_t gprs32[ppc_num_gprs]; 1229 double fprs[ppc_num_fprs]; 1230 struct ptxsprs sprs64; 1231 struct ptsprs sprs32; 1232 int i; 1233 1234 if (debug_aix_thread) 1235 fprintf_unfiltered (gdb_stdlog, 1236 "fetch_regs_kernel_thread tid=%lx regno=%d arch64=%d\n", 1237 (long) tid, regno, arch64); 1238 1239 /* General-purpose registers. */ 1240 if (regno == -1 1241 || (tdep->ppc_gp0_regnum <= regno 1242 && regno < tdep->ppc_gp0_regnum + ppc_num_gprs)) 1243 { 1244 if (arch64) 1245 { 1246 if (!ptrace64aix (PTT_READ_GPRS, tid, 1247 (unsigned long) gprs64, 0, NULL)) 1248 memset (gprs64, 0, sizeof (gprs64)); 1249 supply_gprs64 (regcache, gprs64); 1250 } 1251 else 1252 { 1253 if (!ptrace32 (PTT_READ_GPRS, tid, (uintptr_t) gprs32, 0, NULL)) 1254 memset (gprs32, 0, sizeof (gprs32)); 1255 for (i = 0; i < ppc_num_gprs; i++) 1256 supply_reg32 (regcache, tdep->ppc_gp0_regnum + i, gprs32[i]); 1257 } 1258 } 1259 1260 /* Floating-point registers. */ 1261 1262 if (ppc_floating_point_unit_p (gdbarch) 1263 && (regno == -1 1264 || (regno >= tdep->ppc_fp0_regnum 1265 && regno < tdep->ppc_fp0_regnum + ppc_num_fprs))) 1266 { 1267 if (!ptrace32 (PTT_READ_FPRS, tid, (uintptr_t) fprs, 0, NULL)) 1268 memset (fprs, 0, sizeof (fprs)); 1269 supply_fprs (regcache, fprs); 1270 } 1271 1272 /* Special-purpose registers. */ 1273 1274 if (regno == -1 || special_register_p (gdbarch, regno)) 1275 { 1276 if (arch64) 1277 { 1278 if (!ptrace64aix (PTT_READ_SPRS, tid, 1279 (unsigned long) &sprs64, 0, NULL)) 1280 memset (&sprs64, 0, sizeof (sprs64)); 1281 supply_sprs64 (regcache, sprs64.pt_iar, sprs64.pt_msr, 1282 sprs64.pt_cr, sprs64.pt_lr, sprs64.pt_ctr, 1283 sprs64.pt_xer, sprs64.pt_fpscr); 1284 } 1285 else 1286 { 1287 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); 1288 1289 if (!ptrace32 (PTT_READ_SPRS, tid, (uintptr_t) &sprs32, 0, NULL)) 1290 memset (&sprs32, 0, sizeof (sprs32)); 1291 supply_sprs32 (regcache, sprs32.pt_iar, sprs32.pt_msr, sprs32.pt_cr, 1292 sprs32.pt_lr, sprs32.pt_ctr, sprs32.pt_xer, 1293 sprs32.pt_fpscr); 1294 1295 if (tdep->ppc_mq_regnum >= 0) 1296 regcache_raw_supply (regcache, tdep->ppc_mq_regnum, 1297 (char *) &sprs32.pt_mq); 1298 } 1299 } 1300} 1301 1302/* Fetch register REGNO if != -1 or all registers otherwise in the 1303 thread/process specified by inferior_ptid. */ 1304 1305static void 1306aix_thread_fetch_registers (struct target_ops *ops, 1307 struct regcache *regcache, int regno) 1308{ 1309 struct thread_info *thread; 1310 pthdb_tid_t tid; 1311 struct target_ops *beneath = find_target_beneath (ops); 1312 1313 if (!PD_TID (inferior_ptid)) 1314 beneath->to_fetch_registers (beneath, regcache, regno); 1315 else 1316 { 1317 thread = find_thread_ptid (inferior_ptid); 1318 tid = thread->private->tid; 1319 1320 if (tid == PTHDB_INVALID_TID) 1321 fetch_regs_user_thread (regcache, thread->private->pdtid); 1322 else 1323 fetch_regs_kernel_thread (regcache, regno, tid); 1324 } 1325} 1326 1327/* Store the gp registers into an array of uint32_t or uint64_t. */ 1328 1329static void 1330fill_gprs64 (const struct regcache *regcache, uint64_t *vals) 1331{ 1332 struct gdbarch_tdep *tdep = gdbarch_tdep (get_regcache_arch (regcache)); 1333 int regno; 1334 1335 for (regno = 0; regno < ppc_num_gprs; regno++) 1336 if (REG_VALID == regcache_register_status (regcache, 1337 tdep->ppc_gp0_regnum + regno)) 1338 regcache_raw_collect (regcache, tdep->ppc_gp0_regnum + regno, 1339 vals + regno); 1340} 1341 1342static void 1343fill_gprs32 (const struct regcache *regcache, uint32_t *vals) 1344{ 1345 struct gdbarch_tdep *tdep = gdbarch_tdep (get_regcache_arch (regcache)); 1346 int regno; 1347 1348 for (regno = 0; regno < ppc_num_gprs; regno++) 1349 if (REG_VALID == regcache_register_status (regcache, 1350 tdep->ppc_gp0_regnum + regno)) 1351 regcache_raw_collect (regcache, tdep->ppc_gp0_regnum + regno, 1352 vals + regno); 1353} 1354 1355/* Store the floating point registers into a double array. */ 1356static void 1357fill_fprs (const struct regcache *regcache, double *vals) 1358{ 1359 struct gdbarch *gdbarch = get_regcache_arch (regcache); 1360 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); 1361 int regno; 1362 1363 /* This function should never be called on architectures without 1364 floating-point registers. */ 1365 gdb_assert (ppc_floating_point_unit_p (gdbarch)); 1366 1367 for (regno = tdep->ppc_fp0_regnum; 1368 regno < tdep->ppc_fp0_regnum + ppc_num_fprs; 1369 regno++) 1370 if (REG_VALID == regcache_register_status (regcache, regno)) 1371 regcache_raw_collect (regcache, regno, 1372 vals + regno - tdep->ppc_fp0_regnum); 1373} 1374 1375/* Store the special registers into the specified 64-bit and 32-bit 1376 locations. */ 1377 1378static void 1379fill_sprs64 (const struct regcache *regcache, 1380 uint64_t *iar, uint64_t *msr, uint32_t *cr, 1381 uint64_t *lr, uint64_t *ctr, uint32_t *xer, 1382 uint32_t *fpscr) 1383{ 1384 struct gdbarch *gdbarch = get_regcache_arch (regcache); 1385 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); 1386 1387 /* Verify that the size of the size of the IAR buffer is the 1388 same as the raw size of the PC (in the register cache). If 1389 they're not, then either GDB has been built incorrectly, or 1390 there's some other kind of internal error. To be really safe, 1391 we should check all of the sizes. */ 1392 gdb_assert (sizeof (*iar) == register_size 1393 (gdbarch, gdbarch_pc_regnum (gdbarch))); 1394 1395 if (REG_VALID == regcache_register_status (regcache, 1396 gdbarch_pc_regnum (gdbarch))) 1397 regcache_raw_collect (regcache, gdbarch_pc_regnum (gdbarch), iar); 1398 if (REG_VALID == regcache_register_status (regcache, tdep->ppc_ps_regnum)) 1399 regcache_raw_collect (regcache, tdep->ppc_ps_regnum, msr); 1400 if (REG_VALID == regcache_register_status (regcache, tdep->ppc_cr_regnum)) 1401 regcache_raw_collect (regcache, tdep->ppc_cr_regnum, cr); 1402 if (REG_VALID == regcache_register_status (regcache, tdep->ppc_lr_regnum)) 1403 regcache_raw_collect (regcache, tdep->ppc_lr_regnum, lr); 1404 if (REG_VALID == regcache_register_status (regcache, tdep->ppc_ctr_regnum)) 1405 regcache_raw_collect (regcache, tdep->ppc_ctr_regnum, ctr); 1406 if (REG_VALID == regcache_register_status (regcache, tdep->ppc_xer_regnum)) 1407 regcache_raw_collect (regcache, tdep->ppc_xer_regnum, xer); 1408 if (tdep->ppc_fpscr_regnum >= 0 1409 && REG_VALID == regcache_register_status (regcache, 1410 tdep->ppc_fpscr_regnum)) 1411 regcache_raw_collect (regcache, tdep->ppc_fpscr_regnum, fpscr); 1412} 1413 1414static void 1415fill_sprs32 (const struct regcache *regcache, 1416 uint32_t *iar, uint32_t *msr, uint32_t *cr, 1417 uint32_t *lr, uint32_t *ctr, uint32_t *xer, 1418 uint32_t *fpscr) 1419{ 1420 struct gdbarch *gdbarch = get_regcache_arch (regcache); 1421 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); 1422 1423 /* Verify that the size of the size of the IAR buffer is the 1424 same as the raw size of the PC (in the register cache). If 1425 they're not, then either GDB has been built incorrectly, or 1426 there's some other kind of internal error. To be really safe, 1427 we should check all of the sizes. */ 1428 gdb_assert (sizeof (*iar) == register_size (gdbarch, 1429 gdbarch_pc_regnum (gdbarch))); 1430 1431 if (REG_VALID == regcache_register_status (regcache, 1432 gdbarch_pc_regnum (gdbarch))) 1433 regcache_raw_collect (regcache, gdbarch_pc_regnum (gdbarch), iar); 1434 if (REG_VALID == regcache_register_status (regcache, tdep->ppc_ps_regnum)) 1435 regcache_raw_collect (regcache, tdep->ppc_ps_regnum, msr); 1436 if (REG_VALID == regcache_register_status (regcache, tdep->ppc_cr_regnum)) 1437 regcache_raw_collect (regcache, tdep->ppc_cr_regnum, cr); 1438 if (REG_VALID == regcache_register_status (regcache, tdep->ppc_lr_regnum)) 1439 regcache_raw_collect (regcache, tdep->ppc_lr_regnum, lr); 1440 if (REG_VALID == regcache_register_status (regcache, tdep->ppc_ctr_regnum)) 1441 regcache_raw_collect (regcache, tdep->ppc_ctr_regnum, ctr); 1442 if (REG_VALID == regcache_register_status (regcache, tdep->ppc_xer_regnum)) 1443 regcache_raw_collect (regcache, tdep->ppc_xer_regnum, xer); 1444 if (tdep->ppc_fpscr_regnum >= 0 1445 && REG_VALID == regcache_register_status (regcache, tdep->ppc_fpscr_regnum)) 1446 regcache_raw_collect (regcache, tdep->ppc_fpscr_regnum, fpscr); 1447} 1448 1449/* Store all registers into pthread PDTID, which doesn't have a kernel 1450 thread. 1451 1452 It's possible to store a single register into a non-kernel pthread, 1453 but I doubt it's worth the effort. */ 1454 1455static void 1456store_regs_user_thread (const struct regcache *regcache, pthdb_pthread_t pdtid) 1457{ 1458 struct gdbarch *gdbarch = get_regcache_arch (regcache); 1459 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); 1460 int status, i; 1461 pthdb_context_t ctx; 1462 uint32_t int32; 1463 uint64_t int64; 1464 double dbl; 1465 1466 if (debug_aix_thread) 1467 fprintf_unfiltered (gdb_stdlog, 1468 "store_regs_user_thread %lx\n", (long) pdtid); 1469 1470 /* Retrieve the thread's current context for its non-register 1471 values. */ 1472 status = pthdb_pthread_context (pd_session, pdtid, &ctx); 1473 if (status != PTHDB_SUCCESS) 1474 error (_("aix-thread: store_registers: pthdb_pthread_context returned %s"), 1475 pd_status2str (status)); 1476 1477 /* Collect general-purpose register values from the regcache. */ 1478 1479 for (i = 0; i < ppc_num_gprs; i++) 1480 if (REG_VALID == regcache_register_status (regcache, 1481 tdep->ppc_gp0_regnum + i)) 1482 { 1483 if (arch64) 1484 { 1485 regcache_raw_collect (regcache, tdep->ppc_gp0_regnum + i, 1486 (void *) &int64); 1487 ctx.gpr[i] = int64; 1488 } 1489 else 1490 { 1491 regcache_raw_collect (regcache, tdep->ppc_gp0_regnum + i, 1492 (void *) &int32); 1493 ctx.gpr[i] = int32; 1494 } 1495 } 1496 1497 /* Collect floating-point register values from the regcache. */ 1498 if (ppc_floating_point_unit_p (gdbarch)) 1499 fill_fprs (regcache, ctx.fpr); 1500 1501 /* Special registers (always kept in ctx as 64 bits). */ 1502 if (arch64) 1503 { 1504 fill_sprs64 (regcache, &ctx.iar, &ctx.msr, &ctx.cr, &ctx.lr, &ctx.ctr, 1505 &ctx.xer, &ctx.fpscr); 1506 } 1507 else 1508 { 1509 /* Problem: ctx.iar etc. are 64 bits, but raw_registers are 32. 1510 Solution: use 32-bit temp variables. */ 1511 uint32_t tmp_iar, tmp_msr, tmp_cr, tmp_lr, tmp_ctr, tmp_xer, 1512 tmp_fpscr; 1513 1514 fill_sprs32 (regcache, &tmp_iar, &tmp_msr, &tmp_cr, &tmp_lr, &tmp_ctr, 1515 &tmp_xer, &tmp_fpscr); 1516 if (REG_VALID == regcache_register_status (regcache, 1517 gdbarch_pc_regnum (gdbarch))) 1518 ctx.iar = tmp_iar; 1519 if (REG_VALID == regcache_register_status (regcache, tdep->ppc_ps_regnum)) 1520 ctx.msr = tmp_msr; 1521 if (REG_VALID == regcache_register_status (regcache, tdep->ppc_cr_regnum)) 1522 ctx.cr = tmp_cr; 1523 if (REG_VALID == regcache_register_status (regcache, tdep->ppc_lr_regnum)) 1524 ctx.lr = tmp_lr; 1525 if (REG_VALID == regcache_register_status (regcache, 1526 tdep->ppc_ctr_regnum)) 1527 ctx.ctr = tmp_ctr; 1528 if (REG_VALID == regcache_register_status (regcache, 1529 tdep->ppc_xer_regnum)) 1530 ctx.xer = tmp_xer; 1531 if (REG_VALID == regcache_register_status (regcache, 1532 tdep->ppc_xer_regnum)) 1533 ctx.fpscr = tmp_fpscr; 1534 } 1535 1536 status = pthdb_pthread_setcontext (pd_session, pdtid, &ctx); 1537 if (status != PTHDB_SUCCESS) 1538 error (_("aix-thread: store_registers: " 1539 "pthdb_pthread_setcontext returned %s"), 1540 pd_status2str (status)); 1541} 1542 1543/* Store register REGNO if != -1 or all registers otherwise into 1544 kernel thread TID. 1545 1546 AIX provides a way to set all of a kernel thread's GPRs, FPRs, or 1547 SPRs, but there's no way to set individual registers within those 1548 groups. Therefore, if REGNO != -1, this function stores an entire 1549 group. */ 1550 1551static void 1552store_regs_kernel_thread (const struct regcache *regcache, int regno, 1553 pthdb_tid_t tid) 1554{ 1555 struct gdbarch *gdbarch = get_regcache_arch (regcache); 1556 struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); 1557 uint64_t gprs64[ppc_num_gprs]; 1558 uint32_t gprs32[ppc_num_gprs]; 1559 double fprs[ppc_num_fprs]; 1560 struct ptxsprs sprs64; 1561 struct ptsprs sprs32; 1562 int i; 1563 1564 if (debug_aix_thread) 1565 fprintf_unfiltered (gdb_stdlog, 1566 "store_regs_kernel_thread tid=%lx regno=%d\n", 1567 (long) tid, regno); 1568 1569 /* General-purpose registers. */ 1570 if (regno == -1 1571 || (tdep->ppc_gp0_regnum <= regno 1572 && regno < tdep->ppc_gp0_regnum + ppc_num_fprs)) 1573 { 1574 if (arch64) 1575 { 1576 /* Pre-fetch: some regs may not be in the cache. */ 1577 ptrace64aix (PTT_READ_GPRS, tid, (unsigned long) gprs64, 0, NULL); 1578 fill_gprs64 (regcache, gprs64); 1579 ptrace64aix (PTT_WRITE_GPRS, tid, (unsigned long) gprs64, 0, NULL); 1580 } 1581 else 1582 { 1583 /* Pre-fetch: some regs may not be in the cache. */ 1584 ptrace32 (PTT_READ_GPRS, tid, (uintptr_t) gprs32, 0, NULL); 1585 fill_gprs32 (regcache, gprs32); 1586 ptrace32 (PTT_WRITE_GPRS, tid, (uintptr_t) gprs32, 0, NULL); 1587 } 1588 } 1589 1590 /* Floating-point registers. */ 1591 1592 if (ppc_floating_point_unit_p (gdbarch) 1593 && (regno == -1 1594 || (regno >= tdep->ppc_fp0_regnum 1595 && regno < tdep->ppc_fp0_regnum + ppc_num_fprs))) 1596 { 1597 /* Pre-fetch: some regs may not be in the cache. */ 1598 ptrace32 (PTT_READ_FPRS, tid, (uintptr_t) fprs, 0, NULL); 1599 fill_fprs (regcache, fprs); 1600 ptrace32 (PTT_WRITE_FPRS, tid, (uintptr_t) fprs, 0, NULL); 1601 } 1602 1603 /* Special-purpose registers. */ 1604 1605 if (regno == -1 || special_register_p (gdbarch, regno)) 1606 { 1607 if (arch64) 1608 { 1609 /* Pre-fetch: some registers won't be in the cache. */ 1610 ptrace64aix (PTT_READ_SPRS, tid, 1611 (unsigned long) &sprs64, 0, NULL); 1612 fill_sprs64 (regcache, &sprs64.pt_iar, &sprs64.pt_msr, 1613 &sprs64.pt_cr, &sprs64.pt_lr, &sprs64.pt_ctr, 1614 &sprs64.pt_xer, &sprs64.pt_fpscr); 1615 ptrace64aix (PTT_WRITE_SPRS, tid, 1616 (unsigned long) &sprs64, 0, NULL); 1617 } 1618 else 1619 { 1620 /* The contents of "struct ptspr" were declared as "unsigned 1621 long" up to AIX 5.2, but are "unsigned int" since 5.3. 1622 Use temporaries to work around this problem. Also, add an 1623 assert here to make sure we fail if the system header files 1624 use "unsigned long", and the size of that type is not what 1625 the headers expect. */ 1626 uint32_t tmp_iar, tmp_msr, tmp_cr, tmp_lr, tmp_ctr, tmp_xer, 1627 tmp_fpscr; 1628 1629 gdb_assert (sizeof (sprs32.pt_iar) == 4); 1630 1631 /* Pre-fetch: some registers won't be in the cache. */ 1632 ptrace32 (PTT_READ_SPRS, tid, (uintptr_t) &sprs32, 0, NULL); 1633 1634 fill_sprs32 (regcache, &tmp_iar, &tmp_msr, &tmp_cr, &tmp_lr, 1635 &tmp_ctr, &tmp_xer, &tmp_fpscr); 1636 1637 sprs32.pt_iar = tmp_iar; 1638 sprs32.pt_msr = tmp_msr; 1639 sprs32.pt_cr = tmp_cr; 1640 sprs32.pt_lr = tmp_lr; 1641 sprs32.pt_ctr = tmp_ctr; 1642 sprs32.pt_xer = tmp_xer; 1643 sprs32.pt_fpscr = tmp_fpscr; 1644 1645 if (tdep->ppc_mq_regnum >= 0) 1646 if (REG_VALID == regcache_register_status (regcache, 1647 tdep->ppc_mq_regnum)) 1648 regcache_raw_collect (regcache, tdep->ppc_mq_regnum, 1649 &sprs32.pt_mq); 1650 1651 ptrace32 (PTT_WRITE_SPRS, tid, (uintptr_t) &sprs32, 0, NULL); 1652 } 1653 } 1654} 1655 1656/* Store gdb's current view of the register set into the 1657 thread/process specified by inferior_ptid. */ 1658 1659static void 1660aix_thread_store_registers (struct target_ops *ops, 1661 struct regcache *regcache, int regno) 1662{ 1663 struct thread_info *thread; 1664 pthdb_tid_t tid; 1665 struct target_ops *beneath = find_target_beneath (ops); 1666 1667 if (!PD_TID (inferior_ptid)) 1668 beneath->to_store_registers (beneath, regcache, regno); 1669 else 1670 { 1671 thread = find_thread_ptid (inferior_ptid); 1672 tid = thread->private->tid; 1673 1674 if (tid == PTHDB_INVALID_TID) 1675 store_regs_user_thread (regcache, thread->private->pdtid); 1676 else 1677 store_regs_kernel_thread (regcache, regno, tid); 1678 } 1679} 1680 1681/* Attempt a transfer all LEN bytes starting at OFFSET between the 1682 inferior's OBJECT:ANNEX space and GDB's READBUF/WRITEBUF buffer. 1683 Return the number of bytes actually transferred. */ 1684 1685static LONGEST 1686aix_thread_xfer_partial (struct target_ops *ops, enum target_object object, 1687 const char *annex, gdb_byte *readbuf, 1688 const gdb_byte *writebuf, 1689 ULONGEST offset, LONGEST len) 1690{ 1691 struct cleanup *old_chain = save_inferior_ptid (); 1692 LONGEST xfer; 1693 struct target_ops *beneath = find_target_beneath (ops); 1694 1695 inferior_ptid = pid_to_ptid (ptid_get_pid (inferior_ptid)); 1696 xfer = beneath->to_xfer_partial (beneath, object, annex, 1697 readbuf, writebuf, offset, len); 1698 1699 do_cleanups (old_chain); 1700 return xfer; 1701} 1702 1703/* Clean up after the inferior exits. */ 1704 1705static void 1706aix_thread_mourn_inferior (struct target_ops *ops) 1707{ 1708 struct target_ops *beneath = find_target_beneath (ops); 1709 1710 pd_deactivate (); 1711 beneath->to_mourn_inferior (beneath); 1712} 1713 1714/* Return whether thread PID is still valid. */ 1715 1716static int 1717aix_thread_thread_alive (struct target_ops *ops, ptid_t ptid) 1718{ 1719 struct target_ops *beneath = find_target_beneath (ops); 1720 1721 if (!PD_TID (ptid)) 1722 return beneath->to_thread_alive (beneath, ptid); 1723 1724 /* We update the thread list every time the child stops, so all 1725 valid threads should be in the thread list. */ 1726 return in_thread_list (ptid); 1727} 1728 1729/* Return a printable representation of composite PID for use in 1730 "info threads" output. */ 1731 1732static char * 1733aix_thread_pid_to_str (struct target_ops *ops, ptid_t ptid) 1734{ 1735 static char *ret = NULL; 1736 struct target_ops *beneath = find_target_beneath (ops); 1737 1738 if (!PD_TID (ptid)) 1739 return beneath->to_pid_to_str (beneath, ptid); 1740 1741 /* Free previous return value; a new one will be allocated by 1742 xstrprintf(). */ 1743 xfree (ret); 1744 1745 ret = xstrprintf (_("Thread %ld"), ptid_get_tid (ptid)); 1746 return ret; 1747} 1748 1749/* Return a printable representation of extra information about 1750 THREAD, for use in "info threads" output. */ 1751 1752static char * 1753aix_thread_extra_thread_info (struct thread_info *thread) 1754{ 1755 struct ui_file *buf; 1756 int status; 1757 pthdb_pthread_t pdtid; 1758 pthdb_tid_t tid; 1759 pthdb_state_t state; 1760 pthdb_suspendstate_t suspendstate; 1761 pthdb_detachstate_t detachstate; 1762 int cancelpend; 1763 static char *ret = NULL; 1764 1765 if (!PD_TID (thread->ptid)) 1766 return NULL; 1767 1768 buf = mem_fileopen (); 1769 1770 pdtid = thread->private->pdtid; 1771 tid = thread->private->tid; 1772 1773 if (tid != PTHDB_INVALID_TID) 1774 /* i18n: Like "thread-identifier %d, [state] running, suspended" */ 1775 fprintf_unfiltered (buf, _("tid %d"), (int)tid); 1776 1777 status = pthdb_pthread_state (pd_session, pdtid, &state); 1778 if (status != PTHDB_SUCCESS) 1779 state = PST_NOTSUP; 1780 fprintf_unfiltered (buf, ", %s", state2str (state)); 1781 1782 status = pthdb_pthread_suspendstate (pd_session, pdtid, 1783 &suspendstate); 1784 if (status == PTHDB_SUCCESS && suspendstate == PSS_SUSPENDED) 1785 /* i18n: Like "Thread-Id %d, [state] running, suspended" */ 1786 fprintf_unfiltered (buf, _(", suspended")); 1787 1788 status = pthdb_pthread_detachstate (pd_session, pdtid, 1789 &detachstate); 1790 if (status == PTHDB_SUCCESS && detachstate == PDS_DETACHED) 1791 /* i18n: Like "Thread-Id %d, [state] running, detached" */ 1792 fprintf_unfiltered (buf, _(", detached")); 1793 1794 pthdb_pthread_cancelpend (pd_session, pdtid, &cancelpend); 1795 if (status == PTHDB_SUCCESS && cancelpend) 1796 /* i18n: Like "Thread-Id %d, [state] running, cancel pending" */ 1797 fprintf_unfiltered (buf, _(", cancel pending")); 1798 1799 ui_file_write (buf, "", 1); 1800 1801 xfree (ret); /* Free old buffer. */ 1802 1803 ret = ui_file_xstrdup (buf, NULL); 1804 ui_file_delete (buf); 1805 1806 return ret; 1807} 1808 1809static ptid_t 1810aix_thread_get_ada_task_ptid (long lwp, long thread) 1811{ 1812 return ptid_build (ptid_get_pid (inferior_ptid), 0, thread); 1813} 1814 1815/* Initialize target aix_thread_ops. */ 1816 1817static void 1818init_aix_thread_ops (void) 1819{ 1820 aix_thread_ops.to_shortname = "aix-threads"; 1821 aix_thread_ops.to_longname = _("AIX pthread support"); 1822 aix_thread_ops.to_doc = _("AIX pthread support"); 1823 1824 aix_thread_ops.to_attach = aix_thread_attach; 1825 aix_thread_ops.to_detach = aix_thread_detach; 1826 aix_thread_ops.to_resume = aix_thread_resume; 1827 aix_thread_ops.to_wait = aix_thread_wait; 1828 aix_thread_ops.to_fetch_registers = aix_thread_fetch_registers; 1829 aix_thread_ops.to_store_registers = aix_thread_store_registers; 1830 aix_thread_ops.to_xfer_partial = aix_thread_xfer_partial; 1831 /* No need for aix_thread_ops.to_create_inferior, because we activate thread 1832 debugging when the inferior reaches pd_brk_addr. */ 1833 aix_thread_ops.to_mourn_inferior = aix_thread_mourn_inferior; 1834 aix_thread_ops.to_thread_alive = aix_thread_thread_alive; 1835 aix_thread_ops.to_pid_to_str = aix_thread_pid_to_str; 1836 aix_thread_ops.to_extra_thread_info = aix_thread_extra_thread_info; 1837 aix_thread_ops.to_get_ada_task_ptid = aix_thread_get_ada_task_ptid; 1838 aix_thread_ops.to_stratum = thread_stratum; 1839 aix_thread_ops.to_magic = OPS_MAGIC; 1840} 1841 1842/* Module startup initialization function, automagically called by 1843 init.c. */ 1844 1845void _initialize_aix_thread (void); 1846 1847void 1848_initialize_aix_thread (void) 1849{ 1850 init_aix_thread_ops (); 1851 complete_target_initialization (&aix_thread_ops); 1852 1853 /* Notice when object files get loaded and unloaded. */ 1854 observer_attach_new_objfile (new_objfile); 1855 1856 add_setshow_boolean_cmd ("aix-thread", class_maintenance, &debug_aix_thread, 1857 _("Set debugging of AIX thread module."), 1858 _("Show debugging of AIX thread module."), 1859 _("Enables debugging output (used to debug GDB)."), 1860 NULL, NULL, 1861 /* FIXME: i18n: Debugging of AIX thread 1862 module is \"%d\". */ 1863 &setdebuglist, &showdebuglist); 1864} 1865