X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fppc-linux-nat.c;h=66e80629c460ac3785f1f54021ba67349d6afa4f;hb=403cb6b138c38faf72f7abc034db3505b9bdb82f;hp=1bd157be96c145df2fed72d42a44d261eae3961a;hpb=b261e0c5364661b66d55f4e77e95e7d09af8b9aa;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/ppc-linux-nat.c b/gdb/ppc-linux-nat.c index 1bd157be96..66e80629c4 100644 --- a/gdb/ppc-linux-nat.c +++ b/gdb/ppc-linux-nat.c @@ -1,7 +1,6 @@ /* PPC GNU/Linux native support. - Copyright (C) 1988-1989, 1991-1992, 1994, 1996, 2000-2012 Free - Software Foundation, Inc. + Copyright (C) 1988-2013 Free Software Foundation, Inc. This file is part of GDB. @@ -32,7 +31,6 @@ #include #include -#include #include #include #include @@ -103,7 +101,7 @@ #endif /* Similarly for the hardware watchpoint support. These requests are used - when the BookE kernel interface is not available. */ + when the PowerPC HWDEBUG ptrace interface is not available. */ #ifndef PTRACE_GET_DEBUGREG #define PTRACE_GET_DEBUGREG 25 #endif @@ -114,15 +112,15 @@ #define PTRACE_GETSIGINFO 0x4202 #endif -/* These requests are used when the BookE kernel interface is available. - It exposes the additional debug features of BookE processors, such as - ranged breakpoints and watchpoints and hardware-accelerated condition - evaluation. */ +/* These requests are used when the PowerPC HWDEBUG ptrace interface is + available. It exposes the debug facilities of PowerPC processors, as well + as additional features of BookE processors, such as ranged breakpoints and + watchpoints and hardware-accelerated condition evaluation. */ #ifndef PPC_PTRACE_GETHWDBGINFO -/* Not having PPC_PTRACE_GETHWDBGINFO defined means that the new BookE - interface is not present in ptrace.h, so we'll have to pretty much include - it all here so that the code at least compiles on older systems. */ +/* Not having PPC_PTRACE_GETHWDBGINFO defined means that the PowerPC HWDEBUG + ptrace interface is not present in ptrace.h, so we'll have to pretty much + include it all here so that the code at least compiles on older systems. */ #define PPC_PTRACE_GETHWDBGINFO 0x89 #define PPC_PTRACE_SETHWDEBUG 0x88 #define PPC_PTRACE_DELHWDEBUG 0x87 @@ -179,7 +177,11 @@ struct ppc_hw_breakpoint (1<<((n)+PPC_BREAKPOINT_CONDITION_BE_SHIFT)) #endif /* PPC_PTRACE_GETHWDBGINFO */ - +/* Feature defined on Linux kernel v3.9: DAWR interface, that enables wider + watchpoint (up to 512 bytes). */ +#ifndef PPC_DEBUG_FEATURE_DATA_BP_DAWR +#define PPC_DEBUG_FEATURE_DATA_BP_DAWR 0x10 +#endif /* PPC_DEBUG_FEATURE_DATA_BP_DAWR */ /* Similarly for the general-purpose (gp0 -- gp31) and floating-point registers (fp0 -- fp31). */ @@ -548,7 +550,7 @@ fetch_register (struct regcache *regcache, int tid, int regno) CORE_ADDR regaddr = ppc_register_u_addr (gdbarch, regno); int bytes_transferred; unsigned int offset; /* Offset of registers within the u area. */ - char buf[MAX_REGISTER_SIZE]; + gdb_byte buf[MAX_REGISTER_SIZE]; if (altivec_register_p (gdbarch, regno)) { @@ -601,8 +603,8 @@ fetch_register (struct regcache *regcache, int tid, int regno) if (errno != 0) { char message[128]; - sprintf (message, "reading register %s (#%d)", - gdbarch_register_name (gdbarch, regno), regno); + xsnprintf (message, sizeof (message), "reading register %s (#%d)", + gdbarch_register_name (gdbarch, regno), regno); perror_with_name (message); } memcpy (&buf[bytes_transferred], &l, sizeof (l)); @@ -862,11 +864,11 @@ ppc_linux_fetch_inferior_registers (struct target_ops *ops, struct regcache *regcache, int regno) { /* Overload thread id onto process id. */ - int tid = TIDGET (inferior_ptid); + int tid = ptid_get_lwp (inferior_ptid); /* No thread id, just use process id. */ if (tid == 0) - tid = PIDGET (inferior_ptid); + tid = ptid_get_pid (inferior_ptid); if (regno == -1) fetch_ppc_registers (regcache, tid); @@ -1035,7 +1037,7 @@ store_register (const struct regcache *regcache, int tid, int regno) CORE_ADDR regaddr = ppc_register_u_addr (gdbarch, regno); int i; size_t bytes_to_transfer; - char buf[MAX_REGISTER_SIZE]; + gdb_byte buf[MAX_REGISTER_SIZE]; if (altivec_register_p (gdbarch, regno)) { @@ -1095,8 +1097,8 @@ store_register (const struct regcache *regcache, int tid, int regno) if (errno != 0) { char message[128]; - sprintf (message, "writing register %s (#%d)", - gdbarch_register_name (gdbarch, regno), regno); + xsnprintf (message, sizeof (message), "writing register %s (#%d)", + gdbarch_register_name (gdbarch, regno), regno); perror_with_name (message); } } @@ -1363,16 +1365,17 @@ ppc_linux_get_hwcap (void) } /* The cached DABR value, to install in new threads. - This variable is used when we are dealing with non-BookE - processors. */ + This variable is used when the PowerPC HWDEBUG ptrace + interface is not available. */ static long saved_dabr_value; /* Global structure that will store information about the available - features on this BookE processor. */ -static struct ppc_debug_info booke_debug_info; + features provided by the PowerPC HWDEBUG ptrace interface. */ +static struct ppc_debug_info hwdebug_info; /* Global variable that holds the maximum number of slots that the - kernel will use. This is only used when the processor is BookE. */ + kernel will use. This is only used when PowerPC HWDEBUG ptrace interface + is available. */ static size_t max_slots_number = 0; struct hw_break_tuple @@ -1382,7 +1385,8 @@ struct hw_break_tuple }; /* This is an internal VEC created to store information about *points inserted - for each thread. This is used for BookE processors. */ + for each thread. This is used when PowerPC HWDEBUG ptrace interface is + available. */ typedef struct thread_points { /* The TID to which this *point relates. */ @@ -1399,42 +1403,44 @@ DEF_VEC_P (thread_points_p); VEC(thread_points_p) *ppc_threads = NULL; -/* The version of the kernel interface that we will use if the processor is - BookE. */ +/* The version of the PowerPC HWDEBUG kernel interface that we will use, if + available. */ #define PPC_DEBUG_CURRENT_VERSION 1 -/* Returns non-zero if we support the ptrace interface which enables - booke debugging resources. */ +/* Returns non-zero if we support the PowerPC HWDEBUG ptrace interface. */ static int -have_ptrace_booke_interface (void) +have_ptrace_hwdebug_interface (void) { - static int have_ptrace_booke_interface = -1; + static int have_ptrace_hwdebug_interface = -1; - if (have_ptrace_booke_interface == -1) + if (have_ptrace_hwdebug_interface == -1) { int tid; - tid = TIDGET (inferior_ptid); + tid = ptid_get_lwp (inferior_ptid); if (tid == 0) - tid = PIDGET (inferior_ptid); + tid = ptid_get_pid (inferior_ptid); - /* Check for kernel support for BOOKE debug registers. */ - if (ptrace (PPC_PTRACE_GETHWDBGINFO, tid, 0, &booke_debug_info) >= 0) + /* Check for kernel support for PowerPC HWDEBUG ptrace interface. */ + if (ptrace (PPC_PTRACE_GETHWDBGINFO, tid, 0, &hwdebug_info) >= 0) { - have_ptrace_booke_interface = 1; - max_slots_number = booke_debug_info.num_instruction_bps - + booke_debug_info.num_data_bps - + booke_debug_info.num_condition_regs; - } - else - { - /* Old school interface and no BOOKE debug registers support. */ - have_ptrace_booke_interface = 0; - memset (&booke_debug_info, 0, sizeof (struct ppc_debug_info)); + /* Check whether PowerPC HWDEBUG ptrace interface is functional and + provides any supported feature. */ + if (hwdebug_info.features != 0) + { + have_ptrace_hwdebug_interface = 1; + max_slots_number = hwdebug_info.num_instruction_bps + + hwdebug_info.num_data_bps + + hwdebug_info.num_condition_regs; + return have_ptrace_hwdebug_interface; + } } + /* Old school interface and no PowerPC HWDEBUG ptrace support. */ + have_ptrace_hwdebug_interface = 0; + memset (&hwdebug_info, 0, sizeof (struct ppc_debug_info)); } - return have_ptrace_booke_interface; + return have_ptrace_hwdebug_interface; } static int @@ -1442,18 +1448,18 @@ ppc_linux_can_use_hw_breakpoint (int type, int cnt, int ot) { int total_hw_wp, total_hw_bp; - if (have_ptrace_booke_interface ()) + if (have_ptrace_hwdebug_interface ()) { - /* For PPC BookE processors, the number of available hardware - watchpoints and breakpoints is stored at the booke_debug_info - struct. */ - total_hw_bp = booke_debug_info.num_instruction_bps; - total_hw_wp = booke_debug_info.num_data_bps; + /* When PowerPC HWDEBUG ptrace interface is available, the number of + available hardware watchpoints and breakpoints is stored at the + hwdebug_info struct. */ + total_hw_bp = hwdebug_info.num_instruction_bps; + total_hw_wp = hwdebug_info.num_data_bps; } else { - /* For PPC server processors, we accept 1 hardware watchpoint and 0 - hardware breakpoints. */ + /* When we do not have PowerPC HWDEBUG ptrace interface, we should + consider having 1 hardware watchpoint and no hardware breakpoints. */ total_hw_bp = 0; total_hw_wp = 1; } @@ -1461,7 +1467,7 @@ ppc_linux_can_use_hw_breakpoint (int type, int cnt, int ot) if (type == bp_hardware_watchpoint || type == bp_read_watchpoint || type == bp_access_watchpoint || type == bp_watchpoint) { - if (cnt > total_hw_wp) + if (cnt + ot > total_hw_wp) return -1; } else if (type == bp_hardware_breakpoint) @@ -1470,7 +1476,7 @@ ppc_linux_can_use_hw_breakpoint (int type, int cnt, int ot) return -1; } - if (!have_ptrace_booke_interface ()) + if (!have_ptrace_hwdebug_interface ()) { int tid; ptid_t ptid = inferior_ptid; @@ -1478,9 +1484,9 @@ ppc_linux_can_use_hw_breakpoint (int type, int cnt, int ot) /* We need to know whether ptrace supports PTRACE_SET_DEBUGREG and whether the target has DABR. If either answer is no, the ptrace call will return -1. Fail in that case. */ - tid = TIDGET (ptid); + tid = ptid_get_lwp (ptid); if (tid == 0) - tid = PIDGET (ptid); + tid = ptid_get_pid (ptid); if (ptrace (PTRACE_SET_DEBUGREG, tid, 0, 0) == -1) return 0; @@ -1496,27 +1502,38 @@ ppc_linux_region_ok_for_hw_watchpoint (CORE_ADDR addr, int len) if (len <= 0) return 0; - /* The new BookE ptrace interface tells if there are alignment restrictions - for watchpoints in the processors. In that case, we use that information - to determine the hardcoded watchable region for watchpoints. */ - if (have_ptrace_booke_interface ()) - { - /* DAC-based processors (i.e., embedded processors), like the PowerPC 440 - have ranged watchpoints and can watch any access within an arbitrary - memory region. This is useful to watch arrays and structs, for - instance. It takes two hardware watchpoints though. */ + /* The PowerPC HWDEBUG ptrace interface tells if there are alignment + restrictions for watchpoints in the processors. In that case, we use that + information to determine the hardcoded watchable region for + watchpoints. */ + if (have_ptrace_hwdebug_interface ()) + { + int region_size; + /* Embedded DAC-based processors, like the PowerPC 440 have ranged + watchpoints and can watch any access within an arbitrary memory + region. This is useful to watch arrays and structs, for instance. It + takes two hardware watchpoints though. */ if (len > 1 - && booke_debug_info.features & PPC_DEBUG_FEATURE_DATA_BP_RANGE) + && hwdebug_info.features & PPC_DEBUG_FEATURE_DATA_BP_RANGE + && ppc_linux_get_hwcap () & PPC_FEATURE_BOOKE) return 2; - else if (booke_debug_info.data_bp_alignment - && (addr + len > (addr & ~(booke_debug_info.data_bp_alignment - 1)) - + booke_debug_info.data_bp_alignment)) + /* Check if the processor provides DAWR interface. */ + if (hwdebug_info.features & PPC_DEBUG_FEATURE_DATA_BP_DAWR) + /* DAWR interface allows to watch up to 512 byte wide ranges which + can't cross a 512 byte boundary. */ + region_size = 512; + else + region_size = hwdebug_info.data_bp_alignment; + /* Server processors provide one hardware watchpoint and addr+len should + fall in the watchable region provided by the ptrace interface. */ + if (region_size + && (addr + len > (addr & ~(region_size - 1)) + region_size)) return 0; } /* addr+len must fall in the 8 byte watchable region for DABR-based - processors (i.e., server processors). Without the new BookE ptrace - interface, DAC-based processors (i.e., embedded processors) will use - addresses aligned to 4-bytes due to the way the read/write flags are + processors (i.e., server processors). Without the new PowerPC HWDEBUG + ptrace interface, DAC-based processors (i.e., embedded processors) will + use addresses aligned to 4-bytes due to the way the read/write flags are passed in the old ptrace interface. */ else if (((ppc_linux_get_hwcap () & PPC_FEATURE_BOOKE) && (addr + len) > (addr & ~3) + 4) @@ -1528,7 +1545,7 @@ ppc_linux_region_ok_for_hw_watchpoint (CORE_ADDR addr, int len) /* This function compares two ppc_hw_breakpoint structs field-by-field. */ static int -booke_cmp_hw_point (struct ppc_hw_breakpoint *a, struct ppc_hw_breakpoint *b) +hwdebug_point_cmp (struct ppc_hw_breakpoint *a, struct ppc_hw_breakpoint *b) { return (a->trigger_type == b->trigger_type && a->addr_mode == b->addr_mode @@ -1543,7 +1560,7 @@ booke_cmp_hw_point (struct ppc_hw_breakpoint *a, struct ppc_hw_breakpoint *b) it returns NULL. If ALLOC_NEW is non-zero, a new thread_points for the provided TID will be created and returned. */ static struct thread_points * -booke_find_thread_points_by_tid (int tid, int alloc_new) +hwdebug_find_thread_points_by_tid (int tid, int alloc_new) { int i; struct thread_points *t; @@ -1572,7 +1589,7 @@ booke_find_thread_points_by_tid (int tid, int alloc_new) *point (i.e., calling `ptrace' in order to issue the request to the kernel) and registering it internally in GDB. */ static void -booke_insert_point (struct ppc_hw_breakpoint *b, int tid) +hwdebug_insert_point (struct ppc_hw_breakpoint *b, int tid) { int i; long slot; @@ -1590,7 +1607,7 @@ booke_insert_point (struct ppc_hw_breakpoint *b, int tid) perror_with_name (_("Unexpected error setting breakpoint or watchpoint")); /* Everything went fine, so we have to register this *point. */ - t = booke_find_thread_points_by_tid (tid, 1); + t = hwdebug_find_thread_points_by_tid (tid, 1); gdb_assert (t != NULL); hw_breaks = t->hw_breaks; @@ -1612,18 +1629,18 @@ booke_insert_point (struct ppc_hw_breakpoint *b, int tid) *point (i.e., calling `ptrace' in order to issue the request to the kernel), and unregistering it internally at GDB. */ static void -booke_remove_point (struct ppc_hw_breakpoint *b, int tid) +hwdebug_remove_point (struct ppc_hw_breakpoint *b, int tid) { int i; struct hw_break_tuple *hw_breaks; struct thread_points *t; - t = booke_find_thread_points_by_tid (tid, 0); + t = hwdebug_find_thread_points_by_tid (tid, 0); gdb_assert (t != NULL); hw_breaks = t->hw_breaks; for (i = 0; i < max_slots_number; i++) - if (hw_breaks[i].hw_break && booke_cmp_hw_point (hw_breaks[i].hw_break, b)) + if (hw_breaks[i].hw_break && hwdebug_point_cmp (hw_breaks[i].hw_break, b)) break; gdb_assert (i != max_slots_number); @@ -1646,8 +1663,8 @@ booke_remove_point (struct ppc_hw_breakpoint *b, int tid) static int ppc_linux_ranged_break_num_registers (struct target_ops *target) { - return ((have_ptrace_booke_interface () - && booke_debug_info.features & PPC_DEBUG_FEATURE_INSN_BP_RANGE)? + return ((have_ptrace_hwdebug_interface () + && hwdebug_info.features & PPC_DEBUG_FEATURE_INSN_BP_RANGE)? 2 : -1); } @@ -1661,7 +1678,7 @@ ppc_linux_insert_hw_breakpoint (struct gdbarch *gdbarch, struct lwp_info *lp; struct ppc_hw_breakpoint p; - if (!have_ptrace_booke_interface ()) + if (!have_ptrace_hwdebug_interface ()) return -1; p.version = PPC_DEBUG_CURRENT_VERSION; @@ -1685,7 +1702,7 @@ ppc_linux_insert_hw_breakpoint (struct gdbarch *gdbarch, } ALL_LWPS (lp) - booke_insert_point (&p, TIDGET (lp->ptid)); + hwdebug_insert_point (&p, ptid_get_lwp (lp->ptid)); return 0; } @@ -1697,7 +1714,7 @@ ppc_linux_remove_hw_breakpoint (struct gdbarch *gdbarch, struct lwp_info *lp; struct ppc_hw_breakpoint p; - if (!have_ptrace_booke_interface ()) + if (!have_ptrace_hwdebug_interface ()) return -1; p.version = PPC_DEBUG_CURRENT_VERSION; @@ -1721,7 +1738,7 @@ ppc_linux_remove_hw_breakpoint (struct gdbarch *gdbarch, } ALL_LWPS (lp) - booke_remove_point (&p, TIDGET (lp->ptid)); + hwdebug_remove_point (&p, ptid_get_lwp (lp->ptid)); return 0; } @@ -1753,7 +1770,7 @@ ppc_linux_insert_mask_watchpoint (struct target_ops *ops, CORE_ADDR addr, struct lwp_info *lp; struct ppc_hw_breakpoint p; - gdb_assert (have_ptrace_booke_interface ()); + gdb_assert (have_ptrace_hwdebug_interface ()); p.version = PPC_DEBUG_CURRENT_VERSION; p.trigger_type = get_trigger_type (rw); @@ -1764,7 +1781,7 @@ ppc_linux_insert_mask_watchpoint (struct target_ops *ops, CORE_ADDR addr, p.condition_value = 0; ALL_LWPS (lp) - booke_insert_point (&p, TIDGET (lp->ptid)); + hwdebug_insert_point (&p, ptid_get_lwp (lp->ptid)); return 0; } @@ -1781,7 +1798,7 @@ ppc_linux_remove_mask_watchpoint (struct target_ops *ops, CORE_ADDR addr, struct lwp_info *lp; struct ppc_hw_breakpoint p; - gdb_assert (have_ptrace_booke_interface ()); + gdb_assert (have_ptrace_hwdebug_interface ()); p.version = PPC_DEBUG_CURRENT_VERSION; p.trigger_type = get_trigger_type (rw); @@ -1792,7 +1809,7 @@ ppc_linux_remove_mask_watchpoint (struct target_ops *ops, CORE_ADDR addr, p.condition_value = 0; ALL_LWPS (lp) - booke_remove_point (&p, TIDGET (lp->ptid)); + hwdebug_remove_point (&p, ptid_get_lwp (lp->ptid)); return 0; } @@ -1802,14 +1819,14 @@ static int can_use_watchpoint_cond_accel (void) { struct thread_points *p; - int tid = TIDGET (inferior_ptid); - int cnt = booke_debug_info.num_condition_regs, i; + int tid = ptid_get_lwp (inferior_ptid); + int cnt = hwdebug_info.num_condition_regs, i; CORE_ADDR tmp_value; - if (!have_ptrace_booke_interface () || cnt == 0) + if (!have_ptrace_hwdebug_interface () || cnt == 0) return 0; - p = booke_find_thread_points_by_tid (tid, 0); + p = hwdebug_find_thread_points_by_tid (tid, 0); if (p) { @@ -1848,10 +1865,10 @@ calculate_dvc (CORE_ADDR addr, int len, CORE_ADDR data_value, We need to calculate where our watch region is relative to that window and enable comparison of the bytes which fall within it. */ - align_offset = addr % booke_debug_info.sizeof_condition; + align_offset = addr % hwdebug_info.sizeof_condition; addr_end_data = addr + len; addr_end_dvc = (addr - align_offset - + booke_debug_info.sizeof_condition); + + hwdebug_info.sizeof_condition); num_bytes_off_dvc = (addr_end_data > addr_end_dvc)? addr_end_data - addr_end_dvc : 0; num_byte_enable = len - num_bytes_off_dvc; @@ -1935,7 +1952,7 @@ check_condition (CORE_ADDR watch_addr, struct expression *cond, if (cond->elts[0].opcode != BINOP_EQUAL) return 0; - fetch_subexp_value (cond, &pc, &left_val, NULL, &left_chain); + fetch_subexp_value (cond, &pc, &left_val, NULL, &left_chain, 0); num_accesses_left = num_memory_accesses (left_chain); if (left_val == NULL || num_accesses_left < 0) @@ -1945,7 +1962,7 @@ check_condition (CORE_ADDR watch_addr, struct expression *cond, return 0; } - fetch_subexp_value (cond, &pc, &right_val, NULL, &right_chain); + fetch_subexp_value (cond, &pc, &right_val, NULL, &right_chain, 0); num_accesses_right = num_memory_accesses (right_chain); if (right_val == NULL || num_accesses_right < 0) @@ -1999,8 +2016,8 @@ ppc_linux_can_accel_watchpoint_condition (CORE_ADDR addr, int len, int rw, { CORE_ADDR data_value; - return (have_ptrace_booke_interface () - && booke_debug_info.num_condition_regs > 0 + return (have_ptrace_hwdebug_interface () + && hwdebug_info.num_condition_regs > 0 && check_condition (addr, cond, &data_value, &len)); } @@ -2015,13 +2032,13 @@ create_watchpoint_request (struct ppc_hw_breakpoint *p, CORE_ADDR addr, int insert) { if (len == 1 - || !(booke_debug_info.features & PPC_DEBUG_FEATURE_DATA_BP_RANGE)) + || !(hwdebug_info.features & PPC_DEBUG_FEATURE_DATA_BP_RANGE)) { int use_condition; CORE_ADDR data_value; use_condition = (insert? can_use_watchpoint_cond_accel () - : booke_debug_info.num_condition_regs > 0); + : hwdebug_info.num_condition_regs > 0); if (cond && use_condition && check_condition (addr, cond, &data_value, &len)) calculate_dvc (addr, len, data_value, &p->condition_mode, @@ -2062,14 +2079,14 @@ ppc_linux_insert_watchpoint (CORE_ADDR addr, int len, int rw, struct lwp_info *lp; int ret = -1; - if (have_ptrace_booke_interface ()) + if (have_ptrace_hwdebug_interface ()) { struct ppc_hw_breakpoint p; create_watchpoint_request (&p, addr, len, rw, cond, 1); ALL_LWPS (lp) - booke_insert_point (&p, TIDGET (lp->ptid)); + hwdebug_insert_point (&p, ptid_get_lwp (lp->ptid)); ret = 0; } @@ -2113,7 +2130,7 @@ ppc_linux_insert_watchpoint (CORE_ADDR addr, int len, int rw, saved_dabr_value = dabr_value; ALL_LWPS (lp) - if (ptrace (PTRACE_SET_DEBUGREG, TIDGET (lp->ptid), 0, + if (ptrace (PTRACE_SET_DEBUGREG, ptid_get_lwp (lp->ptid), 0, saved_dabr_value) < 0) return -1; @@ -2130,14 +2147,14 @@ ppc_linux_remove_watchpoint (CORE_ADDR addr, int len, int rw, struct lwp_info *lp; int ret = -1; - if (have_ptrace_booke_interface ()) + if (have_ptrace_hwdebug_interface ()) { struct ppc_hw_breakpoint p; create_watchpoint_request (&p, addr, len, rw, cond, 0); ALL_LWPS (lp) - booke_remove_point (&p, TIDGET (lp->ptid)); + hwdebug_remove_point (&p, ptid_get_lwp (lp->ptid)); ret = 0; } @@ -2145,7 +2162,7 @@ ppc_linux_remove_watchpoint (CORE_ADDR addr, int len, int rw, { saved_dabr_value = 0; ALL_LWPS (lp) - if (ptrace (PTRACE_SET_DEBUGREG, TIDGET (lp->ptid), 0, + if (ptrace (PTRACE_SET_DEBUGREG, ptid_get_lwp (lp->ptid), 0, saved_dabr_value) < 0) return -1; @@ -2158,9 +2175,9 @@ ppc_linux_remove_watchpoint (CORE_ADDR addr, int len, int rw, static void ppc_linux_new_thread (struct lwp_info *lp) { - int tid = TIDGET (lp->ptid); + int tid = ptid_get_lwp (lp->ptid); - if (have_ptrace_booke_interface ()) + if (have_ptrace_hwdebug_interface ()) { int i; struct thread_points *p; @@ -2176,7 +2193,18 @@ ppc_linux_new_thread (struct lwp_info *lp) /* Copy that thread's breakpoints and watchpoints to the new thread. */ for (i = 0; i < max_slots_number; i++) if (hw_breaks[i].hw_break) - booke_insert_point (hw_breaks[i].hw_break, tid); + { + /* Older kernels did not make new threads inherit their parent + thread's debug state, so we always clear the slot and replicate + the debug state ourselves, ensuring compatibility with all + kernels. */ + + /* The ppc debug resource accounting is done through "slots". + Ask the kernel the deallocate this specific *point's slot. */ + ptrace (PPC_PTRACE_DELHWDEBUG, tid, 0, hw_breaks[i].slot); + + hwdebug_insert_point (hw_breaks[i].hw_break, tid); + } } else ptrace (PTRACE_SET_DEBUGREG, tid, 0, saved_dabr_value); @@ -2186,11 +2214,11 @@ static void ppc_linux_thread_exit (struct thread_info *tp, int silent) { int i; - int tid = TIDGET (tp->ptid); + int tid = ptid_get_lwp (tp->ptid); struct hw_break_tuple *hw_breaks; struct thread_points *t = NULL, *p; - if (!have_ptrace_booke_interface ()) + if (!have_ptrace_hwdebug_interface ()) return; for (i = 0; VEC_iterate (thread_points_p, ppc_threads, i, p); i++) @@ -2218,23 +2246,24 @@ ppc_linux_thread_exit (struct thread_info *tp, int silent) static int ppc_linux_stopped_data_address (struct target_ops *target, CORE_ADDR *addr_p) { - struct siginfo *siginfo_p; + siginfo_t siginfo; - siginfo_p = linux_nat_get_siginfo (inferior_ptid); + if (!linux_nat_get_siginfo (inferior_ptid, &siginfo)) + return 0; - if (siginfo_p->si_signo != SIGTRAP - || (siginfo_p->si_code & 0xffff) != 0x0004 /* TRAP_HWBKPT */) + if (siginfo.si_signo != SIGTRAP + || (siginfo.si_code & 0xffff) != 0x0004 /* TRAP_HWBKPT */) return 0; - if (have_ptrace_booke_interface ()) + if (have_ptrace_hwdebug_interface ()) { int i; struct thread_points *t; struct hw_break_tuple *hw_breaks; /* The index (or slot) of the *point is passed in the si_errno field. */ - int slot = siginfo_p->si_errno; + int slot = siginfo.si_errno; - t = booke_find_thread_points_by_tid (TIDGET (inferior_ptid), 0); + t = hwdebug_find_thread_points_by_tid (ptid_get_lwp (inferior_ptid), 0); /* Find out if this *point is a hardware breakpoint. If so, we should return 0. */ @@ -2249,7 +2278,7 @@ ppc_linux_stopped_data_address (struct target_ops *target, CORE_ADDR *addr_p) } } - *addr_p = (CORE_ADDR) (uintptr_t) siginfo_p->si_addr; + *addr_p = (CORE_ADDR) (uintptr_t) siginfo.si_addr; return 1; } @@ -2267,7 +2296,7 @@ ppc_linux_watchpoint_addr_within_range (struct target_ops *target, { int mask; - if (have_ptrace_booke_interface () + if (have_ptrace_hwdebug_interface () && ppc_linux_get_hwcap () & PPC_FEATURE_BOOKE) return start <= addr && start + length >= addr; else if (ppc_linux_get_hwcap () & PPC_FEATURE_BOOKE) @@ -2287,8 +2316,8 @@ static int ppc_linux_masked_watch_num_registers (struct target_ops *target, CORE_ADDR addr, CORE_ADDR mask) { - if (!have_ptrace_booke_interface () - || (booke_debug_info.features & PPC_DEBUG_FEATURE_DATA_BP_MASK) == 0) + if (!have_ptrace_hwdebug_interface () + || (hwdebug_info.features & PPC_DEBUG_FEATURE_DATA_BP_MASK) == 0) return -1; else if ((mask & 0xC0000000) != 0xC0000000) { @@ -2306,11 +2335,11 @@ ppc_linux_store_inferior_registers (struct target_ops *ops, struct regcache *regcache, int regno) { /* Overload thread id onto process id. */ - int tid = TIDGET (inferior_ptid); + int tid = ptid_get_lwp (inferior_ptid); /* No thread id, just use process id. */ if (tid == 0) - tid = PIDGET (inferior_ptid); + tid = ptid_get_pid (inferior_ptid); if (regno >= 0) store_register (regcache, tid, regno); @@ -2372,9 +2401,9 @@ ppc_linux_target_wordsize (void) #ifdef __powerpc64__ long msr; - int tid = TIDGET (inferior_ptid); + int tid = ptid_get_lwp (inferior_ptid); if (tid == 0) - tid = PIDGET (inferior_ptid); + tid = ptid_get_pid (inferior_ptid); errno = 0; msr = (long) ptrace (PTRACE_PEEKUSER, tid, PT_MSR * 8, 0); @@ -2390,7 +2419,7 @@ ppc_linux_auxv_parse (struct target_ops *ops, gdb_byte **readptr, gdb_byte *endptr, CORE_ADDR *typep, CORE_ADDR *valp) { int sizeof_auxv_field = ppc_linux_target_wordsize (); - enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch); + enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ()); gdb_byte *ptr = *readptr; if (endptr == ptr) @@ -2416,9 +2445,9 @@ ppc_linux_read_description (struct target_ops *ops) int isa205 = 0; int cell = 0; - int tid = TIDGET (inferior_ptid); + int tid = ptid_get_lwp (inferior_ptid); if (tid == 0) - tid = PIDGET (inferior_ptid); + tid = ptid_get_pid (inferior_ptid); if (have_ptrace_getsetevrregs) {