GDB (xrefs)

/tmp/gdb-8.1/gdb/mt-tdep.c
Go to the documentation of this file.
1 /* Target-dependent code for Morpho mt processor, for GDB.
2
3 Copyright (C) 2005-2018 Free Software Foundation, Inc.
4
5 This file is part of GDB.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
19
20 /* Contributed by Michael Snyder, msnyder@redhat.com. */
21
22 #include "defs.h"
23 #include "frame.h"
24 #include "frame-unwind.h"
25 #include "frame-base.h"
26 #include "symtab.h"
27 #include "dis-asm.h"
28 #include "arch-utils.h"
29 #include "gdbtypes.h"
30 #include "regcache.h"
31 #include "reggroups.h"
32 #include "gdbcore.h"
33 #include "trad-frame.h"
34 #include "inferior.h"
35 #include "dwarf2-frame.h"
36 #include "infcall.h"
37 #include "language.h"
38 #include "valprint.h"
39 #include "common/byte-vector.h"
40
41 enum mt_arch_constants
42 {
43 MT_MAX_STRUCT_SIZE = 16
44 };
45
46 enum mt_gdb_regnums
47 {
48 MT_R0_REGNUM, /* 32 bit regs. */
49 MT_R1_REGNUM,
50 MT_1ST_ARGREG = MT_R1_REGNUM,
51 MT_R2_REGNUM,
52 MT_R3_REGNUM,
53 MT_R4_REGNUM,
54 MT_LAST_ARGREG = MT_R4_REGNUM,
55 MT_R5_REGNUM,
56 MT_R6_REGNUM,
57 MT_R7_REGNUM,
58 MT_R8_REGNUM,
59 MT_R9_REGNUM,
60 MT_R10_REGNUM,
61 MT_R11_REGNUM,
62 MT_R12_REGNUM,
63 MT_FP_REGNUM = MT_R12_REGNUM,
64 MT_R13_REGNUM,
65 MT_SP_REGNUM = MT_R13_REGNUM,
66 MT_R14_REGNUM,
67 MT_RA_REGNUM = MT_R14_REGNUM,
68 MT_R15_REGNUM,
69 MT_IRA_REGNUM = MT_R15_REGNUM,
70 MT_PC_REGNUM,
71
72 /* Interrupt Enable pseudo-register, exported by SID. */
73 MT_INT_ENABLE_REGNUM,
74 /* End of CPU regs. */
75
76 MT_NUM_CPU_REGS,
77
78 /* Co-processor registers. */
79 MT_COPRO_REGNUM = MT_NUM_CPU_REGS, /* 16 bit regs. */
80 MT_CPR0_REGNUM,
81 MT_CPR1_REGNUM,
82 MT_CPR2_REGNUM,
83 MT_CPR3_REGNUM,
84 MT_CPR4_REGNUM,
85 MT_CPR5_REGNUM,
86 MT_CPR6_REGNUM,
87 MT_CPR7_REGNUM,
88 MT_CPR8_REGNUM,
89 MT_CPR9_REGNUM,
90 MT_CPR10_REGNUM,
91 MT_CPR11_REGNUM,
92 MT_CPR12_REGNUM,
93 MT_CPR13_REGNUM,
94 MT_CPR14_REGNUM,
95 MT_CPR15_REGNUM,
96 MT_BYPA_REGNUM, /* 32 bit regs. */
97 MT_BYPB_REGNUM,
98 MT_BYPC_REGNUM,
99 MT_FLAG_REGNUM,
100 MT_CONTEXT_REGNUM, /* 38 bits (treat as array of
101 six bytes). */
102 MT_MAC_REGNUM, /* 32 bits. */
103 MT_Z1_REGNUM, /* 16 bits. */
104 MT_Z2_REGNUM, /* 16 bits. */
105 MT_ICHANNEL_REGNUM, /* 32 bits. */
106 MT_ISCRAMB_REGNUM, /* 32 bits. */
107 MT_QSCRAMB_REGNUM, /* 32 bits. */
108 MT_OUT_REGNUM, /* 16 bits. */
109 MT_EXMAC_REGNUM, /* 32 bits (8 used). */
110 MT_QCHANNEL_REGNUM, /* 32 bits. */
111 MT_ZI2_REGNUM, /* 16 bits. */
112 MT_ZQ2_REGNUM, /* 16 bits. */
113 MT_CHANNEL2_REGNUM, /* 32 bits. */
114 MT_ISCRAMB2_REGNUM, /* 32 bits. */
115 MT_QSCRAMB2_REGNUM, /* 32 bits. */
116 MT_QCHANNEL2_REGNUM, /* 32 bits. */
117
118 /* Number of real registers. */
119 MT_NUM_REGS,
120
121 /* Pseudo-registers. */
122 MT_COPRO_PSEUDOREG_REGNUM = MT_NUM_REGS,
123 MT_MAC_PSEUDOREG_REGNUM,
124 MT_COPRO_PSEUDOREG_ARRAY,
125
126 MT_COPRO_PSEUDOREG_DIM_1 = 2,
127 MT_COPRO_PSEUDOREG_DIM_2 = 8,
128 /* The number of pseudo-registers for each coprocessor. These
129 include the real coprocessor registers, the pseudo-registe for
130 the coprocessor number, and the pseudo-register for the MAC. */
131 MT_COPRO_PSEUDOREG_REGS = MT_NUM_REGS - MT_NUM_CPU_REGS + 2,
132 /* The register number of the MAC, relative to a given coprocessor. */
133 MT_COPRO_PSEUDOREG_MAC_REGNUM = MT_COPRO_PSEUDOREG_REGS - 1,
134
135 /* Two pseudo-regs ('coprocessor' and 'mac'). */
136 MT_NUM_PSEUDO_REGS = 2 + (MT_COPRO_PSEUDOREG_REGS
137 * MT_COPRO_PSEUDOREG_DIM_1
138 * MT_COPRO_PSEUDOREG_DIM_2)
139 };
140
141 /* The tdep structure. */
142 struct gdbarch_tdep
143 {
144 /* ISA-specific types. */
145 struct type *copro_type;
146 };
147
148
149 /* Return name of register number specified by REGNUM. */
150
151 static const char *
152 mt_register_name (struct gdbarch *gdbarch, int regnum)
153 {
154 static const char *const register_names[] = {
155 /* CPU regs. */
156 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
157 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
158 "pc", "IE",
159 /* Co-processor regs. */
160 "", /* copro register. */
161 "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",
162 "cr8", "cr9", "cr10", "cr11", "cr12", "cr13", "cr14", "cr15",
163 "bypa", "bypb", "bypc", "flag", "context", "" /* mac. */ , "z1", "z2",
164 "Ichannel", "Iscramb", "Qscramb", "out", "" /* ex-mac. */ , "Qchannel",
165 "zi2", "zq2", "Ichannel2", "Iscramb2", "Qscramb2", "Qchannel2",
166 /* Pseudo-registers. */
167 "coprocessor", "MAC"
168 };
169 static const char *array_names[MT_COPRO_PSEUDOREG_REGS
170 * MT_COPRO_PSEUDOREG_DIM_1
171 * MT_COPRO_PSEUDOREG_DIM_2];
172
173 if (regnum < 0)
174 return "";
175 if (regnum < ARRAY_SIZE (register_names))
176 return register_names[regnum];
177 if (array_names[regnum - MT_COPRO_PSEUDOREG_ARRAY])
178 return array_names[regnum - MT_COPRO_PSEUDOREG_ARRAY];
179
180 {
181 char *name;
182 const char *stub;
183 unsigned dim_1;
184 unsigned dim_2;
185 unsigned index;
186
187 regnum -= MT_COPRO_PSEUDOREG_ARRAY;
188 index = regnum % MT_COPRO_PSEUDOREG_REGS;
189 dim_2 = (regnum / MT_COPRO_PSEUDOREG_REGS) % MT_COPRO_PSEUDOREG_DIM_2;
190 dim_1 = ((regnum / MT_COPRO_PSEUDOREG_REGS / MT_COPRO_PSEUDOREG_DIM_2)
191 % MT_COPRO_PSEUDOREG_DIM_1);
192
193 if (index == MT_COPRO_PSEUDOREG_MAC_REGNUM)
194 stub = register_names[MT_MAC_PSEUDOREG_REGNUM];
195 else if (index >= MT_NUM_REGS - MT_CPR0_REGNUM)
196 stub = "";
197 else
198 stub = register_names[index + MT_CPR0_REGNUM];
199 if (!*stub)
200 {
201 array_names[regnum] = stub;
202 return stub;
203 }
204 name = (char *) xmalloc (30);
205 sprintf (name, "copro_%d_%d_%s", dim_1, dim_2, stub);
206 array_names[regnum] = name;
207 return name;
208 }
209 }
210
211 /* Return the type of a coprocessor register. */
212
213 static struct type *
214 mt_copro_register_type (struct gdbarch *arch, int regnum)
215 {
216 switch (regnum)
217 {
218 case MT_INT_ENABLE_REGNUM:
219 case MT_ICHANNEL_REGNUM:
220 case MT_QCHANNEL_REGNUM:
221 case MT_ISCRAMB_REGNUM:
222 case MT_QSCRAMB_REGNUM:
223 return builtin_type (arch)->builtin_int32;
224 case MT_BYPA_REGNUM:
225 case MT_BYPB_REGNUM:
226 case MT_BYPC_REGNUM:
227 case MT_Z1_REGNUM:
228 case MT_Z2_REGNUM:
229 case MT_OUT_REGNUM:
230 case MT_ZI2_REGNUM:
231 case MT_ZQ2_REGNUM:
232 return builtin_type (arch)->builtin_int16;
233 case MT_EXMAC_REGNUM:
234 case MT_MAC_REGNUM:
235 return builtin_type (arch)->builtin_uint32;
236 case MT_CONTEXT_REGNUM:
237 return builtin_type (arch)->builtin_long_long;
238 case MT_FLAG_REGNUM:
239 return builtin_type (arch)->builtin_unsigned_char;
240 default:
241 if (regnum >= MT_CPR0_REGNUM && regnum <= MT_CPR15_REGNUM)
242 return builtin_type (arch)->builtin_int16;
243 else if (regnum == MT_CPR0_REGNUM + MT_COPRO_PSEUDOREG_MAC_REGNUM)
244 {
245 if (gdbarch_bfd_arch_info (arch)->mach == bfd_mach_mrisc2
246 || gdbarch_bfd_arch_info (arch)->mach == bfd_mach_ms2)
247 return builtin_type (arch)->builtin_uint64;
248 else
249 return builtin_type (arch)->builtin_uint32;
250 }
251 else
252 return builtin_type (arch)->builtin_uint32;
253 }
254 }
255
256 /* Given ARCH and a register number specified by REGNUM, return the
257 type of that register. */
258
259 static struct type *
260 mt_register_type (struct gdbarch *arch, int regnum)
261 {
262 struct gdbarch_tdep *tdep = gdbarch_tdep (arch);
263
264 if (regnum >= 0 && regnum < MT_NUM_REGS + MT_NUM_PSEUDO_REGS)
265 {
266 switch (regnum)
267 {
268 case MT_PC_REGNUM:
269 case MT_RA_REGNUM:
270 case MT_IRA_REGNUM:
271 return builtin_type (arch)->builtin_func_ptr;
272 case MT_SP_REGNUM:
273 case MT_FP_REGNUM:
274 return builtin_type (arch)->builtin_data_ptr;
275 case MT_COPRO_REGNUM:
276 case MT_COPRO_PSEUDOREG_REGNUM:
277 if (tdep->copro_type == NULL)
278 {
279 struct type *elt = builtin_type (arch)->builtin_int16;
280 tdep->copro_type = lookup_array_range_type (elt, 0, 1);
281 }
282 return tdep->copro_type;
283 case MT_MAC_PSEUDOREG_REGNUM:
284 return mt_copro_register_type (arch,
285 MT_CPR0_REGNUM
286 + MT_COPRO_PSEUDOREG_MAC_REGNUM);
287 default:
288 if (regnum >= MT_R0_REGNUM && regnum <= MT_R15_REGNUM)
289 return builtin_type (arch)->builtin_int32;
290 else if (regnum < MT_COPRO_PSEUDOREG_ARRAY)
291 return mt_copro_register_type (arch, regnum);
292 else
293 {
294 regnum -= MT_COPRO_PSEUDOREG_ARRAY;
295 regnum %= MT_COPRO_PSEUDOREG_REGS;
296 regnum += MT_CPR0_REGNUM;
297 return mt_copro_register_type (arch, regnum);
298 }
299 }
300 }
301 internal_error (__FILE__, __LINE__,
302 _("mt_register_type: illegal register number %d"), regnum);
303 }
304
305 /* Return true if register REGNUM is a member of the register group
306 specified by GROUP. */
307
308 static int
309 mt_register_reggroup_p (struct gdbarch *gdbarch, int regnum,
310 struct reggroup *group)
311 {
312 /* Groups of registers that can be displayed via "info reg". */
313 if (group == all_reggroup)
314 return (regnum >= 0
315 && regnum < MT_NUM_REGS + MT_NUM_PSEUDO_REGS
316 && mt_register_name (gdbarch, regnum)[0] != '\0');
317
318 if (group == general_reggroup)
319 return (regnum >= MT_R0_REGNUM && regnum <= MT_R15_REGNUM);
320
321 if (group == float_reggroup)
322 return 0; /* No float regs. */
323
324 if (group == vector_reggroup)
325 return 0; /* No vector regs. */
326
327 /* For any that are not handled above. */
328 return default_register_reggroup_p (gdbarch, regnum, group);
329 }
330
331 /* Return the return value convention used for a given type TYPE.
332 Optionally, fetch or set the return value via READBUF or
333 WRITEBUF respectively using REGCACHE for the register
334 values. */
335
336 static enum return_value_convention
337 mt_return_value (struct gdbarch *gdbarch, struct value *function,
338 struct type *type, struct regcache *regcache,
339 gdb_byte *readbuf, const gdb_byte *writebuf)
340 {
341 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
342
343 if (TYPE_LENGTH (type) > 4)
344 {
345 /* Return values > 4 bytes are returned in memory,
346 pointed to by R11. */
347 if (readbuf)
348 {
349 ULONGEST addr;
350
351 regcache_cooked_read_unsigned (regcache, MT_R11_REGNUM, &addr);
352 read_memory (addr, readbuf, TYPE_LENGTH (type));
353 }
354
355 if (writebuf)
356 {
357 ULONGEST addr;
358
359 regcache_cooked_read_unsigned (regcache, MT_R11_REGNUM, &addr);
360 write_memory (addr, writebuf, TYPE_LENGTH (type));
361 }
362
363 return RETURN_VALUE_ABI_RETURNS_ADDRESS;
364 }
365 else
366 {
367 if (readbuf)
368 {
369 ULONGEST temp;
370
371 /* Return values of <= 4 bytes are returned in R11. */
372 regcache_cooked_read_unsigned (regcache, MT_R11_REGNUM, &temp);
373 store_unsigned_integer (readbuf, TYPE_LENGTH (type),
374 byte_order, temp);
375 }
376
377 if (writebuf)
378 {
379 if (TYPE_LENGTH (type) < 4)
380 {
381 gdb_byte buf[4];
382 /* Add leading zeros to the value. */
383 memset (buf, 0, sizeof (buf));
384 memcpy (buf + sizeof (buf) - TYPE_LENGTH (type),
385 writebuf, TYPE_LENGTH (type));
386 regcache_cooked_write (regcache, MT_R11_REGNUM, buf);
387 }
388 else /* (TYPE_LENGTH (type) == 4 */
389 regcache_cooked_write (regcache, MT_R11_REGNUM, writebuf);
390 }
391
392 return RETURN_VALUE_REGISTER_CONVENTION;
393 }
394 }
395
396 /* If the input address, PC, is in a function prologue, return the
397 address of the end of the prologue, otherwise return the input
398 address.
399
400 Note: PC is likely to be the function start, since this function
401 is mainly used for advancing a breakpoint to the first line, or
402 stepping to the first line when we have stepped into a function
403 call. */
404
405 static CORE_ADDR
406 mt_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
407 {
408 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
409 CORE_ADDR func_addr = 0, func_end = 0;
410 const char *func_name;
411 unsigned long instr;
412
413 if (find_pc_partial_function (pc, &func_name, &func_addr, &func_end))
414 {
415 struct symtab_and_line sal;
416 struct symbol *sym;
417
418 /* Found a function. */
419 sym = lookup_symbol (func_name, NULL, VAR_DOMAIN, NULL).symbol;
420 if (sym && SYMBOL_LANGUAGE (sym) != language_asm)
421 {
422 /* Don't use this trick for assembly source files. */
423 sal = find_pc_line (func_addr, 0);
424
425 if (sal.end && sal.end < func_end)
426 {
427 /* Found a line number, use it as end of prologue. */
428 return sal.end;
429 }
430 }
431 }
432
433 /* No function symbol, or no line symbol. Use prologue scanning method. */
434 for (;; pc += 4)
435 {
436 instr = read_memory_unsigned_integer (pc, 4, byte_order);
437 if (instr == 0x12000000) /* nop */
438 continue;
439 if (instr == 0x12ddc000) /* copy sp into fp */
440 continue;
441 instr >>= 16;
442 if (instr == 0x05dd) /* subi sp, sp, imm */
443 continue;
444 if (instr >= 0x43c0 && instr <= 0x43df) /* push */
445 continue;
446 /* Not an obvious prologue instruction. */
447 break;
448 }
449
450 return pc;
451 }
452
453 /* Implement the breakpoint_kind_from_pc gdbarch method. */
454
455 static int
456 mt_breakpoint_kind_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr)
457 {
458 return 4;
459 }
460
461 /* Implement the sw_breakpoint_from_kind gdbarch method. */
462
463 static const gdb_byte *
464 mt_sw_breakpoint_from_kind (struct gdbarch *gdbarch, int kind, int *size)
465 {
466 /* The breakpoint instruction must be the same size as the smallest
467 instruction in the instruction set.
468
469 The BP for ms1 is defined as 0x68000000 (BREAK).
470 The BP for ms2 is defined as 0x69000000 (illegal). */
471 static gdb_byte ms1_breakpoint[] = { 0x68, 0, 0, 0 };
472 static gdb_byte ms2_breakpoint[] = { 0x69, 0, 0, 0 };
473
474 *size = kind;
475
476 if (gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_ms2)
477 return ms2_breakpoint;
478
479 return ms1_breakpoint;
480 }
481
482 /* Select the correct coprocessor register bank. Return the pseudo
483 regnum we really want to read. */
484
485 static int
486 mt_select_coprocessor (struct gdbarch *gdbarch,
487 struct regcache *regcache, int regno)
488 {
489 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
490 unsigned index, base;
491 gdb_byte copro[4];
492
493 /* Get the copro pseudo regnum. */
494 regcache_raw_read (regcache, MT_COPRO_REGNUM, copro);
495 base = ((extract_signed_integer (&copro[0], 2, byte_order)
496 * MT_COPRO_PSEUDOREG_DIM_2)
497 + extract_signed_integer (&copro[2], 2, byte_order));
498
499 regno -= MT_COPRO_PSEUDOREG_ARRAY;
500 index = regno % MT_COPRO_PSEUDOREG_REGS;
501 regno /= MT_COPRO_PSEUDOREG_REGS;
502 if (base != regno)
503 {
504 /* Select the correct coprocessor register bank. Invalidate the
505 coprocessor register cache. */
506 unsigned ix;
507
508 store_signed_integer (&copro[0], 2, byte_order,
509 regno / MT_COPRO_PSEUDOREG_DIM_2);
510 store_signed_integer (&copro[2], 2, byte_order,
511 regno % MT_COPRO_PSEUDOREG_DIM_2);
512 regcache_raw_write (regcache, MT_COPRO_REGNUM, copro);
513
514 /* We must flush the cache, as it is now invalid. */
515 for (ix = MT_NUM_CPU_REGS; ix != MT_NUM_REGS; ix++)
516 regcache_invalidate (regcache, ix);
517 }
518
519 return index;
520 }
521
522 /* Fetch the pseudo registers:
523
524 There are two regular pseudo-registers:
525 1) The 'coprocessor' pseudo-register (which mirrors the
526 "real" coprocessor register sent by the target), and
527 2) The 'MAC' pseudo-register (which represents the union
528 of the original 32 bit target MAC register and the new
529 8-bit extended-MAC register).
530
531 Additionally there is an array of coprocessor registers which track
532 the coprocessor registers for each coprocessor. */
533
534 static enum register_status
535 mt_pseudo_register_read (struct gdbarch *gdbarch,
536 struct regcache *regcache, int regno, gdb_byte *buf)
537 {
538 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
539
540 switch (regno)
541 {
542 case MT_COPRO_REGNUM:
543 case MT_COPRO_PSEUDOREG_REGNUM:
544 return regcache_raw_read (regcache, MT_COPRO_REGNUM, buf);
545 case MT_MAC_REGNUM:
546 case MT_MAC_PSEUDOREG_REGNUM:
547 if (gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_mrisc2
548 || gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_ms2)
549 {
550 enum register_status status;
551 ULONGEST oldmac = 0, ext_mac = 0;
552 ULONGEST newmac;
553
554 status = regcache_cooked_read_unsigned (regcache, MT_MAC_REGNUM, &oldmac);
555 if (status != REG_VALID)
556 return status;
557
558 regcache_cooked_read_unsigned (regcache, MT_EXMAC_REGNUM, &ext_mac);
559 if (status != REG_VALID)
560 return status;
561
562 newmac =
563 (oldmac & 0xffffffff) | ((long long) (ext_mac & 0xff) << 32);
564 store_signed_integer (buf, 8, byte_order, newmac);
565
566 return REG_VALID;
567 }
568 else
569 return regcache_raw_read (regcache, MT_MAC_REGNUM, buf);
570 break;
571 default:
572 {
573 unsigned index = mt_select_coprocessor (gdbarch, regcache, regno);
574
575 if (index == MT_COPRO_PSEUDOREG_MAC_REGNUM)
576 return mt_pseudo_register_read (gdbarch, regcache,
577 MT_MAC_PSEUDOREG_REGNUM, buf);
578 else if (index < MT_NUM_REGS - MT_CPR0_REGNUM)
579 return regcache_raw_read (regcache, index + MT_CPR0_REGNUM, buf);
580 else
581 /* ??? */
582 return REG_VALID;
583 }
584 break;
585 }
586 }
587
588 /* Write the pseudo registers:
589
590 Mt pseudo-registers are stored directly to the target. The
591 'coprocessor' register is special, because when it is modified, all
592 the other coprocessor regs must be flushed from the reg cache. */
593
594 static void
595 mt_pseudo_register_write (struct gdbarch *gdbarch,
596 struct regcache *regcache,
597 int regno, const gdb_byte *buf)
598 {
599 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
600 int i;
601
602 switch (regno)
603 {
604 case MT_COPRO_REGNUM:
605 case MT_COPRO_PSEUDOREG_REGNUM:
606 regcache_raw_write (regcache, MT_COPRO_REGNUM, buf);
607 for (i = MT_NUM_CPU_REGS; i < MT_NUM_REGS; i++)
608 regcache_invalidate (regcache, i);
609 break;
610 case MT_MAC_REGNUM:
611 case MT_MAC_PSEUDOREG_REGNUM:
612 if (gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_mrisc2
613 || gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_ms2)
614 {
615 /* The 8-byte MAC pseudo-register must be broken down into two
616 32-byte registers. */
617 unsigned int oldmac, ext_mac;
618 ULONGEST newmac;
619
620 newmac = extract_unsigned_integer (buf, 8, byte_order);
621 oldmac = newmac & 0xffffffff;
622 ext_mac = (newmac >> 32) & 0xff;
623 regcache_cooked_write_unsigned (regcache, MT_MAC_REGNUM, oldmac);
624 regcache_cooked_write_unsigned (regcache, MT_EXMAC_REGNUM, ext_mac);
625 }
626 else
627 regcache_raw_write (regcache, MT_MAC_REGNUM, buf);
628 break;
629 default:
630 {
631 unsigned index = mt_select_coprocessor (gdbarch, regcache, regno);
632
633 if (index == MT_COPRO_PSEUDOREG_MAC_REGNUM)
634 mt_pseudo_register_write (gdbarch, regcache,
635 MT_MAC_PSEUDOREG_REGNUM, buf);
636 else if (index < MT_NUM_REGS - MT_CPR0_REGNUM)
637 regcache_raw_write (regcache, index + MT_CPR0_REGNUM, buf);
638 }
639 break;
640 }
641 }
642
643 static CORE_ADDR
644 mt_frame_align (struct gdbarch *gdbarch, CORE_ADDR sp)
645 {
646 /* Register size is 4 bytes. */
647 return align_down (sp, 4);
648 }
649
650 /* Implements the "info registers" command. When ``all'' is non-zero,
651 the coprocessor registers will be printed in addition to the rest
652 of the registers. */
653
654 static void
655 mt_registers_info (struct gdbarch *gdbarch,
656 struct ui_file *file,
657 struct frame_info *frame, int regnum, int all)
658 {
659 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
660
661 if (regnum == -1)
662 {
663 int lim;
664
665 lim = all ? MT_NUM_REGS : MT_NUM_CPU_REGS;
666
667 for (regnum = 0; regnum < lim; regnum++)
668 {
669 /* Don't display the Qchannel register since it will be displayed
670 along with Ichannel. (See below.) */
671 if (regnum == MT_QCHANNEL_REGNUM)
672 continue;
673
674 mt_registers_info (gdbarch, file, frame, regnum, all);
675
676 /* Display the Qchannel register immediately after Ichannel. */
677 if (regnum == MT_ICHANNEL_REGNUM)
678 mt_registers_info (gdbarch, file, frame, MT_QCHANNEL_REGNUM, all);
679 }
680 }
681 else
682 {
683 if (regnum == MT_EXMAC_REGNUM)
684 return;
685 else if (regnum == MT_CONTEXT_REGNUM)
686 {
687 /* Special output handling for 38-bit context register. */
688 unsigned char *buff;
689 unsigned int i, regsize;
690
691 regsize = register_size (gdbarch, regnum);
692
693 buff = (unsigned char *) alloca (regsize);
694
695 deprecated_frame_register_read (frame, regnum, buff);
696
697 fputs_filtered (gdbarch_register_name
698 (gdbarch, regnum), file);
699 print_spaces_filtered (15 - strlen (gdbarch_register_name
700 (gdbarch, regnum)),
701 file);
702 fputs_filtered ("0x", file);
703
704 for (i = 0; i < regsize; i++)
705 fprintf_filtered (file, "%02x", (unsigned int)
706 extract_unsigned_integer (buff + i, 1, byte_order));
707 fputs_filtered ("\t", file);
708 print_longest (file, 'd', 0,
709 extract_unsigned_integer (buff, regsize, byte_order));
710 fputs_filtered ("\n", file);
711 }
712 else if (regnum == MT_COPRO_REGNUM
713 || regnum == MT_COPRO_PSEUDOREG_REGNUM)
714 {
715 /* Special output handling for the 'coprocessor' register. */
716 struct value_print_options opts;
717 struct value *val;
718
719 val = get_frame_register_value (frame, MT_COPRO_REGNUM);
720 /* And print. */
721 regnum = MT_COPRO_PSEUDOREG_REGNUM;
722 fputs_filtered (gdbarch_register_name (gdbarch, regnum),
723 file);
724 print_spaces_filtered (15 - strlen (gdbarch_register_name
725 (gdbarch, regnum)),
726 file);
727 get_no_prettyformat_print_options (&opts);
728 opts.deref_ref = 1;
729 val_print (register_type (gdbarch, regnum),
730 0, 0, file, 0, val,
731 &opts, current_language);
732 fputs_filtered ("\n", file);
733 }
734 else if (regnum == MT_MAC_REGNUM || regnum == MT_MAC_PSEUDOREG_REGNUM)
735 {
736 ULONGEST oldmac, ext_mac, newmac;
737 gdb_byte buf[3 * sizeof (LONGEST)];
738
739 /* Get the two "real" mac registers. */
740 deprecated_frame_register_read (frame, MT_MAC_REGNUM, buf);
741 oldmac = extract_unsigned_integer
742 (buf, register_size (gdbarch, MT_MAC_REGNUM), byte_order);
743 if (gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_mrisc2
744 || gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_ms2)
745 {
746 deprecated_frame_register_read (frame, MT_EXMAC_REGNUM, buf);
747 ext_mac = extract_unsigned_integer
748 (buf, register_size (gdbarch, MT_EXMAC_REGNUM), byte_order);
749 }
750 else
751 ext_mac = 0;
752
753 /* Add them together. */
754 newmac = (oldmac & 0xffffffff) + ((ext_mac & 0xff) << 32);
755
756 /* And print. */
757 regnum = MT_MAC_PSEUDOREG_REGNUM;
758 fputs_filtered (gdbarch_register_name (gdbarch, regnum),
759 file);
760 print_spaces_filtered (15 - strlen (gdbarch_register_name
761 (gdbarch, regnum)),
762 file);
763 fputs_filtered ("0x", file);
764 print_longest (file, 'x', 0, newmac);
765 fputs_filtered ("\t", file);
766 print_longest (file, 'u', 0, newmac);
767 fputs_filtered ("\n", file);
768 }
769 else
770 default_print_registers_info (gdbarch, file, frame, regnum, all);
771 }
772 }
773
774 /* Set up the callee's arguments for an inferior function call. The
775 arguments are pushed on the stack or are placed in registers as
776 appropriate. It also sets up the return address (which points to
777 the call dummy breakpoint).
778
779 Returns the updated (and aligned) stack pointer. */
780
781 static CORE_ADDR
782 mt_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
783 struct regcache *regcache, CORE_ADDR bp_addr,
784 int nargs, struct value **args, CORE_ADDR sp,
785 int struct_return, CORE_ADDR struct_addr)
786 {
787 #define wordsize 4
788 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
789 gdb_byte buf[MT_MAX_STRUCT_SIZE];
790 int argreg = MT_1ST_ARGREG;
791 int split_param_len = 0;
792 int stack_dest = sp;
793 int slacklen;
794 int typelen;
795 int i, j;
796
797 /* First handle however many args we can fit into MT_1ST_ARGREG thru
798 MT_LAST_ARGREG. */
799 for (i = 0; i < nargs && argreg <= MT_LAST_ARGREG; i++)
800 {
801 const gdb_byte *val;
802 typelen = TYPE_LENGTH (value_type (args[i]));
803 switch (typelen)
804 {
805 case 1:
806 case 2:
807 case 3:
808 case 4:
809 regcache_cooked_write_unsigned (regcache, argreg++,
810 extract_unsigned_integer
811 (value_contents (args[i]),
812 wordsize, byte_order));
813 break;
814 case 8:
815 case 12:
816 case 16:
817 val = value_contents (args[i]);
818 while (typelen > 0)
819 {
820 if (argreg <= MT_LAST_ARGREG)
821 {
822 /* This word of the argument is passed in a register. */
823 regcache_cooked_write_unsigned (regcache, argreg++,
824 extract_unsigned_integer
825 (val, wordsize, byte_order));
826 typelen -= wordsize;
827 val += wordsize;
828 }
829 else
830 {
831 /* Remainder of this arg must be passed on the stack
832 (deferred to do later). */
833 split_param_len = typelen;
834 memcpy (buf, val, typelen);
835 break; /* No more args can be handled in regs. */
836 }
837 }
838 break;
839 default:
840 /* By reverse engineering of gcc output, args bigger than
841 16 bytes go on the stack, and their address is passed
842 in the argreg. */
843 stack_dest -= typelen;
844 write_memory (stack_dest, value_contents (args[i]), typelen);
845 regcache_cooked_write_unsigned (regcache, argreg++, stack_dest);
846 break;
847 }
848 }
849
850 /* Next, the rest of the arguments go onto the stack, in reverse order. */
851 for (j = nargs - 1; j >= i; j--)
852 {
853 const gdb_byte *contents = value_contents (args[j]);
854
855 /* Right-justify the value in an aligned-length buffer. */
856 typelen = TYPE_LENGTH (value_type (args[j]));
857 slacklen = (wordsize - (typelen % wordsize)) % wordsize;
858 gdb::byte_vector val (typelen + slacklen);
859 memcpy (val.data (), contents, typelen);
860 memset (val.data () + typelen, 0, slacklen);
861 /* Now write this data to the stack. */
862 stack_dest -= typelen + slacklen;
863 write_memory (stack_dest, val.data (), typelen + slacklen);
864 }
865
866 /* Finally, if a param needs to be split between registers and stack,
867 write the second half to the stack now. */
868 if (split_param_len != 0)
869 {
870 stack_dest -= split_param_len;
871 write_memory (stack_dest, buf, split_param_len);
872 }
873
874 /* Set up return address (provided to us as bp_addr). */
875 regcache_cooked_write_unsigned (regcache, MT_RA_REGNUM, bp_addr);
876
877 /* Store struct return address, if given. */
878 if (struct_return && struct_addr != 0)
879 regcache_cooked_write_unsigned (regcache, MT_R11_REGNUM, struct_addr);
880
881 /* Set aside 16 bytes for the callee to save regs 1-4. */
882 stack_dest -= 16;
883
884 /* Update the stack pointer. */
885 regcache_cooked_write_unsigned (regcache, MT_SP_REGNUM, stack_dest);
886
887 /* And that should do it. Return the new stack pointer. */
888 return stack_dest;
889 }
890
891
892 /* The 'unwind_cache' data structure. */
893
894 struct mt_unwind_cache
895 {
896 /* The previous frame's inner most stack address.
897 Used as this frame ID's stack_addr. */
898 CORE_ADDR prev_sp;
899 CORE_ADDR frame_base;
900 int framesize;
901 int frameless_p;
902
903 /* Table indicating the location of each and every register. */
904 struct trad_frame_saved_reg *saved_regs;
905 };
906
907 /* Initialize an unwind_cache. Build up the saved_regs table etc. for
908 the frame. */
909
910 static struct mt_unwind_cache *
911 mt_frame_unwind_cache (struct frame_info *this_frame,
912 void **this_prologue_cache)
913 {
914 struct gdbarch *gdbarch;
915 struct mt_unwind_cache *info;
916 CORE_ADDR next_addr, start_addr, end_addr, prologue_end_addr;
917 unsigned long instr, upper_half, delayed_store = 0;
918 int regnum, offset;
919 ULONGEST sp, fp;
920
921 if ((*this_prologue_cache))
922 return (struct mt_unwind_cache *) (*this_prologue_cache);
923
924 gdbarch = get_frame_arch (this_frame);
925 info = FRAME_OBSTACK_ZALLOC (struct mt_unwind_cache);
926 (*this_prologue_cache) = info;
927
928 info->prev_sp = 0;
929 info->framesize = 0;
930 info->frame_base = 0;
931 info->frameless_p = 1;
932 info->saved_regs = trad_frame_alloc_saved_regs (this_frame);
933
934 /* Grab the frame-relative values of SP and FP, needed below.
935 The frame_saved_register function will find them on the
936 stack or in the registers as appropriate. */
937 sp = get_frame_register_unsigned (this_frame, MT_SP_REGNUM);
938 fp = get_frame_register_unsigned (this_frame, MT_FP_REGNUM);
939
940 start_addr = get_frame_func (this_frame);
941
942 /* Return early if GDB couldn't find the function. */
943 if (start_addr == 0)
944 return info;
945
946 end_addr = get_frame_pc (this_frame);
947 prologue_end_addr = skip_prologue_using_sal (gdbarch, start_addr);
948 if (end_addr == 0)
949 for (next_addr = start_addr; next_addr < end_addr; next_addr += 4)
950 {
951 instr = get_frame_memory_unsigned (this_frame, next_addr, 4);
952 if (delayed_store) /* Previous instr was a push. */
953 {
954 upper_half = delayed_store >> 16;
955 regnum = upper_half & 0xf;
956 offset = delayed_store & 0xffff;
957 switch (upper_half & 0xfff0)
958 {
959 case 0x43c0: /* push using frame pointer. */
960 info->saved_regs[regnum].addr = offset;
961 break;
962 case 0x43d0: /* push using stack pointer. */
963 info->saved_regs[regnum].addr = offset;
964 break;
965 default: /* lint */
966 break;
967 }
968 delayed_store = 0;
969 }
970
971 switch (instr)
972 {
973 case 0x12000000: /* NO-OP */
974 continue;
975 case 0x12ddc000: /* copy sp into fp */
976 info->frameless_p = 0; /* Record that the frame
977 pointer is in use. */
978 continue;
979 default:
980 upper_half = instr >> 16;
981 if (upper_half == 0x05dd || /* subi sp, sp, imm */
982 upper_half == 0x07dd) /* subui sp, sp, imm */
983 {
984 /* Record the frame size. */
985 info->framesize = instr & 0xffff;
986 continue;
987 }
988 if ((upper_half & 0xfff0) == 0x43c0 || /* frame push */
989 (upper_half & 0xfff0) == 0x43d0) /* stack push */
990 {
991 /* Save this instruction, but don't record the
992 pushed register as 'saved' until we see the
993 next instruction. That's because of deferred stores
994 on this target -- GDB won't be able to read the register
995 from the stack until one instruction later. */
996 delayed_store = instr;
997 continue;
998 }
999 /* Not a prologue instruction. Is this the end of the prologue?
1000 This is the most difficult decision; when to stop scanning.
1001
1002 If we have no line symbol, then the best thing we can do
1003 is to stop scanning when we encounter an instruction that
1004 is not likely to be a part of the prologue.
1005
1006 But if we do have a line symbol, then we should
1007 keep scanning until we reach it (or we reach end_addr). */
1008
1009 if (prologue_end_addr && (prologue_end_addr > (next_addr + 4)))
1010 continue; /* Keep scanning, recording saved_regs etc. */
1011 else
1012 break; /* Quit scanning: breakpoint can be set here. */
1013 }
1014 }
1015
1016 /* Special handling for the "saved" address of the SP:
1017 The SP is of course never saved on the stack at all, so
1018 by convention what we put here is simply the previous
1019 _value_ of the SP (as opposed to an address where the
1020 previous value would have been pushed). This will also
1021 give us the frame base address. */
1022
1023 if (info->frameless_p)
1024 {
1025 info->frame_base = sp + info->framesize;
1026 info->prev_sp = sp + info->framesize;
1027 }
1028 else
1029 {
1030 info->frame_base = fp + info->framesize;
1031 info->prev_sp = fp + info->framesize;
1032 }
1033 /* Save prev_sp in saved_regs as a value, not as an address. */
1034 trad_frame_set_value (info->saved_regs, MT_SP_REGNUM, info->prev_sp);
1035
1036 /* Now convert frame offsets to actual addresses (not offsets). */
1037 for (regnum = 0; regnum < MT_NUM_REGS; regnum++)
1038 if (trad_frame_addr_p (info->saved_regs, regnum))
1039 info->saved_regs[regnum].addr += info->frame_base - info->framesize;
1040
1041 /* The call instruction moves the caller's PC in the callee's RA reg.
1042 Since this is an unwind, do the reverse. Copy the location of RA
1043 into PC (the address / regnum) so that a request for PC will be
1044 converted into a request for the RA. */
1045 info->saved_regs[MT_PC_REGNUM] = info->saved_regs[MT_RA_REGNUM];
1046
1047 return info;
1048 }
1049
1050 static CORE_ADDR
1051 mt_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
1052 {
1053 ULONGEST pc;
1054
1055 pc = frame_unwind_register_unsigned (next_frame, MT_PC_REGNUM);
1056 return pc;
1057 }
1058
1059 static CORE_ADDR
1060 mt_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
1061 {
1062 ULONGEST sp;
1063
1064 sp = frame_unwind_register_unsigned (next_frame, MT_SP_REGNUM);
1065 return sp;
1066 }
1067
1068 /* Assuming THIS_FRAME is a dummy, return the frame ID of that dummy
1069 frame. The frame ID's base needs to match the TOS value saved by
1070 save_dummy_frame_tos(), and the PC match the dummy frame's breakpoint. */
1071
1072 static struct frame_id
1073 mt_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
1074 {
1075 CORE_ADDR sp = get_frame_register_unsigned (this_frame, MT_SP_REGNUM);
1076 return frame_id_build (sp, get_frame_pc (this_frame));
1077 }
1078
1079 /* Given a GDB frame, determine the address of the calling function's
1080 frame. This will be used to create a new GDB frame struct. */
1081
1082 static void
1083 mt_frame_this_id (struct frame_info *this_frame,
1084 void **this_prologue_cache, struct frame_id *this_id)
1085 {
1086 struct mt_unwind_cache *info =
1087 mt_frame_unwind_cache (this_frame, this_prologue_cache);
1088
1089 if (!(info == NULL || info->prev_sp == 0))
1090 (*this_id) = frame_id_build (info->prev_sp, get_frame_func (this_frame));
1091
1092 return;
1093 }
1094
1095 static struct value *
1096 mt_frame_prev_register (struct frame_info *this_frame,
1097 void **this_prologue_cache, int regnum)
1098 {
1099 struct mt_unwind_cache *info =
1100 mt_frame_unwind_cache (this_frame, this_prologue_cache);
1101
1102 return trad_frame_get_prev_register (this_frame, info->saved_regs, regnum);
1103 }
1104
1105 static CORE_ADDR
1106 mt_frame_base_address (struct frame_info *this_frame,
1107 void **this_prologue_cache)
1108 {
1109 struct mt_unwind_cache *info =
1110 mt_frame_unwind_cache (this_frame, this_prologue_cache);
1111
1112 return info->frame_base;
1113 }
1114
1115 /* This is a shared interface: the 'frame_unwind' object is what's
1116 returned by the 'sniffer' function, and in turn specifies how to
1117 get a frame's ID and prev_regs.
1118
1119 This exports the 'prev_register' and 'this_id' methods. */
1120
1121 static const struct frame_unwind mt_frame_unwind = {
1122 NORMAL_FRAME,
1123 default_frame_unwind_stop_reason,
1124 mt_frame_this_id,
1125 mt_frame_prev_register,
1126 NULL,
1127 default_frame_sniffer
1128 };
1129
1130 /* Another shared interface: the 'frame_base' object specifies how to
1131 unwind a frame and secure the base addresses for frame objects
1132 (locals, args). */
1133
1134 static struct frame_base mt_frame_base = {
1135 &mt_frame_unwind,
1136 mt_frame_base_address,
1137 mt_frame_base_address,
1138 mt_frame_base_address
1139 };
1140
1141 static struct gdbarch *
1142 mt_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
1143 {
1144 struct gdbarch *gdbarch;
1145 struct gdbarch_tdep *tdep;
1146
1147 /* Find a candidate among the list of pre-declared architectures. */
1148 arches = gdbarch_list_lookup_by_info (arches, &info);
1149 if (arches != NULL)
1150 return arches->gdbarch;
1151
1152 /* None found, create a new architecture from the information
1153 provided. */
1154 tdep = XCNEW (struct gdbarch_tdep);
1155 gdbarch = gdbarch_alloc (&info, tdep);
1156
1157 set_gdbarch_float_format (gdbarch, floatformats_ieee_single);
1158 set_gdbarch_double_format (gdbarch, floatformats_ieee_double);
1159 set_gdbarch_long_double_format (gdbarch, floatformats_ieee_double);
1160
1161 set_gdbarch_register_name (gdbarch, mt_register_name);
1162 set_gdbarch_num_regs (gdbarch, MT_NUM_REGS);
1163 set_gdbarch_num_pseudo_regs (gdbarch, MT_NUM_PSEUDO_REGS);
1164 set_gdbarch_pc_regnum (gdbarch, MT_PC_REGNUM);
1165 set_gdbarch_sp_regnum (gdbarch, MT_SP_REGNUM);
1166 set_gdbarch_pseudo_register_read (gdbarch, mt_pseudo_register_read);
1167 set_gdbarch_pseudo_register_write (gdbarch, mt_pseudo_register_write);
1168 set_gdbarch_skip_prologue (gdbarch, mt_skip_prologue);
1169 set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
1170 set_gdbarch_breakpoint_kind_from_pc (gdbarch, mt_breakpoint_kind_from_pc);
1171 set_gdbarch_sw_breakpoint_from_kind (gdbarch, mt_sw_breakpoint_from_kind);
1172 set_gdbarch_decr_pc_after_break (gdbarch, 0);
1173 set_gdbarch_frame_args_skip (gdbarch, 0);
1174 set_gdbarch_register_type (gdbarch, mt_register_type);
1175 set_gdbarch_register_reggroup_p (gdbarch, mt_register_reggroup_p);
1176
1177 set_gdbarch_return_value (gdbarch, mt_return_value);
1178 set_gdbarch_sp_regnum (gdbarch, MT_SP_REGNUM);
1179
1180 set_gdbarch_frame_align (gdbarch, mt_frame_align);
1181
1182 set_gdbarch_print_registers_info (gdbarch, mt_registers_info);
1183
1184 set_gdbarch_push_dummy_call (gdbarch, mt_push_dummy_call);
1185
1186 /* Target builtin data types. */
1187 set_gdbarch_short_bit (gdbarch, 16);
1188 set_gdbarch_int_bit (gdbarch, 32);
1189 set_gdbarch_long_bit (gdbarch, 32);
1190 set_gdbarch_long_long_bit (gdbarch, 64);
1191 set_gdbarch_float_bit (gdbarch, 32);
1192 set_gdbarch_double_bit (gdbarch, 64);
1193 set_gdbarch_long_double_bit (gdbarch, 64);
1194 set_gdbarch_ptr_bit (gdbarch, 32);
1195
1196 /* Register the DWARF 2 sniffer first, and then the traditional prologue
1197 based sniffer. */
1198 dwarf2_append_unwinders (gdbarch);
1199 frame_unwind_append_unwinder (gdbarch, &mt_frame_unwind);
1200 frame_base_set_default (gdbarch, &mt_frame_base);
1201
1202 /* Register the 'unwind_pc' method. */
1203 set_gdbarch_unwind_pc (gdbarch, mt_unwind_pc);
1204 set_gdbarch_unwind_sp (gdbarch, mt_unwind_sp);
1205
1206 /* Methods for saving / extracting a dummy frame's ID.
1207 The ID's stack address must match the SP value returned by
1208 PUSH_DUMMY_CALL, and saved by generic_save_dummy_frame_tos. */
1209 set_gdbarch_dummy_id (gdbarch, mt_dummy_id);
1210
1211 return gdbarch;
1212 }
1213
1214 void
1215 _initialize_mt_tdep (void)
1216 {
1217 register_gdbarch_init (bfd_arch_mt, mt_gdbarch_init);
1218 }
MT_R11_REGNUM
Definition: mt-tdep.c:61
set_gdbarch_num_regs
void set_gdbarch_num_regs(struct gdbarch *gdbarch, int num_regs)
Definition: gdbarch.c:2050
gdbarch
Definition: gdbarch.c:127
language_asm
Definition: defs.h:214
set_gdbarch_double_bit
void set_gdbarch_double_bit(struct gdbarch *gdbarch, int double_bit)
Definition: gdbarch.c:1723
set_gdbarch_frame_align
void set_gdbarch_frame_align(struct gdbarch *gdbarch, gdbarch_frame_align_ftype frame_align)
Definition: gdbarch.c:3151
MT_CPR10_REGNUM
Definition: mt-tdep.c:90
set_gdbarch_float_format
void set_gdbarch_float_format(struct gdbarch *gdbarch, const struct floatformat **float_format)
Definition: gdbarch.c:1706
MT_COPRO_PSEUDOREG_REGS
Definition: mt-tdep.c:131
_initialize_mt_tdep
void _initialize_mt_tdep(void)
Definition: mt-tdep.c:1215
lookup_array_range_type
struct type * lookup_array_range_type(struct type *element_type, LONGEST low_bound, LONGEST high_bound)
Definition: gdbtypes.c:1232
frame_id_build
struct frame_id frame_id_build(CORE_ADDR stack_addr, CORE_ADDR code_addr)
Definition: frame.c:624
MT_CPR15_REGNUM
Definition: mt-tdep.c:95
MT_ICHANNEL_REGNUM
Definition: mt-tdep.c:105
MT_CPR12_REGNUM
Definition: mt-tdep.c:92
REG_VALID
Definition: common-regcache.h:32
builtin_type::builtin_func_ptr
struct type * builtin_func_ptr
Definition: gdbtypes.h:1565
set_gdbarch_float_bit
void set_gdbarch_float_bit(struct gdbarch *gdbarch, int float_bit)
Definition: gdbarch.c:1690
get_frame_pc
CORE_ADDR get_frame_pc(struct frame_info *frame)
Definition: frame.c:2376
value_print_options::deref_ref
int deref_ref
Definition: valprint.h:75
infcall.h
CORE_ADDR
bfd_vma CORE_ADDR
Definition: common-types.h:41
MT_BYPB_REGNUM
Definition: mt-tdep.c:97
trad_frame_get_prev_register
struct value * trad_frame_get_prev_register(struct frame_info *this_frame, struct trad_frame_saved_reg this_saved_regs[], int regnum)
Definition: trad-frame.c:142
floatformats_ieee_double
const struct floatformat * floatformats_ieee_double[BFD_ENDIAN_UNKNOWN]
Definition: gdbtypes.c:76
trad_frame_addr_p
int trad_frame_addr_p(struct trad_frame_saved_reg this_saved_regs[], int regnum)
Definition: trad-frame.c:84
mt_unwind_cache
Definition: mt-tdep.c:894
symtab_and_line::end
CORE_ADDR end
Definition: symtab.h:1760
trad_frame_set_value
void trad_frame_set_value(struct trad_frame_saved_reg this_saved_regs[], int regnum, LONGEST val)
Definition: trad-frame.c:99
MT_R12_REGNUM
Definition: mt-tdep.c:62
default_print_registers_info
void default_print_registers_info(struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, int regnum, int print_all)
Definition: infcmd.c:2365
mt_frame_unwind_cache
static struct mt_unwind_cache * mt_frame_unwind_cache(struct frame_info *this_frame, void **this_prologue_cache)
Definition: mt-tdep.c:911
align_down
ULONGEST align_down(ULONGEST v, int n)
Definition: utils.c:3005
frame_unwind_register_unsigned
ULONGEST frame_unwind_register_unsigned(struct frame_info *frame, int regnum)
Definition: frame.c:1279
MT_BYPC_REGNUM
Definition: mt-tdep.c:98
reggroups.h
set_gdbarch_short_bit
void set_gdbarch_short_bit(struct gdbarch *gdbarch, int short_bit)
Definition: gdbarch.c:1572
builtin_type
const struct builtin_type * builtin_type(struct gdbarch *gdbarch)
Definition: gdbtypes.c:5217
MT_ISCRAMB2_REGNUM
Definition: mt-tdep.c:114
memset
void * memset(T *s, int c, size_t n)=delete
internal_error
void internal_error(const char *file, int line, const char *fmt,...)
Definition: errors.c:50
gdbarch_tdep
Definition: aarch64-tdep.h:55
return_value_convention
return_value_convention
Definition: defs.h:247
MT_R0_REGNUM
Definition: mt-tdep.c:48
set_gdbarch_register_reggroup_p
void set_gdbarch_register_reggroup_p(struct gdbarch *gdbarch, gdbarch_register_reggroup_p_ftype register_reggroup_p)
Definition: gdbarch.c:3599
frame_info
Definition: frame.c:85
mt_frame_unwind
static const struct frame_unwind mt_frame_unwind
Definition: mt-tdep.c:1121
MT_QSCRAMB_REGNUM
Definition: mt-tdep.c:107
MT_COPRO_PSEUDOREG_ARRAY
Definition: mt-tdep.c:124
gdbarch_list_lookup_by_info
struct gdbarch_list * gdbarch_list_lookup_by_info(struct gdbarch_list *arches, const struct gdbarch_info *info)
Definition: gdbarch.c:5309
register_status
register_status
Definition: common-regcache.h:25
skip_prologue_using_sal
CORE_ADDR skip_prologue_using_sal(struct gdbarch *gdbarch, CORE_ADDR func_addr)
Definition: symtab.c:3854
get_no_prettyformat_print_options
void get_no_prettyformat_print_options(struct value_print_options *opts)
Definition: valprint.c:128
lookup_symbol
struct block_symbol lookup_symbol(const char *name, const struct block *block, domain_enum domain, struct field_of_this_result *is_a_field_of_this)
Definition: symtab.c:1893
MT_NUM_PSEUDO_REGS
Definition: mt-tdep.c:136
MT_COPRO_PSEUDOREG_MAC_REGNUM
Definition: mt-tdep.c:133
all_reggroup
struct reggroup *const all_reggroup
Definition: reggroups.c:318
_
#define _(String)
Definition: gdb_locale.h:35
get_frame_memory_unsigned
ULONGEST get_frame_memory_unsigned(struct frame_info *this_frame, CORE_ADDR addr, int len)
Definition: frame.c:2671
ui_file
Definition: ui-file.h:26
MT_QCHANNEL2_REGNUM
Definition: mt-tdep.c:116
gdbarch_tdep::copro_type
struct type * copro_type
Definition: mt-tdep.c:145
MT_CPR8_REGNUM
Definition: mt-tdep.c:88
defs.h
MT_PC_REGNUM
Definition: mt-tdep.c:70
gdbarch_tdep
struct gdbarch_tdep * gdbarch_tdep(struct gdbarch *gdbarch)
Definition: gdbarch.c:1491
MT_EXMAC_REGNUM
Definition: mt-tdep.c:109
reggroup
Definition: reggroups.c:33
frame_unwind_append_unwinder
void frame_unwind_append_unwinder(struct gdbarch *gdbarch, const struct frame_unwind *unwinder)
Definition: frame-unwind.c:79
frame_info::this_id
struct frame_info::@60 this_id
set_gdbarch_print_registers_info
void set_gdbarch_print_registers_info(struct gdbarch *gdbarch, gdbarch_print_registers_info_ftype print_registers_info)
Definition: gdbarch.c:2456
builtin_type::builtin_int32
struct type * builtin_int32
Definition: gdbtypes.h:1538
MT_ISCRAMB_REGNUM
Definition: mt-tdep.c:106
FRAME_OBSTACK_ZALLOC
#define FRAME_OBSTACK_ZALLOC(TYPE)
Definition: frame.h:678
mt_frame_base
static struct frame_base mt_frame_base
Definition: mt-tdep.c:1134
arch-utils.h
MT_MAC_REGNUM
Definition: mt-tdep.c:102
mt_sw_breakpoint_from_kind
static const gdb_byte * mt_sw_breakpoint_from_kind(struct gdbarch *gdbarch, int kind, int *size)
Definition: mt-tdep.c:464
mt_unwind_pc
static CORE_ADDR mt_unwind_pc(struct gdbarch *gdbarch, struct frame_info *next_frame)
Definition: mt-tdep.c:1051
symtab.h
mt_frame_prev_register
static struct value * mt_frame_prev_register(struct frame_info *this_frame, void **this_prologue_cache, int regnum)
Definition: mt-tdep.c:1096
MT_ZQ2_REGNUM
Definition: mt-tdep.c:112
float_reggroup
struct reggroup *const float_reggroup
Definition: reggroups.c:315
value::contents
gdb_byte * contents
Definition: value.c:320
frame_base_set_default
void frame_base_set_default(struct gdbarch *gdbarch, const struct frame_base *default_base)
Definition: frame-base.c:95
name
const char *const name
Definition: aarch64-tdep.c:76
MT_COPRO_PSEUDOREG_DIM_1
Definition: mt-tdep.c:126
get_frame_register_value
struct value * get_frame_register_value(struct frame_info *frame, int regnum)
Definition: frame.c:1238
set_gdbarch_pseudo_register_write
void set_gdbarch_pseudo_register_write(struct gdbarch *gdbarch, gdbarch_pseudo_register_write_ftype pseudo_register_write)
Definition: gdbarch.c:2032
set_gdbarch_register_type
void set_gdbarch_register_type(struct gdbarch *gdbarch, gdbarch_register_type_ftype register_type)
Definition: gdbarch.c:2316
NORMAL_FRAME
Definition: frame.h:244
mt_unwind_cache::saved_regs
struct trad_frame_saved_reg * saved_regs
Definition: mt-tdep.c:904
value_contents
const gdb_byte * value_contents(struct value *value)
Definition: value.c:1407
general_reggroup
struct reggroup *const general_reggroup
Definition: reggroups.c:314
MT_R10_REGNUM
Definition: mt-tdep.c:60
MT_CPR11_REGNUM
Definition: mt-tdep.c:91
value_print_options
Definition: valprint.h:25
MT_R6_REGNUM
Definition: mt-tdep.c:56
MT_R4_REGNUM
Definition: mt-tdep.c:53
find_pc_line
struct symtab_and_line find_pc_line(CORE_ADDR pc, int notcurrent)
Definition: symtab.c:3288
trad-frame.h
fprintf_filtered
void fprintf_filtered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2008
MT_R8_REGNUM
Definition: mt-tdep.c:58
extract_unsigned_integer
static ULONGEST extract_unsigned_integer(const gdb_byte *addr, int len, enum bfd_endian byte_order)
Definition: defs.h:577
regcache_cooked_read_unsigned
enum register_status regcache_cooked_read_unsigned(struct regcache *regcache, int regnum, ULONGEST *val)
Definition: regcache.c:777
mt_pseudo_register_read
static enum register_status mt_pseudo_register_read(struct gdbarch *gdbarch, struct regcache *regcache, int regno, gdb_byte *buf)
Definition: mt-tdep.c:535
regcache.h
set_gdbarch_sp_regnum
void set_gdbarch_sp_regnum(struct gdbarch *gdbarch, int sp_regnum)
Definition: gdbarch.c:2156
mt_register_type
static struct type * mt_register_type(struct gdbarch *arch, int regnum)
Definition: mt-tdep.c:260
set_gdbarch_decr_pc_after_break
void set_gdbarch_decr_pc_after_break(struct gdbarch *gdbarch, CORE_ADDR decr_pc_after_break)
Definition: gdbarch.c:2980
MT_R13_REGNUM
Definition: mt-tdep.c:64
register_type
struct type * register_type(struct gdbarch *gdbarch, int regnum)
Definition: regcache.c:152
set_gdbarch_dummy_id
void set_gdbarch_dummy_id(struct gdbarch *gdbarch, gdbarch_dummy_id_ftype dummy_id)
Definition: gdbarch.c:2340
mt_gdbarch_init
static struct gdbarch * mt_gdbarch_init(struct gdbarch_info info, struct gdbarch_list *arches)
Definition: mt-tdep.c:1142
struct_return
struct_return
Definition: arm-tdep.h:88
fputs_filtered
void fputs_filtered(const char *linebuffer, struct ui_file *stream)
Definition: utils.c:1811
frame.h
mt_frame_this_id
static void mt_frame_this_id(struct frame_info *this_frame, void **this_prologue_cache, struct frame_id *this_id)
Definition: mt-tdep.c:1083
MT_NUM_REGS
Definition: mt-tdep.c:119
builtin_type::builtin_int16
struct type * builtin_int16
Definition: gdbtypes.h:1536
mt_breakpoint_kind_from_pc
static int mt_breakpoint_kind_from_pc(struct gdbarch *gdbarch, CORE_ADDR *pcptr)
Definition: mt-tdep.c:456
gdbarch_byte_order
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition: gdbarch.c:1509
inferior.h
type
Definition: gdbtypes.h:749
find_pc_partial_function
int find_pc_partial_function(CORE_ADDR pc, const char **name, CORE_ADDR *address, CORE_ADDR *endaddr)
Definition: blockframe.c:320
language.h
byte-vector.h
MT_COPRO_PSEUDOREG_REGNUM
Definition: mt-tdep.c:122
frame-unwind.h
set_gdbarch_unwind_pc
void set_gdbarch_unwind_pc(struct gdbarch *gdbarch, gdbarch_unwind_pc_ftype unwind_pc)
Definition: gdbarch.c:3079
builtin_type::builtin_uint32
struct type * builtin_uint32
Definition: gdbtypes.h:1539
default_frame_sniffer
int default_frame_sniffer(const struct frame_unwind *self, struct frame_info *this_frame, void **this_prologue_cache)
Definition: frame-unwind.c:174
MT_R7_REGNUM
Definition: mt-tdep.c:57
mt_push_dummy_call
static CORE_ADDR mt_push_dummy_call(struct gdbarch *gdbarch, struct value *function, struct regcache *regcache, CORE_ADDR bp_addr, int nargs, struct value **args, CORE_ADDR sp, int struct_return, CORE_ADDR struct_addr)
Definition: mt-tdep.c:782
MT_LAST_ARGREG
Definition: mt-tdep.c:54
MT_CPR13_REGNUM
Definition: mt-tdep.c:93
gdbarch_register_name
const char * gdbarch_register_name(struct gdbarch *gdbarch, int regnr)
Definition: gdbarch.c:2282
status
mach_port_t mach_port_t name mach_port_t mach_port_t name kern_return_t int status
Definition: gnu-nat.c:1822
MT_R1_REGNUM
Definition: mt-tdep.c:49
mt_skip_prologue
static CORE_ADDR mt_skip_prologue(struct gdbarch *gdbarch, CORE_ADDR pc)
Definition: mt-tdep.c:406
MT_Z2_REGNUM
Definition: mt-tdep.c:104
set_gdbarch_unwind_sp
void set_gdbarch_unwind_sp(struct gdbarch *gdbarch, gdbarch_unwind_sp_ftype unwind_sp)
Definition: gdbarch.c:3103
builtin_type::builtin_unsigned_char
struct type * builtin_unsigned_char
Definition: gdbtypes.h:1506
gdbarch_list::gdbarch
struct gdbarch * gdbarch
Definition: gdbarch.h:1622
MT_CPR2_REGNUM
Definition: mt-tdep.c:82
regnum
int regnum
Definition: aarch64-tdep.c:77
frame_base
Definition: frame-base.h:58
mt_gdb_regnums
mt_gdb_regnums
Definition: mt-tdep.c:46
MT_COPRO_REGNUM
Definition: mt-tdep.c:79
MT_CPR0_REGNUM
Definition: mt-tdep.c:80
read_memory
void read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition: corefile.c:258
all
Definition: mi-cmd-stack.c:39
vector_reggroup
struct reggroup *const vector_reggroup
Definition: reggroups.c:317
get_frame_register_unsigned
ULONGEST get_frame_register_unsigned(struct frame_info *frame, int regnum)
Definition: frame.c:1308
MT_MAC_PSEUDOREG_REGNUM
Definition: mt-tdep.c:123
xmalloc
void * xmalloc(YYSIZE_T)
MT_CHANNEL2_REGNUM
Definition: mt-tdep.c:113
frame-base.h
set_gdbarch_breakpoint_kind_from_pc
void set_gdbarch_breakpoint_kind_from_pc(struct gdbarch *gdbarch, gdbarch_breakpoint_kind_from_pc_ftype breakpoint_kind_from_pc)
Definition: gdbarch.c:2871
trad_frame_alloc_saved_regs
struct trad_frame_saved_reg * trad_frame_alloc_saved_regs(struct gdbarch *gdbarch)
Definition: trad-frame.c:47
set_gdbarch_frame_args_skip
void set_gdbarch_frame_args_skip(struct gdbarch *gdbarch, CORE_ADDR frame_args_skip)
Definition: gdbarch.c:3055
set_gdbarch_long_long_bit
void set_gdbarch_long_long_bit(struct gdbarch *gdbarch, int long_long_bit)
Definition: gdbarch.c:1623
block_symbol::symbol
struct symbol * symbol
Definition: symtab.h:1136
mt_frame_base_address
static CORE_ADDR mt_frame_base_address(struct frame_info *this_frame, void **this_prologue_cache)
Definition: mt-tdep.c:1106
MT_OUT_REGNUM
Definition: mt-tdep.c:108
mt_unwind_cache::frame_base
CORE_ADDR frame_base
Definition: mt-tdep.c:899
value
Definition: value.c:169
MT_FLAG_REGNUM
Definition: mt-tdep.c:99
floatformats_ieee_single
const struct floatformat * floatformats_ieee_single[BFD_ENDIAN_UNKNOWN]
Definition: gdbtypes.c:72
trad_frame_saved_reg::addr
LONGEST addr
Definition: trad-frame.h:83
regcache_invalidate
void regcache_invalidate(struct regcache *regcache, int regnum)
Definition: regcache.c:378
MT_COPRO_PSEUDOREG_DIM_2
Definition: mt-tdep.c:127
symtab_and_line
Definition: symtab.h:1746
mt_select_coprocessor
static int mt_select_coprocessor(struct gdbarch *gdbarch, struct regcache *regcache, int regno)
Definition: mt-tdep.c:486
MT_CONTEXT_REGNUM
Definition: mt-tdep.c:100
MT_R5_REGNUM
Definition: mt-tdep.c:55
MT_CPR5_REGNUM
Definition: mt-tdep.c:85
print_spaces_filtered
void print_spaces_filtered(int n, struct ui_file *stream)
Definition: utils.c:2121
core_addr_lessthan
int core_addr_lessthan(CORE_ADDR lhs, CORE_ADDR rhs)
Definition: arch-utils.c:117
gdb_byte
bfd_byte gdb_byte
Definition: common-types.h:38
MT_R2_REGNUM
Definition: mt-tdep.c:51
mt_unwind_cache::frameless_p
int frameless_p
Definition: mt-tdep.c:901
MT_CPR7_REGNUM
Definition: mt-tdep.c:87
RETURN_VALUE_ABI_RETURNS_ADDRESS
Definition: defs.h:264
set_gdbarch_pseudo_register_read
void set_gdbarch_pseudo_register_read(struct gdbarch *gdbarch, gdbarch_pseudo_register_read_ftype pseudo_register_read)
Definition: gdbarch.c:1984
mt_register_name
static const char * mt_register_name(struct gdbarch *gdbarch, int regnum)
Definition: mt-tdep.c:152
current_language
const struct language_defn * current_language
Definition: language.c:81
print_longest
void print_longest(struct ui_file *stream, int format, int use_c_format, LONGEST val_long)
Definition: valprint.c:1303
dwarf2-frame.h
deprecated_frame_register_read
int deprecated_frame_register_read(struct frame_info *frame, int regnum, gdb_byte *myaddr)
Definition: frame.c:1372
mt_pseudo_register_write
static void mt_pseudo_register_write(struct gdbarch *gdbarch, struct regcache *regcache, int regno, const gdb_byte *buf)
Definition: mt-tdep.c:595
mt_register_reggroup_p
static int mt_register_reggroup_p(struct gdbarch *gdbarch, int regnum, struct reggroup *group)
Definition: mt-tdep.c:309
XCNEW
#define XCNEW(T)
Definition: poison.h:121
gdbcore.h
mt_registers_info
static void mt_registers_info(struct gdbarch *gdbarch, struct ui_file *file, struct frame_info *frame, int regnum, int all)
Definition: mt-tdep.c:655
MT_BYPA_REGNUM
Definition: mt-tdep.c:96
MT_RA_REGNUM
Definition: mt-tdep.c:67
regcache_raw_read
enum register_status regcache_raw_read(struct regcache *regcache, int regnum, gdb_byte *buf)
Definition: regcache.c:565
regcache_cooked_write_unsigned
void regcache_cooked_write_unsigned(struct regcache *regcache, int regnum, ULONGEST val)
Definition: regcache.c:806
builtin_type::builtin_data_ptr
struct type * builtin_data_ptr
Definition: gdbtypes.h:1554
set_gdbarch_int_bit
void set_gdbarch_int_bit(struct gdbarch *gdbarch, int int_bit)
Definition: gdbarch.c:1589
MT_R3_REGNUM
Definition: mt-tdep.c:52
mt_dummy_id
static struct frame_id mt_dummy_id(struct gdbarch *gdbarch, struct frame_info *this_frame)
Definition: mt-tdep.c:1073
offset
int offset
Definition: agent.c:65
MT_Z1_REGNUM
Definition: mt-tdep.c:103
MT_R14_REGNUM
Definition: mt-tdep.c:66
MT_FP_REGNUM
Definition: mt-tdep.c:63
set_gdbarch_num_pseudo_regs
void set_gdbarch_num_pseudo_regs(struct gdbarch *gdbarch, int num_pseudo_regs)
Definition: gdbarch.c:2067
dwarf2_append_unwinders
void dwarf2_append_unwinders(struct gdbarch *gdbarch)
Definition: dwarf2-frame.c:1384
SYMBOL_LANGUAGE
#define SYMBOL_LANGUAGE(symbol)
Definition: symtab.h:469
MT_MAX_STRUCT_SIZE
Definition: mt-tdep.c:43
MT_CPR1_REGNUM
Definition: mt-tdep.c:81
mt_unwind_sp
static CORE_ADDR mt_unwind_sp(struct gdbarch *gdbarch, struct frame_info *next_frame)
Definition: mt-tdep.c:1060
extract_signed_integer
static LONGEST extract_signed_integer(const gdb_byte *addr, int len, enum bfd_endian byte_order)
Definition: defs.h:570
VAR_DOMAIN
Definition: symtab.h:739
MT_CPR4_REGNUM
Definition: mt-tdep.c:84
MT_R15_REGNUM
Definition: mt-tdep.c:68
mt_frame_align
static CORE_ADDR mt_frame_align(struct gdbarch *gdbarch, CORE_ADDR sp)
Definition: mt-tdep.c:644
frame_unwind
Definition: frame-unwind.h:144
mt_return_value
static enum return_value_convention mt_return_value(struct gdbarch *gdbarch, struct value *function, struct type *type, struct regcache *regcache, gdb_byte *readbuf, const gdb_byte *writebuf)
Definition: mt-tdep.c:337
MT_CPR14_REGNUM
Definition: mt-tdep.c:94
set_gdbarch_double_format
void set_gdbarch_double_format(struct gdbarch *gdbarch, const struct floatformat **double_format)
Definition: gdbarch.c:1739
gdb::byte_vector
gdb::def_vector< gdb_byte > byte_vector
Definition: byte-vector.h:58
val_print
void val_print(struct type *type, LONGEST embedded_offset, CORE_ADDR address, struct ui_file *stream, int recurse, struct value *val, const struct value_print_options *options, const struct language_defn *language)
Definition: valprint.c:1015
mt_unwind_cache::prev_sp
CORE_ADDR prev_sp
Definition: mt-tdep.c:898
gdbtypes.h
ULONGEST
unsigned long long ULONGEST
Definition: common-types.h:53
default_frame_unwind_stop_reason
enum unwind_stop_reason default_frame_unwind_stop_reason(struct frame_info *this_frame, void **this_cache)
Definition: frame-unwind.c:184
builtin_type::builtin_long_long
struct type * builtin_long_long
Definition: gdbtypes.h:1517
register_size
int register_size(struct gdbarch *gdbarch, int regnum)
Definition: regcache.c:164
regcache
Definition: regcache.h:232
gdbarch_info
Definition: gdbarch.h:1626
set_gdbarch_long_double_bit
void set_gdbarch_long_double_bit(struct gdbarch *gdbarch, int long_double_bit)
Definition: gdbarch.c:1756
value_type
struct type * value_type(const struct value *value)
Definition: value.c:1095
set_gdbarch_long_bit
void set_gdbarch_long_bit(struct gdbarch *gdbarch, int long_bit)
Definition: gdbarch.c:1606
MT_IRA_REGNUM
Definition: mt-tdep.c:69
symbol
Definition: symtab.h:1049
set_gdbarch_return_value
void set_gdbarch_return_value(struct gdbarch *gdbarch, gdbarch_return_value_ftype return_value)
Definition: gdbarch.c:2738
gdbarch_bfd_arch_info
const struct bfd_arch_info * gdbarch_bfd_arch_info(struct gdbarch *gdbarch)
Definition: gdbarch.c:1500
set_gdbarch_long_double_format
void set_gdbarch_long_double_format(struct gdbarch *gdbarch, const struct floatformat **long_double_format)
Definition: gdbarch.c:1772
MT_ZI2_REGNUM
Definition: mt-tdep.c:111
mt_copro_register_type
static struct type * mt_copro_register_type(struct gdbarch *arch, int regnum)
Definition: mt-tdep.c:214
default_register_reggroup_p
int default_register_reggroup_p(struct gdbarch *gdbarch, int regnum, struct reggroup *group)
Definition: reggroups.c:192
TYPE_LENGTH
#define TYPE_LENGTH(thistype)
Definition: gdbtypes.h:1235
set_gdbarch_ptr_bit
void set_gdbarch_ptr_bit(struct gdbarch *gdbarch, int ptr_bit)
Definition: gdbarch.c:1841
set_gdbarch_push_dummy_call
void set_gdbarch_push_dummy_call(struct gdbarch *gdbarch, gdbarch_push_dummy_call_ftype push_dummy_call)
Definition: gdbarch.c:2381
read_memory_unsigned_integer
ULONGEST read_memory_unsigned_integer(CORE_ADDR memaddr, int len, enum bfd_endian byte_order)
Definition: corefile.c:326
builtin_type::builtin_uint64
struct type * builtin_uint64
Definition: gdbtypes.h:1541
set_gdbarch_sw_breakpoint_from_kind
void set_gdbarch_sw_breakpoint_from_kind(struct gdbarch *gdbarch, gdbarch_sw_breakpoint_from_kind_ftype sw_breakpoint_from_kind)
Definition: gdbarch.c:2888
register_gdbarch_init
void register_gdbarch_init(enum bfd_architecture bfd_architecture, gdbarch_init_ftype *init)
Definition: gdbarch.c:5299
write_memory
void write_memory(CORE_ADDR memaddr, const bfd_byte *myaddr, ssize_t len)
Definition: corefile.c:394
set_gdbarch_skip_prologue
void set_gdbarch_skip_prologue(struct gdbarch *gdbarch, gdbarch_skip_prologue_ftype skip_prologue)
Definition: gdbarch.c:2772
MT_R9_REGNUM
Definition: mt-tdep.c:59
valprint.h
RETURN_VALUE_REGISTER_CONVENTION
Definition: defs.h:251
set_gdbarch_pc_regnum
void set_gdbarch_pc_regnum(struct gdbarch *gdbarch, int pc_regnum)
Definition: gdbarch.c:2173
MT_NUM_CPU_REGS
Definition: mt-tdep.c:76
trad_frame_saved_reg
Definition: trad-frame.h:81
set_gdbarch_register_name
void set_gdbarch_register_name(struct gdbarch *gdbarch, gdbarch_register_name_ftype register_name)
Definition: gdbarch.c:2292
get_frame_func
CORE_ADDR get_frame_func(struct frame_info *this_frame)
Definition: frame.c:1001
MT_CPR9_REGNUM
Definition: mt-tdep.c:89
store_signed_integer
static void store_signed_integer(gdb_byte *addr, int len, enum bfd_endian byte_order, LONGEST val)
Definition: defs.h:597
size
size_t size
Definition: go32-nat.c:242
gdbarch_alloc
struct gdbarch * gdbarch_alloc(const struct gdbarch_info *info, struct gdbarch_tdep *tdep)
Definition: gdbarch.c:361
set_gdbarch_inner_than
void set_gdbarch_inner_than(struct gdbarch *gdbarch, gdbarch_inner_than_ftype inner_than)
Definition: gdbarch.c:2837
MT_1ST_ARGREG
Definition: mt-tdep.c:50
MT_QSCRAMB2_REGNUM
Definition: mt-tdep.c:115
frame_id
Definition: frame.h:111
get_frame_arch
struct gdbarch * get_frame_arch(struct frame_info *this_frame)
Definition: frame.c:2691
mt_arch_constants
mt_arch_constants
Definition: mt-tdep.c:41
MT_QCHANNEL_REGNUM
Definition: mt-tdep.c:110
LONGEST
long long LONGEST
Definition: common-types.h:52
wordsize
#define wordsize
regcache_cooked_write
void regcache_cooked_write(struct regcache *regcache, int regnum, const gdb_byte *buf)
Definition: regcache.c:873
MT_INT_ENABLE_REGNUM
Definition: mt-tdep.c:73
MT_CPR3_REGNUM
Definition: mt-tdep.c:83
store_unsigned_integer
static void store_unsigned_integer(gdb_byte *addr, int len, enum bfd_endian byte_order, ULONGEST val)
Definition: defs.h:604
MT_SP_REGNUM
Definition: mt-tdep.c:65
MT_CPR6_REGNUM
Definition: mt-tdep.c:86
regcache_raw_write
void regcache_raw_write(struct regcache *regcache, int regnum, const gdb_byte *buf)
Definition: regcache.c:831
mt_unwind_cache::framesize
int framesize
Definition: mt-tdep.c:900
gdbarch_list
Definition: gdbarch.h:1620