1 /* Target-dependent code for Morpho mt processor, for GDB.
3 Copyright (C) 2005, 2007, 2008, 2009, 2010, 2011
4 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 /* Contributed by Michael Snyder, msnyder@redhat.com. */
25 #include "frame-unwind.h"
26 #include "frame-base.h"
29 #include "arch-utils.h"
31 #include "gdb_string.h"
33 #include "reggroups.h"
35 #include "trad-frame.h"
37 #include "dwarf2-frame.h"
39 #include "gdb_assert.h"
43 enum mt_arch_constants
45 MT_MAX_STRUCT_SIZE
= 16
50 MT_R0_REGNUM
, /* 32 bit regs. */
52 MT_1ST_ARGREG
= MT_R1_REGNUM
,
56 MT_LAST_ARGREG
= MT_R4_REGNUM
,
65 MT_FP_REGNUM
= MT_R12_REGNUM
,
67 MT_SP_REGNUM
= MT_R13_REGNUM
,
69 MT_RA_REGNUM
= MT_R14_REGNUM
,
71 MT_IRA_REGNUM
= MT_R15_REGNUM
,
74 /* Interrupt Enable pseudo-register, exported by SID. */
76 /* End of CPU regs. */
80 /* Co-processor registers. */
81 MT_COPRO_REGNUM
= MT_NUM_CPU_REGS
, /* 16 bit regs. */
98 MT_BYPA_REGNUM
, /* 32 bit regs. */
102 MT_CONTEXT_REGNUM
, /* 38 bits (treat as array of
104 MT_MAC_REGNUM
, /* 32 bits. */
105 MT_Z1_REGNUM
, /* 16 bits. */
106 MT_Z2_REGNUM
, /* 16 bits. */
107 MT_ICHANNEL_REGNUM
, /* 32 bits. */
108 MT_ISCRAMB_REGNUM
, /* 32 bits. */
109 MT_QSCRAMB_REGNUM
, /* 32 bits. */
110 MT_OUT_REGNUM
, /* 16 bits. */
111 MT_EXMAC_REGNUM
, /* 32 bits (8 used). */
112 MT_QCHANNEL_REGNUM
, /* 32 bits. */
113 MT_ZI2_REGNUM
, /* 16 bits. */
114 MT_ZQ2_REGNUM
, /* 16 bits. */
115 MT_CHANNEL2_REGNUM
, /* 32 bits. */
116 MT_ISCRAMB2_REGNUM
, /* 32 bits. */
117 MT_QSCRAMB2_REGNUM
, /* 32 bits. */
118 MT_QCHANNEL2_REGNUM
, /* 32 bits. */
120 /* Number of real registers. */
123 /* Pseudo-registers. */
124 MT_COPRO_PSEUDOREG_REGNUM
= MT_NUM_REGS
,
125 MT_MAC_PSEUDOREG_REGNUM
,
126 MT_COPRO_PSEUDOREG_ARRAY
,
128 MT_COPRO_PSEUDOREG_DIM_1
= 2,
129 MT_COPRO_PSEUDOREG_DIM_2
= 8,
130 /* The number of pseudo-registers for each coprocessor. These
131 include the real coprocessor registers, the pseudo-registe for
132 the coprocessor number, and the pseudo-register for the MAC. */
133 MT_COPRO_PSEUDOREG_REGS
= MT_NUM_REGS
- MT_NUM_CPU_REGS
+ 2,
134 /* The register number of the MAC, relative to a given coprocessor. */
135 MT_COPRO_PSEUDOREG_MAC_REGNUM
= MT_COPRO_PSEUDOREG_REGS
- 1,
137 /* Two pseudo-regs ('coprocessor' and 'mac'). */
138 MT_NUM_PSEUDO_REGS
= 2 + (MT_COPRO_PSEUDOREG_REGS
139 * MT_COPRO_PSEUDOREG_DIM_1
140 * MT_COPRO_PSEUDOREG_DIM_2
)
143 /* The tdep structure. */
146 /* ISA-specific types. */
147 struct type
*copro_type
;
151 /* Return name of register number specified by REGNUM. */
154 mt_register_name (struct gdbarch
*gdbarch
, int regnum
)
156 static const char *const register_names
[] = {
158 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
159 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
161 /* Co-processor regs. */
162 "", /* copro register. */
163 "cr0", "cr1", "cr2", "cr3", "cr4", "cr5", "cr6", "cr7",
164 "cr8", "cr9", "cr10", "cr11", "cr12", "cr13", "cr14", "cr15",
165 "bypa", "bypb", "bypc", "flag", "context", "" /* mac. */ , "z1", "z2",
166 "Ichannel", "Iscramb", "Qscramb", "out", "" /* ex-mac. */ , "Qchannel",
167 "zi2", "zq2", "Ichannel2", "Iscramb2", "Qscramb2", "Qchannel2",
168 /* Pseudo-registers. */
171 static const char *array_names
[MT_COPRO_PSEUDOREG_REGS
172 * MT_COPRO_PSEUDOREG_DIM_1
173 * MT_COPRO_PSEUDOREG_DIM_2
];
177 if (regnum
< ARRAY_SIZE (register_names
))
178 return register_names
[regnum
];
179 if (array_names
[regnum
- MT_COPRO_PSEUDOREG_ARRAY
])
180 return array_names
[regnum
- MT_COPRO_PSEUDOREG_ARRAY
];
189 regnum
-= MT_COPRO_PSEUDOREG_ARRAY
;
190 index
= regnum
% MT_COPRO_PSEUDOREG_REGS
;
191 dim_2
= (regnum
/ MT_COPRO_PSEUDOREG_REGS
) % MT_COPRO_PSEUDOREG_DIM_2
;
192 dim_1
= ((regnum
/ MT_COPRO_PSEUDOREG_REGS
/ MT_COPRO_PSEUDOREG_DIM_2
)
193 % MT_COPRO_PSEUDOREG_DIM_1
);
195 if (index
== MT_COPRO_PSEUDOREG_MAC_REGNUM
)
196 stub
= register_names
[MT_MAC_PSEUDOREG_REGNUM
];
197 else if (index
>= MT_NUM_REGS
- MT_CPR0_REGNUM
)
200 stub
= register_names
[index
+ MT_CPR0_REGNUM
];
203 array_names
[regnum
] = stub
;
207 sprintf (name
, "copro_%d_%d_%s", dim_1
, dim_2
, stub
);
208 array_names
[regnum
] = name
;
213 /* Return the type of a coprocessor register. */
216 mt_copro_register_type (struct gdbarch
*arch
, int regnum
)
220 case MT_INT_ENABLE_REGNUM
:
221 case MT_ICHANNEL_REGNUM
:
222 case MT_QCHANNEL_REGNUM
:
223 case MT_ISCRAMB_REGNUM
:
224 case MT_QSCRAMB_REGNUM
:
225 return builtin_type (arch
)->builtin_int32
;
234 return builtin_type (arch
)->builtin_int16
;
235 case MT_EXMAC_REGNUM
:
237 return builtin_type (arch
)->builtin_uint32
;
238 case MT_CONTEXT_REGNUM
:
239 return builtin_type (arch
)->builtin_long_long
;
241 return builtin_type (arch
)->builtin_unsigned_char
;
243 if (regnum
>= MT_CPR0_REGNUM
&& regnum
<= MT_CPR15_REGNUM
)
244 return builtin_type (arch
)->builtin_int16
;
245 else if (regnum
== MT_CPR0_REGNUM
+ MT_COPRO_PSEUDOREG_MAC_REGNUM
)
247 if (gdbarch_bfd_arch_info (arch
)->mach
== bfd_mach_mrisc2
248 || gdbarch_bfd_arch_info (arch
)->mach
== bfd_mach_ms2
)
249 return builtin_type (arch
)->builtin_uint64
;
251 return builtin_type (arch
)->builtin_uint32
;
254 return builtin_type (arch
)->builtin_uint32
;
258 /* Given ARCH and a register number specified by REGNUM, return the
259 type of that register. */
262 mt_register_type (struct gdbarch
*arch
, int regnum
)
264 struct gdbarch_tdep
*tdep
= gdbarch_tdep (arch
);
266 if (regnum
>= 0 && regnum
< MT_NUM_REGS
+ MT_NUM_PSEUDO_REGS
)
273 return builtin_type (arch
)->builtin_func_ptr
;
276 return builtin_type (arch
)->builtin_data_ptr
;
277 case MT_COPRO_REGNUM
:
278 case MT_COPRO_PSEUDOREG_REGNUM
:
279 if (tdep
->copro_type
== NULL
)
281 struct type
*elt
= builtin_type (arch
)->builtin_int16
;
282 tdep
->copro_type
= lookup_array_range_type (elt
, 0, 1);
284 return tdep
->copro_type
;
285 case MT_MAC_PSEUDOREG_REGNUM
:
286 return mt_copro_register_type (arch
,
288 + MT_COPRO_PSEUDOREG_MAC_REGNUM
);
290 if (regnum
>= MT_R0_REGNUM
&& regnum
<= MT_R15_REGNUM
)
291 return builtin_type (arch
)->builtin_int32
;
292 else if (regnum
< MT_COPRO_PSEUDOREG_ARRAY
)
293 return mt_copro_register_type (arch
, regnum
);
296 regnum
-= MT_COPRO_PSEUDOREG_ARRAY
;
297 regnum
%= MT_COPRO_PSEUDOREG_REGS
;
298 regnum
+= MT_CPR0_REGNUM
;
299 return mt_copro_register_type (arch
, regnum
);
303 internal_error (__FILE__
, __LINE__
,
304 _("mt_register_type: illegal register number %d"), regnum
);
307 /* Return true if register REGNUM is a member of the register group
308 specified by GROUP. */
311 mt_register_reggroup_p (struct gdbarch
*gdbarch
, int regnum
,
312 struct reggroup
*group
)
314 /* Groups of registers that can be displayed via "info reg". */
315 if (group
== all_reggroup
)
317 && regnum
< MT_NUM_REGS
+ MT_NUM_PSEUDO_REGS
318 && mt_register_name (gdbarch
, regnum
)[0] != '\0');
320 if (group
== general_reggroup
)
321 return (regnum
>= MT_R0_REGNUM
&& regnum
<= MT_R15_REGNUM
);
323 if (group
== float_reggroup
)
324 return 0; /* No float regs. */
326 if (group
== vector_reggroup
)
327 return 0; /* No vector regs. */
329 /* For any that are not handled above. */
330 return default_register_reggroup_p (gdbarch
, regnum
, group
);
333 /* Return the return value convention used for a given type TYPE.
334 Optionally, fetch or set the return value via READBUF or
335 WRITEBUF respectively using REGCACHE for the register
338 static enum return_value_convention
339 mt_return_value (struct gdbarch
*gdbarch
, struct type
*func_type
,
340 struct type
*type
, struct regcache
*regcache
,
341 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
343 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
345 if (TYPE_LENGTH (type
) > 4)
347 /* Return values > 4 bytes are returned in memory,
348 pointed to by R11. */
353 regcache_cooked_read_unsigned (regcache
, MT_R11_REGNUM
, &addr
);
354 read_memory (addr
, readbuf
, TYPE_LENGTH (type
));
361 regcache_cooked_read_unsigned (regcache
, MT_R11_REGNUM
, &addr
);
362 write_memory (addr
, writebuf
, TYPE_LENGTH (type
));
365 return RETURN_VALUE_ABI_RETURNS_ADDRESS
;
373 /* Return values of <= 4 bytes are returned in R11. */
374 regcache_cooked_read_unsigned (regcache
, MT_R11_REGNUM
, &temp
);
375 store_unsigned_integer (readbuf
, TYPE_LENGTH (type
),
381 if (TYPE_LENGTH (type
) < 4)
384 /* Add leading zeros to the value. */
385 memset (buf
, 0, sizeof (buf
));
386 memcpy (buf
+ sizeof (buf
) - TYPE_LENGTH (type
),
387 writebuf
, TYPE_LENGTH (type
));
388 regcache_cooked_write (regcache
, MT_R11_REGNUM
, buf
);
390 else /* (TYPE_LENGTH (type) == 4 */
391 regcache_cooked_write (regcache
, MT_R11_REGNUM
, writebuf
);
394 return RETURN_VALUE_REGISTER_CONVENTION
;
398 /* If the input address, PC, is in a function prologue, return the
399 address of the end of the prologue, otherwise return the input
402 Note: PC is likely to be the function start, since this function
403 is mainly used for advancing a breakpoint to the first line, or
404 stepping to the first line when we have stepped into a function
408 mt_skip_prologue (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
410 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
411 CORE_ADDR func_addr
= 0, func_end
= 0;
415 if (find_pc_partial_function (pc
, &func_name
, &func_addr
, &func_end
))
417 struct symtab_and_line sal
;
420 /* Found a function. */
421 sym
= lookup_symbol (func_name
, NULL
, VAR_DOMAIN
, NULL
);
422 if (sym
&& SYMBOL_LANGUAGE (sym
) != language_asm
)
424 /* Don't use this trick for assembly source files. */
425 sal
= find_pc_line (func_addr
, 0);
427 if (sal
.end
&& sal
.end
< func_end
)
429 /* Found a line number, use it as end of prologue. */
435 /* No function symbol, or no line symbol. Use prologue scanning method. */
438 instr
= read_memory_unsigned_integer (pc
, 4, byte_order
);
439 if (instr
== 0x12000000) /* nop */
441 if (instr
== 0x12ddc000) /* copy sp into fp */
444 if (instr
== 0x05dd) /* subi sp, sp, imm */
446 if (instr
>= 0x43c0 && instr
<= 0x43df) /* push */
448 /* Not an obvious prologue instruction. */
455 /* The breakpoint instruction must be the same size as the smallest
456 instruction in the instruction set.
458 The BP for ms1 is defined as 0x68000000 (BREAK).
459 The BP for ms2 is defined as 0x69000000 (illegal) */
461 static const gdb_byte
*
462 mt_breakpoint_from_pc (struct gdbarch
*gdbarch
, CORE_ADDR
*bp_addr
,
465 static gdb_byte ms1_breakpoint
[] = { 0x68, 0, 0, 0 };
466 static gdb_byte ms2_breakpoint
[] = { 0x69, 0, 0, 0 };
469 if (gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_ms2
)
470 return ms2_breakpoint
;
472 return ms1_breakpoint
;
475 /* Select the correct coprocessor register bank. Return the pseudo
476 regnum we really want to read. */
479 mt_select_coprocessor (struct gdbarch
*gdbarch
,
480 struct regcache
*regcache
, int regno
)
482 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
483 unsigned index
, base
;
486 /* Get the copro pseudo regnum. */
487 regcache_raw_read (regcache
, MT_COPRO_REGNUM
, copro
);
488 base
= ((extract_signed_integer (&copro
[0], 2, byte_order
)
489 * MT_COPRO_PSEUDOREG_DIM_2
)
490 + extract_signed_integer (&copro
[2], 2, byte_order
));
492 regno
-= MT_COPRO_PSEUDOREG_ARRAY
;
493 index
= regno
% MT_COPRO_PSEUDOREG_REGS
;
494 regno
/= MT_COPRO_PSEUDOREG_REGS
;
497 /* Select the correct coprocessor register bank. Invalidate the
498 coprocessor register cache. */
501 store_signed_integer (&copro
[0], 2, byte_order
,
502 regno
/ MT_COPRO_PSEUDOREG_DIM_2
);
503 store_signed_integer (&copro
[2], 2, byte_order
,
504 regno
% MT_COPRO_PSEUDOREG_DIM_2
);
505 regcache_raw_write (regcache
, MT_COPRO_REGNUM
, copro
);
507 /* We must flush the cache, as it is now invalid. */
508 for (ix
= MT_NUM_CPU_REGS
; ix
!= MT_NUM_REGS
; ix
++)
509 regcache_invalidate (regcache
, ix
);
515 /* Fetch the pseudo registers:
517 There are two regular pseudo-registers:
518 1) The 'coprocessor' pseudo-register (which mirrors the
519 "real" coprocessor register sent by the target), and
520 2) The 'MAC' pseudo-register (which represents the union
521 of the original 32 bit target MAC register and the new
522 8-bit extended-MAC register).
524 Additionally there is an array of coprocessor registers which track
525 the coprocessor registers for each coprocessor. */
528 mt_pseudo_register_read (struct gdbarch
*gdbarch
,
529 struct regcache
*regcache
, int regno
, gdb_byte
*buf
)
531 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
535 case MT_COPRO_REGNUM
:
536 case MT_COPRO_PSEUDOREG_REGNUM
:
537 regcache_raw_read (regcache
, MT_COPRO_REGNUM
, buf
);
540 case MT_MAC_PSEUDOREG_REGNUM
:
541 if (gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_mrisc2
542 || gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_ms2
)
544 ULONGEST oldmac
= 0, ext_mac
= 0;
547 regcache_cooked_read_unsigned (regcache
, MT_MAC_REGNUM
, &oldmac
);
548 regcache_cooked_read_unsigned (regcache
, MT_EXMAC_REGNUM
, &ext_mac
);
550 (oldmac
& 0xffffffff) | ((long long) (ext_mac
& 0xff) << 32);
551 store_signed_integer (buf
, 8, byte_order
, newmac
);
554 regcache_raw_read (regcache
, MT_MAC_REGNUM
, buf
);
558 unsigned index
= mt_select_coprocessor (gdbarch
, regcache
, regno
);
560 if (index
== MT_COPRO_PSEUDOREG_MAC_REGNUM
)
561 mt_pseudo_register_read (gdbarch
, regcache
,
562 MT_MAC_PSEUDOREG_REGNUM
, buf
);
563 else if (index
< MT_NUM_REGS
- MT_CPR0_REGNUM
)
564 regcache_raw_read (regcache
, index
+ MT_CPR0_REGNUM
, buf
);
570 /* Write the pseudo registers:
572 Mt pseudo-registers are stored directly to the target. The
573 'coprocessor' register is special, because when it is modified, all
574 the other coprocessor regs must be flushed from the reg cache. */
577 mt_pseudo_register_write (struct gdbarch
*gdbarch
,
578 struct regcache
*regcache
,
579 int regno
, const gdb_byte
*buf
)
581 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
586 case MT_COPRO_REGNUM
:
587 case MT_COPRO_PSEUDOREG_REGNUM
:
588 regcache_raw_write (regcache
, MT_COPRO_REGNUM
, buf
);
589 for (i
= MT_NUM_CPU_REGS
; i
< MT_NUM_REGS
; i
++)
590 regcache_invalidate (regcache
, i
);
593 case MT_MAC_PSEUDOREG_REGNUM
:
594 if (gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_mrisc2
595 || gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_ms2
)
597 /* The 8-byte MAC pseudo-register must be broken down into two
598 32-byte registers. */
599 unsigned int oldmac
, ext_mac
;
602 newmac
= extract_unsigned_integer (buf
, 8, byte_order
);
603 oldmac
= newmac
& 0xffffffff;
604 ext_mac
= (newmac
>> 32) & 0xff;
605 regcache_cooked_write_unsigned (regcache
, MT_MAC_REGNUM
, oldmac
);
606 regcache_cooked_write_unsigned (regcache
, MT_EXMAC_REGNUM
, ext_mac
);
609 regcache_raw_write (regcache
, MT_MAC_REGNUM
, buf
);
613 unsigned index
= mt_select_coprocessor (gdbarch
, regcache
, regno
);
615 if (index
== MT_COPRO_PSEUDOREG_MAC_REGNUM
)
616 mt_pseudo_register_write (gdbarch
, regcache
,
617 MT_MAC_PSEUDOREG_REGNUM
, buf
);
618 else if (index
< MT_NUM_REGS
- MT_CPR0_REGNUM
)
619 regcache_raw_write (regcache
, index
+ MT_CPR0_REGNUM
, buf
);
626 mt_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR sp
)
628 /* Register size is 4 bytes. */
629 return align_down (sp
, 4);
632 /* Implements the "info registers" command. When ``all'' is non-zero,
633 the coprocessor registers will be printed in addition to the rest
637 mt_registers_info (struct gdbarch
*gdbarch
,
638 struct ui_file
*file
,
639 struct frame_info
*frame
, int regnum
, int all
)
641 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
647 lim
= all
? MT_NUM_REGS
: MT_NUM_CPU_REGS
;
649 for (regnum
= 0; regnum
< lim
; regnum
++)
651 /* Don't display the Qchannel register since it will be displayed
652 along with Ichannel. (See below.) */
653 if (regnum
== MT_QCHANNEL_REGNUM
)
656 mt_registers_info (gdbarch
, file
, frame
, regnum
, all
);
658 /* Display the Qchannel register immediately after Ichannel. */
659 if (regnum
== MT_ICHANNEL_REGNUM
)
660 mt_registers_info (gdbarch
, file
, frame
, MT_QCHANNEL_REGNUM
, all
);
665 if (regnum
== MT_EXMAC_REGNUM
)
667 else if (regnum
== MT_CONTEXT_REGNUM
)
669 /* Special output handling for 38-bit context register. */
671 unsigned int *bytes
, i
, regsize
;
673 regsize
= register_size (gdbarch
, regnum
);
675 buff
= alloca (regsize
);
676 bytes
= alloca (regsize
* sizeof (*bytes
));
678 frame_register_read (frame
, regnum
, buff
);
680 fputs_filtered (gdbarch_register_name
681 (gdbarch
, regnum
), file
);
682 print_spaces_filtered (15 - strlen (gdbarch_register_name
685 fputs_filtered ("0x", file
);
687 for (i
= 0; i
< regsize
; i
++)
688 fprintf_filtered (file
, "%02x", (unsigned int)
689 extract_unsigned_integer (buff
+ i
, 1, byte_order
));
690 fputs_filtered ("\t", file
);
691 print_longest (file
, 'd', 0,
692 extract_unsigned_integer (buff
, regsize
, byte_order
));
693 fputs_filtered ("\n", file
);
695 else if (regnum
== MT_COPRO_REGNUM
696 || regnum
== MT_COPRO_PSEUDOREG_REGNUM
)
698 /* Special output handling for the 'coprocessor' register. */
700 struct value_print_options opts
;
702 buf
= alloca (register_size (gdbarch
, MT_COPRO_REGNUM
));
703 frame_register_read (frame
, MT_COPRO_REGNUM
, buf
);
705 regnum
= MT_COPRO_PSEUDOREG_REGNUM
;
706 fputs_filtered (gdbarch_register_name (gdbarch
, regnum
),
708 print_spaces_filtered (15 - strlen (gdbarch_register_name
711 get_raw_print_options (&opts
);
713 val_print (register_type (gdbarch
, regnum
), buf
,
715 &opts
, current_language
);
716 fputs_filtered ("\n", file
);
718 else if (regnum
== MT_MAC_REGNUM
|| regnum
== MT_MAC_PSEUDOREG_REGNUM
)
720 ULONGEST oldmac
, ext_mac
, newmac
;
721 gdb_byte buf
[3 * sizeof (LONGEST
)];
723 /* Get the two "real" mac registers. */
724 frame_register_read (frame
, MT_MAC_REGNUM
, buf
);
725 oldmac
= extract_unsigned_integer
726 (buf
, register_size (gdbarch
, MT_MAC_REGNUM
), byte_order
);
727 if (gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_mrisc2
728 || gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_ms2
)
730 frame_register_read (frame
, MT_EXMAC_REGNUM
, buf
);
731 ext_mac
= extract_unsigned_integer
732 (buf
, register_size (gdbarch
, MT_EXMAC_REGNUM
), byte_order
);
737 /* Add them together. */
738 newmac
= (oldmac
& 0xffffffff) + ((ext_mac
& 0xff) << 32);
741 regnum
= MT_MAC_PSEUDOREG_REGNUM
;
742 fputs_filtered (gdbarch_register_name (gdbarch
, regnum
),
744 print_spaces_filtered (15 - strlen (gdbarch_register_name
747 fputs_filtered ("0x", file
);
748 print_longest (file
, 'x', 0, newmac
);
749 fputs_filtered ("\t", file
);
750 print_longest (file
, 'u', 0, newmac
);
751 fputs_filtered ("\n", file
);
754 default_print_registers_info (gdbarch
, file
, frame
, regnum
, all
);
758 /* Set up the callee's arguments for an inferior function call. The
759 arguments are pushed on the stack or are placed in registers as
760 appropriate. It also sets up the return address (which points to
761 the call dummy breakpoint).
763 Returns the updated (and aligned) stack pointer. */
766 mt_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
767 struct regcache
*regcache
, CORE_ADDR bp_addr
,
768 int nargs
, struct value
**args
, CORE_ADDR sp
,
769 int struct_return
, CORE_ADDR struct_addr
)
772 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
773 gdb_byte buf
[MT_MAX_STRUCT_SIZE
];
774 int argreg
= MT_1ST_ARGREG
;
775 int split_param_len
= 0;
781 /* First handle however many args we can fit into MT_1ST_ARGREG thru
783 for (i
= 0; i
< nargs
&& argreg
<= MT_LAST_ARGREG
; i
++)
786 typelen
= TYPE_LENGTH (value_type (args
[i
]));
793 regcache_cooked_write_unsigned (regcache
, argreg
++,
794 extract_unsigned_integer
795 (value_contents (args
[i
]),
796 wordsize
, byte_order
));
801 val
= value_contents (args
[i
]);
804 if (argreg
<= MT_LAST_ARGREG
)
806 /* This word of the argument is passed in a register. */
807 regcache_cooked_write_unsigned (regcache
, argreg
++,
808 extract_unsigned_integer
809 (val
, wordsize
, byte_order
));
815 /* Remainder of this arg must be passed on the stack
816 (deferred to do later). */
817 split_param_len
= typelen
;
818 memcpy (buf
, val
, typelen
);
819 break; /* No more args can be handled in regs. */
824 /* By reverse engineering of gcc output, args bigger than
825 16 bytes go on the stack, and their address is passed
827 stack_dest
-= typelen
;
828 write_memory (stack_dest
, value_contents (args
[i
]), typelen
);
829 regcache_cooked_write_unsigned (regcache
, argreg
++, stack_dest
);
834 /* Next, the rest of the arguments go onto the stack, in reverse order. */
835 for (j
= nargs
- 1; j
>= i
; j
--)
839 /* Right-justify the value in an aligned-length buffer. */
840 typelen
= TYPE_LENGTH (value_type (args
[j
]));
841 slacklen
= (wordsize
- (typelen
% wordsize
)) % wordsize
;
842 val
= alloca (typelen
+ slacklen
);
843 memcpy (val
, value_contents (args
[j
]), typelen
);
844 memset (val
+ typelen
, 0, slacklen
);
845 /* Now write this data to the stack. */
846 stack_dest
-= typelen
+ slacklen
;
847 write_memory (stack_dest
, val
, typelen
+ slacklen
);
850 /* Finally, if a param needs to be split between registers and stack,
851 write the second half to the stack now. */
852 if (split_param_len
!= 0)
854 stack_dest
-= split_param_len
;
855 write_memory (stack_dest
, buf
, split_param_len
);
858 /* Set up return address (provided to us as bp_addr). */
859 regcache_cooked_write_unsigned (regcache
, MT_RA_REGNUM
, bp_addr
);
861 /* Store struct return address, if given. */
862 if (struct_return
&& struct_addr
!= 0)
863 regcache_cooked_write_unsigned (regcache
, MT_R11_REGNUM
, struct_addr
);
865 /* Set aside 16 bytes for the callee to save regs 1-4. */
868 /* Update the stack pointer. */
869 regcache_cooked_write_unsigned (regcache
, MT_SP_REGNUM
, stack_dest
);
871 /* And that should do it. Return the new stack pointer. */
876 /* The 'unwind_cache' data structure. */
878 struct mt_unwind_cache
880 /* The previous frame's inner most stack address.
881 Used as this frame ID's stack_addr. */
883 CORE_ADDR frame_base
;
887 /* Table indicating the location of each and every register. */
888 struct trad_frame_saved_reg
*saved_regs
;
891 /* Initialize an unwind_cache. Build up the saved_regs table etc. for
894 static struct mt_unwind_cache
*
895 mt_frame_unwind_cache (struct frame_info
*this_frame
,
896 void **this_prologue_cache
)
898 struct gdbarch
*gdbarch
;
899 struct mt_unwind_cache
*info
;
900 CORE_ADDR next_addr
, start_addr
, end_addr
, prologue_end_addr
;
901 unsigned long instr
, upper_half
, delayed_store
= 0;
905 if ((*this_prologue_cache
))
906 return (*this_prologue_cache
);
908 gdbarch
= get_frame_arch (this_frame
);
909 info
= FRAME_OBSTACK_ZALLOC (struct mt_unwind_cache
);
910 (*this_prologue_cache
) = info
;
914 info
->frame_base
= 0;
915 info
->frameless_p
= 1;
916 info
->saved_regs
= trad_frame_alloc_saved_regs (this_frame
);
918 /* Grab the frame-relative values of SP and FP, needed below.
919 The frame_saved_register function will find them on the
920 stack or in the registers as appropriate. */
921 sp
= get_frame_register_unsigned (this_frame
, MT_SP_REGNUM
);
922 fp
= get_frame_register_unsigned (this_frame
, MT_FP_REGNUM
);
924 start_addr
= get_frame_func (this_frame
);
926 /* Return early if GDB couldn't find the function. */
930 end_addr
= get_frame_pc (this_frame
);
931 prologue_end_addr
= skip_prologue_using_sal (gdbarch
, start_addr
);
933 for (next_addr
= start_addr
; next_addr
< end_addr
; next_addr
+= 4)
935 instr
= get_frame_memory_unsigned (this_frame
, next_addr
, 4);
936 if (delayed_store
) /* previous instr was a push */
938 upper_half
= delayed_store
>> 16;
939 regnum
= upper_half
& 0xf;
940 offset
= delayed_store
& 0xffff;
941 switch (upper_half
& 0xfff0)
943 case 0x43c0: /* push using frame pointer */
944 info
->saved_regs
[regnum
].addr
= offset
;
946 case 0x43d0: /* push using stack pointer */
947 info
->saved_regs
[regnum
].addr
= offset
;
957 case 0x12000000: /* NO-OP */
959 case 0x12ddc000: /* copy sp into fp */
960 info
->frameless_p
= 0; /* Record that the frame pointer is in use. */
963 upper_half
= instr
>> 16;
964 if (upper_half
== 0x05dd || /* subi sp, sp, imm */
965 upper_half
== 0x07dd) /* subui sp, sp, imm */
967 /* Record the frame size. */
968 info
->framesize
= instr
& 0xffff;
971 if ((upper_half
& 0xfff0) == 0x43c0 || /* frame push */
972 (upper_half
& 0xfff0) == 0x43d0) /* stack push */
974 /* Save this instruction, but don't record the
975 pushed register as 'saved' until we see the
976 next instruction. That's because of deferred stores
977 on this target -- GDB won't be able to read the register
978 from the stack until one instruction later. */
979 delayed_store
= instr
;
982 /* Not a prologue instruction. Is this the end of the prologue?
983 This is the most difficult decision; when to stop scanning.
985 If we have no line symbol, then the best thing we can do
986 is to stop scanning when we encounter an instruction that
987 is not likely to be a part of the prologue.
989 But if we do have a line symbol, then we should
990 keep scanning until we reach it (or we reach end_addr). */
992 if (prologue_end_addr
&& (prologue_end_addr
> (next_addr
+ 4)))
993 continue; /* Keep scanning, recording saved_regs etc. */
995 break; /* Quit scanning: breakpoint can be set here. */
999 /* Special handling for the "saved" address of the SP:
1000 The SP is of course never saved on the stack at all, so
1001 by convention what we put here is simply the previous
1002 _value_ of the SP (as opposed to an address where the
1003 previous value would have been pushed). This will also
1004 give us the frame base address. */
1006 if (info
->frameless_p
)
1008 info
->frame_base
= sp
+ info
->framesize
;
1009 info
->prev_sp
= sp
+ info
->framesize
;
1013 info
->frame_base
= fp
+ info
->framesize
;
1014 info
->prev_sp
= fp
+ info
->framesize
;
1016 /* Save prev_sp in saved_regs as a value, not as an address. */
1017 trad_frame_set_value (info
->saved_regs
, MT_SP_REGNUM
, info
->prev_sp
);
1019 /* Now convert frame offsets to actual addresses (not offsets). */
1020 for (regnum
= 0; regnum
< MT_NUM_REGS
; regnum
++)
1021 if (trad_frame_addr_p (info
->saved_regs
, regnum
))
1022 info
->saved_regs
[regnum
].addr
+= info
->frame_base
- info
->framesize
;
1024 /* The call instruction moves the caller's PC in the callee's RA reg.
1025 Since this is an unwind, do the reverse. Copy the location of RA
1026 into PC (the address / regnum) so that a request for PC will be
1027 converted into a request for the RA. */
1028 info
->saved_regs
[MT_PC_REGNUM
] = info
->saved_regs
[MT_RA_REGNUM
];
1034 mt_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
1038 pc
= frame_unwind_register_unsigned (next_frame
, MT_PC_REGNUM
);
1043 mt_unwind_sp (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
1047 sp
= frame_unwind_register_unsigned (next_frame
, MT_SP_REGNUM
);
1051 /* Assuming THIS_FRAME is a dummy, return the frame ID of that dummy
1052 frame. The frame ID's base needs to match the TOS value saved by
1053 save_dummy_frame_tos(), and the PC match the dummy frame's breakpoint. */
1055 static struct frame_id
1056 mt_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*this_frame
)
1058 CORE_ADDR sp
= get_frame_register_unsigned (this_frame
, MT_SP_REGNUM
);
1059 return frame_id_build (sp
, get_frame_pc (this_frame
));
1062 /* Given a GDB frame, determine the address of the calling function's
1063 frame. This will be used to create a new GDB frame struct. */
1066 mt_frame_this_id (struct frame_info
*this_frame
,
1067 void **this_prologue_cache
, struct frame_id
*this_id
)
1069 struct mt_unwind_cache
*info
=
1070 mt_frame_unwind_cache (this_frame
, this_prologue_cache
);
1072 if (!(info
== NULL
|| info
->prev_sp
== 0))
1073 (*this_id
) = frame_id_build (info
->prev_sp
, get_frame_func (this_frame
));
1078 static struct value
*
1079 mt_frame_prev_register (struct frame_info
*this_frame
,
1080 void **this_prologue_cache
, int regnum
)
1082 struct mt_unwind_cache
*info
=
1083 mt_frame_unwind_cache (this_frame
, this_prologue_cache
);
1085 return trad_frame_get_prev_register (this_frame
, info
->saved_regs
, regnum
);
1089 mt_frame_base_address (struct frame_info
*this_frame
,
1090 void **this_prologue_cache
)
1092 struct mt_unwind_cache
*info
=
1093 mt_frame_unwind_cache (this_frame
, this_prologue_cache
);
1095 return info
->frame_base
;
1098 /* This is a shared interface: the 'frame_unwind' object is what's
1099 returned by the 'sniffer' function, and in turn specifies how to
1100 get a frame's ID and prev_regs.
1102 This exports the 'prev_register' and 'this_id' methods. */
1104 static const struct frame_unwind mt_frame_unwind
= {
1107 mt_frame_prev_register
,
1109 default_frame_sniffer
1112 /* Another shared interface: the 'frame_base' object specifies how to
1113 unwind a frame and secure the base addresses for frame objects
1116 static struct frame_base mt_frame_base
= {
1118 mt_frame_base_address
,
1119 mt_frame_base_address
,
1120 mt_frame_base_address
1123 static struct gdbarch
*
1124 mt_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
1126 struct gdbarch
*gdbarch
;
1127 struct gdbarch_tdep
*tdep
;
1129 /* Find a candidate among the list of pre-declared architectures. */
1130 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
1132 return arches
->gdbarch
;
1134 /* None found, create a new architecture from the information
1136 tdep
= XCALLOC (1, struct gdbarch_tdep
);
1137 gdbarch
= gdbarch_alloc (&info
, tdep
);
1139 set_gdbarch_float_format (gdbarch
, floatformats_ieee_single
);
1140 set_gdbarch_double_format (gdbarch
, floatformats_ieee_double
);
1141 set_gdbarch_long_double_format (gdbarch
, floatformats_ieee_double
);
1143 set_gdbarch_register_name (gdbarch
, mt_register_name
);
1144 set_gdbarch_num_regs (gdbarch
, MT_NUM_REGS
);
1145 set_gdbarch_num_pseudo_regs (gdbarch
, MT_NUM_PSEUDO_REGS
);
1146 set_gdbarch_pc_regnum (gdbarch
, MT_PC_REGNUM
);
1147 set_gdbarch_sp_regnum (gdbarch
, MT_SP_REGNUM
);
1148 set_gdbarch_pseudo_register_read (gdbarch
, mt_pseudo_register_read
);
1149 set_gdbarch_pseudo_register_write (gdbarch
, mt_pseudo_register_write
);
1150 set_gdbarch_skip_prologue (gdbarch
, mt_skip_prologue
);
1151 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
1152 set_gdbarch_breakpoint_from_pc (gdbarch
, mt_breakpoint_from_pc
);
1153 set_gdbarch_decr_pc_after_break (gdbarch
, 0);
1154 set_gdbarch_frame_args_skip (gdbarch
, 0);
1155 set_gdbarch_print_insn (gdbarch
, print_insn_mt
);
1156 set_gdbarch_register_type (gdbarch
, mt_register_type
);
1157 set_gdbarch_register_reggroup_p (gdbarch
, mt_register_reggroup_p
);
1159 set_gdbarch_return_value (gdbarch
, mt_return_value
);
1160 set_gdbarch_sp_regnum (gdbarch
, MT_SP_REGNUM
);
1162 set_gdbarch_frame_align (gdbarch
, mt_frame_align
);
1164 set_gdbarch_print_registers_info (gdbarch
, mt_registers_info
);
1166 set_gdbarch_push_dummy_call (gdbarch
, mt_push_dummy_call
);
1168 /* Target builtin data types. */
1169 set_gdbarch_short_bit (gdbarch
, 16);
1170 set_gdbarch_int_bit (gdbarch
, 32);
1171 set_gdbarch_long_bit (gdbarch
, 32);
1172 set_gdbarch_long_long_bit (gdbarch
, 64);
1173 set_gdbarch_float_bit (gdbarch
, 32);
1174 set_gdbarch_double_bit (gdbarch
, 64);
1175 set_gdbarch_long_double_bit (gdbarch
, 64);
1176 set_gdbarch_ptr_bit (gdbarch
, 32);
1178 /* Register the DWARF 2 sniffer first, and then the traditional prologue
1180 dwarf2_append_unwinders (gdbarch
);
1181 frame_unwind_append_unwinder (gdbarch
, &mt_frame_unwind
);
1182 frame_base_set_default (gdbarch
, &mt_frame_base
);
1184 /* Register the 'unwind_pc' method. */
1185 set_gdbarch_unwind_pc (gdbarch
, mt_unwind_pc
);
1186 set_gdbarch_unwind_sp (gdbarch
, mt_unwind_sp
);
1188 /* Methods for saving / extracting a dummy frame's ID.
1189 The ID's stack address must match the SP value returned by
1190 PUSH_DUMMY_CALL, and saved by generic_save_dummy_frame_tos. */
1191 set_gdbarch_dummy_id (gdbarch
, mt_dummy_id
);
1196 /* Provide a prototype to silence -Wmissing-prototypes. */
1197 extern initialize_file_ftype _initialize_mt_tdep
;
1200 _initialize_mt_tdep (void)
1202 register_gdbarch_init (bfd_arch_mt
, mt_gdbarch_init
);