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