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