1 /* Functions specific to running gdb native on IA-64 running
4 Copyright (C) 1999-2019 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
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.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
26 #include "ia64-tdep.h"
27 #include "linux-nat.h"
30 #include "nat/gdb_ptrace.h"
31 #include "common/gdb_wait.h"
35 #include <sys/syscall.h>
38 #include <asm/ptrace_offsets.h>
39 #include <sys/procfs.h>
41 /* Prototypes for supply_gregset etc. */
44 #include "inf-ptrace.h"
46 class ia64_linux_nat_target final
: public linux_nat_target
49 /* Add our register access methods. */
50 void fetch_registers (struct regcache
*, int) override
;
51 void store_registers (struct regcache
*, int) override
;
53 enum target_xfer_status
xfer_partial (enum target_object object
,
56 const gdb_byte
*writebuf
,
57 ULONGEST offset
, ULONGEST len
,
58 ULONGEST
*xfered_len
) override
;
60 /* Override watchpoint routines. */
62 /* The IA-64 architecture can step over a watch point (without
63 triggering it again) if the "dd" (data debug fault disable) bit
64 in the processor status word is set.
66 This PSR bit is set in
67 ia64_linux_nat_target::stopped_by_watchpoint when the code there
68 has determined that a hardware watchpoint has indeed been hit.
69 The CPU will then be able to execute one instruction without
70 triggering a watchpoint. */
71 bool have_steppable_watchpoint () override
{ return true; }
73 int can_use_hw_breakpoint (enum bptype
, int, int) override
;
74 bool stopped_by_watchpoint () override
;
75 bool stopped_data_address (CORE_ADDR
*) override
;
76 int insert_watchpoint (CORE_ADDR
, int, enum target_hw_bp_type
,
77 struct expression
*) override
;
78 int remove_watchpoint (CORE_ADDR
, int, enum target_hw_bp_type
,
79 struct expression
*) override
;
80 /* Override linux_nat_target low methods. */
81 void low_new_thread (struct lwp_info
*lp
) override
;
82 bool low_status_is_event (int status
) override
;
85 static ia64_linux_nat_target the_ia64_linux_nat_target
;
87 /* These must match the order of the register names.
89 Some sort of lookup table is needed because the offsets associated
90 with the registers are all over the board. */
92 static int u_offsets
[] =
94 /* general registers */
95 -1, /* gr0 not available; i.e, it's always zero. */
127 /* gr32 through gr127 not directly available via the ptrace interface. */
128 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
129 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
130 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
131 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
132 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
133 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
134 /* Floating point registers */
135 -1, -1, /* f0 and f1 not available (f0 is +0.0 and f1 is +1.0). */
262 /* Predicate registers - we don't fetch these individually. */
263 -1, -1, -1, -1, -1, -1, -1, -1,
264 -1, -1, -1, -1, -1, -1, -1, -1,
265 -1, -1, -1, -1, -1, -1, -1, -1,
266 -1, -1, -1, -1, -1, -1, -1, -1,
267 -1, -1, -1, -1, -1, -1, -1, -1,
268 -1, -1, -1, -1, -1, -1, -1, -1,
269 -1, -1, -1, -1, -1, -1, -1, -1,
270 -1, -1, -1, -1, -1, -1, -1, -1,
271 /* branch registers */
280 /* Virtual frame pointer and virtual return address pointer. */
282 /* other registers */
285 PT_CR_IPSR
, /* psr */
287 /* kernel registers not visible via ptrace interface (?) */
288 -1, -1, -1, -1, -1, -1, -1, -1,
290 -1, -1, -1, -1, -1, -1, -1, -1,
296 -1, /* Not available: FCR, IA32 floating control register. */
298 -1, /* Not available: EFLAG */
299 -1, /* Not available: CSD */
300 -1, /* Not available: SSD */
301 -1, /* Not available: CFLG */
302 -1, /* Not available: FSR */
303 -1, /* Not available: FIR */
304 -1, /* Not available: FDR */
312 -1, /* Not available: ITC */
313 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
314 -1, -1, -1, -1, -1, -1, -1, -1, -1,
318 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
319 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
320 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
321 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
322 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
323 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
325 /* nat bits - not fetched directly; instead we obtain these bits from
326 either rnat or unat or from memory. */
327 -1, -1, -1, -1, -1, -1, -1, -1,
328 -1, -1, -1, -1, -1, -1, -1, -1,
329 -1, -1, -1, -1, -1, -1, -1, -1,
330 -1, -1, -1, -1, -1, -1, -1, -1,
331 -1, -1, -1, -1, -1, -1, -1, -1,
332 -1, -1, -1, -1, -1, -1, -1, -1,
333 -1, -1, -1, -1, -1, -1, -1, -1,
334 -1, -1, -1, -1, -1, -1, -1, -1,
335 -1, -1, -1, -1, -1, -1, -1, -1,
336 -1, -1, -1, -1, -1, -1, -1, -1,
337 -1, -1, -1, -1, -1, -1, -1, -1,
338 -1, -1, -1, -1, -1, -1, -1, -1,
339 -1, -1, -1, -1, -1, -1, -1, -1,
340 -1, -1, -1, -1, -1, -1, -1, -1,
341 -1, -1, -1, -1, -1, -1, -1, -1,
342 -1, -1, -1, -1, -1, -1, -1, -1,
346 ia64_register_addr (struct gdbarch
*gdbarch
, int regno
)
350 if (regno
< 0 || regno
>= gdbarch_num_regs (gdbarch
))
351 error (_("Invalid register number %d."), regno
);
353 if (u_offsets
[regno
] == -1)
356 addr
= (CORE_ADDR
) u_offsets
[regno
];
362 ia64_cannot_fetch_register (struct gdbarch
*gdbarch
, int regno
)
365 || regno
>= gdbarch_num_regs (gdbarch
)
366 || u_offsets
[regno
] == -1;
370 ia64_cannot_store_register (struct gdbarch
*gdbarch
, int regno
)
372 /* Rationale behind not permitting stores to bspstore...
374 The IA-64 architecture provides bspstore and bsp which refer
375 memory locations in the RSE's backing store. bspstore is the
376 next location which will be written when the RSE needs to write
377 to memory. bsp is the address at which r32 in the current frame
378 would be found if it were written to the backing store.
380 The IA-64 architecture provides read-only access to bsp and
381 read/write access to bspstore (but only when the RSE is in
382 the enforced lazy mode). It should be noted that stores
383 to bspstore also affect the value of bsp. Changing bspstore
384 does not affect the number of dirty entries between bspstore
385 and bsp, so changing bspstore by N words will also cause bsp
386 to be changed by (roughly) N as well. (It could be N-1 or N+1
387 depending upon where the NaT collection bits fall.)
389 OTOH, the Linux kernel provides read/write access to bsp (and
390 currently read/write access to bspstore as well). But it
391 is definitely the case that if you change one, the other
392 will change at the same time. It is more useful to gdb to
393 be able to change bsp. So in order to prevent strange and
394 undesirable things from happening when a dummy stack frame
395 is popped (after calling an inferior function), we allow
396 bspstore to be read, but not written. (Note that popping
397 a (generic) dummy stack frame causes all registers that
398 were previously read from the inferior process to be written
402 || regno
>= gdbarch_num_regs (gdbarch
)
403 || u_offsets
[regno
] == -1
404 || regno
== IA64_BSPSTORE_REGNUM
;
408 supply_gregset (struct regcache
*regcache
, const gregset_t
*gregsetp
)
411 const greg_t
*regp
= (const greg_t
*) gregsetp
;
413 for (regi
= IA64_GR0_REGNUM
; regi
<= IA64_GR31_REGNUM
; regi
++)
415 regcache
->raw_supply (regi
, regp
+ (regi
- IA64_GR0_REGNUM
));
418 /* FIXME: NAT collection bits are at index 32; gotta deal with these
421 regcache
->raw_supply (IA64_PR_REGNUM
, regp
+ 33);
423 for (regi
= IA64_BR0_REGNUM
; regi
<= IA64_BR7_REGNUM
; regi
++)
425 regcache
->raw_supply (regi
, regp
+ 34 + (regi
- IA64_BR0_REGNUM
));
428 regcache
->raw_supply (IA64_IP_REGNUM
, regp
+ 42);
429 regcache
->raw_supply (IA64_CFM_REGNUM
, regp
+ 43);
430 regcache
->raw_supply (IA64_PSR_REGNUM
, regp
+ 44);
431 regcache
->raw_supply (IA64_RSC_REGNUM
, regp
+ 45);
432 regcache
->raw_supply (IA64_BSP_REGNUM
, regp
+ 46);
433 regcache
->raw_supply (IA64_BSPSTORE_REGNUM
, regp
+ 47);
434 regcache
->raw_supply (IA64_RNAT_REGNUM
, regp
+ 48);
435 regcache
->raw_supply (IA64_CCV_REGNUM
, regp
+ 49);
436 regcache
->raw_supply (IA64_UNAT_REGNUM
, regp
+ 50);
437 regcache
->raw_supply (IA64_FPSR_REGNUM
, regp
+ 51);
438 regcache
->raw_supply (IA64_PFS_REGNUM
, regp
+ 52);
439 regcache
->raw_supply (IA64_LC_REGNUM
, regp
+ 53);
440 regcache
->raw_supply (IA64_EC_REGNUM
, regp
+ 54);
444 fill_gregset (const struct regcache
*regcache
, gregset_t
*gregsetp
, int regno
)
447 greg_t
*regp
= (greg_t
*) gregsetp
;
449 #define COPY_REG(_idx_,_regi_) \
450 if ((regno == -1) || regno == _regi_) \
451 regcache->raw_collect (_regi_, regp + _idx_)
453 for (regi
= IA64_GR0_REGNUM
; regi
<= IA64_GR31_REGNUM
; regi
++)
455 COPY_REG (regi
- IA64_GR0_REGNUM
, regi
);
458 /* FIXME: NAT collection bits at index 32? */
460 COPY_REG (33, IA64_PR_REGNUM
);
462 for (regi
= IA64_BR0_REGNUM
; regi
<= IA64_BR7_REGNUM
; regi
++)
464 COPY_REG (34 + (regi
- IA64_BR0_REGNUM
), regi
);
467 COPY_REG (42, IA64_IP_REGNUM
);
468 COPY_REG (43, IA64_CFM_REGNUM
);
469 COPY_REG (44, IA64_PSR_REGNUM
);
470 COPY_REG (45, IA64_RSC_REGNUM
);
471 COPY_REG (46, IA64_BSP_REGNUM
);
472 COPY_REG (47, IA64_BSPSTORE_REGNUM
);
473 COPY_REG (48, IA64_RNAT_REGNUM
);
474 COPY_REG (49, IA64_CCV_REGNUM
);
475 COPY_REG (50, IA64_UNAT_REGNUM
);
476 COPY_REG (51, IA64_FPSR_REGNUM
);
477 COPY_REG (52, IA64_PFS_REGNUM
);
478 COPY_REG (53, IA64_LC_REGNUM
);
479 COPY_REG (54, IA64_EC_REGNUM
);
482 /* Given a pointer to a floating point register set in /proc format
483 (fpregset_t *), unpack the register contents and supply them as gdb's
484 idea of the current floating point register values. */
487 supply_fpregset (struct regcache
*regcache
, const fpregset_t
*fpregsetp
)
491 const gdb_byte f_zero
[16] = { 0 };
492 const gdb_byte f_one
[16] =
493 { 0, 0, 0, 0, 0, 0, 0, 0x80, 0xff, 0xff, 0, 0, 0, 0, 0, 0 };
495 /* Kernel generated cores have fr1==0 instead of 1.0. Older GDBs
496 did the same. So ignore whatever might be recorded in fpregset_t
497 for fr0/fr1 and always supply their expected values. */
499 /* fr0 is always read as zero. */
500 regcache
->raw_supply (IA64_FR0_REGNUM
, f_zero
);
501 /* fr1 is always read as one (1.0). */
502 regcache
->raw_supply (IA64_FR1_REGNUM
, f_one
);
504 for (regi
= IA64_FR2_REGNUM
; regi
<= IA64_FR127_REGNUM
; regi
++)
506 from
= (const char *) &((*fpregsetp
)[regi
- IA64_FR0_REGNUM
]);
507 regcache
->raw_supply (regi
, from
);
511 /* Given a pointer to a floating point register set in /proc format
512 (fpregset_t *), update the register specified by REGNO from gdb's idea
513 of the current floating point register set. If REGNO is -1, update
517 fill_fpregset (const struct regcache
*regcache
,
518 fpregset_t
*fpregsetp
, int regno
)
522 for (regi
= IA64_FR0_REGNUM
; regi
<= IA64_FR127_REGNUM
; regi
++)
524 if ((regno
== -1) || (regno
== regi
))
525 regcache
->raw_collect (regi
, &((*fpregsetp
)[regi
- IA64_FR0_REGNUM
]));
529 #define IA64_PSR_DB (1UL << 24)
530 #define IA64_PSR_DD (1UL << 39)
533 enable_watchpoints_in_psr (ptid_t ptid
)
535 struct regcache
*regcache
= get_thread_regcache (ptid
);
538 regcache_cooked_read_unsigned (regcache
, IA64_PSR_REGNUM
, &psr
);
539 if (!(psr
& IA64_PSR_DB
))
541 psr
|= IA64_PSR_DB
; /* Set the db bit - this enables hardware
542 watchpoints and breakpoints. */
543 regcache_cooked_write_unsigned (regcache
, IA64_PSR_REGNUM
, psr
);
547 static long debug_registers
[8];
550 store_debug_register (ptid_t ptid
, int idx
, long val
)
558 (void) ptrace (PT_WRITE_U
, tid
, (PTRACE_TYPE_ARG3
) (PT_DBR
+ 8 * idx
), val
);
562 store_debug_register_pair (ptid_t ptid
, int idx
, long *dbr_addr
,
566 store_debug_register (ptid
, 2 * idx
, *dbr_addr
);
568 store_debug_register (ptid
, 2 * idx
+ 1, *dbr_mask
);
572 is_power_of_2 (int val
)
577 for (i
= 0; i
< 8 * sizeof (val
); i
++)
581 return onecount
<= 1;
585 ia64_linux_nat_target::insert_watchpoint (CORE_ADDR addr
, int len
,
586 enum target_hw_bp_type type
,
587 struct expression
*cond
)
591 long dbr_addr
, dbr_mask
;
592 int max_watchpoints
= 4;
594 if (len
<= 0 || !is_power_of_2 (len
))
597 for (idx
= 0; idx
< max_watchpoints
; idx
++)
599 dbr_mask
= debug_registers
[idx
* 2 + 1];
600 if ((dbr_mask
& (0x3UL
<< 62)) == 0)
602 /* Exit loop if both r and w bits clear. */
607 if (idx
== max_watchpoints
)
610 dbr_addr
= (long) addr
;
611 dbr_mask
= (~(len
- 1) & 0x00ffffffffffffffL
); /* construct mask to match */
612 dbr_mask
|= 0x0800000000000000L
; /* Only match privilege level 3 */
616 dbr_mask
|= (1L << 62); /* Set w bit */
619 dbr_mask
|= (1L << 63); /* Set r bit */
622 dbr_mask
|= (3L << 62); /* Set both r and w bits */
628 debug_registers
[2 * idx
] = dbr_addr
;
629 debug_registers
[2 * idx
+ 1] = dbr_mask
;
632 store_debug_register_pair (lp
->ptid
, idx
, &dbr_addr
, &dbr_mask
);
633 enable_watchpoints_in_psr (lp
->ptid
);
640 ia64_linux_nat_target::remove_watchpoint (CORE_ADDR addr
, int len
,
641 enum target_hw_bp_type type
,
642 struct expression
*cond
)
645 long dbr_addr
, dbr_mask
;
646 int max_watchpoints
= 4;
648 if (len
<= 0 || !is_power_of_2 (len
))
651 for (idx
= 0; idx
< max_watchpoints
; idx
++)
653 dbr_addr
= debug_registers
[2 * idx
];
654 dbr_mask
= debug_registers
[2 * idx
+ 1];
655 if ((dbr_mask
& (0x3UL
<< 62)) && addr
== (CORE_ADDR
) dbr_addr
)
659 debug_registers
[2 * idx
] = 0;
660 debug_registers
[2 * idx
+ 1] = 0;
665 store_debug_register_pair (lp
->ptid
, idx
, &dbr_addr
, &dbr_mask
);
674 ia64_linux_nat_target::low_new_thread (struct lwp_info
*lp
)
679 for (i
= 0; i
< 8; i
++)
681 if (debug_registers
[i
] != 0)
683 store_debug_register (lp
->ptid
, i
, debug_registers
[i
]);
687 enable_watchpoints_in_psr (lp
->ptid
);
691 ia64_linux_nat_target::stopped_data_address (CORE_ADDR
*addr_p
)
695 struct regcache
*regcache
= get_current_regcache ();
697 if (!linux_nat_get_siginfo (inferior_ptid
, &siginfo
))
700 if (siginfo
.si_signo
!= SIGTRAP
701 || (siginfo
.si_code
& 0xffff) != 0x0004 /* TRAP_HWBKPT */)
704 regcache_cooked_read_unsigned (regcache
, IA64_PSR_REGNUM
, &psr
);
705 psr
|= IA64_PSR_DD
; /* Set the dd bit - this will disable the watchpoint
706 for the next instruction. */
707 regcache_cooked_write_unsigned (regcache
, IA64_PSR_REGNUM
, psr
);
709 *addr_p
= (CORE_ADDR
) siginfo
.si_addr
;
714 ia64_linux_nat_target::stopped_by_watchpoint ()
717 return stopped_data_address (&addr
);
721 ia64_linux_nat_target::can_use_hw_breakpoint (enum bptype type
,
722 int cnt
, int othertype
)
728 /* Fetch register REGNUM from the inferior. */
731 ia64_linux_fetch_register (struct regcache
*regcache
, int regnum
)
733 struct gdbarch
*gdbarch
= regcache
->arch ();
736 PTRACE_TYPE_RET
*buf
;
740 /* r0 cannot be fetched but is always zero. */
741 if (regnum
== IA64_GR0_REGNUM
)
743 const gdb_byte zero
[8] = { 0 };
745 gdb_assert (sizeof (zero
) == register_size (gdbarch
, regnum
));
746 regcache
->raw_supply (regnum
, zero
);
750 /* fr0 cannot be fetched but is always zero. */
751 if (regnum
== IA64_FR0_REGNUM
)
753 const gdb_byte f_zero
[16] = { 0 };
755 gdb_assert (sizeof (f_zero
) == register_size (gdbarch
, regnum
));
756 regcache
->raw_supply (regnum
, f_zero
);
760 /* fr1 cannot be fetched but is always one (1.0). */
761 if (regnum
== IA64_FR1_REGNUM
)
763 const gdb_byte f_one
[16] =
764 { 0, 0, 0, 0, 0, 0, 0, 0x80, 0xff, 0xff, 0, 0, 0, 0, 0, 0 };
766 gdb_assert (sizeof (f_one
) == register_size (gdbarch
, regnum
));
767 regcache
->raw_supply (regnum
, f_one
);
771 if (ia64_cannot_fetch_register (gdbarch
, regnum
))
773 regcache
->raw_supply (regnum
, NULL
);
777 pid
= get_ptrace_pid (regcache
->ptid ());
779 /* This isn't really an address, but ptrace thinks of it as one. */
780 addr
= ia64_register_addr (gdbarch
, regnum
);
781 size
= register_size (gdbarch
, regnum
);
783 gdb_assert ((size
% sizeof (PTRACE_TYPE_RET
)) == 0);
784 buf
= (PTRACE_TYPE_RET
*) alloca (size
);
786 /* Read the register contents from the inferior a chunk at a time. */
787 for (i
= 0; i
< size
/ sizeof (PTRACE_TYPE_RET
); i
++)
790 buf
[i
] = ptrace (PT_READ_U
, pid
, (PTRACE_TYPE_ARG3
)addr
, 0);
792 error (_("Couldn't read register %s (#%d): %s."),
793 gdbarch_register_name (gdbarch
, regnum
),
794 regnum
, safe_strerror (errno
));
796 addr
+= sizeof (PTRACE_TYPE_RET
);
798 regcache
->raw_supply (regnum
, buf
);
801 /* Fetch register REGNUM from the inferior. If REGNUM is -1, do this
802 for all registers. */
805 ia64_linux_nat_target::fetch_registers (struct regcache
*regcache
, int regnum
)
809 regnum
< gdbarch_num_regs (regcache
->arch ());
811 ia64_linux_fetch_register (regcache
, regnum
);
813 ia64_linux_fetch_register (regcache
, regnum
);
816 /* Store register REGNUM into the inferior. */
819 ia64_linux_store_register (const struct regcache
*regcache
, int regnum
)
821 struct gdbarch
*gdbarch
= regcache
->arch ();
824 PTRACE_TYPE_RET
*buf
;
828 if (ia64_cannot_store_register (gdbarch
, regnum
))
831 pid
= get_ptrace_pid (regcache
->ptid ());
833 /* This isn't really an address, but ptrace thinks of it as one. */
834 addr
= ia64_register_addr (gdbarch
, regnum
);
835 size
= register_size (gdbarch
, regnum
);
837 gdb_assert ((size
% sizeof (PTRACE_TYPE_RET
)) == 0);
838 buf
= (PTRACE_TYPE_RET
*) alloca (size
);
840 /* Write the register contents into the inferior a chunk at a time. */
841 regcache
->raw_collect (regnum
, buf
);
842 for (i
= 0; i
< size
/ sizeof (PTRACE_TYPE_RET
); i
++)
845 ptrace (PT_WRITE_U
, pid
, (PTRACE_TYPE_ARG3
)addr
, buf
[i
]);
847 error (_("Couldn't write register %s (#%d): %s."),
848 gdbarch_register_name (gdbarch
, regnum
),
849 regnum
, safe_strerror (errno
));
851 addr
+= sizeof (PTRACE_TYPE_RET
);
855 /* Store register REGNUM back into the inferior. If REGNUM is -1, do
856 this for all registers. */
859 ia64_linux_nat_target::store_registers (struct regcache
*regcache
, int regnum
)
863 regnum
< gdbarch_num_regs (regcache
->arch ());
865 ia64_linux_store_register (regcache
, regnum
);
867 ia64_linux_store_register (regcache
, regnum
);
870 /* Implement the xfer_partial target_ops method. */
872 enum target_xfer_status
873 ia64_linux_nat_target::xfer_partial (enum target_object object
,
875 gdb_byte
*readbuf
, const gdb_byte
*writebuf
,
876 ULONGEST offset
, ULONGEST len
,
877 ULONGEST
*xfered_len
)
879 if (object
== TARGET_OBJECT_UNWIND_TABLE
&& readbuf
!= NULL
)
881 static long gate_table_size
;
885 /* Probe for the table size once. */
886 if (gate_table_size
== 0)
887 gate_table_size
= syscall (__NR_getunwind
, NULL
, 0);
888 if (gate_table_size
< 0)
889 return TARGET_XFER_E_IO
;
891 if (offset
>= gate_table_size
)
892 return TARGET_XFER_EOF
;
894 tmp_buf
= (gdb_byte
*) alloca (gate_table_size
);
895 res
= syscall (__NR_getunwind
, tmp_buf
, gate_table_size
);
897 return TARGET_XFER_E_IO
;
898 gdb_assert (res
== gate_table_size
);
900 if (offset
+ len
> gate_table_size
)
901 len
= gate_table_size
- offset
;
903 memcpy (readbuf
, tmp_buf
+ offset
, len
);
905 return TARGET_XFER_OK
;
908 return linux_nat_target::xfer_partial (object
, annex
, readbuf
, writebuf
,
909 offset
, len
, xfered_len
);
912 /* For break.b instruction ia64 CPU forgets the immediate value and generates
913 SIGILL with ILL_ILLOPC instead of more common SIGTRAP with TRAP_BRKPT.
914 ia64 does not use gdbarch_decr_pc_after_break so we do not have to make any
915 difference for the signals here. */
918 ia64_linux_nat_target::low_status_is_event (int status
)
920 return WIFSTOPPED (status
) && (WSTOPSIG (status
) == SIGTRAP
921 || WSTOPSIG (status
) == SIGILL
);
925 _initialize_ia64_linux_nat (void)
927 /* Register the target. */
928 linux_target
= &the_ia64_linux_nat_target
;
929 add_inf_child_target (&the_ia64_linux_nat_target
);