aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorJames Hogan <james.hogan@imgtec.com>2012-10-09 05:54:36 -0400
committerJames Hogan <james.hogan@imgtec.com>2013-03-02 15:09:22 -0500
commitbc3966bf1583a6c22b76397535174445c43952de (patch)
tree8854b33e95c672078bb32fe878f39b9d716accb5
parent29dd78cf0b526d24063364a8c634b3e92514c1a2 (diff)
metag: ptrace
The ptrace interface for metag provides access to some core register sets using the PTRACE_GETREGSET and PTRACE_SETREGSET operations. The details of the internal context structures is abstracted into user API structures to both ease use and allow flexibility to change the internal context layouts. Copyin and copyout functions for these register sets are exposed to allow signal handling code to use them to copy to and from the signal context. struct user_gp_regs (NT_PRSTATUS) provides access to the core general purpose register context. struct user_cb_regs (NT_METAG_CBUF) provides access to the TXCATCH* registers which contains information abuot a memory fault, unaligned access error or watchpoint. This can be modified to alter the way the fault is replayed on resume ("catch replay"), or to prevent the replay taking place. struct user_rp_state (NT_METAG_RPIPE) provides access to the state of the Meta read pipeline which can be used to hide memory latencies in hand optimised data loops. Extended DSP register state, DSP RAM, and hardware breakpoint registers aren't yet exposed through ptrace. Signed-off-by: James Hogan <james.hogan@imgtec.com> Cc: Andrew Morton <akpm@linux-foundation.org> Cc: Denys Vlasenko <vda.linux@googlemail.com> Cc: Arnd Bergmann <arnd@arndb.de> Cc: Tony Lindgren <tony@atomide.com> Cc: "Paul E. McKenney" <paulmck@linux.vnet.ibm.com>
Diffstat
-rw-r--r--arch/metag/include/asm/ptrace.h60
-rw-r--r--arch/metag/include/uapi/asm/ptrace.h113
-rw-r--r--arch/metag/kernel/ptrace.c380
-rw-r--r--include/uapi/linux/elf.h2
4 files changed, 555 insertions, 0 deletions
diff --git a/arch/metag/include/asm/ptrace.h b/arch/metag/include/asm/ptrace.h
new file mode 100644
index 000000000000..fcabc18daf25
--- /dev/null
+++ b/arch/metag/include/asm/ptrace.h
@@ -0,0 +1,60 @@
1#ifndef _METAG_PTRACE_H
2#define _METAG_PTRACE_H
3
4#include <linux/compiler.h>
5#include <uapi/asm/ptrace.h>
6#include <asm/tbx.h>
7
8#ifndef __ASSEMBLY__
9
10/* this struct defines the way the registers are stored on the
11 stack during a system call. */
12
13struct pt_regs {
14 TBICTX ctx;
15 TBICTXEXTCB0 extcb0[5];
16};
17
18#define user_mode(regs) (((regs)->ctx.SaveMask & TBICTX_PRIV_BIT) > 0)
19
20#define instruction_pointer(regs) ((unsigned long)(regs)->ctx.CurrPC)
21#define profile_pc(regs) instruction_pointer(regs)
22
23#define task_pt_regs(task) \
24 ((struct pt_regs *)(task_stack_page(task) + \
25 sizeof(struct thread_info)))
26
27#define current_pt_regs() \
28 ((struct pt_regs *)((char *)current_thread_info() + \
29 sizeof(struct thread_info)))
30
31int syscall_trace_enter(struct pt_regs *regs);
32void syscall_trace_leave(struct pt_regs *regs);
33
34/* copy a struct user_gp_regs out to user */
35int metag_gp_regs_copyout(const struct pt_regs *regs,
36 unsigned int pos, unsigned int count,
37 void *kbuf, void __user *ubuf);
38/* copy a struct user_gp_regs in from user */
39int metag_gp_regs_copyin(struct pt_regs *regs,
40 unsigned int pos, unsigned int count,
41 const void *kbuf, const void __user *ubuf);
42/* copy a struct user_cb_regs out to user */
43int metag_cb_regs_copyout(const struct pt_regs *regs,
44 unsigned int pos, unsigned int count,
45 void *kbuf, void __user *ubuf);
46/* copy a struct user_cb_regs in from user */
47int metag_cb_regs_copyin(struct pt_regs *regs,
48 unsigned int pos, unsigned int count,
49 const void *kbuf, const void __user *ubuf);
50/* copy a struct user_rp_state out to user */
51int metag_rp_state_copyout(const struct pt_regs *regs,
52 unsigned int pos, unsigned int count,
53 void *kbuf, void __user *ubuf);
54/* copy a struct user_rp_state in from user */
55int metag_rp_state_copyin(struct pt_regs *regs,
56 unsigned int pos, unsigned int count,
57 const void *kbuf, const void __user *ubuf);
58
59#endif /* __ASSEMBLY__ */
60#endif /* _METAG_PTRACE_H */
diff --git a/arch/metag/include/uapi/asm/ptrace.h b/arch/metag/include/uapi/asm/ptrace.h
new file mode 100644
index 000000000000..45d97809d33e
--- /dev/null
+++ b/arch/metag/include/uapi/asm/ptrace.h
@@ -0,0 +1,113 @@
1#ifndef _UAPI_METAG_PTRACE_H
2#define _UAPI_METAG_PTRACE_H
3
4#ifndef __ASSEMBLY__
5
6/*
7 * These are the layouts of the regsets returned by the GETREGSET ptrace call
8 */
9
10/* user_gp_regs::status */
11
12/* CBMarker bit (indicates catch state / catch replay) */
13#define USER_GP_REGS_STATUS_CATCH_BIT (1 << 22)
14#define USER_GP_REGS_STATUS_CATCH_S 22
15/* LSM_STEP field (load/store multiple step) */
16#define USER_GP_REGS_STATUS_LSM_STEP_BITS (0x7 << 8)
17#define USER_GP_REGS_STATUS_LSM_STEP_S 8
18/* SCC bit (indicates split 16x16 condition flags) */
19#define USER_GP_REGS_STATUS_SCC_BIT (1 << 4)
20#define USER_GP_REGS_STATUS_SCC_S 4
21
22/* normal condition flags */
23/* CF_Z bit (Zero flag) */
24#define USER_GP_REGS_STATUS_CF_Z_BIT (1 << 3)
25#define USER_GP_REGS_STATUS_CF_Z_S 3
26/* CF_N bit (Negative flag) */
27#define USER_GP_REGS_STATUS_CF_N_BIT (1 << 2)
28#define USER_GP_REGS_STATUS_CF_N_S 2
29/* CF_V bit (oVerflow flag) */
30#define USER_GP_REGS_STATUS_CF_V_BIT (1 << 1)
31#define USER_GP_REGS_STATUS_CF_V_S 1
32/* CF_C bit (Carry flag) */
33#define USER_GP_REGS_STATUS_CF_C_BIT (1 << 0)
34#define USER_GP_REGS_STATUS_CF_C_S 0
35
36/* split 16x16 condition flags */
37/* SCF_LZ bit (Low Zero flag) */
38#define USER_GP_REGS_STATUS_SCF_LZ_BIT (1 << 3)
39#define USER_GP_REGS_STATUS_SCF_LZ_S 3
40/* SCF_HZ bit (High Zero flag) */
41#define USER_GP_REGS_STATUS_SCF_HZ_BIT (1 << 2)
42#define USER_GP_REGS_STATUS_SCF_HZ_S 2
43/* SCF_HC bit (High Carry flag) */
44#define USER_GP_REGS_STATUS_SCF_HC_BIT (1 << 1)
45#define USER_GP_REGS_STATUS_SCF_HC_S 1
46/* SCF_LC bit (Low Carry flag) */
47#define USER_GP_REGS_STATUS_SCF_LC_BIT (1 << 0)
48#define USER_GP_REGS_STATUS_SCF_LC_S 0
49
50/**
51 * struct user_gp_regs - User general purpose registers
52 * @dx: GP data unit regs (dx[reg][unit] = D{unit:0-1}.{reg:0-7})
53 * @ax: GP address unit regs (ax[reg][unit] = A{unit:0-1}.{reg:0-3})
54 * @pc: PC register
55 * @status: TXSTATUS register (condition flags, LSM_STEP etc)
56 * @rpt: TXRPT registers (branch repeat counter)
57 * @bpobits: TXBPOBITS register ("branch prediction other" bits)
58 * @mode: TXMODE register
59 * @_pad1: Reserved padding to make sizeof obviously 64bit aligned
60 *
61 * This is the user-visible general purpose register state structure.
62 *
63 * It can be accessed through PTRACE_GETREGSET with NT_PRSTATUS.
64 *
65 * It is also used in the signal context.
66 */
67struct user_gp_regs {
68 unsigned long dx[8][2];
69 unsigned long ax[4][2];
70 unsigned long pc;
71 unsigned long status;
72 unsigned long rpt;
73 unsigned long bpobits;
74 unsigned long mode;
75 unsigned long _pad1;
76};
77
78/**
79 * struct user_cb_regs - User catch buffer registers
80 * @flags: TXCATCH0 register (fault flags)
81 * @addr: TXCATCH1 register (fault address)
82 * @data: TXCATCH2 and TXCATCH3 registers (low and high data word)
83 *
84 * This is the user-visible catch buffer register state structure containing
85 * information about a failed memory access, and allowing the access to be
86 * modified and replayed.
87 *
88 * It can be accessed through PTRACE_GETREGSET with NT_METAG_CBUF.
89 */
90struct user_cb_regs {
91 unsigned long flags;
92 unsigned long addr;
93 unsigned long long data;
94};
95
96/**
97 * struct user_rp_state - User read pipeline state
98 * @entries: Read pipeline entries
99 * @mask: Mask of valid pipeline entries (RPMask from TXDIVTIME register)
100 *
101 * This is the user-visible read pipeline state structure containing the entries
102 * currently in the read pipeline and the mask of valid entries.
103 *
104 * It can be accessed through PTRACE_GETREGSET with NT_METAG_RPIPE.
105 */
106struct user_rp_state {
107 unsigned long long entries[6];
108 unsigned long mask;
109};
110
111#endif /* __ASSEMBLY__ */
112
113#endif /* _UAPI_METAG_PTRACE_H */
diff --git a/arch/metag/kernel/ptrace.c b/arch/metag/kernel/ptrace.c
new file mode 100644
index 000000000000..47a8828615a5
--- /dev/null
+++ b/arch/metag/kernel/ptrace.c
@@ -0,0 +1,380 @@
1/*
2 * Copyright (C) 2005-2012 Imagination Technologies Ltd.
3 *
4 * This file is subject to the terms and conditions of the GNU General
5 * Public License. See the file COPYING in the main directory of
6 * this archive for more details.
7 */
8
9#include <linux/kernel.h>
10#include <linux/mm.h>
11#include <linux/errno.h>
12#include <linux/ptrace.h>
13#include <linux/user.h>
14#include <linux/regset.h>
15#include <linux/tracehook.h>
16#include <linux/elf.h>
17#include <linux/uaccess.h>
18#include <trace/syscall.h>
19
20#define CREATE_TRACE_POINTS
21#include <trace/events/syscalls.h>
22
23/*
24 * user_regset definitions.
25 */
26
27int metag_gp_regs_copyout(const struct pt_regs *regs,
28 unsigned int pos, unsigned int count,
29 void *kbuf, void __user *ubuf)
30{
31 const void *ptr;
32 unsigned long data;
33 int ret;
34
35 /* D{0-1}.{0-7} */
36 ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf,
37 regs->ctx.DX, 0, 4*16);
38 if (ret)
39 goto out;
40 /* A{0-1}.{0-1} */
41 ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf,
42 regs->ctx.AX, 4*16, 4*20);
43 if (ret)
44 goto out;
45 /* A{0-1}.2 */
46 if (regs->ctx.SaveMask & TBICTX_XEXT_BIT)
47 ptr = regs->ctx.Ext.Ctx.pExt;
48 else
49 ptr = &regs->ctx.Ext.AX2;
50 ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf,
51 ptr, 4*20, 4*22);
52 if (ret)
53 goto out;
54 /* A{0-1}.3 */
55 ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf,
56 &regs->ctx.AX3, 4*22, 4*24);
57 if (ret)
58 goto out;
59 /* PC */
60 ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf,
61 &regs->ctx.CurrPC, 4*24, 4*25);
62 if (ret)
63 goto out;
64 /* TXSTATUS */
65 data = (unsigned long)regs->ctx.Flags;
66 if (regs->ctx.SaveMask & TBICTX_CBUF_BIT)
67 data |= USER_GP_REGS_STATUS_CATCH_BIT;
68 ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf,
69 &data, 4*25, 4*26);
70 if (ret)
71 goto out;
72 /* TXRPT, TXBPOBITS, TXMODE */
73 ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf,
74 &regs->ctx.CurrRPT, 4*26, 4*29);
75 if (ret)
76 goto out;
77 /* Padding */
78 ret = user_regset_copyout_zero(&pos, &count, &kbuf, &ubuf,
79 4*29, 4*30);
80out:
81 return ret;
82}
83
84int metag_gp_regs_copyin(struct pt_regs *regs,
85 unsigned int pos, unsigned int count,
86 const void *kbuf, const void __user *ubuf)
87{
88 void *ptr;
89 unsigned long data;
90 int ret;
91
92 /* D{0-1}.{0-7} */
93 ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
94 regs->ctx.DX, 0, 4*16);
95 if (ret)
96 goto out;
97 /* A{0-1}.{0-1} */
98 ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
99 regs->ctx.AX, 4*16, 4*20);
100 if (ret)
101 goto out;
102 /* A{0-1}.2 */
103 if (regs->ctx.SaveMask & TBICTX_XEXT_BIT)
104 ptr = regs->ctx.Ext.Ctx.pExt;
105 else
106 ptr = &regs->ctx.Ext.AX2;
107 ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
108 ptr, 4*20, 4*22);
109 if (ret)
110 goto out;
111 /* A{0-1}.3 */
112 ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
113 &regs->ctx.AX3, 4*22, 4*24);
114 if (ret)
115 goto out;
116 /* PC */
117 ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
118 &regs->ctx.CurrPC, 4*24, 4*25);
119 if (ret)
120 goto out;
121 /* TXSTATUS */
122 ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
123 &data, 4*25, 4*26);
124 if (ret)
125 goto out;
126 regs->ctx.Flags = data & 0xffff;
127 if (data & USER_GP_REGS_STATUS_CATCH_BIT)
128 regs->ctx.SaveMask |= TBICTX_XCBF_BIT | TBICTX_CBUF_BIT;
129 else
130 regs->ctx.SaveMask &= ~TBICTX_CBUF_BIT;
131 /* TXRPT, TXBPOBITS, TXMODE */
132 ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
133 &regs->ctx.CurrRPT, 4*26, 4*29);
134out:
135 return ret;
136}
137
138static int metag_gp_regs_get(struct task_struct *target,
139 const struct user_regset *regset,
140 unsigned int pos, unsigned int count,
141 void *kbuf, void __user *ubuf)
142{
143 const struct pt_regs *regs = task_pt_regs(target);
144 return metag_gp_regs_copyout(regs, pos, count, kbuf, ubuf);
145}
146
147static int metag_gp_regs_set(struct task_struct *target,
148 const struct user_regset *regset,
149 unsigned int pos, unsigned int count,
150 const void *kbuf, const void __user *ubuf)
151{
152 struct pt_regs *regs = task_pt_regs(target);
153 return metag_gp_regs_copyin(regs, pos, count, kbuf, ubuf);
154}
155
156int metag_cb_regs_copyout(const struct pt_regs *regs,
157 unsigned int pos, unsigned int count,
158 void *kbuf, void __user *ubuf)
159{
160 int ret;
161
162 /* TXCATCH{0-3} */
163 if (regs->ctx.SaveMask & TBICTX_XCBF_BIT)
164 ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf,
165 regs->extcb0, 0, 4*4);
166 else
167 ret = user_regset_copyout_zero(&pos, &count, &kbuf, &ubuf,
168 0, 4*4);
169 return ret;
170}
171
172int metag_cb_regs_copyin(struct pt_regs *regs,
173 unsigned int pos, unsigned int count,
174 const void *kbuf, const void __user *ubuf)
175{
176 int ret;
177
178 /* TXCATCH{0-3} */
179 ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
180 regs->extcb0, 0, 4*4);
181 return ret;
182}
183
184static int metag_cb_regs_get(struct task_struct *target,
185 const struct user_regset *regset,
186 unsigned int pos, unsigned int count,
187 void *kbuf, void __user *ubuf)
188{
189 const struct pt_regs *regs = task_pt_regs(target);
190 return metag_cb_regs_copyout(regs, pos, count, kbuf, ubuf);
191}
192
193static int metag_cb_regs_set(struct task_struct *target,
194 const struct user_regset *regset,
195 unsigned int pos, unsigned int count,
196 const void *kbuf, const void __user *ubuf)
197{
198 struct pt_regs *regs = task_pt_regs(target);
199 return metag_cb_regs_copyin(regs, pos, count, kbuf, ubuf);
200}
201
202int metag_rp_state_copyout(const struct pt_regs *regs,
203 unsigned int pos, unsigned int count,
204 void *kbuf, void __user *ubuf)
205{
206 unsigned long mask;
207 u64 *ptr;
208 int ret, i;
209
210 /* Empty read pipeline */
211 if (!(regs->ctx.SaveMask & TBICTX_CBRP_BIT)) {
212 ret = user_regset_copyout_zero(&pos, &count, &kbuf, &ubuf,
213 0, 4*13);
214 goto out;
215 }
216
217 mask = (regs->ctx.CurrDIVTIME & TXDIVTIME_RPMASK_BITS) >>
218 TXDIVTIME_RPMASK_S;
219
220 /* Read pipeline entries */
221 ptr = (void *)&regs->extcb0[1];
222 for (i = 0; i < 6; ++i, ++ptr) {
223 if (mask & (1 << i))
224 ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf,
225 ptr, 8*i, 8*(i + 1));
226 else
227 ret = user_regset_copyout_zero(&pos, &count, &kbuf,
228 &ubuf, 8*i, 8*(i + 1));
229 if (ret)
230 goto out;
231 }
232 /* Mask of entries */
233 ret = user_regset_copyout(&pos, &count, &kbuf, &ubuf,
234 &mask, 4*12, 4*13);
235out:
236 return ret;
237}
238
239int metag_rp_state_copyin(struct pt_regs *regs,
240 unsigned int pos, unsigned int count,
241 const void *kbuf, const void __user *ubuf)
242{
243 struct user_rp_state rp;
244 unsigned long long *ptr;
245 int ret, i;
246
247 /* Read the entire pipeline before making any changes */
248 ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf,
249 &rp, 0, 4*13);
250 if (ret)
251 goto out;
252
253 /* Write pipeline entries */
254 ptr = (void *)&regs->extcb0[1];
255 for (i = 0; i < 6; ++i, ++ptr)
256 if (rp.mask & (1 << i))
257 *ptr = rp.entries[i];
258
259 /* Update RPMask in TXDIVTIME */
260 regs->ctx.CurrDIVTIME &= ~TXDIVTIME_RPMASK_BITS;
261 regs->ctx.CurrDIVTIME |= (rp.mask << TXDIVTIME_RPMASK_S)
262 & TXDIVTIME_RPMASK_BITS;
263
264 /* Set/clear flags to indicate catch/read pipeline state */
265 if (rp.mask)
266 regs->ctx.SaveMask |= TBICTX_XCBF_BIT | TBICTX_CBRP_BIT;
267 else
268 regs->ctx.SaveMask &= ~TBICTX_CBRP_BIT;
269out:
270 return ret;
271}
272
273static int metag_rp_state_get(struct task_struct *target,
274 const struct user_regset *regset,
275 unsigned int pos, unsigned int count,
276 void *kbuf, void __user *ubuf)
277{
278 const struct pt_regs *regs = task_pt_regs(target);
279 return metag_rp_state_copyout(regs, pos, count, kbuf, ubuf);
280}
281
282static int metag_rp_state_set(struct task_struct *target,
283 const struct user_regset *regset,
284 unsigned int pos, unsigned int count,
285 const void *kbuf, const void __user *ubuf)
286{
287 struct pt_regs *regs = task_pt_regs(target);
288 return metag_rp_state_copyin(regs, pos, count, kbuf, ubuf);
289}
290
291enum metag_regset {
292 REGSET_GENERAL,
293 REGSET_CBUF,
294 REGSET_READPIPE,
295};
296
297static const struct user_regset metag_regsets[] = {
298 [REGSET_GENERAL] = {
299 .core_note_type = NT_PRSTATUS,
300 .n = ELF_NGREG,
301 .size = sizeof(long),
302 .align = sizeof(long long),
303 .get = metag_gp_regs_get,
304 .set = metag_gp_regs_set,
305 },
306 [REGSET_CBUF] = {
307 .core_note_type = NT_METAG_CBUF,
308 .n = sizeof(struct user_cb_regs) / sizeof(long),
309 .size = sizeof(long),
310 .align = sizeof(long long),
311 .get = metag_cb_regs_get,
312 .set = metag_cb_regs_set,
313 },
314 [REGSET_READPIPE] = {
315 .core_note_type = NT_METAG_RPIPE,
316 .n = sizeof(struct user_rp_state) / sizeof(long),
317 .size = sizeof(long),
318 .align = sizeof(long long),
319 .get = metag_rp_state_get,
320 .set = metag_rp_state_set,
321 },
322};
323
324static const struct user_regset_view user_metag_view = {
325 .name = "metag",
326 .e_machine = EM_METAG,
327 .regsets = metag_regsets,
328 .n = ARRAY_SIZE(metag_regsets)
329};
330
331const struct user_regset_view *task_user_regset_view(struct task_struct *task)
332{
333 return &user_metag_view;
334}
335
336/*
337 * Called by kernel/ptrace.c when detaching..
338 *
339 * Make sure single step bits etc are not set.
340 */
341void ptrace_disable(struct task_struct *child)
342{
343 /* nothing to do.. */
344}
345
346long arch_ptrace(struct task_struct *child, long request, unsigned long addr,
347 unsigned long data)
348{
349 int ret;
350
351 switch (request) {
352 default:
353 ret = ptrace_request(child, request, addr, data);
354 break;
355 }
356
357 return ret;
358}
359
360int syscall_trace_enter(struct pt_regs *regs)
361{
362 int ret = 0;
363
364 if (test_thread_flag(TIF_SYSCALL_TRACE))
365 ret = tracehook_report_syscall_entry(regs);
366
367 if (unlikely(test_thread_flag(TIF_SYSCALL_TRACEPOINT)))
368 trace_sys_enter(regs, regs->ctx.DX[0].U1);
369
370 return ret ? -1 : regs->ctx.DX[0].U1;
371}
372
373void syscall_trace_leave(struct pt_regs *regs)
374{
375 if (unlikely(test_thread_flag(TIF_SYSCALL_TRACEPOINT)))
376 trace_sys_exit(regs, regs->ctx.DX[0].U1);
377
378 if (test_thread_flag(TIF_SYSCALL_TRACE))
379 tracehook_report_syscall_exit(regs, 0);
380}
diff --git a/include/uapi/linux/elf.h b/include/uapi/linux/elf.h
index 126a8175e3e2..eb164a298b98 100644
--- a/include/uapi/linux/elf.h
+++ b/include/uapi/linux/elf.h
@@ -395,6 +395,8 @@ typedef struct elf64_shdr {
395#define NT_ARM_TLS 0x401 /* ARM TLS register */ 395#define NT_ARM_TLS 0x401 /* ARM TLS register */
396#define NT_ARM_HW_BREAK 0x402 /* ARM hardware breakpoint registers */ 396#define NT_ARM_HW_BREAK 0x402 /* ARM hardware breakpoint registers */
397#define NT_ARM_HW_WATCH 0x403 /* ARM hardware watchpoint registers */ 397#define NT_ARM_HW_WATCH 0x403 /* ARM hardware watchpoint registers */
398#define NT_METAG_CBUF 0x500 /* Metag catch buffer registers */
399#define NT_METAG_RPIPE 0x501 /* Metag read pipeline state */
398 400
399 401
400/* Note header in a PT_NOTE section */ 402/* Note header in a PT_NOTE section */
generated by cgit v1.2.2 (git 2.25.0) at 2025-02-23 05:32:49 -0500