GDBserver

linux-tic6x-low.c
Go to the documentation of this file.
1 /* Target dependent code for GDB on TI C6x systems.
2
3 Copyright (C) 2010-2018 Free Software Foundation, Inc.
4 Contributed by Andrew Jenner <andrew@codesourcery.com>
5 Contributed by Yao Qi <yao@codesourcery.com>
6
7 This file is part of GDB.
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21
22 #include "server.h"
23 #include "linux-low.h"
24 #include "arch/tic6x.h"
25 #include "tdesc.h"
26
27 #include "nat/gdb_ptrace.h"
28 #include <endian.h>
29
30 #include "gdb_proc_service.h"
31
32 #ifndef PTRACE_GET_THREAD_AREA
33 #define PTRACE_GET_THREAD_AREA 25
34 #endif
35
36 /* There are at most 69 registers accessible in ptrace. */
37 #define TIC6X_NUM_REGS 69
38
39 #include <asm/ptrace.h>
40
41 /* Defined in auto-generated file tic6x-c64xp-linux.c. */
42 void init_registers_tic6x_c64xp_linux (void);
43 extern const struct target_desc *tdesc_tic6x_c64xp_linux;
44
45 /* Defined in auto-generated file tic6x-c64x-linux.c. */
46 void init_registers_tic6x_c64x_linux (void);
47 extern const struct target_desc *tdesc_tic6x_c64x_linux;
48
49 /* Defined in auto-generated file tic62x-c6xp-linux.c. */
50 void init_registers_tic6x_c62x_linux (void);
51 extern const struct target_desc *tdesc_tic6x_c62x_linux;
52
53 union tic6x_register
54 {
55 unsigned char buf[4];
56
57 int reg32;
58 };
59
60 /* Return the ptrace ``address'' of register REGNO. */
61
62 #if __BYTE_ORDER == __BIG_ENDIAN
63 static int tic6x_regmap_c64xp[] = {
64 /* A0 - A15 */
65 53, 52, 55, 54, 57, 56, 59, 58,
66 61, 60, 63, 62, 65, 64, 67, 66,
67 /* B0 - B15 */
68 23, 22, 25, 24, 27, 26, 29, 28,
69 31, 30, 33, 32, 35, 34, 69, 68,
70 /* CSR PC */
71 5, 4,
72 /* A16 - A31 */
73 37, 36, 39, 38, 41, 40, 43, 42,
74 45, 44, 47, 46, 49, 48, 51, 50,
75 /* B16 - B31 */
76 7, 6, 9, 8, 11, 10, 13, 12,
77 15, 14, 17, 16, 19, 18, 21, 20,
78 /* TSR, ILC, RILC */
79 1, 2, 3
80 };
81
82 static int tic6x_regmap_c64x[] = {
83 /* A0 - A15 */
84 51, 50, 53, 52, 55, 54, 57, 56,
85 59, 58, 61, 60, 63, 62, 65, 64,
86 /* B0 - B15 */
87 21, 20, 23, 22, 25, 24, 27, 26,
88 29, 28, 31, 30, 33, 32, 67, 66,
89 /* CSR PC */
90 3, 2,
91 /* A16 - A31 */
92 35, 34, 37, 36, 39, 38, 41, 40,
93 43, 42, 45, 44, 47, 46, 49, 48,
94 /* B16 - B31 */
95 5, 4, 7, 6, 9, 8, 11, 10,
96 13, 12, 15, 14, 17, 16, 19, 18,
97 -1, -1, -1
98 };
99
100 static int tic6x_regmap_c62x[] = {
101 /* A0 - A15 */
102 19, 18, 21, 20, 23, 22, 25, 24,
103 27, 26, 29, 28, 31, 30, 33, 32,
104 /* B0 - B15 */
105 5, 4, 7, 6, 9, 8, 11, 10,
106 13, 12, 15, 14, 17, 16, 35, 34,
107 /* CSR, PC */
108 3, 2,
109 -1, -1, -1, -1, -1, -1, -1, -1,
110 -1, -1, -1, -1, -1, -1, -1, -1,
111 -1, -1, -1, -1, -1, -1, -1, -1,
112 -1, -1, -1, -1, -1, -1, -1, -1,
113 -1, -1, -1
114 };
115
116 #else
117 static int tic6x_regmap_c64xp[] = {
118 /* A0 - A15 */
119 52, 53, 54, 55, 56, 57, 58, 59,
120 60, 61, 62, 63, 64, 65, 66, 67,
121 /* B0 - B15 */
122 22, 23, 24, 25, 26, 27, 28, 29,
123 30, 31, 32, 33, 34, 35, 68, 69,
124 /* CSR PC */
125 4, 5,
126 /* A16 - A31 */
127 36, 37, 38, 39, 40, 41, 42, 43,
128 44, 45, 46, 47, 48, 49, 50, 51,
129 /* B16 -B31 */
130 6, 7, 8, 9, 10, 11, 12, 13,
131 14, 15, 16, 17, 18, 19, 20, 31,
132 /* TSR, ILC, RILC */
133 0, 3, 2
134 };
135
136 static int tic6x_regmap_c64x[] = {
137 /* A0 - A15 */
138 50, 51, 52, 53, 54, 55, 56, 57,
139 58, 59, 60, 61, 62, 63, 64, 65,
140 /* B0 - B15 */
141 20, 21, 22, 23, 24, 25, 26, 27,
142 28, 29, 30, 31, 32, 33, 66, 67,
143 /* CSR PC */
144 2, 3,
145 /* A16 - A31 */
146 34, 35, 36, 37, 38, 39, 40, 41,
147 42, 43, 44, 45, 46, 47, 48, 49,
148 /* B16 - B31 */
149 4, 5, 6, 7, 8, 9, 10, 11,
150 12, 13, 14, 15, 16, 17, 18, 19,
151 -1, -1, -1
152 };
153
154 static int tic6x_regmap_c62x[] = {
155 /* A0 - A15 */
156 18, 19, 20, 21, 22, 23, 24, 25,
157 26, 27, 28, 29, 30, 31, 32, 33,
158 /* B0 - B15 */
159 4, 5, 6, 7, 8, 9, 10, 11,
160 12, 13, 14, 15, 16, 17, 34, 35,
161 /* CSR PC */
162 2, 3,
163 -1, -1, -1, -1, -1, -1, -1, -1,
164 -1, -1, -1, -1, -1, -1, -1, -1,
165 -1, -1, -1, -1, -1, -1, -1, -1,
166 -1, -1, -1, -1, -1, -1, -1, -1,
167 -1, -1, -1
168 };
169
170 #endif
171
172 extern struct linux_target_ops the_low_target;
173
174 static int *tic6x_regmap;
175 static unsigned int tic6x_breakpoint;
176 #define tic6x_breakpoint_len 4
177
178 /* Implementation of linux_target_ops method "sw_breakpoint_from_kind". */
179
180 static const gdb_byte *
181 tic6x_sw_breakpoint_from_kind (int kind, int *size)
182 {
183 *size = tic6x_breakpoint_len;
184 return (const gdb_byte *) &tic6x_breakpoint;
185 }
186
187 static struct usrregs_info tic6x_usrregs_info =
188 {
189 TIC6X_NUM_REGS,
190 NULL, /* Set in tic6x_read_description. */
191 };
192
193 static const struct target_desc *
194 tic6x_read_description (enum c6x_feature feature)
195 {
196 static target_desc *tdescs[C6X_LAST] = { };
197 struct target_desc **tdesc = &tdescs[feature];
198
199 if (*tdesc == NULL)
200 {
201 *tdesc = tic6x_create_target_description (feature);
202 init_target_desc (*tdesc);
203
204 static const char *expedite_regs[] = { "A15", "PC", NULL };
205 (*tdesc)->expedite_regs = expedite_regs;
206 }
207
208 return *tdesc;
209 }
210
211 static int
212 tic6x_cannot_fetch_register (int regno)
213 {
214 return (tic6x_regmap[regno] == -1);
215 }
216
217 static int
218 tic6x_cannot_store_register (int regno)
219 {
220 return (tic6x_regmap[regno] == -1);
221 }
222
223 static CORE_ADDR
224 tic6x_get_pc (struct regcache *regcache)
225 {
226 union tic6x_register pc;
227
228 collect_register_by_name (regcache, "PC", pc.buf);
229 return pc.reg32;
230 }
231
232 static void
233 tic6x_set_pc (struct regcache *regcache, CORE_ADDR pc)
234 {
235 union tic6x_register newpc;
236
237 newpc.reg32 = pc;
238 supply_register_by_name (regcache, "PC", newpc.buf);
239 }
240
241 static int
242 tic6x_breakpoint_at (CORE_ADDR where)
243 {
244 unsigned int insn;
245
246 (*the_target->read_memory) (where, (unsigned char *) &insn, 4);
247 if (insn == tic6x_breakpoint)
248 return 1;
249
250 /* If necessary, recognize more trap instructions here. GDB only uses the
251 one. */
252 return 0;
253 }
254
255 /* Fetch the thread-local storage pointer for libthread_db. */
256
257 ps_err_e
258 ps_get_thread_area (struct ps_prochandle *ph,
259 lwpid_t lwpid, int idx, void **base)
260 {
261 if (ptrace (PTRACE_GET_THREAD_AREA, lwpid, NULL, base) != 0)
262 return PS_ERR;
263
264 /* IDX is the bias from the thread pointer to the beginning of the
265 thread descriptor. It has to be subtracted due to implementation
266 quirks in libthread_db. */
267 *base = (void *) ((char *) *base - idx);
268
269 return PS_OK;
270 }
271
272 static void
273 tic6x_collect_register (struct regcache *regcache, int regno,
274 union tic6x_register *reg)
275 {
276 union tic6x_register tmp_reg;
277
278 collect_register (regcache, regno, &tmp_reg.reg32);
279 reg->reg32 = tmp_reg.reg32;
280 }
281
282 static void
283 tic6x_supply_register (struct regcache *regcache, int regno,
284 const union tic6x_register *reg)
285 {
286 int offset = 0;
287
288 supply_register (regcache, regno, reg->buf + offset);
289 }
290
291 static void
292 tic6x_fill_gregset (struct regcache *regcache, void *buf)
293 {
294 auto regset = static_cast<union tic6x_register *> (buf);
295 int i;
296
297 for (i = 0; i < TIC6X_NUM_REGS; i++)
298 if (tic6x_regmap[i] != -1)
299 tic6x_collect_register (regcache, i, regset + tic6x_regmap[i]);
300 }
301
302 static void
303 tic6x_store_gregset (struct regcache *regcache, const void *buf)
304 {
305 const auto regset = static_cast<const union tic6x_register *> (buf);
306 int i;
307
308 for (i = 0; i < TIC6X_NUM_REGS; i++)
309 if (tic6x_regmap[i] != -1)
310 tic6x_supply_register (regcache, i, regset + tic6x_regmap[i]);
311 }
312
313 static struct regset_info tic6x_regsets[] = {
314 { PTRACE_GETREGS, PTRACE_SETREGS, 0, TIC6X_NUM_REGS * 4, GENERAL_REGS,
315 tic6x_fill_gregset, tic6x_store_gregset },
316 NULL_REGSET
317 };
318
319 static void
320 tic6x_arch_setup (void)
321 {
322 register unsigned int csr asm ("B2");
323 unsigned int cpuid;
324 enum c6x_feature feature = C6X_CORE;
325
326 /* Determine the CPU we're running on to find the register order. */
327 __asm__ ("MVC .S2 CSR,%0" : "=r" (csr) :);
328 cpuid = csr >> 24;
329 switch (cpuid)
330 {
331 case 0x00: /* C62x */
332 case 0x02: /* C67x */
333 tic6x_regmap = tic6x_regmap_c62x;
334 tic6x_breakpoint = 0x0000a122; /* BNOP .S2 0,5 */
335 feature = C6X_CORE;
336 break;
337 case 0x03: /* C67x+ */
338 tic6x_regmap = tic6x_regmap_c64x;
339 tic6x_breakpoint = 0x0000a122; /* BNOP .S2 0,5 */
340 feature = C6X_GP;
341 break;
342 case 0x0c: /* C64x */
343 tic6x_regmap = tic6x_regmap_c64x;
344 tic6x_breakpoint = 0x0000a122; /* BNOP .S2 0,5 */
345 feature = C6X_GP;
346 break;
347 case 0x10: /* C64x+ */
348 case 0x14: /* C674x */
349 case 0x15: /* C66x */
350 tic6x_regmap = tic6x_regmap_c64xp;
351 tic6x_breakpoint = 0x56454314; /* illegal opcode */
352 feature = C6X_C6XP;
353 break;
354 default:
355 error ("Unknown CPU ID 0x%02x", cpuid);
356 }
357 tic6x_usrregs_info.regmap = tic6x_regmap;
358
359 current_process ()->tdesc = tic6x_read_description (feature);
360 }
361
362 /* Support for hardware single step. */
363
364 static int
365 tic6x_supports_hardware_single_step (void)
366 {
367 return 1;
368 }
369
370 static struct regsets_info tic6x_regsets_info =
371 {
372 tic6x_regsets, /* regsets */
373 0, /* num_regsets */
374 NULL, /* disabled_regsets */
375 };
376
377 static struct regs_info regs_info =
378 {
379 NULL, /* regset_bitmap */
380 &tic6x_usrregs_info,
381 &tic6x_regsets_info
382 };
383
384 static const struct regs_info *
385 tic6x_regs_info (void)
386 {
387 return &regs_info;
388 }
389
390 struct linux_target_ops the_low_target = {
391 tic6x_arch_setup,
392 tic6x_regs_info,
393 tic6x_cannot_fetch_register,
394 tic6x_cannot_store_register,
395 NULL, /* fetch_register */
396 tic6x_get_pc,
397 tic6x_set_pc,
398 NULL, /* breakpoint_kind_from_pc */
399 tic6x_sw_breakpoint_from_kind,
400 NULL,
401 0,
402 tic6x_breakpoint_at,
403 NULL, /* supports_z_point_type */
404 NULL, /* insert_point */
405 NULL, /* remove_point */
406 NULL, /* stopped_by_watchpoint */
407 NULL, /* stopped_data_address */
408 NULL, /* collect_ptrace_register */
409 NULL, /* supply_ptrace_register */
410 NULL, /* siginfo_fixup */
411 NULL, /* new_process */
412 NULL, /* delete_process */
413 NULL, /* new_thread */
414 NULL, /* delete_thread */
415 NULL, /* new_fork */
416 NULL, /* prepare_to_resume */
417 NULL, /* process_qsupported */
418 NULL, /* supports_tracepoints */
419 NULL, /* get_thread_area */
420 NULL, /* install_fast_tracepoint_jump_pad */
421 NULL, /* emit_ops */
422 NULL, /* get_min_fast_tracepoint_insn_len */
423 NULL, /* supports_range_stepping */
424 NULL, /* breakpoint_kind_from_current_state */
425 tic6x_supports_hardware_single_step,
426 };
427
428 #if GDB_SELF_TEST
429 #include "common/selftest.h"
430
431 namespace selftests {
432 namespace tdesc {
433 static void
434 tic6x_tdesc_test ()
435 {
436 SELF_CHECK (*tdesc_tic6x_c62x_linux == *tic6x_read_description (C6X_CORE));
437 SELF_CHECK (*tdesc_tic6x_c64x_linux == *tic6x_read_description (C6X_GP));
438 SELF_CHECK (*tdesc_tic6x_c64xp_linux == *tic6x_read_description (C6X_C6XP));
439 }
440 }
441 }
442 #endif
443
444 void
445 initialize_low_arch (void)
446 {
447 #if GDB_SELF_TEST
448 /* Initialize the Linux target descriptions. */
449 init_registers_tic6x_c64xp_linux ();
450 init_registers_tic6x_c64x_linux ();
451 init_registers_tic6x_c62x_linux ();
452
453 selftests::register_test ("tic6x-tdesc", selftests::tdesc::tic6x_tdesc_test);
454 #endif
455
456 initialize_regsets_info (&tic6x_regsets_info);
457 }
lwpid_t
unsigned int lwpid_t
Definition: gdb_proc_service.h:63
tic6x_fill_gregset
static void tic6x_fill_gregset(struct regcache *regcache, void *buf)
Definition: linux-tic6x-low.c:292
tdesc_tic6x_c64xp_linux
const struct target_desc * tdesc_tic6x_c64xp_linux
collect_register
void collect_register(struct regcache *regcache, int n, void *buf)
Definition: regcache.c:402
tic6x_usrregs_info
static struct usrregs_info tic6x_usrregs_info
Definition: linux-tic6x-low.c:187
CORE_ADDR
bfd_vma CORE_ADDR
Definition: common-types.h:41
supply_register_by_name
void supply_register_by_name(struct regcache *regcache, const char *name, const void *buf)
Definition: regcache.c:393
PTRACE_GET_THREAD_AREA
#define PTRACE_GET_THREAD_AREA
Definition: linux-tic6x-low.c:33
tic6x_cannot_fetch_register
static int tic6x_cannot_fetch_register(int regno)
Definition: linux-tic6x-low.c:212
target_desc::expedite_regs
const char ** expedite_regs
Definition: tdesc.h:45
tic6x_regs_info
static const struct regs_info * tic6x_regs_info(void)
Definition: linux-tic6x-low.c:385
tic6x_collect_register
static void tic6x_collect_register(struct regcache *regcache, int regno, union tic6x_register *reg)
Definition: linux-tic6x-low.c:273
tic6x_regsets
static struct regset_info tic6x_regsets[]
Definition: linux-tic6x-low.c:313
ps_prochandle
Definition: gdb_proc_service.h:150
tic6x_read_description
static const struct target_desc * tic6x_read_description(enum c6x_feature feature)
Definition: linux-tic6x-low.c:194
initialize_low_arch
void initialize_low_arch(void)
Definition: linux-tic6x-low.c:445
ps_err_e
ps_err_e
Definition: gdb_proc_service.h:51
linux_target_ops
Definition: linux-low.h:128
the_target
struct target_ops * the_target
Definition: target.c:24
regs_info
static struct regs_info regs_info
Definition: linux-tic6x-low.c:377
tdesc_tic6x_c64x_linux
const struct target_desc * tdesc_tic6x_c64x_linux
process_info::tdesc
const struct target_desc * tdesc
Definition: inferiors.h:67
tic6x_supply_register
static void tic6x_supply_register(struct regcache *regcache, int regno, const union tic6x_register *reg)
Definition: linux-tic6x-low.c:283
regcache
Definition: regcache.h:31
gdb_proc_service.h
selftests
Definition: linux-aarch64-tdesc-selftest.c:27
tic6x_register::buf
unsigned char buf[4]
Definition: linux-tic6x-low.c:55
ptrace
PTRACE_TYPE_RET ptrace()
tic6x_sw_breakpoint_from_kind
static const gdb_byte * tic6x_sw_breakpoint_from_kind(int kind, int *size)
Definition: linux-tic6x-low.c:181
linux-low.h
collect_register_by_name
void collect_register_by_name(struct regcache *regcache, const char *name, void *buf)
Definition: regcache.c:441
tic6x_regmap_c62x
static int tic6x_regmap_c62x[]
Definition: linux-tic6x-low.c:100
TIC6X_NUM_REGS
#define TIC6X_NUM_REGS
Definition: linux-tic6x-low.c:37
regs_info
Definition: linux-low.h:94
offset
int offset
Definition: tracepoint.c:181
tic6x_regmap
static int * tic6x_regmap
Definition: linux-tic6x-low.c:174
tic6x_store_gregset
static void tic6x_store_gregset(struct regcache *regcache, const void *buf)
Definition: linux-tic6x-low.c:303
tic6x_get_pc
static CORE_ADDR tic6x_get_pc(struct regcache *regcache)
Definition: linux-tic6x-low.c:224
server.h
init_registers_tic6x_c64xp_linux
void init_registers_tic6x_c64xp_linux(void)
tic6x_register::reg32
int reg32
Definition: linux-tic6x-low.c:57
tic6x_supports_hardware_single_step
static int tic6x_supports_hardware_single_step(void)
Definition: linux-tic6x-low.c:365
current_process
struct process_info * current_process(void)
Definition: inferiors.c:210
usrregs_info
Definition: linux-low.h:83
tic6x_breakpoint_len
#define tic6x_breakpoint_len
Definition: linux-tic6x-low.c:176
PS_ERR
Definition: gdb_proc_service.h:54
tic6x_regmap_c64x
static int tic6x_regmap_c64x[]
Definition: linux-tic6x-low.c:82
init_target_desc
void init_target_desc(struct target_desc *tdesc)
Definition: tdesc.c:23
gdb_byte
bfd_byte gdb_byte
Definition: common-types.h:38
target_desc
Definition: tdesc.h:33
tic6x_breakpoint
static unsigned int tic6x_breakpoint
Definition: linux-tic6x-low.c:175
target_ops::read_memory
int(* read_memory)(CORE_ADDR memaddr, unsigned char *myaddr, int len)
Definition: target.h:166
init_registers_tic6x_c62x_linux
void init_registers_tic6x_c62x_linux(void)
tic6x_cannot_store_register
static int tic6x_cannot_store_register(int regno)
Definition: linux-tic6x-low.c:218
PS_OK
Definition: gdb_proc_service.h:53
selftest.h
gdb_ptrace.h
ps_get_thread_area
ps_err_e ps_get_thread_area(struct ps_prochandle *ph, lwpid_t lwpid, int idx, void **base)
Definition: linux-tic6x-low.c:258
tdesc_tic6x_c62x_linux
const struct target_desc * tdesc_tic6x_c62x_linux
tic6x_regmap_c64xp
static int tic6x_regmap_c64xp[]
Definition: linux-tic6x-low.c:63
tic6x_set_pc
static void tic6x_set_pc(struct regcache *regcache, CORE_ADDR pc)
Definition: linux-tic6x-low.c:233
tic6x_breakpoint_at
static int tic6x_breakpoint_at(CORE_ADDR where)
Definition: linux-tic6x-low.c:242
tic6x_register
Definition: linux-tic6x-low.c:53
tic6x_arch_setup
static void tic6x_arch_setup(void)
Definition: linux-tic6x-low.c:320
the_low_target
struct linux_target_ops the_low_target
Definition: linux-tic6x-low.c:390
supply_register
void supply_register(struct regcache *regcache, int n, const void *buf)
Definition: regcache.c:318
usrregs_info::regmap
int * regmap
Definition: linux-low.h:89
tic6x_regsets_info
static struct regsets_info tic6x_regsets_info
Definition: linux-tic6x-low.c:370
selftests::register_test
void register_test(const std::string &name, selftest *test)
Definition: selftest.c:52
error
void error(const char *fmt,...)
Definition: errors.c:38
init_registers_tic6x_c64x_linux
void init_registers_tic6x_c64x_linux(void)
tdesc.h
SELF_CHECK
#define SELF_CHECK(VALUE)
Definition: selftest.h:67