diff options
Diffstat (limited to 'meta-microblaze/recipes-devtools/gdb/gdb')
12 files changed, 1295 insertions, 972 deletions
diff --git a/meta-microblaze/recipes-devtools/gdb/gdb/0001-Add-initial-port-of-linux-gdbserver.patch b/meta-microblaze/recipes-devtools/gdb/gdb/0001-Patch-MicroBlaze.patch index bc1c1a93..b5a2726b 100644 --- a/meta-microblaze/recipes-devtools/gdb/gdb/0001-Add-initial-port-of-linux-gdbserver.patch +++ b/meta-microblaze/recipes-devtools/gdb/gdb/0001-Patch-MicroBlaze.patch | |||
@@ -1,8 +1,8 @@ | |||
1 | From 699248a2fc4b9334f5042e1657116ac6b67b7321 Mon Sep 17 00:00:00 2001 | 1 | From b7b3c1eb19b770b2d700dd3c9fa23a7ae225a72b Mon Sep 17 00:00:00 2001 |
2 | From: Mahesh Bodapati <mbodapat@xilinx.com> | 2 | From: Mahesh Bodapati <mbodapat@xilinx.com> |
3 | Date: Mon, 23 Jan 2017 19:07:44 +0530 | 3 | Date: Thu, 16 Jun 2022 09:50:14 +0530 |
4 | Subject: [PATCH 01/10] Add initial port of linux gdbserver add | 4 | Subject: [PATCH 01/10] [Patch,MicroBlaze] : Add initial port of linux |
5 | gdb_proc_service_h to gdbserver microblaze-linux | 5 | gdbserver add gdb_proc_service_h to gdbserver microblaze-linux |
6 | 6 | ||
7 | gdbserver needs to initialise the microblaze registers | 7 | gdbserver needs to initialise the microblaze registers |
8 | 8 | ||
@@ -451,7 +451,7 @@ index 00000000000..bd8a4384424 | |||
451 | +32:slr | 451 | +32:slr |
452 | +32:shr | 452 | +32:shr |
453 | diff --git a/gdbserver/Makefile.in b/gdbserver/Makefile.in | 453 | diff --git a/gdbserver/Makefile.in b/gdbserver/Makefile.in |
454 | index 2bd3a578932..7bee1f1894e 100644 | 454 | index 2bd3a578932..46b5a0c7c60 100644 |
455 | --- a/gdbserver/Makefile.in | 455 | --- a/gdbserver/Makefile.in |
456 | +++ b/gdbserver/Makefile.in | 456 | +++ b/gdbserver/Makefile.in |
457 | @@ -184,7 +184,8 @@ SFILES = \ | 457 | @@ -184,7 +184,8 @@ SFILES = \ |
@@ -468,7 +468,7 @@ index 2bd3a578932..7bee1f1894e 100644 | |||
468 | $(srcdir)/../gdb/nat/linux-namespaces.c \ | 468 | $(srcdir)/../gdb/nat/linux-namespaces.c \ |
469 | $(srcdir)/../gdb/nat/linux-osdata.c \ | 469 | $(srcdir)/../gdb/nat/linux-osdata.c \ |
470 | $(srcdir)/../gdb/nat/linux-personality.c \ | 470 | $(srcdir)/../gdb/nat/linux-personality.c \ |
471 | + $(srcdir)/../gdb/nat/microblaze-linux.c \ | 471 | + $(srcdir)/../gdb/nat/microblaze-linux.c \ |
472 | $(srcdir)/../gdb/nat/mips-linux-watch.c \ | 472 | $(srcdir)/../gdb/nat/mips-linux-watch.c \ |
473 | $(srcdir)/../gdb/nat/ppc-linux.c \ | 473 | $(srcdir)/../gdb/nat/ppc-linux.c \ |
474 | $(srcdir)/../gdb/nat/riscv-linux-tdesc.c \ | 474 | $(srcdir)/../gdb/nat/riscv-linux-tdesc.c \ |
diff --git a/meta-microblaze/recipes-devtools/gdb/gdb/0002-Initial-port-of-core-reading-support.patch b/meta-microblaze/recipes-devtools/gdb/gdb/0002-Initial-port-of-core-reading-support.patch index d49a7fe6..352ed92e 100644 --- a/meta-microblaze/recipes-devtools/gdb/gdb/0002-Initial-port-of-core-reading-support.patch +++ b/meta-microblaze/recipes-devtools/gdb/gdb/0002-Initial-port-of-core-reading-support.patch | |||
@@ -1,4 +1,4 @@ | |||
1 | From eae6f2fc7324729056f4bd3bfa66c0c5887d7b94 Mon Sep 17 00:00:00 2001 | 1 | From da36639f95d23083088a27c27f631d304ae316f1 Mon Sep 17 00:00:00 2001 |
2 | From: Mahesh Bodapati <mbodapat@xilinx.com> | 2 | From: Mahesh Bodapati <mbodapat@xilinx.com> |
3 | Date: Tue, 24 Jan 2017 14:55:56 +0530 | 3 | Date: Tue, 24 Jan 2017 14:55:56 +0530 |
4 | Subject: [PATCH 02/10] Initial port of core reading support Added support for | 4 | Subject: [PATCH 02/10] Initial port of core reading support Added support for |
diff --git a/meta-microblaze/recipes-devtools/gdb/gdb/0003-Fix-debug-message-when-register-is-unavailable.patch b/meta-microblaze/recipes-devtools/gdb/gdb/0003-Fix-debug-message-when-register-is-unavailable.patch index 68d90f27..255bb9b5 100644 --- a/meta-microblaze/recipes-devtools/gdb/gdb/0003-Fix-debug-message-when-register-is-unavailable.patch +++ b/meta-microblaze/recipes-devtools/gdb/gdb/0003-Fix-debug-message-when-register-is-unavailable.patch | |||
@@ -1,4 +1,4 @@ | |||
1 | From 80c56ef8463c23f51759f5c64ce0165e259a4071 Mon Sep 17 00:00:00 2001 | 1 | From da93f5715ff333ac4807b73fe678dde21fb3bd6c Mon Sep 17 00:00:00 2001 |
2 | From: Nathan Rossi <nathan.rossi@petalogix.com> | 2 | From: Nathan Rossi <nathan.rossi@petalogix.com> |
3 | Date: Tue, 8 May 2012 18:11:17 +1000 | 3 | Date: Tue, 8 May 2012 18:11:17 +1000 |
4 | Subject: [PATCH 03/10] Fix debug message when register is unavailable | 4 | Subject: [PATCH 03/10] Fix debug message when register is unavailable |
diff --git a/meta-microblaze/recipes-devtools/gdb/gdb/0004-microblaze-Add-build_gdbserver-yes-to-top-level-conf.patch b/meta-microblaze/recipes-devtools/gdb/gdb/0004-microblaze-Add-build_gdbserver-yes-to-top-level-conf.patch index e63a696d..f1555b8a 100644 --- a/meta-microblaze/recipes-devtools/gdb/gdb/0004-microblaze-Add-build_gdbserver-yes-to-top-level-conf.patch +++ b/meta-microblaze/recipes-devtools/gdb/gdb/0004-microblaze-Add-build_gdbserver-yes-to-top-level-conf.patch | |||
@@ -1,4 +1,4 @@ | |||
1 | From 7d970a0c616063a5095ce3725efed0feb40ceb30 Mon Sep 17 00:00:00 2001 | 1 | From 82ee589db2c1191fb274f4a76e217df318f8d6b2 Mon Sep 17 00:00:00 2001 |
2 | From: David Holsgrove <david.holsgrove@xilinx.com> | 2 | From: David Holsgrove <david.holsgrove@xilinx.com> |
3 | Date: Mon, 16 Dec 2013 16:37:32 +1000 | 3 | Date: Mon, 16 Dec 2013 16:37:32 +1000 |
4 | Subject: [PATCH 04/10] microblaze: Add build_gdbserver=yes to top level | 4 | Subject: [PATCH 04/10] microblaze: Add build_gdbserver=yes to top level |
diff --git a/meta-microblaze/recipes-devtools/gdb/gdb/0006-Fixing-the-issues-related-to-GDB-7.12.patch b/meta-microblaze/recipes-devtools/gdb/gdb/0005-Fixing-the-issues-related-to-GDB-7.12.patch index eb1efa71..48e203a9 100644 --- a/meta-microblaze/recipes-devtools/gdb/gdb/0006-Fixing-the-issues-related-to-GDB-7.12.patch +++ b/meta-microblaze/recipes-devtools/gdb/gdb/0005-Fixing-the-issues-related-to-GDB-7.12.patch | |||
@@ -1,34 +1,19 @@ | |||
1 | From 41b0d54fa00ce765e9a2ce09136938b72b2b96d7 Mon Sep 17 00:00:00 2001 | 1 | From ca1158d19ab9879167ca9fbe2fdf8d19094cc53f Mon Sep 17 00:00:00 2001 |
2 | From: Nagaraju Mekala <nmekala@xilix.com> | 2 | From: Nagaraju Mekala <nmekala@xilix.com> |
3 | Date: Fri, 17 Feb 2017 14:09:40 +0530 | 3 | Date: Fri, 17 Feb 2017 14:09:40 +0530 |
4 | Subject: [PATCH 06/10] Fixing the issues related to GDB-7.12 | 4 | Subject: [PATCH 05/10] Fixing the issues related to GDB-7.12 |
5 | 5 | ||
6 | added all the required function which are new in 7.12 and removed | 6 | added all the required function which are new in 7.12 and removed |
7 | few deprecated functions from 7.6 | 7 | few deprecated functions from 7.6 |
8 | |||
9 | Conflicts: | ||
10 | gdb/config/microblaze/linux.mh | ||
8 | --- | 11 | --- |
9 | gdb/config/microblaze/linux.mh | 4 +- | ||
10 | gdb/gdbserver/linux-microblaze-low.c | 97 ++++++++++++++++++++++++---- | 12 | gdb/gdbserver/linux-microblaze-low.c | 97 ++++++++++++++++++++++++---- |
11 | gdb/microblaze-tdep.h | 1 + | 13 | gdb/microblaze-tdep.h | 1 + |
12 | gdbserver/configure.srv | 3 +- | 14 | gdbserver/configure.srv | 3 +- |
13 | 4 files changed, 89 insertions(+), 16 deletions(-) | 15 | 3 files changed, 86 insertions(+), 15 deletions(-) |
14 | 16 | ||
15 | diff --git a/gdb/config/microblaze/linux.mh b/gdb/config/microblaze/linux.mh | ||
16 | index a4eaf540e1d..74a53b854a4 100644 | ||
17 | --- a/gdb/config/microblaze/linux.mh | ||
18 | +++ b/gdb/config/microblaze/linux.mh | ||
19 | @@ -1,9 +1,11 @@ | ||
20 | # Host: Microblaze, running Linux | ||
21 | |||
22 | +#linux-nat.o linux-waitpid.o linux-osdata.o linux-fork.o linux-procfs.o linux-ptrace.o | ||
23 | NAT_FILE= config/nm-linux.h | ||
24 | NATDEPFILES= inf-ptrace.o fork-child.o \ | ||
25 | microblaze-linux-nat.o proc-service.o linux-thread-db.o \ | ||
26 | - linux-nat.o linux-osdata.o linux-fork.o linux-procfs.o linux-ptrace.o | ||
27 | + linux-nat.o linux-osdata.o linux-fork.o linux-procfs.o linux-ptrace.o \ | ||
28 | + linux-waitpid.o linux-personality.o linux-namespaces.o | ||
29 | NAT_CDEPS = $(srcdir)/proc-service.list | ||
30 | |||
31 | LOADLIBES = -ldl $(RDYNAMIC) | ||
32 | diff --git a/gdb/gdbserver/linux-microblaze-low.c b/gdb/gdbserver/linux-microblaze-low.c | 17 | diff --git a/gdb/gdbserver/linux-microblaze-low.c b/gdb/gdbserver/linux-microblaze-low.c |
33 | index cba5d6fc585..a2733f3c21c 100644 | 18 | index cba5d6fc585..a2733f3c21c 100644 |
34 | --- a/gdb/gdbserver/linux-microblaze-low.c | 19 | --- a/gdb/gdbserver/linux-microblaze-low.c |
diff --git a/meta-microblaze/recipes-devtools/gdb/gdb/0005-Initial-support-for-native-gdb.patch b/meta-microblaze/recipes-devtools/gdb/gdb/0005-Initial-support-for-native-gdb.patch deleted file mode 100644 index 3482bcd8..00000000 --- a/meta-microblaze/recipes-devtools/gdb/gdb/0005-Initial-support-for-native-gdb.patch +++ /dev/null | |||
@@ -1,492 +0,0 @@ | |||
1 | From bac086097dfa813fcc0b978dc32eb9ae469bf4a8 Mon Sep 17 00:00:00 2001 | ||
2 | From: David Holsgrove <david.holsgrove@petalogix.com> | ||
3 | Date: Fri, 20 Jul 2012 15:18:35 +1000 | ||
4 | Subject: [PATCH 05/10] Initial support for native gdb | ||
5 | |||
6 | microblaze: Follow PPC method of getting setting registers | ||
7 | using PTRACE PEEK/POKE | ||
8 | |||
9 | Signed-off-by: David Holsgrove <david.holsgrove@petalogix.com> | ||
10 | --- | ||
11 | gdb/Makefile.in | 2 + | ||
12 | gdb/config/microblaze/linux.mh | 9 + | ||
13 | gdb/microblaze-linux-nat.c | 431 +++++++++++++++++++++++++++++++++ | ||
14 | 3 files changed, 442 insertions(+) | ||
15 | create mode 100644 gdb/config/microblaze/linux.mh | ||
16 | create mode 100644 gdb/microblaze-linux-nat.c | ||
17 | |||
18 | diff --git a/gdb/Makefile.in b/gdb/Makefile.in | ||
19 | index ec371fc7e52..2e8d4cfe82e 100644 | ||
20 | --- a/gdb/Makefile.in | ||
21 | +++ b/gdb/Makefile.in | ||
22 | @@ -1336,6 +1336,7 @@ HFILES_NO_SRCDIR = \ | ||
23 | memory-map.h \ | ||
24 | memrange.h \ | ||
25 | microblaze-tdep.h \ | ||
26 | + microblaze-linux-tdep.h \ | ||
27 | mips-linux-tdep.h \ | ||
28 | mips-nbsd-tdep.h \ | ||
29 | mips-tdep.h \ | ||
30 | @@ -2216,6 +2217,7 @@ ALLDEPFILES = \ | ||
31 | m68k-tdep.c \ | ||
32 | microblaze-linux-tdep.c \ | ||
33 | microblaze-tdep.c \ | ||
34 | + microblaze-linux-nat.c \ | ||
35 | mingw-hdep.c \ | ||
36 | mips-fbsd-nat.c \ | ||
37 | mips-fbsd-tdep.c \ | ||
38 | diff --git a/gdb/config/microblaze/linux.mh b/gdb/config/microblaze/linux.mh | ||
39 | new file mode 100644 | ||
40 | index 00000000000..a4eaf540e1d | ||
41 | --- /dev/null | ||
42 | +++ b/gdb/config/microblaze/linux.mh | ||
43 | @@ -0,0 +1,9 @@ | ||
44 | +# Host: Microblaze, running Linux | ||
45 | + | ||
46 | +NAT_FILE= config/nm-linux.h | ||
47 | +NATDEPFILES= inf-ptrace.o fork-child.o \ | ||
48 | + microblaze-linux-nat.o proc-service.o linux-thread-db.o \ | ||
49 | + linux-nat.o linux-osdata.o linux-fork.o linux-procfs.o linux-ptrace.o | ||
50 | +NAT_CDEPS = $(srcdir)/proc-service.list | ||
51 | + | ||
52 | +LOADLIBES = -ldl $(RDYNAMIC) | ||
53 | diff --git a/gdb/microblaze-linux-nat.c b/gdb/microblaze-linux-nat.c | ||
54 | new file mode 100644 | ||
55 | index 00000000000..e9b8c9c5221 | ||
56 | --- /dev/null | ||
57 | +++ b/gdb/microblaze-linux-nat.c | ||
58 | @@ -0,0 +1,431 @@ | ||
59 | +/* Microblaze GNU/Linux native support. | ||
60 | + | ||
61 | + Copyright (C) 1988-1989, 1991-1992, 1994, 1996, 2000-2012 Free | ||
62 | + Software Foundation, Inc. | ||
63 | + | ||
64 | + This file is part of GDB. | ||
65 | + | ||
66 | + This program is free software; you can redistribute it and/or modify | ||
67 | + it under the terms of the GNU General Public License as published by | ||
68 | + the Free Software Foundation; either version 3 of the License, or | ||
69 | + (at your option) any later version. | ||
70 | + | ||
71 | + This program is distributed in the hope that it will be useful, | ||
72 | + but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
73 | + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
74 | + GNU General Public License for more details. | ||
75 | + | ||
76 | + You should have received a copy of the GNU General Public License | ||
77 | + along with this program. If not, see <http://www.gnu.org/licenses/>. */ | ||
78 | + | ||
79 | +#include "defs.h" | ||
80 | +#include "arch-utils.h" | ||
81 | +#include "dis-asm.h" | ||
82 | +#include "frame.h" | ||
83 | +#include "trad-frame.h" | ||
84 | +#include "symtab.h" | ||
85 | +#include "value.h" | ||
86 | +#include "gdbcmd.h" | ||
87 | +#include "breakpoint.h" | ||
88 | +#include "inferior.h" | ||
89 | +#include "regcache.h" | ||
90 | +#include "target.h" | ||
91 | +#include "frame.h" | ||
92 | +#include "frame-base.h" | ||
93 | +#include "frame-unwind.h" | ||
94 | +#include "dwarf2-frame.h" | ||
95 | +#include "osabi.h" | ||
96 | + | ||
97 | +#include "gdb_assert.h" | ||
98 | +#include "gdb_string.h" | ||
99 | +#include "target-descriptions.h" | ||
100 | +#include "opcodes/microblaze-opcm.h" | ||
101 | +#include "opcodes/microblaze-dis.h" | ||
102 | + | ||
103 | +#include "linux-nat.h" | ||
104 | +#include "target-descriptions.h" | ||
105 | + | ||
106 | +#include <sys/user.h> | ||
107 | +#include <sys/utsname.h> | ||
108 | +#include <sys/procfs.h> | ||
109 | +#include <sys/ptrace.h> | ||
110 | + | ||
111 | +/* Prototypes for supply_gregset etc. */ | ||
112 | +#include "gregset.h" | ||
113 | + | ||
114 | +#include "microblaze-tdep.h" | ||
115 | + | ||
116 | +#include <elf/common.h> | ||
117 | +#include "auxv.h" | ||
118 | + | ||
119 | +/* Defines ps_err_e, struct ps_prochandle. */ | ||
120 | +#include "gdb_proc_service.h" | ||
121 | + | ||
122 | +/* On GNU/Linux, threads are implemented as pseudo-processes, in which | ||
123 | + case we may be tracing more than one process at a time. In that | ||
124 | + case, inferior_ptid will contain the main process ID and the | ||
125 | + individual thread (process) ID. get_thread_id () is used to get | ||
126 | + the thread id if it's available, and the process id otherwise. */ | ||
127 | + | ||
128 | +int | ||
129 | +get_thread_id (ptid_t ptid) | ||
130 | +{ | ||
131 | + int tid = TIDGET (ptid); | ||
132 | + if (0 == tid) | ||
133 | + tid = PIDGET (ptid); | ||
134 | + return tid; | ||
135 | +} | ||
136 | + | ||
137 | +#define GET_THREAD_ID(PTID) get_thread_id (PTID) | ||
138 | + | ||
139 | +/* Non-zero if our kernel may support the PTRACE_GETREGS and | ||
140 | + PTRACE_SETREGS requests, for reading and writing the | ||
141 | + general-purpose registers. Zero if we've tried one of | ||
142 | + them and gotten an error. */ | ||
143 | +int have_ptrace_getsetregs = 1; | ||
144 | + | ||
145 | +static int | ||
146 | +microblaze_register_u_addr (struct gdbarch *gdbarch, int regno) | ||
147 | +{ | ||
148 | + int u_addr = -1; | ||
149 | + struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); | ||
150 | + /* NOTE: cagney/2003-11-25: This is the word size used by the ptrace | ||
151 | + interface, and not the wordsize of the program's ABI. */ | ||
152 | + int wordsize = sizeof (long); | ||
153 | + | ||
154 | + /* General purpose registers occupy 1 slot each in the buffer. */ | ||
155 | + if (regno >= MICROBLAZE_R0_REGNUM | ||
156 | + && regno <= MICROBLAZE_FSR_REGNUM) | ||
157 | + u_addr = (regno * wordsize); | ||
158 | + | ||
159 | + return u_addr; | ||
160 | +} | ||
161 | + | ||
162 | + | ||
163 | +static void | ||
164 | +fetch_register (struct regcache *regcache, int tid, int regno) | ||
165 | +{ | ||
166 | + struct gdbarch *gdbarch = get_regcache_arch (regcache); | ||
167 | + struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); | ||
168 | + /* This isn't really an address. But ptrace thinks of it as one. */ | ||
169 | + CORE_ADDR regaddr = microblaze_register_u_addr (gdbarch, regno); | ||
170 | + int bytes_transferred; | ||
171 | + unsigned int offset; /* Offset of registers within the u area. */ | ||
172 | + char buf[MAX_REGISTER_SIZE]; | ||
173 | + | ||
174 | + if (regaddr == -1) | ||
175 | + { | ||
176 | + memset (buf, '\0', register_size (gdbarch, regno)); /* Supply zeroes */ | ||
177 | + regcache_raw_supply (regcache, regno, buf); | ||
178 | + return; | ||
179 | + } | ||
180 | + | ||
181 | + /* Read the raw register using sizeof(long) sized chunks. On a | ||
182 | + 32-bit platform, 64-bit floating-point registers will require two | ||
183 | + transfers. */ | ||
184 | + for (bytes_transferred = 0; | ||
185 | + bytes_transferred < register_size (gdbarch, regno); | ||
186 | + bytes_transferred += sizeof (long)) | ||
187 | + { | ||
188 | + long l; | ||
189 | + | ||
190 | + errno = 0; | ||
191 | + l = ptrace (PTRACE_PEEKUSER, tid, (PTRACE_TYPE_ARG3) regaddr, 0); | ||
192 | + regaddr += sizeof (long); | ||
193 | + if (errno != 0) | ||
194 | + { | ||
195 | + char message[128]; | ||
196 | + sprintf (message, "reading register %s (#%d)", | ||
197 | + gdbarch_register_name (gdbarch, regno), regno); | ||
198 | + perror_with_name (message); | ||
199 | + } | ||
200 | + memcpy (&buf[bytes_transferred], &l, sizeof (l)); | ||
201 | + } | ||
202 | + | ||
203 | + /* Now supply the register. Keep in mind that the regcache's idea | ||
204 | + of the register's size may not be a multiple of sizeof | ||
205 | + (long). */ | ||
206 | + if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_LITTLE) | ||
207 | + { | ||
208 | + /* Little-endian values are always found at the left end of the | ||
209 | + bytes transferred. */ | ||
210 | + regcache_raw_supply (regcache, regno, buf); | ||
211 | + } | ||
212 | + else if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG) | ||
213 | + { | ||
214 | + /* Big-endian values are found at the right end of the bytes | ||
215 | + transferred. */ | ||
216 | + size_t padding = (bytes_transferred - register_size (gdbarch, regno)); | ||
217 | + regcache_raw_supply (regcache, regno, buf + padding); | ||
218 | + } | ||
219 | + else | ||
220 | + internal_error (__FILE__, __LINE__, | ||
221 | + _("fetch_register: unexpected byte order: %d"), | ||
222 | + gdbarch_byte_order (gdbarch)); | ||
223 | +} | ||
224 | + | ||
225 | +/* This function actually issues the request to ptrace, telling | ||
226 | + it to get all general-purpose registers and put them into the | ||
227 | + specified regset. | ||
228 | + | ||
229 | + If the ptrace request does not exist, this function returns 0 | ||
230 | + and properly sets the have_ptrace_* flag. If the request fails, | ||
231 | + this function calls perror_with_name. Otherwise, if the request | ||
232 | + succeeds, then the regcache gets filled and 1 is returned. */ | ||
233 | +static int | ||
234 | +fetch_all_gp_regs (struct regcache *regcache, int tid) | ||
235 | +{ | ||
236 | + struct gdbarch *gdbarch = get_regcache_arch (regcache); | ||
237 | + struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); | ||
238 | + gdb_gregset_t gregset; | ||
239 | + | ||
240 | + if (ptrace (PTRACE_GETREGS, tid, 0, (void *) &gregset) < 0) | ||
241 | + { | ||
242 | + if (errno == EIO) | ||
243 | + { | ||
244 | + have_ptrace_getsetregs = 0; | ||
245 | + return 0; | ||
246 | + } | ||
247 | + perror_with_name (_("Couldn't get general-purpose registers.")); | ||
248 | + } | ||
249 | + | ||
250 | + supply_gregset (regcache, (const gdb_gregset_t *) &gregset); | ||
251 | + | ||
252 | + return 1; | ||
253 | +} | ||
254 | + | ||
255 | + | ||
256 | +/* This is a wrapper for the fetch_all_gp_regs function. It is | ||
257 | + responsible for verifying if this target has the ptrace request | ||
258 | + that can be used to fetch all general-purpose registers at one | ||
259 | + shot. If it doesn't, then we should fetch them using the | ||
260 | + old-fashioned way, which is to iterate over the registers and | ||
261 | + request them one by one. */ | ||
262 | +static void | ||
263 | +fetch_gp_regs (struct regcache *regcache, int tid) | ||
264 | +{ | ||
265 | + struct gdbarch *gdbarch = get_regcache_arch (regcache); | ||
266 | + struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); | ||
267 | + int i; | ||
268 | + | ||
269 | + if (have_ptrace_getsetregs) | ||
270 | + if (fetch_all_gp_regs (regcache, tid)) | ||
271 | + return; | ||
272 | + | ||
273 | + /* If we've hit this point, it doesn't really matter which | ||
274 | + architecture we are using. We just need to read the | ||
275 | + registers in the "old-fashioned way". */ | ||
276 | + for (i = MICROBLAZE_R0_REGNUM; i <= MICROBLAZE_FSR_REGNUM; i++) | ||
277 | + fetch_register (regcache, tid, i); | ||
278 | +} | ||
279 | + | ||
280 | + | ||
281 | +static void | ||
282 | +store_register (const struct regcache *regcache, int tid, int regno) | ||
283 | +{ | ||
284 | + struct gdbarch *gdbarch = get_regcache_arch (regcache); | ||
285 | + struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); | ||
286 | + /* This isn't really an address. But ptrace thinks of it as one. */ | ||
287 | + CORE_ADDR regaddr = microblaze_register_u_addr (gdbarch, regno); | ||
288 | + int i; | ||
289 | + size_t bytes_to_transfer; | ||
290 | + char buf[MAX_REGISTER_SIZE]; | ||
291 | + | ||
292 | + if (regaddr == -1) | ||
293 | + return; | ||
294 | + | ||
295 | + /* First collect the register. Keep in mind that the regcache's | ||
296 | + idea of the register's size may not be a multiple of sizeof | ||
297 | + (long). */ | ||
298 | + memset (buf, 0, sizeof buf); | ||
299 | + bytes_to_transfer = align_up (register_size (gdbarch, regno), sizeof (long)); | ||
300 | + if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_LITTLE) | ||
301 | + { | ||
302 | + /* Little-endian values always sit at the left end of the buffer. */ | ||
303 | + regcache_raw_collect (regcache, regno, buf); | ||
304 | + } | ||
305 | + else if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG) | ||
306 | + { | ||
307 | + /* Big-endian values sit at the right end of the buffer. */ | ||
308 | + size_t padding = (bytes_to_transfer - register_size (gdbarch, regno)); | ||
309 | + regcache_raw_collect (regcache, regno, buf + padding); | ||
310 | + } | ||
311 | + | ||
312 | + for (i = 0; i < bytes_to_transfer; i += sizeof (long)) | ||
313 | + { | ||
314 | + long l; | ||
315 | + | ||
316 | + memcpy (&l, &buf[i], sizeof (l)); | ||
317 | + errno = 0; | ||
318 | + ptrace (PTRACE_POKEUSER, tid, (PTRACE_TYPE_ARG3) regaddr, l); | ||
319 | + regaddr += sizeof (long); | ||
320 | + | ||
321 | + if (errno != 0) | ||
322 | + { | ||
323 | + char message[128]; | ||
324 | + sprintf (message, "writing register %s (#%d)", | ||
325 | + gdbarch_register_name (gdbarch, regno), regno); | ||
326 | + perror_with_name (message); | ||
327 | + } | ||
328 | + } | ||
329 | +} | ||
330 | + | ||
331 | +/* This function actually issues the request to ptrace, telling | ||
332 | + it to store all general-purpose registers present in the specified | ||
333 | + regset. | ||
334 | + | ||
335 | + If the ptrace request does not exist, this function returns 0 | ||
336 | + and properly sets the have_ptrace_* flag. If the request fails, | ||
337 | + this function calls perror_with_name. Otherwise, if the request | ||
338 | + succeeds, then the regcache is stored and 1 is returned. */ | ||
339 | +static int | ||
340 | +store_all_gp_regs (const struct regcache *regcache, int tid, int regno) | ||
341 | +{ | ||
342 | + struct gdbarch *gdbarch = get_regcache_arch (regcache); | ||
343 | + struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); | ||
344 | + gdb_gregset_t gregset; | ||
345 | + | ||
346 | + if (ptrace (PTRACE_GETREGS, tid, 0, (void *) &gregset) < 0) | ||
347 | + { | ||
348 | + if (errno == EIO) | ||
349 | + { | ||
350 | + have_ptrace_getsetregs = 0; | ||
351 | + return 0; | ||
352 | + } | ||
353 | + perror_with_name (_("Couldn't get general-purpose registers.")); | ||
354 | + } | ||
355 | + | ||
356 | + fill_gregset (regcache, &gregset, regno); | ||
357 | + | ||
358 | + if (ptrace (PTRACE_SETREGS, tid, 0, (void *) &gregset) < 0) | ||
359 | + { | ||
360 | + if (errno == EIO) | ||
361 | + { | ||
362 | + have_ptrace_getsetregs = 0; | ||
363 | + return 0; | ||
364 | + } | ||
365 | + perror_with_name (_("Couldn't set general-purpose registers.")); | ||
366 | + } | ||
367 | + | ||
368 | + return 1; | ||
369 | +} | ||
370 | + | ||
371 | +/* This is a wrapper for the store_all_gp_regs function. It is | ||
372 | + responsible for verifying if this target has the ptrace request | ||
373 | + that can be used to store all general-purpose registers at one | ||
374 | + shot. If it doesn't, then we should store them using the | ||
375 | + old-fashioned way, which is to iterate over the registers and | ||
376 | + store them one by one. */ | ||
377 | +static void | ||
378 | +store_gp_regs (const struct regcache *regcache, int tid, int regno) | ||
379 | +{ | ||
380 | + struct gdbarch *gdbarch = get_regcache_arch (regcache); | ||
381 | + struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); | ||
382 | + int i; | ||
383 | + | ||
384 | + if (have_ptrace_getsetregs) | ||
385 | + if (store_all_gp_regs (regcache, tid, regno)) | ||
386 | + return; | ||
387 | + | ||
388 | + /* If we hit this point, it doesn't really matter which | ||
389 | + architecture we are using. We just need to store the | ||
390 | + registers in the "old-fashioned way". */ | ||
391 | + for (i = MICROBLAZE_R0_REGNUM; i <= MICROBLAZE_FSR_REGNUM; i++) | ||
392 | + store_register (regcache, tid, i); | ||
393 | +} | ||
394 | + | ||
395 | + | ||
396 | +/* Fetch registers from the child process. Fetch all registers if | ||
397 | + regno == -1, otherwise fetch all general registers or all floating | ||
398 | + point registers depending upon the value of regno. */ | ||
399 | + | ||
400 | +static void | ||
401 | +microblaze_linux_fetch_inferior_registers (struct target_ops *ops, | ||
402 | + struct regcache *regcache, int regno) | ||
403 | +{ | ||
404 | + /* Get the thread id for the ptrace call. */ | ||
405 | + int tid = GET_THREAD_ID (inferior_ptid); | ||
406 | + | ||
407 | + if (regno == -1) | ||
408 | + fetch_gp_regs (regcache, tid); | ||
409 | + else | ||
410 | + fetch_register (regcache, tid, regno); | ||
411 | +} | ||
412 | + | ||
413 | +/* Store registers back into the inferior. Store all registers if | ||
414 | + regno == -1, otherwise store all general registers or all floating | ||
415 | + point registers depending upon the value of regno. */ | ||
416 | + | ||
417 | +static void | ||
418 | +microblaze_linux_store_inferior_registers (struct target_ops *ops, | ||
419 | + struct regcache *regcache, int regno) | ||
420 | +{ | ||
421 | + /* Get the thread id for the ptrace call. */ | ||
422 | + int tid = GET_THREAD_ID (inferior_ptid); | ||
423 | + | ||
424 | + if (regno >= 0) | ||
425 | + store_register (regcache, tid, regno); | ||
426 | + else | ||
427 | + store_gp_regs (regcache, tid, -1); | ||
428 | +} | ||
429 | + | ||
430 | +/* Wrapper functions for the standard regset handling, used by | ||
431 | + thread debugging. */ | ||
432 | + | ||
433 | +void | ||
434 | +fill_gregset (const struct regcache *regcache, | ||
435 | + gdb_gregset_t *gregsetp, int regno) | ||
436 | +{ | ||
437 | + microblaze_collect_gregset (NULL, regcache, regno, gregsetp); | ||
438 | +} | ||
439 | + | ||
440 | +void | ||
441 | +supply_gregset (struct regcache *regcache, const gdb_gregset_t *gregsetp) | ||
442 | +{ | ||
443 | + microblaze_supply_gregset (NULL, regcache, -1, gregsetp); | ||
444 | +} | ||
445 | + | ||
446 | +void | ||
447 | +fill_fpregset (const struct regcache *regcache, | ||
448 | + gdb_fpregset_t *fpregsetp, int regno) | ||
449 | +{ | ||
450 | + /* FIXME. */ | ||
451 | +} | ||
452 | + | ||
453 | +void | ||
454 | +supply_fpregset (struct regcache *regcache, const gdb_fpregset_t *fpregsetp) | ||
455 | +{ | ||
456 | + /* FIXME. */ | ||
457 | +} | ||
458 | + | ||
459 | +static const struct target_desc * | ||
460 | +microblaze_linux_read_description (struct target_ops *ops) | ||
461 | +{ | ||
462 | + CORE_ADDR microblaze_hwcap = 0; | ||
463 | + | ||
464 | + if (target_auxv_search (ops, AT_HWCAP, µblaze_hwcap) != 1) | ||
465 | + return NULL; | ||
466 | + | ||
467 | + return NULL; | ||
468 | +} | ||
469 | + | ||
470 | + | ||
471 | +void _initialize_microblaze_linux_nat (void); | ||
472 | + | ||
473 | +void | ||
474 | +_initialize_microblaze_linux_nat (void) | ||
475 | +{ | ||
476 | + struct target_ops *t; | ||
477 | + | ||
478 | + /* Fill in the generic GNU/Linux methods. */ | ||
479 | + t = linux_target (); | ||
480 | + | ||
481 | + /* Add our register access methods. */ | ||
482 | + t->to_fetch_registers = microblaze_linux_fetch_inferior_registers; | ||
483 | + t->to_store_registers = microblaze_linux_store_inferior_registers; | ||
484 | + | ||
485 | + t->to_read_description = microblaze_linux_read_description; | ||
486 | + | ||
487 | + /* Register the target. */ | ||
488 | + linux_nat_add_target (t); | ||
489 | +} | ||
490 | -- | ||
491 | 2.17.1 | ||
492 | |||
diff --git a/meta-microblaze/recipes-devtools/gdb/gdb/0006-Patch-MicroBlaze-MicroBlaze-native-gdb-port.patch b/meta-microblaze/recipes-devtools/gdb/gdb/0006-Patch-MicroBlaze-MicroBlaze-native-gdb-port.patch new file mode 100644 index 00000000..9498e8f7 --- /dev/null +++ b/meta-microblaze/recipes-devtools/gdb/gdb/0006-Patch-MicroBlaze-MicroBlaze-native-gdb-port.patch | |||
@@ -0,0 +1,831 @@ | |||
1 | From b37df6ced77898e8cb7e1c343af005d5bfe1272f Mon Sep 17 00:00:00 2001 | ||
2 | From: Mahesh Bodapati <mbodapat@xilinx.com> | ||
3 | Date: Wed, 15 Jun 2022 10:29:09 +0530 | ||
4 | Subject: [PATCH 06/10] [Patch,MicroBlaze] : MicroBlaze native gdb port. | ||
5 | |||
6 | --- | ||
7 | gdb/Makefile.in | 2 + | ||
8 | gdb/configure.nat | 4 + | ||
9 | gdb/features/microblaze-linux.c | 79 +++++++ | ||
10 | gdb/microblaze-linux-nat.c | 366 ++++++++++++++++++++++++++++++++ | ||
11 | gdb/microblaze-linux-tdep.c | 2 + | ||
12 | gdb/microblaze-linux-tdep.h | 24 +++ | ||
13 | gdb/microblaze-tdep.c | 151 ++++++++++++- | ||
14 | gdb/microblaze-tdep.h | 15 +- | ||
15 | 8 files changed, 629 insertions(+), 14 deletions(-) | ||
16 | create mode 100755 gdb/features/microblaze-linux.c | ||
17 | create mode 100755 gdb/microblaze-linux-nat.c | ||
18 | create mode 100644 gdb/microblaze-linux-tdep.h | ||
19 | |||
20 | diff --git a/gdb/Makefile.in b/gdb/Makefile.in | ||
21 | index ec371fc7e52..0449b8e4c2b 100644 | ||
22 | --- a/gdb/Makefile.in | ||
23 | +++ b/gdb/Makefile.in | ||
24 | @@ -1336,6 +1336,7 @@ HFILES_NO_SRCDIR = \ | ||
25 | memory-map.h \ | ||
26 | memrange.h \ | ||
27 | microblaze-tdep.h \ | ||
28 | + microblaze-linux-tdep.h \ | ||
29 | mips-linux-tdep.h \ | ||
30 | mips-nbsd-tdep.h \ | ||
31 | mips-tdep.h \ | ||
32 | @@ -2214,6 +2215,7 @@ ALLDEPFILES = \ | ||
33 | m68k-linux-nat.c \ | ||
34 | m68k-linux-tdep.c \ | ||
35 | m68k-tdep.c \ | ||
36 | + microblaze-linux-nat.c \ | ||
37 | microblaze-linux-tdep.c \ | ||
38 | microblaze-tdep.c \ | ||
39 | mingw-hdep.c \ | ||
40 | diff --git a/gdb/configure.nat b/gdb/configure.nat | ||
41 | index bb70e303384..53f19a3d263 100644 | ||
42 | --- a/gdb/configure.nat | ||
43 | +++ b/gdb/configure.nat | ||
44 | @@ -261,6 +261,10 @@ case ${gdb_host} in | ||
45 | # Host: Motorola m68k running GNU/Linux. | ||
46 | NATDEPFILES="${NATDEPFILES} m68k-linux-nat.o" | ||
47 | ;; | ||
48 | + microblaze) | ||
49 | + # Host: Microblaze running GNU/Linux. | ||
50 | + NATDEPFILES="${NATDEPFILES} microblaze-linux-nat.o" | ||
51 | + ;; | ||
52 | mips) | ||
53 | # Host: Linux/MIPS | ||
54 | NATDEPFILES="${NATDEPFILES} linux-nat-trad.o \ | ||
55 | diff --git a/gdb/features/microblaze-linux.c b/gdb/features/microblaze-linux.c | ||
56 | new file mode 100755 | ||
57 | index 00000000000..29f681bf2ac | ||
58 | --- /dev/null | ||
59 | +++ b/gdb/features/microblaze-linux.c | ||
60 | @@ -0,0 +1,79 @@ | ||
61 | +/* THIS FILE IS GENERATED. -*- buffer-read-only: t -*- vi:set ro: | ||
62 | + Original: microblaze.xml */ | ||
63 | + | ||
64 | +#include "defs.h" | ||
65 | +#include "osabi.h" | ||
66 | +#include "target-descriptions.h" | ||
67 | + | ||
68 | +struct target_desc *tdesc_microblaze_linux; | ||
69 | +static void | ||
70 | +initialize_tdesc_microblaze_linux (void) | ||
71 | +{ | ||
72 | + struct target_desc *result = allocate_target_description (); | ||
73 | + struct tdesc_feature *feature; | ||
74 | + set_tdesc_architecture (result, bfd_scan_arch ("microblaze")); | ||
75 | + set_tdesc_osabi (result, osabi_from_tdesc_string ("GNU/Linux")); | ||
76 | + | ||
77 | + feature = tdesc_create_feature (result, "org.gnu.gdb.microblaze.core"); | ||
78 | + tdesc_create_reg (feature, "r0", 0, 1, NULL, 32, "int"); | ||
79 | + tdesc_create_reg (feature, "r1", 1, 1, NULL, 32, "int"); | ||
80 | + tdesc_create_reg (feature, "r2", 2, 1, NULL, 32, "int"); | ||
81 | + tdesc_create_reg (feature, "r3", 3, 1, NULL, 32, "int"); | ||
82 | + tdesc_create_reg (feature, "r4", 4, 1, NULL, 32, "int"); | ||
83 | + tdesc_create_reg (feature, "r5", 5, 1, NULL, 32, "int"); | ||
84 | + tdesc_create_reg (feature, "r6", 6, 1, NULL, 32, "int"); | ||
85 | + tdesc_create_reg (feature, "r7", 7, 1, NULL, 32, "int"); | ||
86 | + tdesc_create_reg (feature, "r8", 8, 1, NULL, 32, "int"); | ||
87 | + tdesc_create_reg (feature, "r9", 9, 1, NULL, 32, "int"); | ||
88 | + tdesc_create_reg (feature, "r10", 10, 1, NULL, 32, "int"); | ||
89 | + tdesc_create_reg (feature, "r11", 11, 1, NULL, 32, "int"); | ||
90 | + tdesc_create_reg (feature, "r12", 12, 1, NULL, 32, "int"); | ||
91 | + tdesc_create_reg (feature, "r13", 13, 1, NULL, 32, "int"); | ||
92 | + tdesc_create_reg (feature, "r14", 14, 1, NULL, 32, "int"); | ||
93 | + tdesc_create_reg (feature, "r15", 15, 1, NULL, 32, "int"); | ||
94 | + tdesc_create_reg (feature, "r16", 16, 1, NULL, 32, "int"); | ||
95 | + tdesc_create_reg (feature, "r17", 17, 1, NULL, 32, "int"); | ||
96 | + tdesc_create_reg (feature, "r18", 18, 1, NULL, 32, "int"); | ||
97 | + tdesc_create_reg (feature, "r19", 19, 1, NULL, 32, "int"); | ||
98 | + tdesc_create_reg (feature, "r20", 20, 1, NULL, 32, "int"); | ||
99 | + tdesc_create_reg (feature, "r21", 21, 1, NULL, 32, "int"); | ||
100 | + tdesc_create_reg (feature, "r22", 22, 1, NULL, 32, "int"); | ||
101 | + tdesc_create_reg (feature, "r23", 23, 1, NULL, 32, "int"); | ||
102 | + tdesc_create_reg (feature, "r24", 24, 1, NULL, 32, "int"); | ||
103 | + tdesc_create_reg (feature, "r25", 25, 1, NULL, 32, "int"); | ||
104 | + tdesc_create_reg (feature, "r26", 26, 1, NULL, 32, "int"); | ||
105 | + tdesc_create_reg (feature, "r27", 27, 1, NULL, 32, "int"); | ||
106 | + tdesc_create_reg (feature, "r28", 28, 1, NULL, 32, "int"); | ||
107 | + tdesc_create_reg (feature, "r29", 29, 1, NULL, 32, "int"); | ||
108 | + tdesc_create_reg (feature, "r30", 30, 1, NULL, 32, "int"); | ||
109 | + tdesc_create_reg (feature, "r31", 31, 1, NULL, 32, "int"); | ||
110 | + tdesc_create_reg (feature, "rpc", 32, 1, NULL, 32, "int"); | ||
111 | + tdesc_create_reg (feature, "rmsr", 33, 1, NULL, 32, "int"); | ||
112 | + tdesc_create_reg (feature, "rear", 34, 1, NULL, 32, "int"); | ||
113 | + tdesc_create_reg (feature, "resr", 35, 1, NULL, 32, "int"); | ||
114 | + tdesc_create_reg (feature, "rfsr", 36, 1, NULL, 32, "int"); | ||
115 | + tdesc_create_reg (feature, "rbtr", 37, 1, NULL, 32, "int"); | ||
116 | + tdesc_create_reg (feature, "rpvr0", 38, 1, NULL, 32, "int"); | ||
117 | + tdesc_create_reg (feature, "rpvr1", 39, 1, NULL, 32, "int"); | ||
118 | + tdesc_create_reg (feature, "rpvr2", 40, 1, NULL, 32, "int"); | ||
119 | + tdesc_create_reg (feature, "rpvr3", 41, 1, NULL, 32, "int"); | ||
120 | + tdesc_create_reg (feature, "rpvr4", 42, 1, NULL, 32, "int"); | ||
121 | + tdesc_create_reg (feature, "rpvr5", 43, 1, NULL, 32, "int"); | ||
122 | + tdesc_create_reg (feature, "rpvr6", 44, 1, NULL, 32, "int"); | ||
123 | + tdesc_create_reg (feature, "rpvr7", 45, 1, NULL, 32, "int"); | ||
124 | + tdesc_create_reg (feature, "rpvr8", 46, 1, NULL, 32, "int"); | ||
125 | + tdesc_create_reg (feature, "rpvr9", 47, 1, NULL, 32, "int"); | ||
126 | + tdesc_create_reg (feature, "rpvr10", 48, 1, NULL, 32, "int"); | ||
127 | + tdesc_create_reg (feature, "rpvr11", 49, 1, NULL, 32, "int"); | ||
128 | + tdesc_create_reg (feature, "redr", 50, 1, NULL, 32, "int"); | ||
129 | + tdesc_create_reg (feature, "rpid", 51, 1, NULL, 32, "int"); | ||
130 | + tdesc_create_reg (feature, "rzpr", 52, 1, NULL, 32, "int"); | ||
131 | + tdesc_create_reg (feature, "rtlbx", 53, 1, NULL, 32, "int"); | ||
132 | + tdesc_create_reg (feature, "rtlbsx", 54, 1, NULL, 32, "int"); | ||
133 | + tdesc_create_reg (feature, "rtlblo", 55, 1, NULL, 32, "int"); | ||
134 | + tdesc_create_reg (feature, "rtlbhi", 56, 1, NULL, 32, "int"); | ||
135 | + tdesc_create_reg (feature, "slr", 57, 1, NULL, 64, "uint64"); | ||
136 | + tdesc_create_reg (feature, "shr", 58, 1, NULL, 64, "uint64"); | ||
137 | + | ||
138 | + tdesc_microblaze_linux = result; | ||
139 | +} | ||
140 | diff --git a/gdb/microblaze-linux-nat.c b/gdb/microblaze-linux-nat.c | ||
141 | new file mode 100755 | ||
142 | index 00000000000..6b9daa23120 | ||
143 | --- /dev/null | ||
144 | +++ b/gdb/microblaze-linux-nat.c | ||
145 | @@ -0,0 +1,366 @@ | ||
146 | +/* Native-dependent code for GNU/Linux MicroBlaze. | ||
147 | + Copyright (C) 2021 Free Software Foundation, Inc. | ||
148 | + | ||
149 | + This file is part of GDB. | ||
150 | + | ||
151 | + This program is free software; you can redistribute it and/or modify | ||
152 | + it under the terms of the GNU General Public License as published by | ||
153 | + the Free Software Foundation; either version 3 of the License, or | ||
154 | + (at your option) any later version. | ||
155 | + | ||
156 | + This program is distributed in the hope that it will be useful, | ||
157 | + but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
158 | + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
159 | + GNU General Public License for more details. | ||
160 | + | ||
161 | + You should have received a copy of the GNU General Public License | ||
162 | + along with this program. If not, see <http://www.gnu.org/licenses/>. */ | ||
163 | + | ||
164 | +#include "defs.h" | ||
165 | +#include "arch-utils.h" | ||
166 | +#include "dis-asm.h" | ||
167 | +#include "frame.h" | ||
168 | +#include "trad-frame.h" | ||
169 | +#include "symtab.h" | ||
170 | +#include "value.h" | ||
171 | +#include "gdbcmd.h" | ||
172 | +#include "breakpoint.h" | ||
173 | +#include "inferior.h" | ||
174 | +#include "gdbthread.h" | ||
175 | +#include "gdbcore.h" | ||
176 | +#include "regcache.h" | ||
177 | +#include "regset.h" | ||
178 | +#include "target.h" | ||
179 | +#include "frame.h" | ||
180 | +#include "frame-base.h" | ||
181 | +#include "frame-unwind.h" | ||
182 | +#include "osabi.h" | ||
183 | +#include "gdbsupport/gdb_assert.h" | ||
184 | +#include <string.h> | ||
185 | +#include "target-descriptions.h" | ||
186 | +#include "opcodes/microblaze-opcm.h" | ||
187 | +#include "opcodes/microblaze-dis.h" | ||
188 | +#include "gregset.h" | ||
189 | + | ||
190 | +#include "linux-nat.h" | ||
191 | +#include "linux-tdep.h" | ||
192 | +#include "target-descriptions.h" | ||
193 | + | ||
194 | +#include <sys/user.h> | ||
195 | +#include <sys/ioctl.h> | ||
196 | +#include <sys/uio.h> | ||
197 | +#include "gdbsupport/gdb_wait.h" | ||
198 | +#include <fcntl.h> | ||
199 | +#include <sys/procfs.h> | ||
200 | +#include "nat/gdb_ptrace.h" | ||
201 | +#include "nat/linux-ptrace.h" | ||
202 | +#include "inf-ptrace.h" | ||
203 | +#include <algorithm> | ||
204 | +#include <unordered_map> | ||
205 | +#include <list> | ||
206 | +#include <sys/ptrace.h> | ||
207 | + | ||
208 | +/* Prototypes for supply_gregset etc. */ | ||
209 | +#include "gregset.h" | ||
210 | + | ||
211 | +#include "microblaze-tdep.h" | ||
212 | +#include "microblaze-linux-tdep.h" | ||
213 | +#include "inferior.h" | ||
214 | + | ||
215 | +#include "elf/common.h" | ||
216 | + | ||
217 | +#include "auxv.h" | ||
218 | +#include "linux-tdep.h" | ||
219 | + | ||
220 | +#include <sys/ptrace.h> | ||
221 | + | ||
222 | + | ||
223 | +//int have_ptrace_getsetregs=1; | ||
224 | + | ||
225 | +/* MicroBlaze Linux native additions to the default linux support. */ | ||
226 | + | ||
227 | +class microblaze_linux_nat_target final : public linux_nat_target | ||
228 | +{ | ||
229 | +public: | ||
230 | + /* Add our register access methods. */ | ||
231 | + void fetch_registers (struct regcache *regcache, int regnum) override; | ||
232 | + void store_registers (struct regcache *regcache, int regnum) override; | ||
233 | + | ||
234 | + /* Read suitable target description. */ | ||
235 | + const struct target_desc *read_description () override; | ||
236 | +}; | ||
237 | + | ||
238 | +static microblaze_linux_nat_target the_microblaze_linux_nat_target; | ||
239 | + | ||
240 | +static int | ||
241 | +microblaze_register_u_addr (struct gdbarch *gdbarch, int regno) | ||
242 | +{ | ||
243 | + int u_addr = -1; | ||
244 | + struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); | ||
245 | + /* NOTE: cagney/2003-11-25: This is the word size used by the ptrace | ||
246 | + * interface, and not the wordsize of the program's ABI. */ | ||
247 | + int wordsize = sizeof (long); | ||
248 | + | ||
249 | + /* General purpose registers occupy 1 slot each in the buffer. */ | ||
250 | + if (regno >= MICROBLAZE_R0_REGNUM | ||
251 | + && regno <= MICROBLAZE_FSR_REGNUM) | ||
252 | + u_addr = ((regno - MICROBLAZE_R0_REGNUM)* wordsize); | ||
253 | + | ||
254 | + return u_addr; | ||
255 | +} | ||
256 | + | ||
257 | +/* Copy general purpose register REGNUM (or all gp regs if REGNUM == -1) | ||
258 | + from regset GREGS into REGCACHE. */ | ||
259 | + | ||
260 | +static void | ||
261 | +supply_gregset_regnum (struct regcache *regcache, const prgregset_t *gregs, | ||
262 | + int regnum) | ||
263 | +{ | ||
264 | + int i; | ||
265 | + const elf_greg_t *regp = *gregs; | ||
266 | + /* Access all registers */ | ||
267 | + if (regnum == -1) | ||
268 | + { | ||
269 | + /* We fill the general purpose registers. */ | ||
270 | + for (i = MICROBLAZE_R0_REGNUM + 1; i < MICROBLAZE_FSR_REGNUM; i++) | ||
271 | + regcache->raw_supply (i, regp + i); | ||
272 | + | ||
273 | + /* Supply MICROBLAZE_PC_REGNUM from index 32. */ | ||
274 | + regcache->raw_supply (MICROBLAZE_PC_REGNUM, regp + 32); | ||
275 | + | ||
276 | + /* Fill the inaccessible zero register with zero. */ | ||
277 | + regcache->raw_supply_zeroed (0); | ||
278 | + } | ||
279 | + else if (regnum == MICROBLAZE_R0_REGNUM) | ||
280 | + regcache->raw_supply_zeroed (0); | ||
281 | + else if (regnum == MICROBLAZE_PC_REGNUM) | ||
282 | + regcache->raw_supply (MICROBLAZE_PC_REGNUM, regp + 32); | ||
283 | + else if (regnum > MICROBLAZE_R0_REGNUM && regnum < MICROBLAZE_FSR_REGNUM) | ||
284 | + regcache->raw_supply (regnum, regp + regnum); | ||
285 | +} | ||
286 | + | ||
287 | +/* Copy all general purpose registers from regset GREGS into REGCACHE. */ | ||
288 | + | ||
289 | +void | ||
290 | +supply_gregset (struct regcache *regcache, const prgregset_t *gregs) | ||
291 | +{ | ||
292 | + supply_gregset_regnum (regcache, gregs, -1); | ||
293 | +} | ||
294 | + | ||
295 | +/* Copy general purpose register REGNUM (or all gp regs if REGNUM == -1) | ||
296 | + from REGCACHE into regset GREGS. */ | ||
297 | + | ||
298 | +void | ||
299 | +fill_gregset (const struct regcache *regcache, prgregset_t *gregs, int regnum) | ||
300 | +{ | ||
301 | + elf_greg_t *regp = *gregs; | ||
302 | + if (regnum == -1) | ||
303 | + { | ||
304 | + /* We fill the general purpose registers. */ | ||
305 | + for (int i = MICROBLAZE_R0_REGNUM + 1; i < MICROBLAZE_FSR_REGNUM; i++) | ||
306 | + regcache->raw_collect (i, regp + i); | ||
307 | + | ||
308 | + regcache->raw_collect (MICROBLAZE_PC_REGNUM, regp + 32); | ||
309 | + } | ||
310 | + else if (regnum == MICROBLAZE_R0_REGNUM) | ||
311 | + /* Nothing to do here. */ | ||
312 | + ; | ||
313 | + else if (regnum > MICROBLAZE_R0_REGNUM && regnum < MICROBLAZE_FSR_REGNUM) | ||
314 | + regcache->raw_collect (regnum, regp + regnum); | ||
315 | + else if (regnum == MICROBLAZE_PC_REGNUM) | ||
316 | + regcache->raw_collect (MICROBLAZE_PC_REGNUM, regp + 32); | ||
317 | +} | ||
318 | + | ||
319 | +/* Transfering floating-point registers between GDB, inferiors and cores. | ||
320 | + Since MicroBlaze floating-point registers are the same as GPRs these do | ||
321 | + nothing. */ | ||
322 | + | ||
323 | +void | ||
324 | +supply_fpregset (struct regcache *regcache, const gdb_fpregset_t *fpregs) | ||
325 | +{ | ||
326 | +} | ||
327 | + | ||
328 | +void | ||
329 | +fill_fpregset (const struct regcache *regcache, | ||
330 | + gdb_fpregset_t *fpregs, int regno) | ||
331 | +{ | ||
332 | +} | ||
333 | + | ||
334 | + | ||
335 | +static void | ||
336 | +fetch_register (struct regcache *regcache, int tid, int regno) | ||
337 | +{ | ||
338 | + struct gdbarch *gdbarch = regcache->arch (); | ||
339 | + struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); | ||
340 | + /* This isn't really an address. But ptrace thinks of it as one. */ | ||
341 | + CORE_ADDR regaddr = microblaze_register_u_addr (gdbarch, regno); | ||
342 | + int bytes_transferred; | ||
343 | + char buf[MICROBLAZE_MAX_REGISTER_SIZE]; | ||
344 | + | ||
345 | + if (regaddr == -1) | ||
346 | + { | ||
347 | + memset (buf, '\0', register_size (gdbarch, regno)); /* Supply zeroes */ | ||
348 | + regcache->raw_supply (regno, buf); | ||
349 | + return; | ||
350 | + } | ||
351 | + | ||
352 | + /* Read the raw register using sizeof(long) sized chunks. On a | ||
353 | + * 32-bit platform, 64-bit floating-point registers will require two | ||
354 | + * transfers. */ | ||
355 | + for (bytes_transferred = 0; | ||
356 | + bytes_transferred < register_size (gdbarch, regno); | ||
357 | + bytes_transferred += sizeof (long)) | ||
358 | + { | ||
359 | + long l; | ||
360 | + | ||
361 | + errno = 0; | ||
362 | + l = ptrace (PTRACE_PEEKUSER, tid, (PTRACE_TYPE_ARG3) regaddr, 0); | ||
363 | + if (errno == EIO) | ||
364 | + { | ||
365 | + printf("ptrace io error\n"); | ||
366 | + } | ||
367 | + regaddr += sizeof (long); | ||
368 | + if (errno != 0) | ||
369 | + { | ||
370 | + char message[128]; | ||
371 | + sprintf (message, "reading register %s (#%d)", | ||
372 | + gdbarch_register_name (gdbarch, regno), regno); | ||
373 | + perror_with_name (message); | ||
374 | + } | ||
375 | + memcpy (&buf[bytes_transferred], &l, sizeof (l)); | ||
376 | + } | ||
377 | + | ||
378 | + /* Now supply the register. Keep in mind that the regcache's idea | ||
379 | + * of the register's size may not be a multiple of sizeof | ||
380 | + * (long). */ | ||
381 | + if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_LITTLE) | ||
382 | + { | ||
383 | + /* Little-endian values are always found at the left end of the | ||
384 | + * bytes transferred. */ | ||
385 | + regcache->raw_supply (regno, buf); | ||
386 | + } | ||
387 | + else if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG) | ||
388 | + { | ||
389 | + /* Big-endian values are found at the right end of the bytes | ||
390 | + * transferred. */ | ||
391 | + size_t padding = (bytes_transferred - register_size (gdbarch, regno)); | ||
392 | + regcache->raw_supply (regno, buf + padding); | ||
393 | + } | ||
394 | + else | ||
395 | + internal_error (__FILE__, __LINE__, | ||
396 | + _("fetch_register: unexpected byte order: %d"), | ||
397 | + gdbarch_byte_order (gdbarch)); | ||
398 | +} | ||
399 | + | ||
400 | + | ||
401 | +/* This is a wrapper for the fetch_all_gp_regs function. It is | ||
402 | + * responsible for verifying if this target has the ptrace request | ||
403 | + * that can be used to fetch all general-purpose registers at one | ||
404 | + * shot. If it doesn't, then we should fetch them using the | ||
405 | + * old-fashioned way, which is to iterate over the registers and | ||
406 | + * request them one by one. */ | ||
407 | +static void | ||
408 | +fetch_gp_regs (struct regcache *regcache, int tid) | ||
409 | +{ | ||
410 | + int i; | ||
411 | +/* If we've hit this point, it doesn't really matter which | ||
412 | + architecture we are using. We just need to read the | ||
413 | + registers in the "old-fashioned way". */ | ||
414 | + for (i = MICROBLAZE_R0_REGNUM; i <= MICROBLAZE_FSR_REGNUM; i++) | ||
415 | + fetch_register (regcache, tid, i); | ||
416 | +} | ||
417 | + | ||
418 | +/* Return a target description for the current target. */ | ||
419 | + | ||
420 | +const struct target_desc * | ||
421 | +microblaze_linux_nat_target::read_description () | ||
422 | +{ | ||
423 | + return tdesc_microblaze_linux; | ||
424 | +} | ||
425 | + | ||
426 | +/* Fetch REGNUM (or all registers if REGNUM == -1) from the target | ||
427 | + into REGCACHE using PTRACE_GETREGSET. */ | ||
428 | + | ||
429 | +void | ||
430 | +microblaze_linux_nat_target::fetch_registers (struct regcache * regcache, | ||
431 | + int regno) | ||
432 | +{ | ||
433 | + /* Get the thread id for the ptrace call. */ | ||
434 | + int tid = regcache->ptid ().lwp (); | ||
435 | +//int tid = get_ptrace_pid (regcache->ptid()); | ||
436 | +#if 1 | ||
437 | + if (regno == -1) | ||
438 | +#endif | ||
439 | + fetch_gp_regs (regcache, tid); | ||
440 | +#if 1 | ||
441 | + else | ||
442 | + fetch_register (regcache, tid, regno); | ||
443 | +#endif | ||
444 | +} | ||
445 | + | ||
446 | + | ||
447 | +/* Store REGNUM (or all registers if REGNUM == -1) to the target | ||
448 | + from REGCACHE using PTRACE_SETREGSET. */ | ||
449 | + | ||
450 | +void | ||
451 | +microblaze_linux_nat_target::store_registers (struct regcache *regcache, int regno) | ||
452 | +{ | ||
453 | + int tid; | ||
454 | + | ||
455 | + tid = get_ptrace_pid (regcache->ptid ()); | ||
456 | + | ||
457 | + struct gdbarch *gdbarch = regcache->arch (); | ||
458 | + /* This isn't really an address. But ptrace thinks of it as one. */ | ||
459 | + CORE_ADDR regaddr = microblaze_register_u_addr (gdbarch, regno); | ||
460 | + int i; | ||
461 | + size_t bytes_to_transfer; | ||
462 | + char buf[MICROBLAZE_MAX_REGISTER_SIZE]; | ||
463 | + | ||
464 | + if (regaddr == -1) | ||
465 | + return; | ||
466 | + | ||
467 | + /* First collect the register. Keep in mind that the regcache's | ||
468 | + * idea of the register's size may not be a multiple of sizeof | ||
469 | + * (long). */ | ||
470 | + memset (buf, 0, sizeof buf); | ||
471 | + bytes_to_transfer = align_up (register_size (gdbarch, regno), sizeof (long)); | ||
472 | + if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_LITTLE) | ||
473 | + { | ||
474 | + /* Little-endian values always sit at the left end of the buffer. */ | ||
475 | + regcache->raw_collect (regno, buf); | ||
476 | + } | ||
477 | + else if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG) | ||
478 | + { | ||
479 | + /* Big-endian values sit at the right end of the buffer. */ | ||
480 | + size_t padding = (bytes_to_transfer - register_size (gdbarch, regno)); | ||
481 | + regcache->raw_collect (regno, buf + padding); | ||
482 | + } | ||
483 | + | ||
484 | + for (i = 0; i < bytes_to_transfer; i += sizeof (long)) | ||
485 | + { | ||
486 | + long l; | ||
487 | + | ||
488 | + memcpy (&l, &buf[i], sizeof (l)); | ||
489 | + errno = 0; | ||
490 | + ptrace (PTRACE_POKEUSER, tid, (PTRACE_TYPE_ARG3) regaddr, l); | ||
491 | + regaddr += sizeof (long); | ||
492 | + | ||
493 | + if (errno != 0) | ||
494 | + { | ||
495 | + char message[128]; | ||
496 | + sprintf (message, "writing register %s (#%d)", | ||
497 | + gdbarch_register_name (gdbarch, regno), regno); | ||
498 | + perror_with_name (message); | ||
499 | + } | ||
500 | + } | ||
501 | +} | ||
502 | + | ||
503 | +void _initialize_microblaze_linux_nat (void); | ||
504 | + | ||
505 | +void | ||
506 | +_initialize_microblaze_linux_nat (void) | ||
507 | +{ | ||
508 | + /* Register the target. */ | ||
509 | + linux_target = &the_microblaze_linux_nat_target; | ||
510 | + add_inf_child_target (linux_target); | ||
511 | +} | ||
512 | diff --git a/gdb/microblaze-linux-tdep.c b/gdb/microblaze-linux-tdep.c | ||
513 | index b8277dfd735..b77acc9dc61 100644 | ||
514 | --- a/gdb/microblaze-linux-tdep.c | ||
515 | +++ b/gdb/microblaze-linux-tdep.c | ||
516 | @@ -37,6 +37,7 @@ | ||
517 | #include "tramp-frame.h" | ||
518 | #include "linux-tdep.h" | ||
519 | #include "glibc-tdep.h" | ||
520 | +#include "features/microblaze-linux.c" | ||
521 | |||
522 | static int microblaze_debug_flag = 0; | ||
523 | |||
524 | @@ -179,4 +180,5 @@ _initialize_microblaze_linux_tdep () | ||
525 | { | ||
526 | gdbarch_register_osabi (bfd_arch_microblaze, 0, GDB_OSABI_LINUX, | ||
527 | microblaze_linux_init_abi); | ||
528 | + initialize_tdesc_microblaze_linux (); | ||
529 | } | ||
530 | diff --git a/gdb/microblaze-linux-tdep.h b/gdb/microblaze-linux-tdep.h | ||
531 | new file mode 100644 | ||
532 | index 00000000000..a2c744e2961 | ||
533 | --- /dev/null | ||
534 | +++ b/gdb/microblaze-linux-tdep.h | ||
535 | @@ -0,0 +1,24 @@ | ||
536 | +/* Target-dependent code for GNU/Linux on OpenRISC. | ||
537 | + | ||
538 | + Copyright (C) 2021 Free Software Foundation, Inc. | ||
539 | + | ||
540 | + This file is part of GDB. | ||
541 | + | ||
542 | + This program is free software; you can redistribute it and/or modify | ||
543 | + it under the terms of the GNU General Public License as published by | ||
544 | + the Free Software Foundation; either version 3 of the License, or | ||
545 | + (at your option) any later version. | ||
546 | + | ||
547 | + This program is distributed in the hope that it will be useful, | ||
548 | + but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
549 | + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
550 | + GNU General Public License for more details. | ||
551 | + | ||
552 | + You should have received a copy of the GNU General Public License | ||
553 | + along with this program. If not, see <http://www.gnu.org/licenses/>. */ | ||
554 | +#ifndef MICROBLAZE_LINUX_TDEP_H | ||
555 | +#define MICROBLAZE_LINUX_TDEP_H | ||
556 | + /* Target descriptions. */ | ||
557 | + extern struct target_desc *tdesc_microblaze_linux; | ||
558 | + | ||
559 | +#endif /* MICROBLAZE_LINUX_TDEP_H */ | ||
560 | diff --git a/gdb/microblaze-tdep.c b/gdb/microblaze-tdep.c | ||
561 | index 399fa0e3dca..0a5b5ab59cc 100644 | ||
562 | --- a/gdb/microblaze-tdep.c | ||
563 | +++ b/gdb/microblaze-tdep.c | ||
564 | @@ -295,6 +295,7 @@ microblaze_analyze_prologue (struct gdbarch *gdbarch, CORE_ADDR pc, | ||
565 | cache->frameless_p = 0; /* Frame found. */ | ||
566 | save_hidden_pointer_found = 0; | ||
567 | non_stack_instruction_found = 0; | ||
568 | + cache->register_offsets[rd] = -imm; | ||
569 | continue; | ||
570 | } | ||
571 | else if (IS_SPILL_SP(op, rd, ra)) | ||
572 | @@ -443,15 +444,17 @@ microblaze_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR start_pc) | ||
573 | if (find_pc_partial_function (start_pc, NULL, &func_start, &func_end)) | ||
574 | { | ||
575 | sal = find_pc_line (func_start, 0); | ||
576 | - | ||
577 | - if (sal.end < func_end | ||
578 | - && start_pc <= sal.end) | ||
579 | + | ||
580 | + if (sal.line !=0 && sal.end <= func_end && start_pc <= sal.end) { | ||
581 | start_pc = sal.end; | ||
582 | + microblaze_debug("start_pc is %d\t sal.end is %d\t func_end is %d\t",start_pc,sal.end,func_end); | ||
583 | + } | ||
584 | } | ||
585 | |||
586 | ostart_pc = microblaze_analyze_prologue (gdbarch, func_start, 0xffffffffUL, | ||
587 | &cache); | ||
588 | |||
589 | + | ||
590 | if (ostart_pc > start_pc) | ||
591 | return ostart_pc; | ||
592 | return start_pc; | ||
593 | @@ -465,6 +468,7 @@ microblaze_frame_cache (struct frame_info *next_frame, void **this_cache) | ||
594 | struct microblaze_frame_cache *cache; | ||
595 | struct gdbarch *gdbarch = get_frame_arch (next_frame); | ||
596 | int rn; | ||
597 | + CORE_ADDR current_pc; | ||
598 | |||
599 | if (*this_cache) | ||
600 | return (struct microblaze_frame_cache *) *this_cache; | ||
601 | @@ -478,10 +482,17 @@ microblaze_frame_cache (struct frame_info *next_frame, void **this_cache) | ||
602 | cache->register_offsets[rn] = -1; | ||
603 | |||
604 | /* Call for side effects. */ | ||
605 | - get_frame_func (next_frame); | ||
606 | - | ||
607 | - cache->pc = get_frame_address_in_block (next_frame); | ||
608 | - | ||
609 | + cache->pc = get_frame_func (next_frame); | ||
610 | + | ||
611 | +// cache->pc = get_frame_address_in_block (next_frame); | ||
612 | + current_pc = get_frame_pc (next_frame); | ||
613 | + if (cache->pc) | ||
614 | + microblaze_analyze_prologue (gdbarch, cache->pc, current_pc, cache); | ||
615 | + | ||
616 | + cache->saved_sp = cache->base + cache->framesize; | ||
617 | + cache->register_offsets[MICROBLAZE_PREV_PC_REGNUM] = cache->base; | ||
618 | + cache->register_offsets[MICROBLAZE_SP_REGNUM] = cache->saved_sp; | ||
619 | + | ||
620 | return cache; | ||
621 | } | ||
622 | |||
623 | @@ -506,6 +517,25 @@ microblaze_frame_prev_register (struct frame_info *this_frame, | ||
624 | struct microblaze_frame_cache *cache = | ||
625 | microblaze_frame_cache (this_frame, this_cache); | ||
626 | |||
627 | +if ((regnum == MICROBLAZE_SP_REGNUM && | ||
628 | + cache->register_offsets[MICROBLAZE_SP_REGNUM]) | ||
629 | + || (regnum == MICROBLAZE_FP_REGNUM && | ||
630 | + cache->register_offsets[MICROBLAZE_SP_REGNUM])) | ||
631 | + | ||
632 | + return frame_unwind_got_constant (this_frame, regnum, | ||
633 | + cache->register_offsets[MICROBLAZE_SP_REGNUM]); | ||
634 | + | ||
635 | +if (regnum == MICROBLAZE_PC_REGNUM) | ||
636 | +{ | ||
637 | + regnum = 15; | ||
638 | + return frame_unwind_got_memory (this_frame, regnum, | ||
639 | + cache->register_offsets[MICROBLAZE_PREV_PC_REGNUM]); | ||
640 | + | ||
641 | +} | ||
642 | +if (regnum == MICROBLAZE_SP_REGNUM) | ||
643 | + regnum = 1; | ||
644 | +#if 0 | ||
645 | + | ||
646 | if (cache->frameless_p) | ||
647 | { | ||
648 | if (regnum == MICROBLAZE_PC_REGNUM) | ||
649 | @@ -518,7 +548,9 @@ microblaze_frame_prev_register (struct frame_info *this_frame, | ||
650 | else | ||
651 | return trad_frame_get_prev_register (this_frame, cache->saved_regs, | ||
652 | regnum); | ||
653 | - | ||
654 | +#endif | ||
655 | + return trad_frame_get_prev_register (this_frame, cache->saved_regs, | ||
656 | + regnum); | ||
657 | } | ||
658 | |||
659 | static const struct frame_unwind microblaze_frame_unwind = | ||
660 | @@ -633,7 +665,106 @@ microblaze_stabs_argument_has_addr (struct gdbarch *gdbarch, struct type *type) | ||
661 | return (TYPE_LENGTH (type) == 16); | ||
662 | } | ||
663 | |||
664 | - | ||
665 | +#if 1 | ||
666 | +static std::vector<CORE_ADDR> | ||
667 | +microblaze_software_single_step (struct regcache *regcache) | ||
668 | +{ | ||
669 | + struct gdbarch *arch = regcache->arch (); | ||
670 | + //struct gdbarch_tdep *tdep = gdbarch_tdep (arch); | ||
671 | + static int le_breakp[] = MICROBLAZE_BREAKPOINT_LE; | ||
672 | + static int be_breakp[] = MICROBLAZE_BREAKPOINT; | ||
673 | + enum bfd_endian byte_order = gdbarch_byte_order (arch); | ||
674 | + int *breakp = byte_order == BFD_ENDIAN_BIG ? be_breakp : le_breakp; | ||
675 | +// std::vector<CORE_ADDR> ret = NULL; | ||
676 | + | ||
677 | + /* Save the address and the values of the next_pc and the target */ | ||
678 | + static struct sstep_breaks | ||
679 | + { | ||
680 | + CORE_ADDR address; | ||
681 | + bfd_boolean valid; | ||
682 | + /* Shadow contents. */ | ||
683 | + char data[INST_WORD_SIZE]; | ||
684 | + } stepbreaks[2]; | ||
685 | + int ii; | ||
686 | + | ||
687 | + CORE_ADDR pc; | ||
688 | + std::vector<CORE_ADDR> next_pcs; | ||
689 | + long insn; | ||
690 | + enum microblaze_instr minstr; | ||
691 | + bfd_boolean isunsignednum; | ||
692 | + enum microblaze_instr_type insn_type; | ||
693 | + short delay_slots; | ||
694 | + int imm; | ||
695 | + bfd_boolean immfound = FALSE; | ||
696 | + | ||
697 | + /* Set a breakpoint at the next instruction */ | ||
698 | + /* If the current instruction is an imm, set it at the inst after */ | ||
699 | + /* If the instruction has a delay slot, skip the delay slot */ | ||
700 | + pc = regcache_read_pc (regcache); | ||
701 | + insn = microblaze_fetch_instruction (pc); | ||
702 | + minstr = get_insn_microblaze (insn, &isunsignednum, &insn_type, &delay_slots); | ||
703 | + if (insn_type == immediate_inst) | ||
704 | + { | ||
705 | + int rd, ra, rb; | ||
706 | + immfound = TRUE; | ||
707 | + minstr = microblaze_decode_insn (insn, &rd, &ra, &rb, &imm); | ||
708 | + pc = pc + INST_WORD_SIZE; | ||
709 | + insn = microblaze_fetch_instruction (pc); | ||
710 | + minstr = get_insn_microblaze (insn, &isunsignednum, &insn_type, &delay_slots); | ||
711 | + } | ||
712 | + stepbreaks[0].address = pc + (delay_slots * INST_WORD_SIZE) + INST_WORD_SIZE; | ||
713 | + if (insn_type != return_inst) { | ||
714 | + stepbreaks[0].valid = TRUE; | ||
715 | + } else { | ||
716 | + stepbreaks[0].valid = FALSE; | ||
717 | + } | ||
718 | + | ||
719 | + microblaze_debug ("single-step insn_type=%x insn=%x\n", insn_type, insn); | ||
720 | + /* Now check for branch or return instructions */ | ||
721 | + if (insn_type == branch_inst || insn_type == return_inst) { | ||
722 | + int limm; | ||
723 | + int lrd, lra, lrb; | ||
724 | + int ra, rb; | ||
725 | + bfd_boolean targetvalid; | ||
726 | + bfd_boolean unconditionalbranch; | ||
727 | + microblaze_decode_insn(insn, &lrd, &lra, &lrb, &limm); | ||
728 | + if (lra >= 0 && lra < MICROBLAZE_NUM_REGS) | ||
729 | + ra = regcache_raw_get_unsigned(regcache, lra); | ||
730 | + else | ||
731 | + ra = 0; | ||
732 | + if (lrb >= 0 && lrb < MICROBLAZE_NUM_REGS) | ||
733 | + rb = regcache_raw_get_unsigned(regcache, lrb); | ||
734 | + else | ||
735 | + rb = 0; | ||
736 | + stepbreaks[1].address = microblaze_get_target_address (insn, immfound, imm, pc, ra, rb, &targetvalid, &unconditionalbranch); | ||
737 | + microblaze_debug ("single-step uncondbr=%d targetvalid=%d target=%x\n", unconditionalbranch, targetvalid, stepbreaks[1].address); | ||
738 | + if (unconditionalbranch) | ||
739 | + stepbreaks[0].valid = FALSE; /* This is a unconditional branch: will not come to the next address */ | ||
740 | + if (targetvalid && (stepbreaks[0].valid == FALSE || | ||
741 | + (stepbreaks[0].address != stepbreaks[1].address)) | ||
742 | + && (stepbreaks[1].address != pc)) { | ||
743 | + stepbreaks[1].valid = TRUE; | ||
744 | + } else { | ||
745 | + stepbreaks[1].valid = FALSE; | ||
746 | + } | ||
747 | + } else { | ||
748 | + stepbreaks[1].valid = FALSE; | ||
749 | + } | ||
750 | + | ||
751 | + /* Insert the breakpoints */ | ||
752 | + for (ii = 0; ii < 2; ++ii) | ||
753 | + { | ||
754 | + | ||
755 | + /* ignore invalid breakpoint. */ | ||
756 | + if (stepbreaks[ii].valid) { | ||
757 | + // VEC_safe_push (CORE_ADDR, next_pcs, stepbreaks[ii].address);; | ||
758 | + next_pcs.push_back (stepbreaks[ii].address); | ||
759 | + } | ||
760 | + } | ||
761 | + return next_pcs; | ||
762 | +} | ||
763 | +#endif | ||
764 | + | ||
765 | static int dwarf2_to_reg_map[78] = | ||
766 | { 0 /* r0 */, 1 /* r1 */, 2 /* r2 */, 3 /* r3 */, /* 0- 3 */ | ||
767 | 4 /* r4 */, 5 /* r5 */, 6 /* r6 */, 7 /* r7 */, /* 4- 7 */ | ||
768 | @@ -805,6 +936,8 @@ microblaze_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) | ||
769 | microblaze_breakpoint::bp_from_kind); | ||
770 | set_gdbarch_memory_remove_breakpoint (gdbarch, microblaze_linux_memory_remove_breakpoint); | ||
771 | |||
772 | + set_gdbarch_software_single_step (gdbarch, microblaze_software_single_step); | ||
773 | + | ||
774 | set_gdbarch_frame_args_skip (gdbarch, 8); | ||
775 | |||
776 | set_gdbarch_unwind_pc (gdbarch, microblaze_unwind_pc); | ||
777 | diff --git a/gdb/microblaze-tdep.h b/gdb/microblaze-tdep.h | ||
778 | index 872a3931f20..7f75c693b74 100644 | ||
779 | --- a/gdb/microblaze-tdep.h | ||
780 | +++ b/gdb/microblaze-tdep.h | ||
781 | @@ -59,11 +59,11 @@ enum microblaze_regnum | ||
782 | MICROBLAZE_R12_REGNUM, | ||
783 | MICROBLAZE_R13_REGNUM, | ||
784 | MICROBLAZE_R14_REGNUM, | ||
785 | - MICROBLAZE_R15_REGNUM, | ||
786 | + MICROBLAZE_R15_REGNUM,MICROBLAZE_PREV_PC_REGNUM = MICROBLAZE_R15_REGNUM, | ||
787 | MICROBLAZE_R16_REGNUM, | ||
788 | MICROBLAZE_R17_REGNUM, | ||
789 | MICROBLAZE_R18_REGNUM, | ||
790 | - MICROBLAZE_R19_REGNUM, | ||
791 | + MICROBLAZE_R19_REGNUM,MICROBLAZE_FP_REGNUM = MICROBLAZE_R19_REGNUM, | ||
792 | MICROBLAZE_R20_REGNUM, | ||
793 | MICROBLAZE_R21_REGNUM, | ||
794 | MICROBLAZE_R22_REGNUM, | ||
795 | @@ -76,7 +76,8 @@ enum microblaze_regnum | ||
796 | MICROBLAZE_R29_REGNUM, | ||
797 | MICROBLAZE_R30_REGNUM, | ||
798 | MICROBLAZE_R31_REGNUM, | ||
799 | - MICROBLAZE_PC_REGNUM, | ||
800 | + MICROBLAZE_MAX_GPR_REGS, | ||
801 | + MICROBLAZE_PC_REGNUM=32, | ||
802 | MICROBLAZE_MSR_REGNUM, | ||
803 | MICROBLAZE_EAR_REGNUM, | ||
804 | MICROBLAZE_ESR_REGNUM, | ||
805 | @@ -101,17 +102,21 @@ enum microblaze_regnum | ||
806 | MICROBLAZE_RTLBSX_REGNUM, | ||
807 | MICROBLAZE_RTLBLO_REGNUM, | ||
808 | MICROBLAZE_RTLBHI_REGNUM, | ||
809 | - MICROBLAZE_SLR_REGNUM, MICROBLAZE_NUM_CORE_REGS = MICROBLAZE_SLR_REGNUM, | ||
810 | + MICROBLAZE_SLR_REGNUM, | ||
811 | MICROBLAZE_SHR_REGNUM, | ||
812 | - MICROBLAZE_NUM_REGS | ||
813 | + MICROBLAZE_NUM_REGS, MICROBLAZE_NUM_CORE_REGS = MICROBLAZE_NUM_REGS | ||
814 | }; | ||
815 | |||
816 | +/* Big enough to hold the size of the largest register in bytes. */ | ||
817 | +#define MICROBLAZE_MAX_REGISTER_SIZE 64 | ||
818 | + | ||
819 | struct microblaze_frame_cache | ||
820 | { | ||
821 | /* Base address. */ | ||
822 | CORE_ADDR base; | ||
823 | CORE_ADDR pc; | ||
824 | |||
825 | + CORE_ADDR saved_sp; | ||
826 | /* Do we have a frame? */ | ||
827 | int frameless_p; | ||
828 | |||
829 | -- | ||
830 | 2.17.1 | ||
831 | |||
diff --git a/meta-microblaze/recipes-devtools/gdb/gdb/0007-Patch-microblaze-Adding-64-bit-MB-support.patch b/meta-microblaze/recipes-devtools/gdb/gdb/0007-Patch-microblaze-Adding-64-bit-MB-support.patch index 6536c22d..564562da 100644 --- a/meta-microblaze/recipes-devtools/gdb/gdb/0007-Patch-microblaze-Adding-64-bit-MB-support.patch +++ b/meta-microblaze/recipes-devtools/gdb/gdb/0007-Patch-microblaze-Adding-64-bit-MB-support.patch | |||
@@ -1,4 +1,4 @@ | |||
1 | From f9e5f9f884470d0a216126b347b4699d6051fcdd Mon Sep 17 00:00:00 2001 | 1 | From 0eea9a3f068837d4792719a8f9ba15736938eea4 Mon Sep 17 00:00:00 2001 |
2 | From: Nagaraju Mekala <nmekala@xilix.com> | 2 | From: Nagaraju Mekala <nmekala@xilix.com> |
3 | Date: Thu, 31 Jan 2019 14:36:00 +0530 | 3 | Date: Thu, 31 Jan 2019 14:36:00 +0530 |
4 | Subject: [PATCH 07/10] [Patch, microblaze]: Adding 64 bit MB support Added new | 4 | Subject: [PATCH 07/10] [Patch, microblaze]: Adding 64 bit MB support Added new |
@@ -16,6 +16,9 @@ Conflicts: | |||
16 | Conflicts: | 16 | Conflicts: |
17 | bfd/configure | 17 | bfd/configure |
18 | opcodes/microblaze-opcm.h | 18 | opcodes/microblaze-opcm.h |
19 | |||
20 | Conflicts: | ||
21 | gdb/microblaze-tdep.c | ||
19 | --- | 22 | --- |
20 | bfd/Makefile.am | 2 + | 23 | bfd/Makefile.am | 2 + |
21 | bfd/Makefile.in | 3 + | 24 | bfd/Makefile.in | 3 + |
@@ -41,8 +44,8 @@ Conflicts: | |||
41 | gdb/features/microblaze64.c | 77 + | 44 | gdb/features/microblaze64.c | 77 + |
42 | gdb/features/microblaze64.xml | 11 + | 45 | gdb/features/microblaze64.xml | 11 + |
43 | gdb/microblaze-linux-tdep.c | 36 +- | 46 | gdb/microblaze-linux-tdep.c | 36 +- |
44 | gdb/microblaze-tdep.c | 210 +- | 47 | gdb/microblaze-tdep.c | 102 +- |
45 | gdb/microblaze-tdep.h | 8 +- | 48 | gdb/microblaze-tdep.h | 4 +- |
46 | .../microblaze-with-stack-protect.dat | 4 +- | 49 | .../microblaze-with-stack-protect.dat | 4 +- |
47 | .../linux-microblaze-low.c | 0 | 50 | .../linux-microblaze-low.c | 0 |
48 | include/elf/common.h | 1 + | 51 | include/elf/common.h | 1 + |
@@ -50,7 +53,7 @@ Conflicts: | |||
50 | opcodes/microblaze-dis.c | 51 +- | 53 | opcodes/microblaze-dis.c | 51 +- |
51 | opcodes/microblaze-opc.h | 180 +- | 54 | opcodes/microblaze-opc.h | 180 +- |
52 | opcodes/microblaze-opcm.h | 36 +- | 55 | opcodes/microblaze-opcm.h | 36 +- |
53 | 41 files changed, 5454 insertions(+), 248 deletions(-) | 56 | 41 files changed, 5345 insertions(+), 245 deletions(-) |
54 | create mode 100755 bfd/elf64-microblaze.c | 57 | create mode 100755 bfd/elf64-microblaze.c |
55 | create mode 100644 gdb/features/microblaze64-core.xml | 58 | create mode 100644 gdb/features/microblaze64-core.xml |
56 | create mode 100644 gdb/features/microblaze64-stack-protect.xml | 59 | create mode 100644 gdb/features/microblaze64-stack-protect.xml |
@@ -4880,18 +4883,18 @@ index 00000000000..515d18e65cf | |||
4880 | + <xi:include href="microblaze64-core.xml"/> | 4883 | + <xi:include href="microblaze64-core.xml"/> |
4881 | +</target> | 4884 | +</target> |
4882 | diff --git a/gdb/microblaze-linux-tdep.c b/gdb/microblaze-linux-tdep.c | 4885 | diff --git a/gdb/microblaze-linux-tdep.c b/gdb/microblaze-linux-tdep.c |
4883 | index b8277dfd735..0c9ec82cee5 100644 | 4886 | index b77acc9dc61..ba87d0bbd63 100644 |
4884 | --- a/gdb/microblaze-linux-tdep.c | 4887 | --- a/gdb/microblaze-linux-tdep.c |
4885 | +++ b/gdb/microblaze-linux-tdep.c | 4888 | +++ b/gdb/microblaze-linux-tdep.c |
4886 | @@ -39,6 +39,7 @@ | 4889 | @@ -40,6 +40,7 @@ |
4887 | #include "glibc-tdep.h" | 4890 | #include "features/microblaze-linux.c" |
4888 | 4891 | ||
4889 | static int microblaze_debug_flag = 0; | 4892 | static int microblaze_debug_flag = 0; |
4890 | +int MICROBLAZE_REGISTER_SIZE=4; | 4893 | +int MICROBLAZE_REGISTER_SIZE=4; |
4891 | 4894 | ||
4892 | static void | 4895 | static void |
4893 | microblaze_debug (const char *fmt, ...) | 4896 | microblaze_debug (const char *fmt, ...) |
4894 | @@ -54,6 +55,7 @@ microblaze_debug (const char *fmt, ...) | 4897 | @@ -55,6 +56,7 @@ microblaze_debug (const char *fmt, ...) |
4895 | } | 4898 | } |
4896 | } | 4899 | } |
4897 | 4900 | ||
@@ -4899,7 +4902,7 @@ index b8277dfd735..0c9ec82cee5 100644 | |||
4899 | static int | 4902 | static int |
4900 | microblaze_linux_memory_remove_breakpoint (struct gdbarch *gdbarch, | 4903 | microblaze_linux_memory_remove_breakpoint (struct gdbarch *gdbarch, |
4901 | struct bp_target_info *bp_tgt) | 4904 | struct bp_target_info *bp_tgt) |
4902 | @@ -85,6 +87,8 @@ microblaze_linux_memory_remove_breakpoint (struct gdbarch *gdbarch, | 4905 | @@ -86,6 +88,8 @@ microblaze_linux_memory_remove_breakpoint (struct gdbarch *gdbarch, |
4903 | return val; | 4906 | return val; |
4904 | } | 4907 | } |
4905 | 4908 | ||
@@ -4908,7 +4911,7 @@ index b8277dfd735..0c9ec82cee5 100644 | |||
4908 | static void | 4911 | static void |
4909 | microblaze_linux_sigtramp_cache (struct frame_info *next_frame, | 4912 | microblaze_linux_sigtramp_cache (struct frame_info *next_frame, |
4910 | struct trad_frame_cache *this_cache, | 4913 | struct trad_frame_cache *this_cache, |
4911 | @@ -146,8 +150,8 @@ microblaze_linux_init_abi (struct gdbarch_info info, | 4914 | @@ -147,8 +151,8 @@ microblaze_linux_init_abi (struct gdbarch_info info, |
4912 | 4915 | ||
4913 | linux_init_abi (info, gdbarch); | 4916 | linux_init_abi (info, gdbarch); |
4914 | 4917 | ||
@@ -4919,7 +4922,7 @@ index b8277dfd735..0c9ec82cee5 100644 | |||
4919 | 4922 | ||
4920 | /* Shared library handling. */ | 4923 | /* Shared library handling. */ |
4921 | set_solib_svr4_fetch_link_map_offsets (gdbarch, | 4924 | set_solib_svr4_fetch_link_map_offsets (gdbarch, |
4922 | @@ -159,10 +163,30 @@ microblaze_linux_init_abi (struct gdbarch_info info, | 4925 | @@ -160,10 +164,30 @@ microblaze_linux_init_abi (struct gdbarch_info info, |
4923 | 4926 | ||
4924 | /* BFD target for core files. */ | 4927 | /* BFD target for core files. */ |
4925 | if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG) | 4928 | if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG) |
@@ -4952,7 +4955,7 @@ index b8277dfd735..0c9ec82cee5 100644 | |||
4952 | 4955 | ||
4953 | /* Shared library handling. */ | 4956 | /* Shared library handling. */ |
4954 | set_gdbarch_skip_trampoline_code (gdbarch, find_solib_trampoline_target); | 4957 | set_gdbarch_skip_trampoline_code (gdbarch, find_solib_trampoline_target); |
4955 | @@ -177,6 +201,8 @@ void _initialize_microblaze_linux_tdep (); | 4958 | @@ -178,7 +202,9 @@ void _initialize_microblaze_linux_tdep (); |
4956 | void | 4959 | void |
4957 | _initialize_microblaze_linux_tdep () | 4960 | _initialize_microblaze_linux_tdep () |
4958 | { | 4961 | { |
@@ -4961,9 +4964,10 @@ index b8277dfd735..0c9ec82cee5 100644 | |||
4961 | + microblaze_linux_init_abi); | 4964 | + microblaze_linux_init_abi); |
4962 | + gdbarch_register_osabi (bfd_arch_microblaze, bfd_mach_microblaze64, GDB_OSABI_LINUX, | 4965 | + gdbarch_register_osabi (bfd_arch_microblaze, bfd_mach_microblaze64, GDB_OSABI_LINUX, |
4963 | microblaze_linux_init_abi); | 4966 | microblaze_linux_init_abi); |
4967 | initialize_tdesc_microblaze_linux (); | ||
4964 | } | 4968 | } |
4965 | diff --git a/gdb/microblaze-tdep.c b/gdb/microblaze-tdep.c | 4969 | diff --git a/gdb/microblaze-tdep.c b/gdb/microblaze-tdep.c |
4966 | index 399fa0e3dca..e51c022c1ba 100644 | 4970 | index 0a5b5ab59cc..667d658adfd 100644 |
4967 | --- a/gdb/microblaze-tdep.c | 4971 | --- a/gdb/microblaze-tdep.c |
4968 | +++ b/gdb/microblaze-tdep.c | 4972 | +++ b/gdb/microblaze-tdep.c |
4969 | @@ -40,7 +40,9 @@ | 4973 | @@ -40,7 +40,9 @@ |
@@ -5023,7 +5027,7 @@ index 399fa0e3dca..e51c022c1ba 100644 | |||
5023 | /* Allocate and initialize a frame cache. */ | 5027 | /* Allocate and initialize a frame cache. */ |
5024 | 5028 | ||
5025 | static struct microblaze_frame_cache * | 5029 | static struct microblaze_frame_cache * |
5026 | @@ -556,17 +568,16 @@ microblaze_extract_return_value (struct type *type, struct regcache *regcache, | 5030 | @@ -588,17 +600,16 @@ microblaze_extract_return_value (struct type *type, struct regcache *regcache, |
5027 | gdb_byte *valbuf) | 5031 | gdb_byte *valbuf) |
5028 | { | 5032 | { |
5029 | gdb_byte buf[8]; | 5033 | gdb_byte buf[8]; |
@@ -5043,118 +5047,10 @@ index 399fa0e3dca..e51c022c1ba 100644 | |||
5043 | return; | 5047 | return; |
5044 | case 4: /* for sizes 4 or 8, copy the required length. */ | 5048 | case 4: /* for sizes 4 or 8, copy the required length. */ |
5045 | case 8: | 5049 | case 8: |
5046 | @@ -633,7 +644,119 @@ microblaze_stabs_argument_has_addr (struct gdbarch *gdbarch, struct type *type) | 5050 | @@ -765,6 +776,12 @@ microblaze_software_single_step (struct regcache *regcache) |
5047 | return (TYPE_LENGTH (type) == 16); | ||
5048 | } | 5051 | } |
5052 | #endif | ||
5049 | 5053 | ||
5050 | - | ||
5051 | +#if 0 | ||
5052 | +static std::vector<CORE_ADDR> | ||
5053 | +microblaze_software_single_step (struct regcache *regcache) | ||
5054 | +{ | ||
5055 | +// struct gdbarch *arch = get_frame_arch(frame); | ||
5056 | + struct gdbarch *arch = get_regcache_arch (regcache); | ||
5057 | + struct address_space *aspace = get_regcache_aspace (regcache); | ||
5058 | +// struct address_space *aspace = get_frame_address_space (frame); | ||
5059 | + struct gdbarch_tdep *tdep = gdbarch_tdep (arch); | ||
5060 | + static char le_breakp[] = MICROBLAZE_BREAKPOINT_LE; | ||
5061 | + static char be_breakp[] = MICROBLAZE_BREAKPOINT; | ||
5062 | + enum bfd_endian byte_order = gdbarch_byte_order (arch); | ||
5063 | + char *breakp = byte_order == BFD_ENDIAN_BIG ? be_breakp : le_breakp; | ||
5064 | + std::vector<CORE_ADDR> ret = 0; | ||
5065 | + | ||
5066 | + /* Save the address and the values of the next_pc and the target */ | ||
5067 | + static struct sstep_breaks | ||
5068 | + { | ||
5069 | + CORE_ADDR address; | ||
5070 | + bfd_boolean valid; | ||
5071 | + /* Shadow contents. */ | ||
5072 | + char data[INST_WORD_SIZE]; | ||
5073 | + } stepbreaks[2]; | ||
5074 | + int ii; | ||
5075 | + | ||
5076 | + if (1) | ||
5077 | + { | ||
5078 | + CORE_ADDR pc; | ||
5079 | + std::vector<CORE_ADDR> *next_pcs = NULL; | ||
5080 | + long insn; | ||
5081 | + enum microblaze_instr minstr; | ||
5082 | + bfd_boolean isunsignednum; | ||
5083 | + enum microblaze_instr_type insn_type; | ||
5084 | + short delay_slots; | ||
5085 | + int imm; | ||
5086 | + bfd_boolean immfound = FALSE; | ||
5087 | + | ||
5088 | + /* Set a breakpoint at the next instruction */ | ||
5089 | + /* If the current instruction is an imm, set it at the inst after */ | ||
5090 | + /* If the instruction has a delay slot, skip the delay slot */ | ||
5091 | + pc = regcache_read_pc (regcache); | ||
5092 | + insn = microblaze_fetch_instruction (pc); | ||
5093 | + minstr = get_insn_microblaze (insn, &isunsignednum, &insn_type, &delay_slots); | ||
5094 | + if (insn_type == immediate_inst) | ||
5095 | + { | ||
5096 | + int rd, ra, rb; | ||
5097 | + immfound = TRUE; | ||
5098 | + minstr = microblaze_decode_insn (insn, &rd, &ra, &rb, &imm); | ||
5099 | + pc = pc + INST_WORD_SIZE; | ||
5100 | + insn = microblaze_fetch_instruction (pc); | ||
5101 | + minstr = get_insn_microblaze (insn, &isunsignednum, &insn_type, &delay_slots); | ||
5102 | + } | ||
5103 | + stepbreaks[0].address = pc + (delay_slots * INST_WORD_SIZE) + INST_WORD_SIZE; | ||
5104 | + if (insn_type != return_inst) { | ||
5105 | + stepbreaks[0].valid = TRUE; | ||
5106 | + } else { | ||
5107 | + stepbreaks[0].valid = FALSE; | ||
5108 | + } | ||
5109 | + | ||
5110 | + microblaze_debug ("single-step insn_type=%x insn=%x\n", insn_type, insn); | ||
5111 | + /* Now check for branch or return instructions */ | ||
5112 | + if (insn_type == branch_inst || insn_type == return_inst) { | ||
5113 | + int limm; | ||
5114 | + int lrd, lra, lrb; | ||
5115 | + int ra, rb; | ||
5116 | + bfd_boolean targetvalid; | ||
5117 | + bfd_boolean unconditionalbranch; | ||
5118 | + microblaze_decode_insn(insn, &lrd, &lra, &lrb, &limm); | ||
5119 | + if (lra >= 0 && lra < MICROBLAZE_NUM_REGS) | ||
5120 | + ra = regcache_raw_get_unsigned(regcache, lra); | ||
5121 | + else | ||
5122 | + ra = 0; | ||
5123 | + if (lrb >= 0 && lrb < MICROBLAZE_NUM_REGS) | ||
5124 | + rb = regcache_raw_get_unsigned(regcache, lrb); | ||
5125 | + else | ||
5126 | + rb = 0; | ||
5127 | + stepbreaks[1].address = microblaze_get_target_address (insn, immfound, imm, pc, ra, rb, &targetvalid, &unconditionalbranch); | ||
5128 | + microblaze_debug ("single-step uncondbr=%d targetvalid=%d target=%x\n", unconditionalbranch, targetvalid, stepbreaks[1].address); | ||
5129 | + if (unconditionalbranch) | ||
5130 | + stepbreaks[0].valid = FALSE; /* This is a unconditional branch: will not come to the next address */ | ||
5131 | + if (targetvalid && (stepbreaks[0].valid == FALSE || | ||
5132 | + (stepbreaks[0].address != stepbreaks[1].address)) | ||
5133 | + && (stepbreaks[1].address != pc)) { | ||
5134 | + stepbreaks[1].valid = TRUE; | ||
5135 | + } else { | ||
5136 | + stepbreaks[1].valid = FALSE; | ||
5137 | + } | ||
5138 | + } else { | ||
5139 | + stepbreaks[1].valid = FALSE; | ||
5140 | + } | ||
5141 | + | ||
5142 | + /* Insert the breakpoints */ | ||
5143 | + for (ii = 0; ii < 2; ++ii) | ||
5144 | + { | ||
5145 | + | ||
5146 | + /* ignore invalid breakpoint. */ | ||
5147 | + if (stepbreaks[ii].valid) { | ||
5148 | + VEC_safe_push (CORE_ADDR, next_pcs, stepbreaks[ii].address);; | ||
5149 | +// insert_single_step_breakpoint (arch, aspace, stepbreaks[ii].address); | ||
5150 | + ret = next_pcs; | ||
5151 | + } | ||
5152 | + } | ||
5153 | + } | ||
5154 | + return ret; | ||
5155 | +} | ||
5156 | +#endif | ||
5157 | + | ||
5158 | +static void | 5054 | +static void |
5159 | +microblaze_write_pc (struct regcache *regcache, CORE_ADDR pc) | 5055 | +microblaze_write_pc (struct regcache *regcache, CORE_ADDR pc) |
5160 | +{ | 5056 | +{ |
@@ -5164,7 +5060,7 @@ index 399fa0e3dca..e51c022c1ba 100644 | |||
5164 | static int dwarf2_to_reg_map[78] = | 5060 | static int dwarf2_to_reg_map[78] = |
5165 | { 0 /* r0 */, 1 /* r1 */, 2 /* r2 */, 3 /* r3 */, /* 0- 3 */ | 5061 | { 0 /* r0 */, 1 /* r1 */, 2 /* r2 */, 3 /* r3 */, /* 0- 3 */ |
5166 | 4 /* r4 */, 5 /* r5 */, 6 /* r6 */, 7 /* r7 */, /* 4- 7 */ | 5062 | 4 /* r4 */, 5 /* r5 */, 6 /* r6 */, 7 /* r7 */, /* 4- 7 */ |
5167 | @@ -668,13 +791,14 @@ microblaze_dwarf2_reg_to_regnum (struct gdbarch *gdbarch, int reg) | 5063 | @@ -799,13 +816,14 @@ microblaze_dwarf2_reg_to_regnum (struct gdbarch *gdbarch, int reg) |
5168 | static void | 5064 | static void |
5169 | microblaze_register_g_packet_guesses (struct gdbarch *gdbarch) | 5065 | microblaze_register_g_packet_guesses (struct gdbarch *gdbarch) |
5170 | { | 5066 | { |
@@ -5182,7 +5078,7 @@ index 399fa0e3dca..e51c022c1ba 100644 | |||
5182 | } | 5078 | } |
5183 | 5079 | ||
5184 | void | 5080 | void |
5185 | @@ -682,7 +806,7 @@ microblaze_supply_gregset (const struct regset *regset, | 5081 | @@ -813,7 +831,7 @@ microblaze_supply_gregset (const struct regset *regset, |
5186 | struct regcache *regcache, | 5082 | struct regcache *regcache, |
5187 | int regnum, const void *gregs) | 5083 | int regnum, const void *gregs) |
5188 | { | 5084 | { |
@@ -5191,7 +5087,7 @@ index 399fa0e3dca..e51c022c1ba 100644 | |||
5191 | if (regnum >= 0) | 5087 | if (regnum >= 0) |
5192 | regcache->raw_supply (regnum, regs + regnum); | 5088 | regcache->raw_supply (regnum, regs + regnum); |
5193 | 5089 | ||
5194 | @@ -690,7 +814,7 @@ microblaze_supply_gregset (const struct regset *regset, | 5090 | @@ -821,7 +839,7 @@ microblaze_supply_gregset (const struct regset *regset, |
5195 | int i; | 5091 | int i; |
5196 | 5092 | ||
5197 | for (i = 0; i < 50; i++) { | 5093 | for (i = 0; i < 50; i++) { |
@@ -5200,7 +5096,7 @@ index 399fa0e3dca..e51c022c1ba 100644 | |||
5200 | } | 5096 | } |
5201 | } | 5097 | } |
5202 | } | 5098 | } |
5203 | @@ -713,6 +837,17 @@ microblaze_iterate_over_regset_sections (struct gdbarch *gdbarch, | 5099 | @@ -844,6 +862,17 @@ microblaze_iterate_over_regset_sections (struct gdbarch *gdbarch, |
5204 | } | 5100 | } |
5205 | 5101 | ||
5206 | 5102 | ||
@@ -5218,7 +5114,7 @@ index 399fa0e3dca..e51c022c1ba 100644 | |||
5218 | 5114 | ||
5219 | static struct gdbarch * | 5115 | static struct gdbarch * |
5220 | microblaze_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) | 5116 | microblaze_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) |
5221 | @@ -727,8 +862,15 @@ microblaze_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) | 5117 | @@ -858,8 +887,15 @@ microblaze_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) |
5222 | if (arches != NULL) | 5118 | if (arches != NULL) |
5223 | return arches->gdbarch; | 5119 | return arches->gdbarch; |
5224 | if (tdesc == NULL) | 5120 | if (tdesc == NULL) |
@@ -5236,7 +5132,7 @@ index 399fa0e3dca..e51c022c1ba 100644 | |||
5236 | /* Check any target description for validity. */ | 5132 | /* Check any target description for validity. */ |
5237 | if (tdesc_has_registers (tdesc)) | 5133 | if (tdesc_has_registers (tdesc)) |
5238 | { | 5134 | { |
5239 | @@ -736,27 +878,35 @@ microblaze_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) | 5135 | @@ -867,27 +903,35 @@ microblaze_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) |
5240 | int valid_p; | 5136 | int valid_p; |
5241 | int i; | 5137 | int i; |
5242 | 5138 | ||
@@ -5277,7 +5173,7 @@ index 399fa0e3dca..e51c022c1ba 100644 | |||
5277 | } | 5173 | } |
5278 | 5174 | ||
5279 | if (!valid_p) | 5175 | if (!valid_p) |
5280 | @@ -764,6 +914,7 @@ microblaze_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) | 5176 | @@ -895,6 +939,7 @@ microblaze_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) |
5281 | tdesc_data_cleanup (tdesc_data); | 5177 | tdesc_data_cleanup (tdesc_data); |
5282 | return NULL; | 5178 | return NULL; |
5283 | } | 5179 | } |
@@ -5285,7 +5181,7 @@ index 399fa0e3dca..e51c022c1ba 100644 | |||
5285 | } | 5181 | } |
5286 | 5182 | ||
5287 | /* Allocate space for the new architecture. */ | 5183 | /* Allocate space for the new architecture. */ |
5288 | @@ -783,7 +934,17 @@ microblaze_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) | 5184 | @@ -914,7 +959,17 @@ microblaze_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) |
5289 | /* Register numbers of various important registers. */ | 5185 | /* Register numbers of various important registers. */ |
5290 | set_gdbarch_sp_regnum (gdbarch, MICROBLAZE_SP_REGNUM); | 5186 | set_gdbarch_sp_regnum (gdbarch, MICROBLAZE_SP_REGNUM); |
5291 | set_gdbarch_pc_regnum (gdbarch, MICROBLAZE_PC_REGNUM); | 5187 | set_gdbarch_pc_regnum (gdbarch, MICROBLAZE_PC_REGNUM); |
@@ -5303,7 +5199,7 @@ index 399fa0e3dca..e51c022c1ba 100644 | |||
5303 | /* Map Dwarf2 registers to GDB registers. */ | 5199 | /* Map Dwarf2 registers to GDB registers. */ |
5304 | set_gdbarch_dwarf2_reg_to_regnum (gdbarch, microblaze_dwarf2_reg_to_regnum); | 5200 | set_gdbarch_dwarf2_reg_to_regnum (gdbarch, microblaze_dwarf2_reg_to_regnum); |
5305 | 5201 | ||
5306 | @@ -803,13 +964,15 @@ microblaze_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) | 5202 | @@ -934,7 +989,9 @@ microblaze_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) |
5307 | microblaze_breakpoint::kind_from_pc); | 5203 | microblaze_breakpoint::kind_from_pc); |
5308 | set_gdbarch_sw_breakpoint_from_kind (gdbarch, | 5204 | set_gdbarch_sw_breakpoint_from_kind (gdbarch, |
5309 | microblaze_breakpoint::bp_from_kind); | 5205 | microblaze_breakpoint::bp_from_kind); |
@@ -5312,7 +5208,9 @@ index 399fa0e3dca..e51c022c1ba 100644 | |||
5312 | + | 5208 | + |
5313 | +// set_gdbarch_software_single_step (gdbarch, microblaze_software_single_step); | 5209 | +// set_gdbarch_software_single_step (gdbarch, microblaze_software_single_step); |
5314 | 5210 | ||
5315 | set_gdbarch_frame_args_skip (gdbarch, 8); | 5211 | set_gdbarch_software_single_step (gdbarch, microblaze_software_single_step); |
5212 | |||
5213 | @@ -942,7 +999,7 @@ microblaze_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) | ||
5316 | 5214 | ||
5317 | set_gdbarch_unwind_pc (gdbarch, microblaze_unwind_pc); | 5215 | set_gdbarch_unwind_pc (gdbarch, microblaze_unwind_pc); |
5318 | 5216 | ||
@@ -5321,7 +5219,7 @@ index 399fa0e3dca..e51c022c1ba 100644 | |||
5321 | 5219 | ||
5322 | frame_base_set_default (gdbarch, µblaze_frame_base); | 5220 | frame_base_set_default (gdbarch, µblaze_frame_base); |
5323 | 5221 | ||
5324 | @@ -824,12 +987,11 @@ microblaze_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) | 5222 | @@ -957,12 +1014,11 @@ microblaze_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) |
5325 | tdesc_use_registers (gdbarch, tdesc, tdesc_data); | 5223 | tdesc_use_registers (gdbarch, tdesc, tdesc_data); |
5326 | //frame_base_append_sniffer (gdbarch, microblaze_frame_sniffer); | 5224 | //frame_base_append_sniffer (gdbarch, microblaze_frame_sniffer); |
5327 | 5225 | ||
@@ -5336,7 +5234,7 @@ index 399fa0e3dca..e51c022c1ba 100644 | |||
5336 | return gdbarch; | 5234 | return gdbarch; |
5337 | } | 5235 | } |
5338 | 5236 | ||
5339 | @@ -841,6 +1003,8 @@ _initialize_microblaze_tdep () | 5237 | @@ -974,6 +1030,8 @@ _initialize_microblaze_tdep () |
5340 | 5238 | ||
5341 | initialize_tdesc_microblaze_with_stack_protect (); | 5239 | initialize_tdesc_microblaze_with_stack_protect (); |
5342 | initialize_tdesc_microblaze (); | 5240 | initialize_tdesc_microblaze (); |
@@ -5346,7 +5244,7 @@ index 399fa0e3dca..e51c022c1ba 100644 | |||
5346 | add_setshow_zuinteger_cmd ("microblaze", class_maintenance, | 5244 | add_setshow_zuinteger_cmd ("microblaze", class_maintenance, |
5347 | µblaze_debug_flag, _("\ | 5245 | µblaze_debug_flag, _("\ |
5348 | diff --git a/gdb/microblaze-tdep.h b/gdb/microblaze-tdep.h | 5246 | diff --git a/gdb/microblaze-tdep.h b/gdb/microblaze-tdep.h |
5349 | index 872a3931f20..dc1d4686914 100644 | 5247 | index 7f75c693b74..e0fa7ef9b12 100644 |
5350 | --- a/gdb/microblaze-tdep.h | 5248 | --- a/gdb/microblaze-tdep.h |
5351 | +++ b/gdb/microblaze-tdep.h | 5249 | +++ b/gdb/microblaze-tdep.h |
5352 | @@ -27,7 +27,7 @@ struct microblaze_gregset | 5250 | @@ -27,7 +27,7 @@ struct microblaze_gregset |
@@ -5358,19 +5256,7 @@ index 872a3931f20..dc1d4686914 100644 | |||
5358 | }; | 5256 | }; |
5359 | 5257 | ||
5360 | struct gdbarch_tdep | 5258 | struct gdbarch_tdep |
5361 | @@ -101,9 +101,9 @@ enum microblaze_regnum | 5259 | @@ -133,7 +133,7 @@ struct microblaze_frame_cache |
5362 | MICROBLAZE_RTLBSX_REGNUM, | ||
5363 | MICROBLAZE_RTLBLO_REGNUM, | ||
5364 | MICROBLAZE_RTLBHI_REGNUM, | ||
5365 | - MICROBLAZE_SLR_REGNUM, MICROBLAZE_NUM_CORE_REGS = MICROBLAZE_SLR_REGNUM, | ||
5366 | + MICROBLAZE_SLR_REGNUM, | ||
5367 | MICROBLAZE_SHR_REGNUM, | ||
5368 | - MICROBLAZE_NUM_REGS | ||
5369 | + MICROBLAZE_NUM_REGS, MICROBLAZE_NUM_CORE_REGS = MICROBLAZE_NUM_REGS | ||
5370 | }; | ||
5371 | |||
5372 | struct microblaze_frame_cache | ||
5373 | @@ -128,7 +128,7 @@ struct microblaze_frame_cache | ||
5374 | struct trad_frame_saved_reg *saved_regs; | 5260 | struct trad_frame_saved_reg *saved_regs; |
5375 | }; | 5261 | }; |
5376 | /* All registers are 32 bits. */ | 5262 | /* All registers are 32 bits. */ |
diff --git a/meta-microblaze/recipes-devtools/gdb/gdb/0009-Patch-MicroBlaze-these-changes-will-make-64-bit-vect.patch b/meta-microblaze/recipes-devtools/gdb/gdb/0008-Patch-MicroBlaze-these-changes-will-make-64-bit-vect.patch index fca85fa2..abbea266 100644 --- a/meta-microblaze/recipes-devtools/gdb/gdb/0009-Patch-MicroBlaze-these-changes-will-make-64-bit-vect.patch +++ b/meta-microblaze/recipes-devtools/gdb/gdb/0008-Patch-MicroBlaze-these-changes-will-make-64-bit-vect.patch | |||
@@ -1,7 +1,7 @@ | |||
1 | From 9ab0a0a551902e5196d46178b57fa1b33b587092 Mon Sep 17 00:00:00 2001 | 1 | From cc8ee172b9145ce488c556a2eb50f931f0676eea Mon Sep 17 00:00:00 2001 |
2 | From: Mahesh Bodapati <mbodapat@xilinx.com> | 2 | From: Mahesh Bodapati <mbodapat@xilinx.com> |
3 | Date: Mon, 19 Apr 2021 14:33:27 +0530 | 3 | Date: Mon, 19 Apr 2021 14:33:27 +0530 |
4 | Subject: [PATCH 09/10] [Patch,MicroBlaze] : these changes will make 64 bit | 4 | Subject: [PATCH 08/10] [Patch,MicroBlaze] : these changes will make 64 bit |
5 | vectors as default target types when we built gdb with microblaze 64 bit type | 5 | vectors as default target types when we built gdb with microblaze 64 bit type |
6 | targets,for instance microblaze-xilinx-elf64/microblazeel-xilinx-elf64 | 6 | targets,for instance microblaze-xilinx-elf64/microblazeel-xilinx-elf64 |
7 | 7 | ||
diff --git a/meta-microblaze/recipes-devtools/gdb/gdb/0008-gdb-Fix-microblaze-target-compilation-3.patch b/meta-microblaze/recipes-devtools/gdb/gdb/0008-gdb-Fix-microblaze-target-compilation-3.patch deleted file mode 100644 index 6a570b6a..00000000 --- a/meta-microblaze/recipes-devtools/gdb/gdb/0008-gdb-Fix-microblaze-target-compilation-3.patch +++ /dev/null | |||
@@ -1,288 +0,0 @@ | |||
1 | From 306ca46b3f330ee39601b9aede6b53c9cdbe9f86 Mon Sep 17 00:00:00 2001 | ||
2 | From: Mark Hatle <mark.hatle@xilinx.com> | ||
3 | Date: Wed, 9 Dec 2020 23:35:35 -0600 | ||
4 | Subject: [PATCH 08/10] gdb: Fix microblaze target compilation (#3) | ||
5 | |||
6 | Add microblaze-linux-nat.c to configure.nat | ||
7 | |||
8 | Transition microblaze-linux-nat.c to use the new gdb C++ style functions. | ||
9 | |||
10 | Signed-off-by: Mark Hatle <mark.hatle@kernel.crashing.org> | ||
11 | --- | ||
12 | gdb/configure.nat | 5 ++ | ||
13 | gdb/microblaze-linux-nat.c | 96 ++++++++++++++------------------------ | ||
14 | gdb/microblaze-tdep.h | 3 ++ | ||
15 | 3 files changed, 43 insertions(+), 61 deletions(-) | ||
16 | |||
17 | diff --git a/gdb/configure.nat b/gdb/configure.nat | ||
18 | index bb70e303384..d8548a6b666 100644 | ||
19 | --- a/gdb/configure.nat | ||
20 | +++ b/gdb/configure.nat | ||
21 | @@ -261,6 +261,11 @@ case ${gdb_host} in | ||
22 | # Host: Motorola m68k running GNU/Linux. | ||
23 | NATDEPFILES="${NATDEPFILES} m68k-linux-nat.o" | ||
24 | ;; | ||
25 | + microblaze) | ||
26 | + # Host: Microblaze running GNU/Linux. | ||
27 | + NATDEPFILES="${NATDEPFILES} microblaze-linux-nat.o" | ||
28 | + NAT_CDEPS= | ||
29 | + ;; | ||
30 | mips) | ||
31 | # Host: Linux/MIPS | ||
32 | NATDEPFILES="${NATDEPFILES} linux-nat-trad.o \ | ||
33 | diff --git a/gdb/microblaze-linux-nat.c b/gdb/microblaze-linux-nat.c | ||
34 | index e9b8c9c5221..bac4697e1e6 100644 | ||
35 | --- a/gdb/microblaze-linux-nat.c | ||
36 | +++ b/gdb/microblaze-linux-nat.c | ||
37 | @@ -36,13 +36,14 @@ | ||
38 | #include "dwarf2-frame.h" | ||
39 | #include "osabi.h" | ||
40 | |||
41 | -#include "gdb_assert.h" | ||
42 | -#include "gdb_string.h" | ||
43 | +#include "gdbsupport/gdb_assert.h" | ||
44 | +#include <string.h> | ||
45 | #include "target-descriptions.h" | ||
46 | #include "opcodes/microblaze-opcm.h" | ||
47 | #include "opcodes/microblaze-dis.h" | ||
48 | |||
49 | #include "linux-nat.h" | ||
50 | +#include "linux-tdep.h" | ||
51 | #include "target-descriptions.h" | ||
52 | |||
53 | #include <sys/user.h> | ||
54 | @@ -61,22 +62,17 @@ | ||
55 | /* Defines ps_err_e, struct ps_prochandle. */ | ||
56 | #include "gdb_proc_service.h" | ||
57 | |||
58 | -/* On GNU/Linux, threads are implemented as pseudo-processes, in which | ||
59 | - case we may be tracing more than one process at a time. In that | ||
60 | - case, inferior_ptid will contain the main process ID and the | ||
61 | - individual thread (process) ID. get_thread_id () is used to get | ||
62 | - the thread id if it's available, and the process id otherwise. */ | ||
63 | - | ||
64 | -int | ||
65 | -get_thread_id (ptid_t ptid) | ||
66 | +class microblaze_linux_nat_target final : public linux_nat_target | ||
67 | { | ||
68 | - int tid = TIDGET (ptid); | ||
69 | - if (0 == tid) | ||
70 | - tid = PIDGET (ptid); | ||
71 | - return tid; | ||
72 | -} | ||
73 | +public: | ||
74 | + /* Add our register access methods. */ | ||
75 | + void fetch_registers (struct regcache *, int) override; | ||
76 | + void store_registers (struct regcache *, int) override; | ||
77 | + | ||
78 | + const struct target_desc *read_description () override; | ||
79 | +}; | ||
80 | |||
81 | -#define GET_THREAD_ID(PTID) get_thread_id (PTID) | ||
82 | +static microblaze_linux_nat_target the_microblaze_linux_nat_target; | ||
83 | |||
84 | /* Non-zero if our kernel may support the PTRACE_GETREGS and | ||
85 | PTRACE_SETREGS requests, for reading and writing the | ||
86 | @@ -88,7 +84,6 @@ static int | ||
87 | microblaze_register_u_addr (struct gdbarch *gdbarch, int regno) | ||
88 | { | ||
89 | int u_addr = -1; | ||
90 | - struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); | ||
91 | /* NOTE: cagney/2003-11-25: This is the word size used by the ptrace | ||
92 | interface, and not the wordsize of the program's ABI. */ | ||
93 | int wordsize = sizeof (long); | ||
94 | @@ -105,18 +100,16 @@ microblaze_register_u_addr (struct gdbarch *gdbarch, int regno) | ||
95 | static void | ||
96 | fetch_register (struct regcache *regcache, int tid, int regno) | ||
97 | { | ||
98 | - struct gdbarch *gdbarch = get_regcache_arch (regcache); | ||
99 | - struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); | ||
100 | + struct gdbarch *gdbarch = regcache->arch (); | ||
101 | /* This isn't really an address. But ptrace thinks of it as one. */ | ||
102 | CORE_ADDR regaddr = microblaze_register_u_addr (gdbarch, regno); | ||
103 | int bytes_transferred; | ||
104 | - unsigned int offset; /* Offset of registers within the u area. */ | ||
105 | - char buf[MAX_REGISTER_SIZE]; | ||
106 | + char buf[MICROBLAZE_MAX_REGISTER_SIZE]; | ||
107 | |||
108 | if (regaddr == -1) | ||
109 | { | ||
110 | memset (buf, '\0', register_size (gdbarch, regno)); /* Supply zeroes */ | ||
111 | - regcache_raw_supply (regcache, regno, buf); | ||
112 | + regcache->raw_supply (regno, buf); | ||
113 | return; | ||
114 | } | ||
115 | |||
116 | @@ -149,14 +142,14 @@ fetch_register (struct regcache *regcache, int tid, int regno) | ||
117 | { | ||
118 | /* Little-endian values are always found at the left end of the | ||
119 | bytes transferred. */ | ||
120 | - regcache_raw_supply (regcache, regno, buf); | ||
121 | + regcache->raw_supply (regno, buf); | ||
122 | } | ||
123 | else if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG) | ||
124 | { | ||
125 | /* Big-endian values are found at the right end of the bytes | ||
126 | transferred. */ | ||
127 | size_t padding = (bytes_transferred - register_size (gdbarch, regno)); | ||
128 | - regcache_raw_supply (regcache, regno, buf + padding); | ||
129 | + regcache->raw_supply (regno, buf + padding); | ||
130 | } | ||
131 | else | ||
132 | internal_error (__FILE__, __LINE__, | ||
133 | @@ -175,8 +168,6 @@ fetch_register (struct regcache *regcache, int tid, int regno) | ||
134 | static int | ||
135 | fetch_all_gp_regs (struct regcache *regcache, int tid) | ||
136 | { | ||
137 | - struct gdbarch *gdbarch = get_regcache_arch (regcache); | ||
138 | - struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); | ||
139 | gdb_gregset_t gregset; | ||
140 | |||
141 | if (ptrace (PTRACE_GETREGS, tid, 0, (void *) &gregset) < 0) | ||
142 | @@ -204,8 +195,6 @@ fetch_all_gp_regs (struct regcache *regcache, int tid) | ||
143 | static void | ||
144 | fetch_gp_regs (struct regcache *regcache, int tid) | ||
145 | { | ||
146 | - struct gdbarch *gdbarch = get_regcache_arch (regcache); | ||
147 | - struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); | ||
148 | int i; | ||
149 | |||
150 | if (have_ptrace_getsetregs) | ||
151 | @@ -223,13 +212,12 @@ fetch_gp_regs (struct regcache *regcache, int tid) | ||
152 | static void | ||
153 | store_register (const struct regcache *regcache, int tid, int regno) | ||
154 | { | ||
155 | - struct gdbarch *gdbarch = get_regcache_arch (regcache); | ||
156 | - struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); | ||
157 | + struct gdbarch *gdbarch = regcache->arch (); | ||
158 | /* This isn't really an address. But ptrace thinks of it as one. */ | ||
159 | CORE_ADDR regaddr = microblaze_register_u_addr (gdbarch, regno); | ||
160 | int i; | ||
161 | size_t bytes_to_transfer; | ||
162 | - char buf[MAX_REGISTER_SIZE]; | ||
163 | + char buf[MICROBLAZE_MAX_REGISTER_SIZE]; | ||
164 | |||
165 | if (regaddr == -1) | ||
166 | return; | ||
167 | @@ -242,13 +230,13 @@ store_register (const struct regcache *regcache, int tid, int regno) | ||
168 | if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_LITTLE) | ||
169 | { | ||
170 | /* Little-endian values always sit at the left end of the buffer. */ | ||
171 | - regcache_raw_collect (regcache, regno, buf); | ||
172 | + regcache->raw_collect (regno, buf); | ||
173 | } | ||
174 | else if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG) | ||
175 | { | ||
176 | /* Big-endian values sit at the right end of the buffer. */ | ||
177 | size_t padding = (bytes_to_transfer - register_size (gdbarch, regno)); | ||
178 | - regcache_raw_collect (regcache, regno, buf + padding); | ||
179 | + regcache->raw_collect (regno, buf + padding); | ||
180 | } | ||
181 | |||
182 | for (i = 0; i < bytes_to_transfer; i += sizeof (long)) | ||
183 | @@ -281,8 +269,6 @@ store_register (const struct regcache *regcache, int tid, int regno) | ||
184 | static int | ||
185 | store_all_gp_regs (const struct regcache *regcache, int tid, int regno) | ||
186 | { | ||
187 | - struct gdbarch *gdbarch = get_regcache_arch (regcache); | ||
188 | - struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); | ||
189 | gdb_gregset_t gregset; | ||
190 | |||
191 | if (ptrace (PTRACE_GETREGS, tid, 0, (void *) &gregset) < 0) | ||
192 | @@ -319,8 +305,6 @@ store_all_gp_regs (const struct regcache *regcache, int tid, int regno) | ||
193 | static void | ||
194 | store_gp_regs (const struct regcache *regcache, int tid, int regno) | ||
195 | { | ||
196 | - struct gdbarch *gdbarch = get_regcache_arch (regcache); | ||
197 | - struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); | ||
198 | int i; | ||
199 | |||
200 | if (have_ptrace_getsetregs) | ||
201 | @@ -339,12 +323,12 @@ store_gp_regs (const struct regcache *regcache, int tid, int regno) | ||
202 | regno == -1, otherwise fetch all general registers or all floating | ||
203 | point registers depending upon the value of regno. */ | ||
204 | |||
205 | -static void | ||
206 | -microblaze_linux_fetch_inferior_registers (struct target_ops *ops, | ||
207 | - struct regcache *regcache, int regno) | ||
208 | +void | ||
209 | +microblaze_linux_nat_target::fetch_registers (struct regcache * regcache, | ||
210 | + int regno) | ||
211 | { | ||
212 | /* Get the thread id for the ptrace call. */ | ||
213 | - int tid = GET_THREAD_ID (inferior_ptid); | ||
214 | + int tid = regcache->ptid ().lwp (); | ||
215 | |||
216 | if (regno == -1) | ||
217 | fetch_gp_regs (regcache, tid); | ||
218 | @@ -356,12 +340,12 @@ microblaze_linux_fetch_inferior_registers (struct target_ops *ops, | ||
219 | regno == -1, otherwise store all general registers or all floating | ||
220 | point registers depending upon the value of regno. */ | ||
221 | |||
222 | -static void | ||
223 | -microblaze_linux_store_inferior_registers (struct target_ops *ops, | ||
224 | - struct regcache *regcache, int regno) | ||
225 | +void | ||
226 | +microblaze_linux_nat_target::store_registers (struct regcache *regcache, | ||
227 | + int regno) | ||
228 | { | ||
229 | /* Get the thread id for the ptrace call. */ | ||
230 | - int tid = GET_THREAD_ID (inferior_ptid); | ||
231 | + int tid = regcache->ptid ().lwp (); | ||
232 | |||
233 | if (regno >= 0) | ||
234 | store_register (regcache, tid, regno); | ||
235 | @@ -398,12 +382,12 @@ supply_fpregset (struct regcache *regcache, const gdb_fpregset_t *fpregsetp) | ||
236 | /* FIXME. */ | ||
237 | } | ||
238 | |||
239 | -static const struct target_desc * | ||
240 | -microblaze_linux_read_description (struct target_ops *ops) | ||
241 | +const struct target_desc * | ||
242 | +microblaze_linux_nat_target::read_description () | ||
243 | { | ||
244 | - CORE_ADDR microblaze_hwcap = 0; | ||
245 | + CORE_ADDR microblaze_hwcap = linux_get_hwcap (this); | ||
246 | |||
247 | - if (target_auxv_search (ops, AT_HWCAP, µblaze_hwcap) != 1) | ||
248 | + if (microblaze_hwcap != 1) | ||
249 | return NULL; | ||
250 | |||
251 | return NULL; | ||
252 | @@ -415,17 +399,7 @@ void _initialize_microblaze_linux_nat (void); | ||
253 | void | ||
254 | _initialize_microblaze_linux_nat (void) | ||
255 | { | ||
256 | - struct target_ops *t; | ||
257 | - | ||
258 | - /* Fill in the generic GNU/Linux methods. */ | ||
259 | - t = linux_target (); | ||
260 | - | ||
261 | - /* Add our register access methods. */ | ||
262 | - t->to_fetch_registers = microblaze_linux_fetch_inferior_registers; | ||
263 | - t->to_store_registers = microblaze_linux_store_inferior_registers; | ||
264 | - | ||
265 | - t->to_read_description = microblaze_linux_read_description; | ||
266 | - | ||
267 | /* Register the target. */ | ||
268 | - linux_nat_add_target (t); | ||
269 | + linux_target = &the_microblaze_linux_nat_target; | ||
270 | + add_inf_child_target (&the_microblaze_linux_nat_target); | ||
271 | } | ||
272 | diff --git a/gdb/microblaze-tdep.h b/gdb/microblaze-tdep.h | ||
273 | index dc1d4686914..a5c12c10e0b 100644 | ||
274 | --- a/gdb/microblaze-tdep.h | ||
275 | +++ b/gdb/microblaze-tdep.h | ||
276 | @@ -106,6 +106,9 @@ enum microblaze_regnum | ||
277 | MICROBLAZE_NUM_REGS, MICROBLAZE_NUM_CORE_REGS = MICROBLAZE_NUM_REGS | ||
278 | }; | ||
279 | |||
280 | +/* Big enough to hold the size of the largest register in bytes. */ | ||
281 | +#define MICROBLAZE_MAX_REGISTER_SIZE 64 | ||
282 | + | ||
283 | struct microblaze_frame_cache | ||
284 | { | ||
285 | /* Base address. */ | ||
286 | -- | ||
287 | 2.17.1 | ||
288 | |||
diff --git a/meta-microblaze/recipes-devtools/gdb/gdb/0010-Patch-MicroBlaze-Added-m64-abi-for-64-bit-target-des.patch b/meta-microblaze/recipes-devtools/gdb/gdb/0009-Patch-MicroBlaze-Added-m64-abi-for-64-bit-target-des.patch index 78ef9202..35466e8f 100644 --- a/meta-microblaze/recipes-devtools/gdb/gdb/0010-Patch-MicroBlaze-Added-m64-abi-for-64-bit-target-des.patch +++ b/meta-microblaze/recipes-devtools/gdb/gdb/0009-Patch-MicroBlaze-Added-m64-abi-for-64-bit-target-des.patch | |||
@@ -1,7 +1,7 @@ | |||
1 | From 67fd78c3fa5894e0038c09a858cb518c20340abf Mon Sep 17 00:00:00 2001 | 1 | From a721a7063f829ccaf6cf8273be04b763b53a735d Mon Sep 17 00:00:00 2001 |
2 | From: Mahesh Bodapati <mbodapat@xilinx.com> | 2 | From: Mahesh Bodapati <mbodapat@xilinx.com> |
3 | Date: Tue, 9 Nov 2021 16:19:17 +0530 | 3 | Date: Tue, 9 Nov 2021 16:19:17 +0530 |
4 | Subject: [PATCH 10/10] [Patch,MicroBlaze] : Added m64 abi for 64 bit target | 4 | Subject: [PATCH 09/10] [Patch,MicroBlaze] : Added m64 abi for 64 bit target |
5 | descriptions. set m64 abi for 64 bit elf. | 5 | descriptions. set m64 abi for 64 bit elf. |
6 | 6 | ||
7 | --- | 7 | --- |
@@ -22,7 +22,7 @@ index 515d18e65cf..9c1b7d22003 100644 | |||
22 | <xi:include href="microblaze64-core.xml"/> | 22 | <xi:include href="microblaze64-core.xml"/> |
23 | </target> | 23 | </target> |
24 | diff --git a/gdb/microblaze-tdep.c b/gdb/microblaze-tdep.c | 24 | diff --git a/gdb/microblaze-tdep.c b/gdb/microblaze-tdep.c |
25 | index e51c022c1ba..3bffbbe4b3d 100644 | 25 | index 667d658adfd..aad6a9cae6e 100644 |
26 | --- a/gdb/microblaze-tdep.c | 26 | --- a/gdb/microblaze-tdep.c |
27 | +++ b/gdb/microblaze-tdep.c | 27 | +++ b/gdb/microblaze-tdep.c |
28 | @@ -65,8 +65,94 @@ | 28 | @@ -65,8 +65,94 @@ |
@@ -139,7 +139,7 @@ index e51c022c1ba..3bffbbe4b3d 100644 | |||
139 | static void ATTRIBUTE_PRINTF (1, 2) | 139 | static void ATTRIBUTE_PRINTF (1, 2) |
140 | microblaze_debug (const char *fmt, ...) | 140 | microblaze_debug (const char *fmt, ...) |
141 | { | 141 | { |
142 | @@ -855,15 +953,30 @@ microblaze_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) | 142 | @@ -880,15 +978,30 @@ microblaze_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) |
143 | struct gdbarch_tdep *tdep; | 143 | struct gdbarch_tdep *tdep; |
144 | struct gdbarch *gdbarch; | 144 | struct gdbarch *gdbarch; |
145 | struct tdesc_arch_data *tdesc_data = NULL; | 145 | struct tdesc_arch_data *tdesc_data = NULL; |
@@ -172,7 +172,7 @@ index e51c022c1ba..3bffbbe4b3d 100644 | |||
172 | { | 172 | { |
173 | tdesc = tdesc_microblaze64; | 173 | tdesc = tdesc_microblaze64; |
174 | reg_size = 8; | 174 | reg_size = 8; |
175 | @@ -878,7 +991,7 @@ microblaze_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) | 175 | @@ -903,7 +1016,7 @@ microblaze_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) |
176 | int valid_p; | 176 | int valid_p; |
177 | int i; | 177 | int i; |
178 | 178 | ||
@@ -181,7 +181,7 @@ index e51c022c1ba..3bffbbe4b3d 100644 | |||
181 | feature = tdesc_find_feature (tdesc, | 181 | feature = tdesc_find_feature (tdesc, |
182 | "org.gnu.gdb.microblaze64.core"); | 182 | "org.gnu.gdb.microblaze64.core"); |
183 | else | 183 | else |
184 | @@ -892,7 +1005,7 @@ microblaze_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) | 184 | @@ -917,7 +1030,7 @@ microblaze_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) |
185 | for (i = 0; i < MICROBLAZE_NUM_REGS; i++) | 185 | for (i = 0; i < MICROBLAZE_NUM_REGS; i++) |
186 | valid_p &= tdesc_numbered_register (feature, tdesc_data, i, | 186 | valid_p &= tdesc_numbered_register (feature, tdesc_data, i, |
187 | microblaze_register_names[i]); | 187 | microblaze_register_names[i]); |
@@ -190,7 +190,7 @@ index e51c022c1ba..3bffbbe4b3d 100644 | |||
190 | feature = tdesc_find_feature (tdesc, | 190 | feature = tdesc_find_feature (tdesc, |
191 | "org.gnu.gdb.microblaze64.stack-protect"); | 191 | "org.gnu.gdb.microblaze64.stack-protect"); |
192 | else | 192 | else |
193 | @@ -943,7 +1056,8 @@ microblaze_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) | 193 | @@ -968,7 +1081,8 @@ microblaze_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) |
194 | set_gdbarch_ptr_bit (gdbarch, 64); | 194 | set_gdbarch_ptr_bit (gdbarch, 64); |
195 | break; | 195 | break; |
196 | } | 196 | } |
@@ -200,7 +200,7 @@ index e51c022c1ba..3bffbbe4b3d 100644 | |||
200 | 200 | ||
201 | /* Map Dwarf2 registers to GDB registers. */ | 201 | /* Map Dwarf2 registers to GDB registers. */ |
202 | set_gdbarch_dwarf2_reg_to_regnum (gdbarch, microblaze_dwarf2_reg_to_regnum); | 202 | set_gdbarch_dwarf2_reg_to_regnum (gdbarch, microblaze_dwarf2_reg_to_regnum); |
203 | @@ -1000,7 +1114,30 @@ void | 203 | @@ -1027,7 +1141,30 @@ void |
204 | _initialize_microblaze_tdep () | 204 | _initialize_microblaze_tdep () |
205 | { | 205 | { |
206 | register_gdbarch_init (bfd_arch_microblaze, microblaze_gdbarch_init); | 206 | register_gdbarch_init (bfd_arch_microblaze, microblaze_gdbarch_init); |
@@ -232,14 +232,14 @@ index e51c022c1ba..3bffbbe4b3d 100644 | |||
232 | initialize_tdesc_microblaze_with_stack_protect (); | 232 | initialize_tdesc_microblaze_with_stack_protect (); |
233 | initialize_tdesc_microblaze (); | 233 | initialize_tdesc_microblaze (); |
234 | initialize_tdesc_microblaze64_with_stack_protect (); | 234 | initialize_tdesc_microblaze64_with_stack_protect (); |
235 | @@ -1015,5 +1152,4 @@ When non-zero, microblaze specific debugging is enabled."), | 235 | @@ -1042,5 +1179,4 @@ When non-zero, microblaze specific debugging is enabled."), |
236 | NULL, | 236 | NULL, |
237 | &setdebuglist, &showdebuglist); | 237 | &setdebuglist, &showdebuglist); |
238 | 238 | ||
239 | - | 239 | - |
240 | } | 240 | } |
241 | diff --git a/gdb/microblaze-tdep.h b/gdb/microblaze-tdep.h | 241 | diff --git a/gdb/microblaze-tdep.h b/gdb/microblaze-tdep.h |
242 | index a5c12c10e0b..29da6d29dcb 100644 | 242 | index e0fa7ef9b12..9cb9628295f 100644 |
243 | --- a/gdb/microblaze-tdep.h | 243 | --- a/gdb/microblaze-tdep.h |
244 | +++ b/gdb/microblaze-tdep.h | 244 | +++ b/gdb/microblaze-tdep.h |
245 | @@ -19,8 +19,16 @@ | 245 | @@ -19,8 +19,16 @@ |
diff --git a/meta-microblaze/recipes-devtools/gdb/gdb/0010-Patch-MicroBlaze-Code-changes-for-gdbserver.patch b/meta-microblaze/recipes-devtools/gdb/gdb/0010-Patch-MicroBlaze-Code-changes-for-gdbserver.patch new file mode 100644 index 00000000..dc38b480 --- /dev/null +++ b/meta-microblaze/recipes-devtools/gdb/gdb/0010-Patch-MicroBlaze-Code-changes-for-gdbserver.patch | |||
@@ -0,0 +1,401 @@ | |||
1 | From 01e16382c8fce4448c911a4c5780259e181e83dd Mon Sep 17 00:00:00 2001 | ||
2 | From: Mahesh Bodapati <mbodapat@xilinx.com> | ||
3 | Date: Fri, 8 Jul 2022 12:53:51 +0530 | ||
4 | Subject: [PATCH 10/10] [Patch,MicroBlaze]: Code changes for gdbserver. | ||
5 | |||
6 | --- | ||
7 | gdb/features/Makefile | 1 + | ||
8 | gdb/features/microblaze-linux.xml | 1 + | ||
9 | gdb/regformats/microblaze-linux.dat | 64 +++++++++ | ||
10 | gdbserver/Makefile.in | 5 +- | ||
11 | gdbserver/configure.srv | 1 + | ||
12 | ...croblaze-low.c => linux-microblaze-low.cc} | 132 ++++++++++-------- | ||
13 | 6 files changed, 138 insertions(+), 66 deletions(-) | ||
14 | create mode 100644 gdb/regformats/microblaze-linux.dat | ||
15 | rename gdbserver/{linux-microblaze-low.c => linux-microblaze-low.cc} (72%) | ||
16 | |||
17 | diff --git a/gdb/features/Makefile b/gdb/features/Makefile | ||
18 | index 131fc14adbf..1b15305862e 100644 | ||
19 | --- a/gdb/features/Makefile | ||
20 | +++ b/gdb/features/Makefile | ||
21 | @@ -47,6 +47,7 @@ | ||
22 | WHICH = mips-linux mips-dsp-linux \ | ||
23 | microblaze-with-stack-protect \ | ||
24 | microblaze64-with-stack-protect \ | ||
25 | + microblaze-linux \ | ||
26 | mips64-linux mips64-dsp-linux \ | ||
27 | nios2-linux \ | ||
28 | rs6000/powerpc-32 \ | ||
29 | diff --git a/gdb/features/microblaze-linux.xml b/gdb/features/microblaze-linux.xml | ||
30 | index 8983e66eb3d..688a3f83d1e 100644 | ||
31 | --- a/gdb/features/microblaze-linux.xml | ||
32 | +++ b/gdb/features/microblaze-linux.xml | ||
33 | @@ -7,6 +7,7 @@ | ||
34 | |||
35 | <!DOCTYPE target SYSTEM "gdb-target.dtd"> | ||
36 | <target> | ||
37 | + <architecture>microblaze</architecture> | ||
38 | <osabi>GNU/Linux</osabi> | ||
39 | <xi:include href="microblaze-core.xml"/> | ||
40 | </target> | ||
41 | diff --git a/gdb/regformats/microblaze-linux.dat b/gdb/regformats/microblaze-linux.dat | ||
42 | new file mode 100644 | ||
43 | index 00000000000..b5b49f485cd | ||
44 | --- /dev/null | ||
45 | +++ b/gdb/regformats/microblaze-linux.dat | ||
46 | @@ -0,0 +1,64 @@ | ||
47 | +# THIS FILE IS GENERATED. -*- buffer-read-only: t -*- vi :set ro: | ||
48 | +# Generated from: microblaze-linux.xml | ||
49 | +name:microblaze_linux | ||
50 | +xmltarget:microblaze-linux.xml | ||
51 | +expedite:r1,rpc | ||
52 | +32:r0 | ||
53 | +32:r1 | ||
54 | +32:r2 | ||
55 | +32:r3 | ||
56 | +32:r4 | ||
57 | +32:r5 | ||
58 | +32:r6 | ||
59 | +32:r7 | ||
60 | +32:r8 | ||
61 | +32:r9 | ||
62 | +32:r10 | ||
63 | +32:r11 | ||
64 | +32:r12 | ||
65 | +32:r13 | ||
66 | +32:r14 | ||
67 | +32:r15 | ||
68 | +32:r16 | ||
69 | +32:r17 | ||
70 | +32:r18 | ||
71 | +32:r19 | ||
72 | +32:r20 | ||
73 | +32:r21 | ||
74 | +32:r22 | ||
75 | +32:r23 | ||
76 | +32:r24 | ||
77 | +32:r25 | ||
78 | +32:r26 | ||
79 | +32:r27 | ||
80 | +32:r28 | ||
81 | +32:r29 | ||
82 | +32:r30 | ||
83 | +32:r31 | ||
84 | +32:rpc | ||
85 | +32:rmsr | ||
86 | +32:rear | ||
87 | +32:resr | ||
88 | +32:rfsr | ||
89 | +32:rbtr | ||
90 | +32:rpvr0 | ||
91 | +32:rpvr1 | ||
92 | +32:rpvr2 | ||
93 | +32:rpvr3 | ||
94 | +32:rpvr4 | ||
95 | +32:rpvr5 | ||
96 | +32:rpvr6 | ||
97 | +32:rpvr7 | ||
98 | +32:rpvr8 | ||
99 | +32:rpvr9 | ||
100 | +32:rpvr10 | ||
101 | +32:rpvr11 | ||
102 | +32:redr | ||
103 | +32:rpid | ||
104 | +32:rzpr | ||
105 | +32:rtlbx | ||
106 | +32:rtlbsx | ||
107 | +32:rtlblo | ||
108 | +32:rtlbhi | ||
109 | +32:slr | ||
110 | +32:shr | ||
111 | diff --git a/gdbserver/Makefile.in b/gdbserver/Makefile.in | ||
112 | index 46b5a0c7c60..eaaf6820fe0 100644 | ||
113 | --- a/gdbserver/Makefile.in | ||
114 | +++ b/gdbserver/Makefile.in | ||
115 | @@ -184,7 +184,7 @@ SFILES = \ | ||
116 | $(srcdir)/linux-ia64-low.cc \ | ||
117 | $(srcdir)/linux-low.cc \ | ||
118 | $(srcdir)/linux-m68k-low.cc \ | ||
119 | - $(srcdir)/linux-microblaze-low.c \ | ||
120 | + $(srcdir)/linux-microblaze-low.cc \ | ||
121 | $(srcdir)/linux-mips-low.cc \ | ||
122 | $(srcdir)/linux-nios2-low.cc \ | ||
123 | $(srcdir)/linux-ppc-low.cc \ | ||
124 | @@ -222,7 +222,6 @@ SFILES = \ | ||
125 | $(srcdir)/../gdb/nat/linux-namespaces.c \ | ||
126 | $(srcdir)/../gdb/nat/linux-osdata.c \ | ||
127 | $(srcdir)/../gdb/nat/linux-personality.c \ | ||
128 | - $(srcdir)/../gdb/nat/microblaze-linux.c \ | ||
129 | $(srcdir)/../gdb/nat/mips-linux-watch.c \ | ||
130 | $(srcdir)/../gdb/nat/ppc-linux.c \ | ||
131 | $(srcdir)/../gdb/nat/riscv-linux-tdesc.c \ | ||
132 | @@ -564,8 +563,6 @@ target/%.o: ../gdb/target/%.c | ||
133 | |||
134 | %-generated.cc: ../gdb/regformats/rs6000/%.dat $(regdat_sh) | ||
135 | $(ECHO_REGDAT) $(SHELL) $(regdat_sh) $< $@ | ||
136 | -microblaze-linux.c : $(srcdir)/../regformats/reg-microblaze.dat $(regdat_sh) | ||
137 | - $(ECHO_REGDAT) $(SHELL) $(regdat_sh) $(srcdir)/../regformats/reg-microblaze.dat microblaze-linux.c | ||
138 | |||
139 | # | ||
140 | # Dependency tracking. | ||
141 | diff --git a/gdbserver/configure.srv b/gdbserver/configure.srv | ||
142 | index af10cb05683..026b156bd60 100644 | ||
143 | --- a/gdbserver/configure.srv | ||
144 | +++ b/gdbserver/configure.srv | ||
145 | @@ -169,6 +169,7 @@ case "${gdbserver_host}" in | ||
146 | microblaze*-*-linux*) srv_regobj="microblaze-linux.o" | ||
147 | srv_tgtobj="$srv_linux_obj linux-microblaze-low.o " | ||
148 | srv_xmlfiles="microblaze-linux.xml" | ||
149 | + srv_xmlfiles="${srv_xmlfiles} microblaze-core.xml" | ||
150 | srv_linux_regsets=yes | ||
151 | srv_linux_usrregs=yes | ||
152 | srv_linux_thread_db=yes | ||
153 | diff --git a/gdbserver/linux-microblaze-low.c b/gdbserver/linux-microblaze-low.cc | ||
154 | similarity index 72% | ||
155 | rename from gdbserver/linux-microblaze-low.c | ||
156 | rename to gdbserver/linux-microblaze-low.cc | ||
157 | index a2733f3c21c..d30fa102b5e 100644 | ||
158 | --- a/gdbserver/linux-microblaze-low.c | ||
159 | +++ b/gdbserver/linux-microblaze-low.cc | ||
160 | @@ -20,12 +20,17 @@ | ||
161 | #include "server.h" | ||
162 | #include "linux-low.h" | ||
163 | |||
164 | +#include "elf/common.h" | ||
165 | +#include "nat/gdb_ptrace.h" | ||
166 | +#include <endian.h> | ||
167 | + | ||
168 | #include <asm/ptrace.h> | ||
169 | #include <sys/procfs.h> | ||
170 | #include <sys/ptrace.h> | ||
171 | |||
172 | #include "gdb_proc_service.h" | ||
173 | |||
174 | + | ||
175 | static int microblaze_regmap[] = | ||
176 | {PT_GPR(0), PT_GPR(1), PT_GPR(2), PT_GPR(3), | ||
177 | PT_GPR(4), PT_GPR(5), PT_GPR(6), PT_GPR(7), | ||
178 | @@ -39,14 +44,46 @@ static int microblaze_regmap[] = | ||
179 | PT_FSR | ||
180 | }; | ||
181 | |||
182 | + | ||
183 | + | ||
184 | +class microblaze_target : public linux_process_target | ||
185 | +{ | ||
186 | +public: | ||
187 | + | ||
188 | + const regs_info *get_regs_info () override; | ||
189 | + | ||
190 | + const gdb_byte *sw_breakpoint_from_kind (int kind, int *size) override; | ||
191 | + // CORE_ADDR microblaze_reinsert_addr (regcache *regcache); | ||
192 | + | ||
193 | +protected: | ||
194 | + | ||
195 | + void low_arch_setup () override; | ||
196 | + | ||
197 | + bool low_cannot_fetch_register (int regno) override; | ||
198 | + | ||
199 | + bool low_cannot_store_register (int regno) override; | ||
200 | + | ||
201 | + // bool low_supports_breakpoints () override; | ||
202 | + | ||
203 | + CORE_ADDR low_get_pc (regcache *regcache) override; | ||
204 | + | ||
205 | + void low_set_pc (regcache *regcache, CORE_ADDR newpc) override; | ||
206 | + | ||
207 | + bool low_breakpoint_at (CORE_ADDR pc) override; | ||
208 | +}; | ||
209 | + | ||
210 | +/* The singleton target ops object. */ | ||
211 | + | ||
212 | +static microblaze_target the_microblaze_target; | ||
213 | + | ||
214 | #define microblaze_num_regs (sizeof (microblaze_regmap) / sizeof (microblaze_regmap[0])) | ||
215 | |||
216 | /* Defined in auto-generated file microblaze-linux.c. */ | ||
217 | -void init_registers_microblaze (void); | ||
218 | -extern const struct target_desc *tdesc_microblaze; | ||
219 | +void init_registers_microblaze_linux (void); | ||
220 | +extern const struct target_desc *tdesc_microblaze_linux; | ||
221 | |||
222 | -static int | ||
223 | -microblaze_cannot_store_register (int regno) | ||
224 | +bool | ||
225 | +microblaze_target::low_cannot_store_register (int regno) | ||
226 | { | ||
227 | if (microblaze_regmap[regno] == -1 || regno == 0) | ||
228 | return 1; | ||
229 | @@ -54,14 +91,14 @@ microblaze_cannot_store_register (int regno) | ||
230 | return 0; | ||
231 | } | ||
232 | |||
233 | -static int | ||
234 | -microblaze_cannot_fetch_register (int regno) | ||
235 | +bool | ||
236 | +microblaze_target::low_cannot_fetch_register (int regno) | ||
237 | { | ||
238 | return 0; | ||
239 | } | ||
240 | |||
241 | -static CORE_ADDR | ||
242 | -microblaze_get_pc (struct regcache *regcache) | ||
243 | +CORE_ADDR | ||
244 | +microblaze_target::low_get_pc (struct regcache *regcache) | ||
245 | { | ||
246 | unsigned long pc; | ||
247 | |||
248 | @@ -69,8 +106,8 @@ microblaze_get_pc (struct regcache *regcache) | ||
249 | return (CORE_ADDR) pc; | ||
250 | } | ||
251 | |||
252 | -static void | ||
253 | -microblaze_set_pc (struct regcache *regcache, CORE_ADDR pc) | ||
254 | +void | ||
255 | +microblaze_target::low_set_pc (struct regcache *regcache, CORE_ADDR pc) | ||
256 | { | ||
257 | unsigned long newpc = pc; | ||
258 | |||
259 | @@ -84,34 +121,35 @@ static const unsigned long microblaze_breakpoint = 0xba0c0018; | ||
260 | |||
261 | /* Implementation of linux_target_ops method "sw_breakpoint_from_kind". */ | ||
262 | |||
263 | -static const gdb_byte * | ||
264 | -microblaze_sw_breakpoint_from_kind (int kind, int *size) | ||
265 | +const gdb_byte * | ||
266 | +microblaze_target::sw_breakpoint_from_kind (int kind, int *size) | ||
267 | { | ||
268 | *size = microblaze_breakpoint_len; | ||
269 | return (const gdb_byte *) µblaze_breakpoint; | ||
270 | } | ||
271 | |||
272 | -static int | ||
273 | -microblaze_breakpoint_at (CORE_ADDR where) | ||
274 | +bool | ||
275 | +microblaze_target::low_breakpoint_at (CORE_ADDR where) | ||
276 | { | ||
277 | unsigned long insn; | ||
278 | |||
279 | - (*the_target->read_memory) (where, (unsigned char *) &insn, 4); | ||
280 | + read_memory (where, (unsigned char *) &insn, 4); | ||
281 | if (insn == microblaze_breakpoint) | ||
282 | return 1; | ||
283 | /* If necessary, recognize more trap instructions here. GDB only uses the | ||
284 | one. */ | ||
285 | return 0; | ||
286 | } | ||
287 | - | ||
288 | -static CORE_ADDR | ||
289 | -microblaze_reinsert_addr (struct regcache *regcache) | ||
290 | +#if 0 | ||
291 | +CORE_ADDR | ||
292 | +microblaze_target::microblaze_reinsert_addr (struct regcache *regcache) | ||
293 | { | ||
294 | unsigned long pc; | ||
295 | collect_register_by_name (regcache, "r15", &pc); | ||
296 | return pc; | ||
297 | } | ||
298 | - | ||
299 | +#endif | ||
300 | +#if 0 | ||
301 | #ifdef HAVE_PTRACE_GETREGS | ||
302 | |||
303 | static void | ||
304 | @@ -166,12 +204,15 @@ microblaze_store_gregset (struct regcache *regcache, const void *buf) | ||
305 | } | ||
306 | |||
307 | #endif /* HAVE_PTRACE_GETREGS */ | ||
308 | +#endif | ||
309 | |||
310 | static struct regset_info microblaze_regsets[] = { | ||
311 | +#if 0 | ||
312 | #ifdef HAVE_PTRACE_GETREGS | ||
313 | { PTRACE_GETREGS, PTRACE_SETREGS, 0, sizeof (elf_gregset_t), GENERAL_REGS, microblaze_fill_gregset, microblaze_store_gregset }, | ||
314 | { 0, 0, 0, -1, GENERAL_REGS, NULL, NULL }, | ||
315 | #endif /* HAVE_PTRACE_GETREGS */ | ||
316 | +#endif | ||
317 | { 0, 0, 0, -1, GENERAL_REGS, NULL, NULL }, | ||
318 | NULL_REGSET | ||
319 | }; | ||
320 | @@ -189,17 +230,17 @@ static struct regsets_info microblaze_regsets_info = | ||
321 | NULL, /* disabled_regsets */ | ||
322 | }; | ||
323 | |||
324 | -static struct regs_info regs_info = | ||
325 | +static struct regs_info microblaze_regs_info = | ||
326 | { | ||
327 | NULL, /* regset_bitmap */ | ||
328 | µblaze_usrregs_info, | ||
329 | µblaze_regsets_info | ||
330 | }; | ||
331 | |||
332 | -static const struct regs_info * | ||
333 | -microblaze_regs_info (void) | ||
334 | +const regs_info * | ||
335 | +microblaze_target::get_regs_info (void) | ||
336 | { | ||
337 | - return ®s_info; | ||
338 | + return µblaze_regs_info; | ||
339 | } | ||
340 | |||
341 | /* Support for hardware single step. */ | ||
342 | @@ -211,50 +252,17 @@ microblaze_supports_hardware_single_step (void) | ||
343 | } | ||
344 | |||
345 | |||
346 | -static void | ||
347 | -microblaze_arch_setup (void) | ||
348 | +void | ||
349 | +microblaze_target::low_arch_setup (void) | ||
350 | { | ||
351 | - current_process ()->tdesc = tdesc_microblaze; | ||
352 | + current_process ()->tdesc = tdesc_microblaze_linux; | ||
353 | } | ||
354 | |||
355 | -struct linux_target_ops the_low_target = { | ||
356 | - microblaze_arch_setup, | ||
357 | - microblaze_regs_info, | ||
358 | - microblaze_cannot_fetch_register, | ||
359 | - microblaze_cannot_store_register, | ||
360 | - NULL, /* fetch_register */ | ||
361 | - microblaze_get_pc, | ||
362 | - microblaze_set_pc, | ||
363 | - NULL, | ||
364 | - microblaze_sw_breakpoint_from_kind, | ||
365 | - NULL, | ||
366 | - 0, | ||
367 | - microblaze_breakpoint_at, | ||
368 | - NULL, | ||
369 | - NULL, | ||
370 | - NULL, | ||
371 | - NULL, | ||
372 | - NULL, | ||
373 | - microblaze_collect_ptrace_register, | ||
374 | - microblaze_supply_ptrace_register, | ||
375 | - NULL, /* siginfo_fixup */ | ||
376 | - NULL, /* new_process */ | ||
377 | - NULL, /* new_thread */ | ||
378 | - NULL, /* new_fork */ | ||
379 | - NULL, /* prepare_to_resume */ | ||
380 | - NULL, /* process_qsupported */ | ||
381 | - NULL, /* supports_tracepoints */ | ||
382 | - NULL, /* get_thread_area */ | ||
383 | - NULL, /* install_fast_tracepoint_jump_pad */ | ||
384 | - NULL, /* emit_ops */ | ||
385 | - NULL, /* get_min_fast_tracepoint_insn_len */ | ||
386 | - NULL, /* supports_range_stepping */ | ||
387 | - NULL, /* breakpoint_kind_from_current_state */ | ||
388 | - microblaze_supports_hardware_single_step, | ||
389 | -}; | ||
390 | +linux_process_target *the_linux_target = &the_microblaze_target; | ||
391 | |||
392 | void | ||
393 | initialize_low_arch (void) | ||
394 | { | ||
395 | - init_registers_microblaze (); | ||
396 | + init_registers_microblaze_linux (); | ||
397 | + initialize_regsets_info (µblaze_regsets_info); | ||
398 | } | ||
399 | -- | ||
400 | 2.17.1 | ||
401 | |||