1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26 #include <sys/stack.h>
27 #include <sys/regset.h>
28 #include <sys/frame.h>
29 #include <sys/sysmacros.h>
30 #include <sys/trap.h>
31 #include <sys/machelf.h>
32
33 #include <stdlib.h>
34 #include <unistd.h>
35 #include <sys/types.h>
36 #include <errno.h>
37 #include <string.h>
38
39 #include <saveargs.h>
40 #include "Pcontrol.h"
41 #include "Pstack.h"
42
43 static uchar_t int_syscall_instr[] = { 0xCD, T_SYSCALLINT };
44 static uchar_t syscall_instr[] = { 0x0f, 0x05 };
45
46 const char *
Ppltdest(struct ps_prochandle * P,uintptr_t pltaddr)47 Ppltdest(struct ps_prochandle *P, uintptr_t pltaddr)
48 {
49 map_info_t *mp = Paddr2mptr(P, pltaddr);
50 file_info_t *fp;
51 size_t i;
52 uintptr_t r_addr;
53
54 if (mp == NULL || (fp = mp->map_file) == NULL ||
55 fp->file_plt_base == 0 ||
56 pltaddr - fp->file_plt_base >= fp->file_plt_size) {
57 errno = EINVAL;
58 return (NULL);
59 }
60
61 i = (pltaddr - fp->file_plt_base) / M_PLT_ENTSIZE - M_PLT_XNumber;
62
63 if (P->status.pr_dmodel == PR_MODEL_LP64) {
64 Elf64_Rela r;
65
66 r_addr = fp->file_jmp_rel + i * sizeof (r);
67
68 if (Pread(P, &r, sizeof (r), r_addr) == sizeof (r) &&
69 (i = ELF64_R_SYM(r.r_info)) < fp->file_dynsym.sym_symn) {
70 Elf_Data *data = fp->file_dynsym.sym_data_pri;
71 Elf64_Sym *symp = &(((Elf64_Sym *)data->d_buf)[i]);
72
73 return (fp->file_dynsym.sym_strs + symp->st_name);
74 }
75 } else {
76 Elf32_Rel r;
77
78 r_addr = fp->file_jmp_rel + i * sizeof (r);
79
80 if (Pread(P, &r, sizeof (r), r_addr) == sizeof (r) &&
81 (i = ELF32_R_SYM(r.r_info)) < fp->file_dynsym.sym_symn) {
82 Elf_Data *data = fp->file_dynsym.sym_data_pri;
83 Elf32_Sym *symp = &(((Elf32_Sym *)data->d_buf)[i]);
84
85 return (fp->file_dynsym.sym_strs + symp->st_name);
86 }
87 }
88
89 return (NULL);
90 }
91
92 int
Pissyscall(struct ps_prochandle * P,uintptr_t addr)93 Pissyscall(struct ps_prochandle *P, uintptr_t addr)
94 {
95 uchar_t instr[16];
96
97 if (P->status.pr_dmodel == PR_MODEL_LP64) {
98 if (Pread(P, instr, sizeof (syscall_instr), addr) !=
99 sizeof (syscall_instr) ||
100 memcmp(instr, syscall_instr, sizeof (syscall_instr)) != 0)
101 return (0);
102 else
103 return (1);
104 }
105
106 if (Pread(P, instr, sizeof (int_syscall_instr), addr) !=
107 sizeof (int_syscall_instr))
108 return (0);
109
110 if (memcmp(instr, int_syscall_instr, sizeof (int_syscall_instr)) == 0)
111 return (1);
112
113 return (0);
114 }
115
116 int
Pissyscall_prev(struct ps_prochandle * P,uintptr_t addr,uintptr_t * dst)117 Pissyscall_prev(struct ps_prochandle *P, uintptr_t addr, uintptr_t *dst)
118 {
119 int ret;
120
121 if (P->status.pr_dmodel == PR_MODEL_LP64) {
122 if (Pissyscall(P, addr - sizeof (syscall_instr))) {
123 if (dst)
124 *dst = addr - sizeof (syscall_instr);
125 return (1);
126 }
127 return (0);
128 }
129
130 if ((ret = Pissyscall(P, addr - sizeof (int_syscall_instr))) != 0) {
131 if (dst)
132 *dst = addr - sizeof (int_syscall_instr);
133 return (ret);
134 }
135
136 return (0);
137 }
138
139 int
Pissyscall_text(struct ps_prochandle * P,const void * buf,size_t buflen)140 Pissyscall_text(struct ps_prochandle *P, const void *buf, size_t buflen)
141 {
142 if (P->status.pr_dmodel == PR_MODEL_LP64) {
143 if (buflen >= sizeof (syscall_instr) &&
144 memcmp(buf, syscall_instr, sizeof (syscall_instr)) == 0)
145 return (1);
146 else
147 return (0);
148 }
149
150 if (buflen < sizeof (int_syscall_instr))
151 return (0);
152
153 if (memcmp(buf, int_syscall_instr, sizeof (int_syscall_instr)) == 0)
154 return (1);
155
156 return (0);
157 }
158
159 #define TR_ARG_MAX 6 /* Max args to print, same as SPARC */
160
161 /*
162 * Given a return address, determine the likely number of arguments
163 * that were pushed on the stack prior to its execution. We do this by
164 * expecting that a typical call sequence consists of pushing arguments on
165 * the stack, executing a call instruction, and then performing an add
166 * on %esp to restore it to the value prior to pushing the arguments for
167 * the call. We attempt to detect such an add, and divide the addend
168 * by the size of a word to determine the number of pushed arguments.
169 *
170 * If we do not find such an add, this does not necessarily imply that the
171 * function took no arguments. It is not possible to reliably detect such a
172 * void function because hand-coded assembler does not always perform an add
173 * to %esp immediately after the "call" instruction (eg. _sys_call()).
174 * Because of this, we default to returning MIN(sz, TR_ARG_MAX) instead of 0
175 * in the absence of an add to %esp.
176 */
177 static ulong_t
argcount(struct ps_prochandle * P,uint32_t pc,ssize_t sz)178 argcount(struct ps_prochandle *P, uint32_t pc, ssize_t sz)
179 {
180 uchar_t instr[6];
181 ulong_t count, max;
182
183 max = MIN(sz / sizeof (uint32_t), TR_ARG_MAX);
184
185 /*
186 * Read the instruction at the return location.
187 */
188 if (Pread(P, instr, sizeof (instr), (uintptr_t)pc) != sizeof (instr))
189 return (max);
190
191 if (instr[1] != 0xc4)
192 return (max);
193
194 switch (instr[0]) {
195 case 0x81: /* count is a longword */
196 count = instr[2]+(instr[3]<<8)+(instr[4]<<16)+(instr[5]<<24);
197 break;
198 case 0x83: /* count is a byte */
199 count = instr[2];
200 break;
201 default:
202 return (max);
203 }
204
205 count /= sizeof (uint32_t);
206 return (MIN(count, max));
207 }
208
209 static void
ucontext_32_to_prgregs(const ucontext32_t * uc,prgregset_t dst)210 ucontext_32_to_prgregs(const ucontext32_t *uc, prgregset_t dst)
211 {
212 const greg32_t *src = &uc->uc_mcontext.gregs[0];
213
214 dst[REG_DS] = (uint16_t)src[DS];
215 dst[REG_ES] = (uint16_t)src[ES];
216
217 dst[REG_GS] = (uint16_t)src[GS];
218 dst[REG_FS] = (uint16_t)src[FS];
219 dst[REG_SS] = (uint16_t)src[SS];
220 dst[REG_RSP] = (uint32_t)src[UESP];
221 dst[REG_RFL] = src[EFL];
222 dst[REG_CS] = (uint16_t)src[CS];
223 dst[REG_RIP] = (uint32_t)src[EIP];
224 dst[REG_ERR] = (uint32_t)src[ERR];
225 dst[REG_TRAPNO] = (uint32_t)src[TRAPNO];
226 dst[REG_RAX] = (uint32_t)src[EAX];
227 dst[REG_RCX] = (uint32_t)src[ECX];
228 dst[REG_RDX] = (uint32_t)src[EDX];
229 dst[REG_RBX] = (uint32_t)src[EBX];
230 dst[REG_RBP] = (uint32_t)src[EBP];
231 dst[REG_RSI] = (uint32_t)src[ESI];
232 dst[REG_RDI] = (uint32_t)src[EDI];
233 }
234
235 static int
Pstack_iter32(struct ps_prochandle * P,const prgregset_t regs,proc_stack_f * func,void * arg)236 Pstack_iter32(struct ps_prochandle *P, const prgregset_t regs,
237 proc_stack_f *func, void *arg)
238 {
239 prgreg_t *prevfp = NULL;
240 uint_t pfpsize = 0;
241 int nfp = 0;
242 struct {
243 prgreg32_t fp;
244 prgreg32_t pc;
245 prgreg32_t args[32];
246 } frame;
247 uint_t argc;
248 ssize_t sz;
249 prgregset_t gregs;
250 uint32_t fp, pfp, pc;
251 long args[32];
252 int rv;
253 int i;
254
255 /*
256 * Type definition for a structure corresponding to an IA32
257 * signal frame. Refer to the comments in Pstack.c for more info
258 */
259 typedef struct {
260 prgreg32_t fp;
261 prgreg32_t pc;
262 int signo;
263 caddr32_t ucp;
264 caddr32_t sip;
265 } sf_t;
266
267 uclist_t ucl;
268 ucontext32_t uc;
269 uintptr_t uc_addr;
270
271 init_uclist(&ucl, P);
272 (void) memcpy(gregs, regs, sizeof (gregs));
273
274 fp = regs[R_FP];
275 pc = regs[R_PC];
276
277 while (fp != 0 || pc != 0) {
278 if (stack_loop(fp, &prevfp, &nfp, &pfpsize))
279 break;
280
281 if (fp != 0 &&
282 (sz = Pread(P, &frame, sizeof (frame), (uintptr_t)fp)
283 >= (ssize_t)(2* sizeof (uint32_t)))) {
284 /*
285 * One more trick for signal frames: the kernel sets
286 * the return pc of the signal frame to 0xffffffff on
287 * Intel IA32, so argcount won't work.
288 */
289 if (frame.pc != -1L) {
290 sz -= 2* sizeof (uint32_t);
291 argc = argcount(P, (uint32_t)frame.pc, sz);
292 } else
293 argc = 3; /* sighandler(signo, sip, ucp) */
294 } else {
295 (void) memset(&frame, 0, sizeof (frame));
296 argc = 0;
297 }
298
299 gregs[R_FP] = fp;
300 gregs[R_PC] = pc;
301
302 for (i = 0; i < argc; i++)
303 args[i] = (uint32_t)frame.args[i];
304
305 if ((rv = func(arg, gregs, argc, args)) != 0)
306 break;
307
308 /*
309 * In order to allow iteration over java frames (which can have
310 * their own frame pointers), we allow the iterator to change
311 * the contents of gregs. If we detect a change, then we assume
312 * that the new values point to the next frame.
313 */
314 if (gregs[R_FP] != fp || gregs[R_PC] != pc) {
315 fp = gregs[R_FP];
316 pc = gregs[R_PC];
317 continue;
318 }
319
320 pfp = fp;
321 fp = frame.fp;
322 pc = frame.pc;
323
324 if (find_uclink(&ucl, pfp + sizeof (sf_t)))
325 uc_addr = pfp + sizeof (sf_t);
326 else
327 uc_addr = NULL;
328
329 if (uc_addr != NULL &&
330 Pread(P, &uc, sizeof (uc), uc_addr) == sizeof (uc)) {
331 ucontext_32_to_prgregs(&uc, gregs);
332 fp = gregs[R_FP];
333 pc = gregs[R_PC];
334 }
335 }
336
337 if (prevfp)
338 free(prevfp);
339
340 free_uclist(&ucl);
341 return (rv);
342 }
343
344 static void
ucontext_n_to_prgregs(const ucontext_t * src,prgregset_t dst)345 ucontext_n_to_prgregs(const ucontext_t *src, prgregset_t dst)
346 {
347 (void) memcpy(dst, src->uc_mcontext.gregs, sizeof (gregset_t));
348 }
349
350 /*
351 * Read arguments from the frame indicated by regs into args, return the
352 * number of arguments successfully read
353 */
354 static int
read_args(struct ps_prochandle * P,uintptr_t fp,uintptr_t pc,prgreg_t * args,size_t argsize)355 read_args(struct ps_prochandle *P, uintptr_t fp, uintptr_t pc, prgreg_t *args,
356 size_t argsize)
357 {
358 GElf_Sym sym;
359 ctf_file_t *ctfp = NULL;
360 ctf_funcinfo_t finfo;
361 prsyminfo_t si = {0};
362 uint8_t ins[SAVEARGS_INSN_SEQ_LEN];
363 size_t insnsize;
364 int argc = 0;
365 int rettype = 0;
366 int start_index = 0;
367 int args_style = 0;
368 int i;
369 ctf_id_t args_types[5];
370
371 if (Pxlookup_by_addr(P, pc, NULL, 0, &sym, &si) != 0)
372 return (0);
373
374 if ((ctfp = Paddr_to_ctf(P, pc)) == NULL)
375 return (0);
376
377 if (ctf_func_info(ctfp, si.prs_id, &finfo) == CTF_ERR)
378 return (0);
379
380 argc = finfo.ctc_argc;
381
382 if (argc == 0)
383 return (0);
384
385 rettype = ctf_type_kind(ctfp, finfo.ctc_return);
386
387 /*
388 * If the function returns a structure or union greater than 16 bytes
389 * in size %rdi contains the address in which to store the return
390 * value rather than for an argument.
391 */
392 if (((rettype == CTF_K_STRUCT) || (rettype == CTF_K_UNION)) &&
393 ctf_type_size(ctfp, finfo.ctc_return) > 16)
394 start_index = 1;
395 else
396 start_index = 0;
397
398 /*
399 * If any of the first 5 arguments are a structure less than 16 bytes
400 * in size, it will be passed spread across two argument registers,
401 * and we will not cope.
402 */
403 if (ctf_func_args(ctfp, si.prs_id, 5, args_types) == CTF_ERR)
404 return (0);
405
406 for (i = 0; i < MIN(5, finfo.ctc_argc); i++) {
407 int t = ctf_type_kind(ctfp, args_types[i]);
408
409 if (((t == CTF_K_STRUCT) || (t == CTF_K_UNION)) &&
410 ctf_type_size(ctfp, args_types[i]) <= 16)
411 return (0);
412 }
413
414 /*
415 * The number of instructions to search for argument saving is limited
416 * such that only instructions prior to %pc are considered and we
417 * never read arguments from a function where the saving code has not
418 * in fact yet executed.
419 */
420 insnsize = MIN(MIN(sym.st_size, SAVEARGS_INSN_SEQ_LEN),
421 pc - sym.st_value);
422
423 if (Pread(P, ins, insnsize, sym.st_value) != insnsize)
424 return (0);
425
426 if ((argc != 0) &&
427 ((args_style = saveargs_has_args(ins, insnsize, argc,
428 start_index)) != SAVEARGS_NO_ARGS)) {
429 int regargs = MIN((6 - start_index), argc);
430 size_t size = regargs * sizeof (long);
431 int i;
432
433 /*
434 * If Studio pushed a structure return address as an argument,
435 * we need to read one more argument than actually exists (the
436 * addr) to make everything line up.
437 */
438 if (args_style == SAVEARGS_STRUCT_ARGS)
439 size += sizeof (long);
440
441 if (Pread(P, args, size, (fp - size)) != size)
442 return (0);
443
444 for (i = 0; i < (regargs / 2); i++) {
445 prgreg_t t = args[i];
446
447 args[i] = args[regargs - i - 1];
448 args[regargs - i - 1] = t;
449 }
450
451 if (argc > regargs) {
452 size = MIN((argc - regargs) * sizeof (long),
453 argsize - (regargs * sizeof (long)));
454
455 if (Pread(P, &args[regargs], size, fp +
456 (sizeof (uintptr_t) * 2)) != size)
457 return (6);
458 }
459
460 return (argc);
461 } else {
462 return (0);
463 }
464 }
465
466 int
Pstack_iter(struct ps_prochandle * P,const prgregset_t regs,proc_stack_f * func,void * arg)467 Pstack_iter(struct ps_prochandle *P, const prgregset_t regs,
468 proc_stack_f *func, void *arg)
469 {
470 struct {
471 uintptr_t fp;
472 uintptr_t pc;
473 } frame;
474
475 uint_t pfpsize = 0;
476 prgreg_t *prevfp = NULL;
477 prgreg_t fp, pfp;
478 prgreg_t pc;
479
480 prgregset_t gregs;
481 int nfp = 0;
482
483 uclist_t ucl;
484 int rv = 0;
485 int argc;
486
487 uintptr_t uc_addr;
488 ucontext_t uc;
489
490 /*
491 * Type definition for a structure corresponding to an IA32
492 * signal frame. Refer to the comments in Pstack.c for more info
493 */
494 typedef struct {
495 prgreg_t fp;
496 prgreg_t pc;
497 prgreg_t signo;
498 siginfo_t *sip;
499 } sigframe_t;
500 prgreg_t args[32] = {0};
501
502 if (P->status.pr_dmodel != PR_MODEL_LP64)
503 return (Pstack_iter32(P, regs, func, arg));
504
505 init_uclist(&ucl, P);
506 (void) memcpy(gregs, regs, sizeof (gregs));
507
508 fp = gregs[R_FP];
509 pc = gregs[R_PC];
510
511 while (fp != 0 || pc != 0) {
512
513 if (stack_loop(fp, &prevfp, &nfp, &pfpsize))
514 break;
515
516 if (fp != 0 &&
517 Pread(P, &frame, sizeof (frame), (uintptr_t)fp) ==
518 sizeof (frame)) {
519 if (frame.pc == -1) {
520 argc = 3;
521 args[2] = fp + sizeof (sigframe_t);
522 if (Pread(P, &args, 2 * sizeof (prgreg_t),
523 fp + 2 * sizeof (prgreg_t)) !=
524 2 * sizeof (prgreg_t))
525 argc = 0;
526 } else {
527 argc = read_args(P, fp, pc, args,
528 sizeof (args));
529 }
530 } else {
531 (void) memset(&frame, 0, sizeof (frame));
532 argc = 0;
533 }
534
535 gregs[R_FP] = fp;
536 gregs[R_PC] = pc;
537
538 if ((rv = func(arg, gregs, argc, args)) != 0)
539 break;
540
541 pfp = fp;
542 fp = frame.fp;
543 pc = frame.pc;
544
545 if (pc == -1 && find_uclink(&ucl, pfp + sizeof (sigframe_t))) {
546 uc_addr = pfp + sizeof (sigframe_t);
547
548 if (Pread(P, &uc, sizeof (uc), uc_addr)
549 == sizeof (uc)) {
550 ucontext_n_to_prgregs(&uc, gregs);
551 fp = gregs[R_FP];
552 pc = gregs[R_PC];
553 }
554 }
555 }
556
557 if (prevfp)
558 free(prevfp);
559
560 free_uclist(&ucl);
561
562 return (rv);
563 }
564
565 uintptr_t
Psyscall_setup(struct ps_prochandle * P,int nargs,int sysindex,uintptr_t sp)566 Psyscall_setup(struct ps_prochandle *P, int nargs, int sysindex, uintptr_t sp)
567 {
568 if (P->status.pr_dmodel == PR_MODEL_ILP32) {
569 sp -= sizeof (int) * (nargs+2);
570
571 P->status.pr_lwp.pr_reg[REG_RAX] = sysindex;
572 P->status.pr_lwp.pr_reg[REG_RSP] = sp;
573 P->status.pr_lwp.pr_reg[REG_RIP] = P->sysaddr;
574 } else {
575 int pusharg = (nargs > 6) ? nargs - 6: 0;
576
577 sp -= sizeof (int64_t) * (pusharg+2);
578
579 P->status.pr_lwp.pr_reg[REG_RAX] = sysindex;
580 P->status.pr_lwp.pr_reg[REG_RSP] = sp;
581 P->status.pr_lwp.pr_reg[REG_RIP] = P->sysaddr;
582 }
583
584 return (sp);
585 }
586
587 int
Psyscall_copyinargs(struct ps_prochandle * P,int nargs,argdes_t * argp,uintptr_t ap)588 Psyscall_copyinargs(struct ps_prochandle *P, int nargs, argdes_t *argp,
589 uintptr_t ap)
590 {
591 if (P->status.pr_dmodel == PR_MODEL_ILP32) {
592 int32_t arglist[MAXARGS+2];
593 int i;
594 argdes_t *adp;
595
596 for (i = 0, adp = argp; i < nargs; i++, adp++)
597 arglist[1 + i] = (int32_t)adp->arg_value;
598
599 arglist[0] = P->status.pr_lwp.pr_reg[REG_RIP];
600 if (Pwrite(P, &arglist[0], sizeof (int) * (nargs+1),
601 (uintptr_t)ap) != sizeof (int) * (nargs+1))
602 return (-1);
603 } else {
604 int64_t arglist[MAXARGS+2];
605 int i;
606 argdes_t *adp;
607 int pusharg = (nargs > 6) ? nargs - 6: 0;
608
609 for (i = 0, adp = argp; i < nargs; i++, adp++) {
610 switch (i) {
611 case 0:
612 (void) Pputareg(P, REG_RDI, adp->arg_value);
613 break;
614 case 1:
615 (void) Pputareg(P, REG_RSI, adp->arg_value);
616 break;
617 case 2:
618 (void) Pputareg(P, REG_RDX, adp->arg_value);
619 break;
620 case 3:
621 (void) Pputareg(P, REG_RCX, adp->arg_value);
622 break;
623 case 4:
624 (void) Pputareg(P, REG_R8, adp->arg_value);
625 break;
626 case 5:
627 (void) Pputareg(P, REG_R9, adp->arg_value);
628 break;
629 default:
630 arglist[i - 5] = (uint64_t)adp->arg_value;
631 break;
632 }
633 }
634
635 arglist[0] = P->status.pr_lwp.pr_reg[REG_RIP];
636
637 if (Pwrite(P, &arglist[0],
638 sizeof (int64_t) * (pusharg + 1), ap) !=
639 sizeof (int64_t) * (pusharg + 1))
640 return (-1);
641 }
642
643 return (0);
644 }
645
646 int
Psyscall_copyoutargs(struct ps_prochandle * P,int nargs,argdes_t * argp,uintptr_t ap)647 Psyscall_copyoutargs(struct ps_prochandle *P, int nargs, argdes_t *argp,
648 uintptr_t ap)
649 {
650 if (P->status.pr_dmodel == PR_MODEL_ILP32) {
651 uint32_t arglist[MAXARGS + 2];
652 int i;
653 argdes_t *adp;
654
655 if (Pread(P, &arglist[0], sizeof (int) * (nargs+1),
656 (uintptr_t)ap) != sizeof (int) * (nargs+1))
657 return (-1);
658
659 for (i = 0, adp = argp; i < nargs; i++, adp++)
660 adp->arg_value = arglist[i];
661 } else {
662 int pusharg = (nargs > 6) ? nargs - 6: 0;
663 int64_t arglist[MAXARGS+2];
664 int i;
665 argdes_t *adp;
666
667 if (pusharg > 0 &&
668 Pread(P, &arglist[0], sizeof (int64_t) * (pusharg + 1),
669 ap) != sizeof (int64_t) * (pusharg + 1))
670 return (-1);
671
672 for (i = 0, adp = argp; i < nargs; i++, adp++) {
673 switch (i) {
674 case 0:
675 adp->arg_value =
676 P->status.pr_lwp.pr_reg[REG_RDI];
677 break;
678 case 1:
679 adp->arg_value =
680 P->status.pr_lwp.pr_reg[REG_RSI];
681 break;
682 case 2:
683 adp->arg_value =
684 P->status.pr_lwp.pr_reg[REG_RDX];
685 break;
686 case 3:
687 adp->arg_value =
688 P->status.pr_lwp.pr_reg[REG_RCX];
689 break;
690 case 4:
691 adp->arg_value =
692 P->status.pr_lwp.pr_reg[REG_R8];
693 break;
694 case 5:
695 adp->arg_value =
696 P->status.pr_lwp.pr_reg[REG_R9];
697 break;
698 default:
699 adp->arg_value = arglist[i - 6];
700 break;
701 }
702 }
703
704 return (0);
705 }
706
707 return (0);
708 }
709