1 /* GNU/Linux/ARM specific low level interface, for the remote server for GDB.
2 Copyright (C) 1995-2015 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>. */
20 #include "linux-low.h"
22 /* Don't include elf.h if linux/elf.h got included by gdb_proc_service.h.
23 On Bionic elf.h and linux/elf.h have conflicting definitions. */
27 #include "nat/gdb_ptrace.h"
30 /* Defined in auto-generated files. */
31 void init_registers_arm (void);
32 extern const struct target_desc
*tdesc_arm
;
34 void init_registers_arm_with_iwmmxt (void);
35 extern const struct target_desc
*tdesc_arm_with_iwmmxt
;
37 void init_registers_arm_with_vfpv2 (void);
38 extern const struct target_desc
*tdesc_arm_with_vfpv2
;
40 void init_registers_arm_with_vfpv3 (void);
41 extern const struct target_desc
*tdesc_arm_with_vfpv3
;
43 void init_registers_arm_with_neon (void);
44 extern const struct target_desc
*tdesc_arm_with_neon
;
46 #ifndef PTRACE_GET_THREAD_AREA
47 #define PTRACE_GET_THREAD_AREA 22
50 #ifndef PTRACE_GETWMMXREGS
51 # define PTRACE_GETWMMXREGS 18
52 # define PTRACE_SETWMMXREGS 19
55 #ifndef PTRACE_GETVFPREGS
56 # define PTRACE_GETVFPREGS 27
57 # define PTRACE_SETVFPREGS 28
60 #ifndef PTRACE_GETHBPREGS
61 #define PTRACE_GETHBPREGS 29
62 #define PTRACE_SETHBPREGS 30
65 /* Information describing the hardware breakpoint capabilities. */
69 unsigned char max_wp_length
;
70 unsigned char wp_count
;
71 unsigned char bp_count
;
74 /* Enum describing the different types of ARM hardware break-/watch-points. */
83 /* Type describing an ARM Hardware Breakpoint Control register value. */
84 typedef unsigned int arm_hwbp_control_t
;
86 /* Structure used to keep track of hardware break-/watch-points. */
87 struct arm_linux_hw_breakpoint
89 /* Address to break on, or being watched. */
91 /* Control register for break-/watch- point. */
92 arm_hwbp_control_t control
;
95 /* Since we cannot dynamically allocate subfields of arch_process_info,
96 assume a maximum number of supported break-/watchpoints. */
100 /* Per-process arch-specific data we want to keep. */
101 struct arch_process_info
103 /* Hardware breakpoints for this process. */
104 struct arm_linux_hw_breakpoint bpts
[MAX_BPTS
];
105 /* Hardware watchpoints for this process. */
106 struct arm_linux_hw_breakpoint wpts
[MAX_WPTS
];
109 /* Per-thread arch-specific data we want to keep. */
112 /* Non-zero if our copy differs from what's recorded in the thread. */
113 char bpts_changed
[MAX_BPTS
];
114 char wpts_changed
[MAX_WPTS
];
115 /* Cached stopped data address. */
116 CORE_ADDR stopped_data_address
;
119 static unsigned long arm_hwcap
;
121 /* These are in <asm/elf.h> in current kernels. */
123 #define HWCAP_IWMMXT 512
124 #define HWCAP_NEON 4096
125 #define HWCAP_VFPv3 8192
126 #define HWCAP_VFPv3D16 16384
128 #ifdef HAVE_SYS_REG_H
132 #define arm_num_regs 26
134 static int arm_regmap
[] = {
135 0, 4, 8, 12, 16, 20, 24, 28,
136 32, 36, 40, 44, 48, 52, 56, 60,
137 -1, -1, -1, -1, -1, -1, -1, -1, -1,
142 arm_cannot_store_register (int regno
)
144 return (regno
>= arm_num_regs
);
148 arm_cannot_fetch_register (int regno
)
150 return (regno
>= arm_num_regs
);
154 arm_fill_gregset (struct regcache
*regcache
, void *buf
)
158 for (i
= 0; i
< arm_num_regs
; i
++)
159 if (arm_regmap
[i
] != -1)
160 collect_register (regcache
, i
, ((char *) buf
) + arm_regmap
[i
]);
164 arm_store_gregset (struct regcache
*regcache
, const void *buf
)
169 memset (zerobuf
, 0, 8);
170 for (i
= 0; i
< arm_num_regs
; i
++)
171 if (arm_regmap
[i
] != -1)
172 supply_register (regcache
, i
, ((char *) buf
) + arm_regmap
[i
]);
174 supply_register (regcache
, i
, zerobuf
);
178 arm_fill_wmmxregset (struct regcache
*regcache
, void *buf
)
182 if (!(arm_hwcap
& HWCAP_IWMMXT
))
185 for (i
= 0; i
< 16; i
++)
186 collect_register (regcache
, arm_num_regs
+ i
, (char *) buf
+ i
* 8);
188 /* We only have access to wcssf, wcasf, and wcgr0-wcgr3. */
189 for (i
= 0; i
< 6; i
++)
190 collect_register (regcache
, arm_num_regs
+ i
+ 16,
191 (char *) buf
+ 16 * 8 + i
* 4);
195 arm_store_wmmxregset (struct regcache
*regcache
, const void *buf
)
199 if (!(arm_hwcap
& HWCAP_IWMMXT
))
202 for (i
= 0; i
< 16; i
++)
203 supply_register (regcache
, arm_num_regs
+ i
, (char *) buf
+ i
* 8);
205 /* We only have access to wcssf, wcasf, and wcgr0-wcgr3. */
206 for (i
= 0; i
< 6; i
++)
207 supply_register (regcache
, arm_num_regs
+ i
+ 16,
208 (char *) buf
+ 16 * 8 + i
* 4);
212 arm_fill_vfpregset (struct regcache
*regcache
, void *buf
)
216 if (!(arm_hwcap
& HWCAP_VFP
))
219 if ((arm_hwcap
& (HWCAP_VFPv3
| HWCAP_VFPv3D16
)) == HWCAP_VFPv3
)
224 base
= find_regno (regcache
->tdesc
, "d0");
225 for (i
= 0; i
< num
; i
++)
226 collect_register (regcache
, base
+ i
, (char *) buf
+ i
* 8);
228 collect_register_by_name (regcache
, "fpscr", (char *) buf
+ 32 * 8);
232 arm_store_vfpregset (struct regcache
*regcache
, const void *buf
)
236 if (!(arm_hwcap
& HWCAP_VFP
))
239 if ((arm_hwcap
& (HWCAP_VFPv3
| HWCAP_VFPv3D16
)) == HWCAP_VFPv3
)
244 base
= find_regno (regcache
->tdesc
, "d0");
245 for (i
= 0; i
< num
; i
++)
246 supply_register (regcache
, base
+ i
, (char *) buf
+ i
* 8);
248 supply_register_by_name (regcache
, "fpscr", (char *) buf
+ 32 * 8);
251 extern int debug_threads
;
254 arm_get_pc (struct regcache
*regcache
)
257 collect_register_by_name (regcache
, "pc", &pc
);
259 debug_printf ("stop pc is %08lx\n", pc
);
264 arm_set_pc (struct regcache
*regcache
, CORE_ADDR pc
)
266 unsigned long newpc
= pc
;
267 supply_register_by_name (regcache
, "pc", &newpc
);
270 /* Correct in either endianness. */
271 static const unsigned long arm_breakpoint
= 0xef9f0001;
272 #define arm_breakpoint_len 4
273 static const unsigned short thumb_breakpoint
= 0xde01;
274 static const unsigned short thumb2_breakpoint
[] = { 0xf7f0, 0xa000 };
276 /* For new EABI binaries. We recognize it regardless of which ABI
277 is used for gdbserver, so single threaded debugging should work
278 OK, but for multi-threaded debugging we only insert the current
279 ABI's breakpoint instruction. For now at least. */
280 static const unsigned long arm_eabi_breakpoint
= 0xe7f001f0;
283 arm_breakpoint_at (CORE_ADDR where
)
285 struct regcache
*regcache
= get_thread_regcache (current_thread
, 1);
288 collect_register_by_name (regcache
, "cpsr", &cpsr
);
295 (*the_target
->read_memory
) (where
, (unsigned char *) &insn
, 2);
296 if (insn
== thumb_breakpoint
)
299 if (insn
== thumb2_breakpoint
[0])
301 (*the_target
->read_memory
) (where
+ 2, (unsigned char *) &insn
, 2);
302 if (insn
== thumb2_breakpoint
[1])
311 (*the_target
->read_memory
) (where
, (unsigned char *) &insn
, 4);
312 if (insn
== arm_breakpoint
)
315 if (insn
== arm_eabi_breakpoint
)
322 /* We only place breakpoints in empty marker functions, and thread locking
323 is outside of the function. So rather than importing software single-step,
324 we can just run until exit. */
326 arm_reinsert_addr (void)
328 struct regcache
*regcache
= get_thread_regcache (current_thread
, 1);
330 collect_register_by_name (regcache
, "lr", &pc
);
334 /* Fetch the thread-local storage pointer for libthread_db. */
337 ps_get_thread_area (const struct ps_prochandle
*ph
,
338 lwpid_t lwpid
, int idx
, void **base
)
340 if (ptrace (PTRACE_GET_THREAD_AREA
, lwpid
, NULL
, base
) != 0)
343 /* IDX is the bias from the thread pointer to the beginning of the
344 thread descriptor. It has to be subtracted due to implementation
345 quirks in libthread_db. */
346 *base
= (void *) ((char *)*base
- idx
);
352 /* Query Hardware Breakpoint information for the target we are attached to
353 (using PID as ptrace argument) and set up arm_linux_hwbp_cap. */
355 arm_linux_init_hwbp_cap (int pid
)
359 if (ptrace (PTRACE_GETHBPREGS
, pid
, 0, &val
) < 0)
362 arm_linux_hwbp_cap
.arch
= (unsigned char)((val
>> 24) & 0xff);
363 if (arm_linux_hwbp_cap
.arch
== 0)
366 arm_linux_hwbp_cap
.max_wp_length
= (unsigned char)((val
>> 16) & 0xff);
367 arm_linux_hwbp_cap
.wp_count
= (unsigned char)((val
>> 8) & 0xff);
368 arm_linux_hwbp_cap
.bp_count
= (unsigned char)(val
& 0xff);
370 if (arm_linux_hwbp_cap
.wp_count
> MAX_WPTS
)
371 internal_error (__FILE__
, __LINE__
, "Unsupported number of watchpoints");
372 if (arm_linux_hwbp_cap
.bp_count
> MAX_BPTS
)
373 internal_error (__FILE__
, __LINE__
, "Unsupported number of breakpoints");
376 /* How many hardware breakpoints are available? */
378 arm_linux_get_hw_breakpoint_count (void)
380 return arm_linux_hwbp_cap
.bp_count
;
383 /* How many hardware watchpoints are available? */
385 arm_linux_get_hw_watchpoint_count (void)
387 return arm_linux_hwbp_cap
.wp_count
;
390 /* Maximum length of area watched by hardware watchpoint. */
392 arm_linux_get_hw_watchpoint_max_length (void)
394 return arm_linux_hwbp_cap
.max_wp_length
;
397 /* Initialize an ARM hardware break-/watch-point control register value.
398 BYTE_ADDRESS_SELECT is the mask of bytes to trigger on; HWBP_TYPE is the
399 type of break-/watch-point; ENABLE indicates whether the point is enabled.
401 static arm_hwbp_control_t
402 arm_hwbp_control_initialize (unsigned byte_address_select
,
403 arm_hwbp_type hwbp_type
,
406 gdb_assert ((byte_address_select
& ~0xffU
) == 0);
407 gdb_assert (hwbp_type
!= arm_hwbp_break
408 || ((byte_address_select
& 0xfU
) != 0));
410 return (byte_address_select
<< 5) | (hwbp_type
<< 3) | (3 << 1) | enable
;
413 /* Does the breakpoint control value CONTROL have the enable bit set? */
415 arm_hwbp_control_is_enabled (arm_hwbp_control_t control
)
417 return control
& 0x1;
420 /* Is the breakpoint control value CONTROL initialized? */
422 arm_hwbp_control_is_initialized (arm_hwbp_control_t control
)
427 /* Change a breakpoint control word so that it is in the disabled state. */
428 static arm_hwbp_control_t
429 arm_hwbp_control_disable (arm_hwbp_control_t control
)
431 return control
& ~0x1;
434 /* Are two break-/watch-points equal? */
436 arm_linux_hw_breakpoint_equal (const struct arm_linux_hw_breakpoint
*p1
,
437 const struct arm_linux_hw_breakpoint
*p2
)
439 return p1
->address
== p2
->address
&& p1
->control
== p2
->control
;
442 /* Convert a raw breakpoint type to an enum arm_hwbp_type. */
445 raw_bkpt_type_to_arm_hwbp_type (enum raw_bkpt_type raw_type
)
449 case raw_bkpt_type_hw
:
450 return arm_hwbp_break
;
451 case raw_bkpt_type_write_wp
:
452 return arm_hwbp_store
;
453 case raw_bkpt_type_read_wp
:
454 return arm_hwbp_load
;
455 case raw_bkpt_type_access_wp
:
456 return arm_hwbp_access
;
458 gdb_assert_not_reached ("unhandled raw type");
462 /* Initialize the hardware breakpoint structure P for a breakpoint or
463 watchpoint at ADDR to LEN. The type of watchpoint is given in TYPE.
464 Returns -1 if TYPE is unsupported, or -2 if the particular combination
465 of ADDR and LEN cannot be implemented. Otherwise, returns 0 if TYPE
466 represents a breakpoint and 1 if type represents a watchpoint. */
468 arm_linux_hw_point_initialize (enum raw_bkpt_type raw_type
, CORE_ADDR addr
,
469 int len
, struct arm_linux_hw_breakpoint
*p
)
471 arm_hwbp_type hwbp_type
;
474 hwbp_type
= raw_bkpt_type_to_arm_hwbp_type (raw_type
);
476 if (hwbp_type
== arm_hwbp_break
)
478 /* For breakpoints, the length field encodes the mode. */
481 case 2: /* 16-bit Thumb mode breakpoint */
482 case 3: /* 32-bit Thumb mode breakpoint */
486 case 4: /* 32-bit ARM mode breakpoint */
497 CORE_ADDR max_wp_length
= arm_linux_get_hw_watchpoint_max_length ();
498 CORE_ADDR aligned_addr
;
500 /* Can not set watchpoints for zero or negative lengths. */
503 /* The current ptrace interface can only handle watchpoints that are a
505 if ((len
& (len
- 1)) != 0)
508 /* Test that the range [ADDR, ADDR + LEN) fits into the largest address
509 range covered by a watchpoint. */
510 aligned_addr
= addr
& ~(max_wp_length
- 1);
511 if (aligned_addr
+ max_wp_length
< addr
+ len
)
514 mask
= (1 << len
) - 1;
517 p
->address
= (unsigned int) addr
;
518 p
->control
= arm_hwbp_control_initialize (mask
, hwbp_type
, 1);
520 return hwbp_type
!= arm_hwbp_break
;
523 /* Callback to mark a watch-/breakpoint to be updated in all threads of
524 the current process. */
526 struct update_registers_data
533 update_registers_callback (struct inferior_list_entry
*entry
, void *arg
)
535 struct thread_info
*thread
= (struct thread_info
*) entry
;
536 struct lwp_info
*lwp
= get_thread_lwp (thread
);
537 struct update_registers_data
*data
= (struct update_registers_data
*) arg
;
539 /* Only update the threads of the current process. */
540 if (pid_of (thread
) == pid_of (current_thread
))
542 /* The actual update is done later just before resuming the lwp,
543 we just mark that the registers need updating. */
545 lwp
->arch_private
->wpts_changed
[data
->i
] = 1;
547 lwp
->arch_private
->bpts_changed
[data
->i
] = 1;
549 /* If the lwp isn't stopped, force it to momentarily pause, so
550 we can update its breakpoint registers. */
552 linux_stop_lwp (lwp
);
559 arm_supports_z_point_type (char z_type
)
564 case Z_PACKET_WRITE_WP
:
565 case Z_PACKET_READ_WP
:
566 case Z_PACKET_ACCESS_WP
:
569 /* Leave the handling of sw breakpoints with the gdb client. */
574 /* Insert hardware break-/watchpoint. */
576 arm_insert_point (enum raw_bkpt_type type
, CORE_ADDR addr
,
577 int len
, struct raw_breakpoint
*bp
)
579 struct process_info
*proc
= current_process ();
580 struct arm_linux_hw_breakpoint p
, *pts
;
583 watch
= arm_linux_hw_point_initialize (type
, addr
, len
, &p
);
587 return watch
== -1 ? 1 : -1;
592 count
= arm_linux_get_hw_watchpoint_count ();
593 pts
= proc
->priv
->arch_private
->wpts
;
597 count
= arm_linux_get_hw_breakpoint_count ();
598 pts
= proc
->priv
->arch_private
->bpts
;
601 for (i
= 0; i
< count
; i
++)
602 if (!arm_hwbp_control_is_enabled (pts
[i
].control
))
604 struct update_registers_data data
= { watch
, i
};
606 find_inferior (&all_threads
, update_registers_callback
, &data
);
610 /* We're out of watchpoints. */
614 /* Remove hardware break-/watchpoint. */
616 arm_remove_point (enum raw_bkpt_type type
, CORE_ADDR addr
,
617 int len
, struct raw_breakpoint
*bp
)
619 struct process_info
*proc
= current_process ();
620 struct arm_linux_hw_breakpoint p
, *pts
;
623 watch
= arm_linux_hw_point_initialize (type
, addr
, len
, &p
);
632 count
= arm_linux_get_hw_watchpoint_count ();
633 pts
= proc
->priv
->arch_private
->wpts
;
637 count
= arm_linux_get_hw_breakpoint_count ();
638 pts
= proc
->priv
->arch_private
->bpts
;
641 for (i
= 0; i
< count
; i
++)
642 if (arm_linux_hw_breakpoint_equal (&p
, pts
+ i
))
644 struct update_registers_data data
= { watch
, i
};
645 pts
[i
].control
= arm_hwbp_control_disable (pts
[i
].control
);
646 find_inferior (&all_threads
, update_registers_callback
, &data
);
650 /* No watchpoint matched. */
654 /* Return whether current thread is stopped due to a watchpoint. */
656 arm_stopped_by_watchpoint (void)
658 struct lwp_info
*lwp
= get_thread_lwp (current_thread
);
661 /* We must be able to set hardware watchpoints. */
662 if (arm_linux_get_hw_watchpoint_count () == 0)
665 /* Retrieve siginfo. */
667 ptrace (PTRACE_GETSIGINFO
, lwpid_of (current_thread
), 0, &siginfo
);
671 /* This must be a hardware breakpoint. */
672 if (siginfo
.si_signo
!= SIGTRAP
673 || (siginfo
.si_code
& 0xffff) != 0x0004 /* TRAP_HWBKPT */)
676 /* If we are in a positive slot then we're looking at a breakpoint and not
678 if (siginfo
.si_errno
>= 0)
681 /* Cache stopped data address for use by arm_stopped_data_address. */
682 lwp
->arch_private
->stopped_data_address
683 = (CORE_ADDR
) (uintptr_t) siginfo
.si_addr
;
688 /* Return data address that triggered watchpoint. Called only if
689 arm_stopped_by_watchpoint returned true. */
691 arm_stopped_data_address (void)
693 struct lwp_info
*lwp
= get_thread_lwp (current_thread
);
694 return lwp
->arch_private
->stopped_data_address
;
697 /* Called when a new process is created. */
698 static struct arch_process_info
*
699 arm_new_process (void)
701 struct arch_process_info
*info
= xcalloc (1, sizeof (*info
));
705 /* Called when a new thread is detected. */
707 arm_new_thread (struct lwp_info
*lwp
)
709 struct arch_lwp_info
*info
= xcalloc (1, sizeof (*info
));
712 for (i
= 0; i
< MAX_BPTS
; i
++)
713 info
->bpts_changed
[i
] = 1;
714 for (i
= 0; i
< MAX_WPTS
; i
++)
715 info
->wpts_changed
[i
] = 1;
717 lwp
->arch_private
= info
;
721 arm_new_fork (struct process_info
*parent
, struct process_info
*child
)
723 struct arch_process_info
*parent_proc_info
= parent
->priv
->arch_private
;
724 struct arch_process_info
*child_proc_info
= child
->priv
->arch_private
;
725 struct lwp_info
*child_lwp
;
726 struct arch_lwp_info
*child_lwp_info
;
729 /* These are allocated by linux_add_process. */
730 gdb_assert (parent
->priv
!= NULL
731 && parent
->priv
->arch_private
!= NULL
);
732 gdb_assert (child
->priv
!= NULL
733 && child
->priv
->arch_private
!= NULL
);
735 /* Linux kernel before 2.6.33 commit
736 72f674d203cd230426437cdcf7dd6f681dad8b0d
737 will inherit hardware debug registers from parent
738 on fork/vfork/clone. Newer Linux kernels create such tasks with
739 zeroed debug registers.
741 GDB core assumes the child inherits the watchpoints/hw
742 breakpoints of the parent, and will remove them all from the
743 forked off process. Copy the debug registers mirrors into the
744 new process so that all breakpoints and watchpoints can be
745 removed together. The debug registers mirror will become zeroed
746 in the end before detaching the forked off process, thus making
747 this compatible with older Linux kernels too. */
749 *child_proc_info
= *parent_proc_info
;
751 /* Mark all the hardware breakpoints and watchpoints as changed to
752 make sure that the registers will be updated. */
753 child_lwp
= find_lwp_pid (ptid_of (child
));
754 child_lwp_info
= child_lwp
->arch_private
;
755 for (i
= 0; i
< MAX_BPTS
; i
++)
756 child_lwp_info
->bpts_changed
[i
] = 1;
757 for (i
= 0; i
< MAX_WPTS
; i
++)
758 child_lwp_info
->wpts_changed
[i
] = 1;
761 /* Called when resuming a thread.
762 If the debug regs have changed, update the thread's copies. */
764 arm_prepare_to_resume (struct lwp_info
*lwp
)
766 struct thread_info
*thread
= get_lwp_thread (lwp
);
767 int pid
= lwpid_of (thread
);
768 struct process_info
*proc
= find_process_pid (pid_of (thread
));
769 struct arch_process_info
*proc_info
= proc
->priv
->arch_private
;
770 struct arch_lwp_info
*lwp_info
= lwp
->arch_private
;
773 for (i
= 0; i
< arm_linux_get_hw_breakpoint_count (); i
++)
774 if (lwp_info
->bpts_changed
[i
])
778 if (arm_hwbp_control_is_enabled (proc_info
->bpts
[i
].control
))
779 if (ptrace (PTRACE_SETHBPREGS
, pid
,
780 (PTRACE_TYPE_ARG3
) ((i
<< 1) + 1),
781 &proc_info
->bpts
[i
].address
) < 0)
782 perror_with_name ("Unexpected error setting breakpoint address");
784 if (arm_hwbp_control_is_initialized (proc_info
->bpts
[i
].control
))
785 if (ptrace (PTRACE_SETHBPREGS
, pid
,
786 (PTRACE_TYPE_ARG3
) ((i
<< 1) + 2),
787 &proc_info
->bpts
[i
].control
) < 0)
788 perror_with_name ("Unexpected error setting breakpoint");
790 lwp_info
->bpts_changed
[i
] = 0;
793 for (i
= 0; i
< arm_linux_get_hw_watchpoint_count (); i
++)
794 if (lwp_info
->wpts_changed
[i
])
798 if (arm_hwbp_control_is_enabled (proc_info
->wpts
[i
].control
))
799 if (ptrace (PTRACE_SETHBPREGS
, pid
,
800 (PTRACE_TYPE_ARG3
) -((i
<< 1) + 1),
801 &proc_info
->wpts
[i
].address
) < 0)
802 perror_with_name ("Unexpected error setting watchpoint address");
804 if (arm_hwbp_control_is_initialized (proc_info
->wpts
[i
].control
))
805 if (ptrace (PTRACE_SETHBPREGS
, pid
,
806 (PTRACE_TYPE_ARG3
) -((i
<< 1) + 2),
807 &proc_info
->wpts
[i
].control
) < 0)
808 perror_with_name ("Unexpected error setting watchpoint");
810 lwp_info
->wpts_changed
[i
] = 0;
816 arm_get_hwcap (unsigned long *valp
)
818 unsigned char *data
= alloca (8);
821 while ((*the_target
->read_auxv
) (offset
, data
, 8) == 8)
823 unsigned int *data_p
= (unsigned int *)data
;
824 if (data_p
[0] == AT_HWCAP
)
837 static const struct target_desc
*
838 arm_read_description (void)
840 int pid
= lwpid_of (current_thread
);
842 /* Query hardware watchpoint/breakpoint capabilities. */
843 arm_linux_init_hwbp_cap (pid
);
846 if (arm_get_hwcap (&arm_hwcap
) == 0)
849 if (arm_hwcap
& HWCAP_IWMMXT
)
850 return tdesc_arm_with_iwmmxt
;
852 if (arm_hwcap
& HWCAP_VFP
)
854 const struct target_desc
*result
;
857 /* NEON implies either no VFP, or VFPv3-D32. We only support
859 if (arm_hwcap
& HWCAP_NEON
)
860 result
= tdesc_arm_with_neon
;
861 else if ((arm_hwcap
& (HWCAP_VFPv3
| HWCAP_VFPv3D16
)) == HWCAP_VFPv3
)
862 result
= tdesc_arm_with_vfpv3
;
864 result
= tdesc_arm_with_vfpv2
;
866 /* Now make sure that the kernel supports reading these
867 registers. Support was added in 2.6.30. */
869 buf
= xmalloc (32 * 8 + 4);
870 if (ptrace (PTRACE_GETVFPREGS
, pid
, 0, buf
) < 0
881 /* The default configuration uses legacy FPA registers, probably
887 arm_arch_setup (void)
889 current_process ()->tdesc
= arm_read_description ();
892 static struct regset_info arm_regsets
[] = {
893 { PTRACE_GETREGS
, PTRACE_SETREGS
, 0, 18 * 4,
895 arm_fill_gregset
, arm_store_gregset
},
896 { PTRACE_GETWMMXREGS
, PTRACE_SETWMMXREGS
, 0, 16 * 8 + 6 * 4,
898 arm_fill_wmmxregset
, arm_store_wmmxregset
},
899 { PTRACE_GETVFPREGS
, PTRACE_SETVFPREGS
, 0, 32 * 8 + 4,
901 arm_fill_vfpregset
, arm_store_vfpregset
},
902 { 0, 0, 0, -1, -1, NULL
, NULL
}
905 static struct regsets_info arm_regsets_info
=
907 arm_regsets
, /* regsets */
909 NULL
, /* disabled_regsets */
912 static struct usrregs_info arm_usrregs_info
=
918 static struct regs_info regs_info
=
920 NULL
, /* regset_bitmap */
925 static const struct regs_info
*
931 struct linux_target_ops the_low_target
= {
934 arm_cannot_fetch_register
,
935 arm_cannot_store_register
,
936 NULL
, /* fetch_register */
940 /* Define an ARM-mode breakpoint; we only set breakpoints in the C
941 library, which is most likely to be ARM. If the kernel supports
942 clone events, we will never insert a breakpoint, so even a Thumb
943 C library will work; so will mixing EABI/non-EABI gdbserver and
946 (const unsigned char *) &arm_breakpoint
,
948 (const unsigned char *) &arm_eabi_breakpoint
,
954 arm_supports_z_point_type
,
957 arm_stopped_by_watchpoint
,
958 arm_stopped_data_address
,
959 NULL
, /* collect_ptrace_register */
960 NULL
, /* supply_ptrace_register */
961 NULL
, /* siginfo_fixup */
965 arm_prepare_to_resume
,
969 initialize_low_arch (void)
971 /* Initialize the Linux target descriptions. */
972 init_registers_arm ();
973 init_registers_arm_with_iwmmxt ();
974 init_registers_arm_with_vfpv2 ();
975 init_registers_arm_with_vfpv3 ();
976 init_registers_arm_with_neon ();
978 initialize_regsets_info (&arm_regsets_info
);