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