1 /* Target-dependent code for Morpho mt processor, for GDB.
3 Copyright (C) 2005-2014 Free Software Foundation, Inc.
5 This file is part of GDB.
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.
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.
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/>. */
20 /* Contributed by Michael Snyder, msnyder@redhat.com. */
24 #include "frame-unwind.h"
25 #include "frame-base.h"
28 #include "arch-utils.h"
32 #include "reggroups.h"
34 #include "trad-frame.h"
36 #include "dwarf2-frame.h"
41 enum mt_arch_constants
43 MT_MAX_STRUCT_SIZE
= 16
48 MT_R0_REGNUM
, /* 32 bit regs. */
50 MT_1ST_ARGREG
= MT_R1_REGNUM
,
54 MT_LAST_ARGREG
= MT_R4_REGNUM
,
63 MT_FP_REGNUM
= MT_R12_REGNUM
,
65 MT_SP_REGNUM
= MT_R13_REGNUM
,
67 MT_RA_REGNUM
= MT_R14_REGNUM
,
69 MT_IRA_REGNUM
= MT_R15_REGNUM
,
72 /* Interrupt Enable pseudo-register, exported by SID. */
74 /* End of CPU regs. */
78 /* Co-processor registers. */
79 MT_COPRO_REGNUM
= MT_NUM_CPU_REGS
, /* 16 bit regs. */
96 MT_BYPA_REGNUM
, /* 32 bit regs. */
100 MT_CONTEXT_REGNUM
, /* 38 bits (treat as array of
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. */
118 /* Number of real registers. */
121 /* Pseudo-registers. */
122 MT_COPRO_PSEUDOREG_REGNUM
= MT_NUM_REGS
,
123 MT_MAC_PSEUDOREG_REGNUM
,
124 MT_COPRO_PSEUDOREG_ARRAY
,
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,
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
)
141 /* The tdep structure. */
144 /* ISA-specific types. */
145 struct type
*copro_type
;
149 /* Return name of register number specified by REGNUM. */
152 mt_register_name (struct gdbarch
*gdbarch
, int regnum
)
154 static const char *const register_names
[] = {
156 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
157 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
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. */
169 static const char *array_names
[MT_COPRO_PSEUDOREG_REGS
170 * MT_COPRO_PSEUDOREG_DIM_1
171 * MT_COPRO_PSEUDOREG_DIM_2
];
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
];
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
);
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
)
198 stub
= register_names
[index
+ MT_CPR0_REGNUM
];
201 array_names
[regnum
] = stub
;
205 sprintf (name
, "copro_%d_%d_%s", dim_1
, dim_2
, stub
);
206 array_names
[regnum
] = name
;
211 /* Return the type of a coprocessor register. */
214 mt_copro_register_type (struct gdbarch
*arch
, int regnum
)
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
;
232 return builtin_type (arch
)->builtin_int16
;
233 case MT_EXMAC_REGNUM
:
235 return builtin_type (arch
)->builtin_uint32
;
236 case MT_CONTEXT_REGNUM
:
237 return builtin_type (arch
)->builtin_long_long
;
239 return builtin_type (arch
)->builtin_unsigned_char
;
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
)
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
;
249 return builtin_type (arch
)->builtin_uint32
;
252 return builtin_type (arch
)->builtin_uint32
;
256 /* Given ARCH and a register number specified by REGNUM, return the
257 type of that register. */
260 mt_register_type (struct gdbarch
*arch
, int regnum
)
262 struct gdbarch_tdep
*tdep
= gdbarch_tdep (arch
);
264 if (regnum
>= 0 && regnum
< MT_NUM_REGS
+ MT_NUM_PSEUDO_REGS
)
271 return builtin_type (arch
)->builtin_func_ptr
;
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
)
279 struct type
*elt
= builtin_type (arch
)->builtin_int16
;
280 tdep
->copro_type
= lookup_array_range_type (elt
, 0, 1);
282 return tdep
->copro_type
;
283 case MT_MAC_PSEUDOREG_REGNUM
:
284 return mt_copro_register_type (arch
,
286 + MT_COPRO_PSEUDOREG_MAC_REGNUM
);
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
);
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
);
301 internal_error (__FILE__
, __LINE__
,
302 _("mt_register_type: illegal register number %d"), regnum
);
305 /* Return true if register REGNUM is a member of the register group
306 specified by GROUP. */
309 mt_register_reggroup_p (struct gdbarch
*gdbarch
, int regnum
,
310 struct reggroup
*group
)
312 /* Groups of registers that can be displayed via "info reg". */
313 if (group
== all_reggroup
)
315 && regnum
< MT_NUM_REGS
+ MT_NUM_PSEUDO_REGS
316 && mt_register_name (gdbarch
, regnum
)[0] != '\0');
318 if (group
== general_reggroup
)
319 return (regnum
>= MT_R0_REGNUM
&& regnum
<= MT_R15_REGNUM
);
321 if (group
== float_reggroup
)
322 return 0; /* No float regs. */
324 if (group
== vector_reggroup
)
325 return 0; /* No vector regs. */
327 /* For any that are not handled above. */
328 return default_register_reggroup_p (gdbarch
, regnum
, group
);
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
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
)
341 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
343 if (TYPE_LENGTH (type
) > 4)
345 /* Return values > 4 bytes are returned in memory,
346 pointed to by R11. */
351 regcache_cooked_read_unsigned (regcache
, MT_R11_REGNUM
, &addr
);
352 read_memory (addr
, readbuf
, TYPE_LENGTH (type
));
359 regcache_cooked_read_unsigned (regcache
, MT_R11_REGNUM
, &addr
);
360 write_memory (addr
, writebuf
, TYPE_LENGTH (type
));
363 return RETURN_VALUE_ABI_RETURNS_ADDRESS
;
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
),
379 if (TYPE_LENGTH (type
) < 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
);
388 else /* (TYPE_LENGTH (type) == 4 */
389 regcache_cooked_write (regcache
, MT_R11_REGNUM
, writebuf
);
392 return RETURN_VALUE_REGISTER_CONVENTION
;
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
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
406 mt_skip_prologue (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
408 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
409 CORE_ADDR func_addr
= 0, func_end
= 0;
410 const char *func_name
;
413 if (find_pc_partial_function (pc
, &func_name
, &func_addr
, &func_end
))
415 struct symtab_and_line sal
;
418 /* Found a function. */
419 sym
= lookup_symbol (func_name
, NULL
, VAR_DOMAIN
, NULL
);
420 if (sym
&& SYMBOL_LANGUAGE (sym
) != language_asm
)
422 /* Don't use this trick for assembly source files. */
423 sal
= find_pc_line (func_addr
, 0);
425 if (sal
.end
&& sal
.end
< func_end
)
427 /* Found a line number, use it as end of prologue. */
433 /* No function symbol, or no line symbol. Use prologue scanning method. */
436 instr
= read_memory_unsigned_integer (pc
, 4, byte_order
);
437 if (instr
== 0x12000000) /* nop */
439 if (instr
== 0x12ddc000) /* copy sp into fp */
442 if (instr
== 0x05dd) /* subi sp, sp, imm */
444 if (instr
>= 0x43c0 && instr
<= 0x43df) /* push */
446 /* Not an obvious prologue instruction. */
453 /* The breakpoint instruction must be the same size as the smallest
454 instruction in the instruction set.
456 The BP for ms1 is defined as 0x68000000 (BREAK).
457 The BP for ms2 is defined as 0x69000000 (illegal). */
459 static const gdb_byte
*
460 mt_breakpoint_from_pc (struct gdbarch
*gdbarch
, CORE_ADDR
*bp_addr
,
463 static gdb_byte ms1_breakpoint
[] = { 0x68, 0, 0, 0 };
464 static gdb_byte ms2_breakpoint
[] = { 0x69, 0, 0, 0 };
467 if (gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_ms2
)
468 return ms2_breakpoint
;
470 return ms1_breakpoint
;
473 /* Select the correct coprocessor register bank. Return the pseudo
474 regnum we really want to read. */
477 mt_select_coprocessor (struct gdbarch
*gdbarch
,
478 struct regcache
*regcache
, int regno
)
480 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
481 unsigned index
, base
;
484 /* Get the copro pseudo regnum. */
485 regcache_raw_read (regcache
, MT_COPRO_REGNUM
, copro
);
486 base
= ((extract_signed_integer (&copro
[0], 2, byte_order
)
487 * MT_COPRO_PSEUDOREG_DIM_2
)
488 + extract_signed_integer (&copro
[2], 2, byte_order
));
490 regno
-= MT_COPRO_PSEUDOREG_ARRAY
;
491 index
= regno
% MT_COPRO_PSEUDOREG_REGS
;
492 regno
/= MT_COPRO_PSEUDOREG_REGS
;
495 /* Select the correct coprocessor register bank. Invalidate the
496 coprocessor register cache. */
499 store_signed_integer (&copro
[0], 2, byte_order
,
500 regno
/ MT_COPRO_PSEUDOREG_DIM_2
);
501 store_signed_integer (&copro
[2], 2, byte_order
,
502 regno
% MT_COPRO_PSEUDOREG_DIM_2
);
503 regcache_raw_write (regcache
, MT_COPRO_REGNUM
, copro
);
505 /* We must flush the cache, as it is now invalid. */
506 for (ix
= MT_NUM_CPU_REGS
; ix
!= MT_NUM_REGS
; ix
++)
507 regcache_invalidate (regcache
, ix
);
513 /* Fetch the pseudo registers:
515 There are two regular pseudo-registers:
516 1) The 'coprocessor' pseudo-register (which mirrors the
517 "real" coprocessor register sent by the target), and
518 2) The 'MAC' pseudo-register (which represents the union
519 of the original 32 bit target MAC register and the new
520 8-bit extended-MAC register).
522 Additionally there is an array of coprocessor registers which track
523 the coprocessor registers for each coprocessor. */
525 static enum register_status
526 mt_pseudo_register_read (struct gdbarch
*gdbarch
,
527 struct regcache
*regcache
, int regno
, gdb_byte
*buf
)
529 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
533 case MT_COPRO_REGNUM
:
534 case MT_COPRO_PSEUDOREG_REGNUM
:
535 return regcache_raw_read (regcache
, MT_COPRO_REGNUM
, buf
);
537 case MT_MAC_PSEUDOREG_REGNUM
:
538 if (gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_mrisc2
539 || gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_ms2
)
541 enum register_status status
;
542 ULONGEST oldmac
= 0, ext_mac
= 0;
545 status
= regcache_cooked_read_unsigned (regcache
, MT_MAC_REGNUM
, &oldmac
);
546 if (status
!= REG_VALID
)
549 regcache_cooked_read_unsigned (regcache
, MT_EXMAC_REGNUM
, &ext_mac
);
550 if (status
!= REG_VALID
)
554 (oldmac
& 0xffffffff) | ((long long) (ext_mac
& 0xff) << 32);
555 store_signed_integer (buf
, 8, byte_order
, newmac
);
560 return regcache_raw_read (regcache
, MT_MAC_REGNUM
, buf
);
564 unsigned index
= mt_select_coprocessor (gdbarch
, regcache
, regno
);
566 if (index
== MT_COPRO_PSEUDOREG_MAC_REGNUM
)
567 return mt_pseudo_register_read (gdbarch
, regcache
,
568 MT_MAC_PSEUDOREG_REGNUM
, buf
);
569 else if (index
< MT_NUM_REGS
- MT_CPR0_REGNUM
)
570 return regcache_raw_read (regcache
, index
+ MT_CPR0_REGNUM
, buf
);
579 /* Write the pseudo registers:
581 Mt pseudo-registers are stored directly to the target. The
582 'coprocessor' register is special, because when it is modified, all
583 the other coprocessor regs must be flushed from the reg cache. */
586 mt_pseudo_register_write (struct gdbarch
*gdbarch
,
587 struct regcache
*regcache
,
588 int regno
, const gdb_byte
*buf
)
590 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
595 case MT_COPRO_REGNUM
:
596 case MT_COPRO_PSEUDOREG_REGNUM
:
597 regcache_raw_write (regcache
, MT_COPRO_REGNUM
, buf
);
598 for (i
= MT_NUM_CPU_REGS
; i
< MT_NUM_REGS
; i
++)
599 regcache_invalidate (regcache
, i
);
602 case MT_MAC_PSEUDOREG_REGNUM
:
603 if (gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_mrisc2
604 || gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_ms2
)
606 /* The 8-byte MAC pseudo-register must be broken down into two
607 32-byte registers. */
608 unsigned int oldmac
, ext_mac
;
611 newmac
= extract_unsigned_integer (buf
, 8, byte_order
);
612 oldmac
= newmac
& 0xffffffff;
613 ext_mac
= (newmac
>> 32) & 0xff;
614 regcache_cooked_write_unsigned (regcache
, MT_MAC_REGNUM
, oldmac
);
615 regcache_cooked_write_unsigned (regcache
, MT_EXMAC_REGNUM
, ext_mac
);
618 regcache_raw_write (regcache
, MT_MAC_REGNUM
, buf
);
622 unsigned index
= mt_select_coprocessor (gdbarch
, regcache
, regno
);
624 if (index
== MT_COPRO_PSEUDOREG_MAC_REGNUM
)
625 mt_pseudo_register_write (gdbarch
, regcache
,
626 MT_MAC_PSEUDOREG_REGNUM
, buf
);
627 else if (index
< MT_NUM_REGS
- MT_CPR0_REGNUM
)
628 regcache_raw_write (regcache
, index
+ MT_CPR0_REGNUM
, buf
);
635 mt_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR sp
)
637 /* Register size is 4 bytes. */
638 return align_down (sp
, 4);
641 /* Implements the "info registers" command. When ``all'' is non-zero,
642 the coprocessor registers will be printed in addition to the rest
646 mt_registers_info (struct gdbarch
*gdbarch
,
647 struct ui_file
*file
,
648 struct frame_info
*frame
, int regnum
, int all
)
650 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
656 lim
= all
? MT_NUM_REGS
: MT_NUM_CPU_REGS
;
658 for (regnum
= 0; regnum
< lim
; regnum
++)
660 /* Don't display the Qchannel register since it will be displayed
661 along with Ichannel. (See below.) */
662 if (regnum
== MT_QCHANNEL_REGNUM
)
665 mt_registers_info (gdbarch
, file
, frame
, regnum
, all
);
667 /* Display the Qchannel register immediately after Ichannel. */
668 if (regnum
== MT_ICHANNEL_REGNUM
)
669 mt_registers_info (gdbarch
, file
, frame
, MT_QCHANNEL_REGNUM
, all
);
674 if (regnum
== MT_EXMAC_REGNUM
)
676 else if (regnum
== MT_CONTEXT_REGNUM
)
678 /* Special output handling for 38-bit context register. */
680 unsigned int *bytes
, i
, regsize
;
682 regsize
= register_size (gdbarch
, regnum
);
684 buff
= alloca (regsize
);
685 bytes
= alloca (regsize
* sizeof (*bytes
));
687 deprecated_frame_register_read (frame
, regnum
, buff
);
689 fputs_filtered (gdbarch_register_name
690 (gdbarch
, regnum
), file
);
691 print_spaces_filtered (15 - strlen (gdbarch_register_name
694 fputs_filtered ("0x", file
);
696 for (i
= 0; i
< regsize
; i
++)
697 fprintf_filtered (file
, "%02x", (unsigned int)
698 extract_unsigned_integer (buff
+ i
, 1, byte_order
));
699 fputs_filtered ("\t", file
);
700 print_longest (file
, 'd', 0,
701 extract_unsigned_integer (buff
, regsize
, byte_order
));
702 fputs_filtered ("\n", file
);
704 else if (regnum
== MT_COPRO_REGNUM
705 || regnum
== MT_COPRO_PSEUDOREG_REGNUM
)
707 /* Special output handling for the 'coprocessor' register. */
709 struct value_print_options opts
;
711 buf
= alloca (register_size (gdbarch
, MT_COPRO_REGNUM
));
712 deprecated_frame_register_read (frame
, MT_COPRO_REGNUM
, buf
);
714 regnum
= MT_COPRO_PSEUDOREG_REGNUM
;
715 fputs_filtered (gdbarch_register_name (gdbarch
, regnum
),
717 print_spaces_filtered (15 - strlen (gdbarch_register_name
720 get_no_prettyformat_print_options (&opts
);
722 val_print (register_type (gdbarch
, regnum
), buf
,
724 &opts
, current_language
);
725 fputs_filtered ("\n", file
);
727 else if (regnum
== MT_MAC_REGNUM
|| regnum
== MT_MAC_PSEUDOREG_REGNUM
)
729 ULONGEST oldmac
, ext_mac
, newmac
;
730 gdb_byte buf
[3 * sizeof (LONGEST
)];
732 /* Get the two "real" mac registers. */
733 deprecated_frame_register_read (frame
, MT_MAC_REGNUM
, buf
);
734 oldmac
= extract_unsigned_integer
735 (buf
, register_size (gdbarch
, MT_MAC_REGNUM
), byte_order
);
736 if (gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_mrisc2
737 || gdbarch_bfd_arch_info (gdbarch
)->mach
== bfd_mach_ms2
)
739 deprecated_frame_register_read (frame
, MT_EXMAC_REGNUM
, buf
);
740 ext_mac
= extract_unsigned_integer
741 (buf
, register_size (gdbarch
, MT_EXMAC_REGNUM
), byte_order
);
746 /* Add them together. */
747 newmac
= (oldmac
& 0xffffffff) + ((ext_mac
& 0xff) << 32);
750 regnum
= MT_MAC_PSEUDOREG_REGNUM
;
751 fputs_filtered (gdbarch_register_name (gdbarch
, regnum
),
753 print_spaces_filtered (15 - strlen (gdbarch_register_name
756 fputs_filtered ("0x", file
);
757 print_longest (file
, 'x', 0, newmac
);
758 fputs_filtered ("\t", file
);
759 print_longest (file
, 'u', 0, newmac
);
760 fputs_filtered ("\n", file
);
763 default_print_registers_info (gdbarch
, file
, frame
, regnum
, all
);
767 /* Set up the callee's arguments for an inferior function call. The
768 arguments are pushed on the stack or are placed in registers as
769 appropriate. It also sets up the return address (which points to
770 the call dummy breakpoint).
772 Returns the updated (and aligned) stack pointer. */
775 mt_push_dummy_call (struct gdbarch
*gdbarch
, struct value
*function
,
776 struct regcache
*regcache
, CORE_ADDR bp_addr
,
777 int nargs
, struct value
**args
, CORE_ADDR sp
,
778 int struct_return
, CORE_ADDR struct_addr
)
781 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
782 gdb_byte buf
[MT_MAX_STRUCT_SIZE
];
783 int argreg
= MT_1ST_ARGREG
;
784 int split_param_len
= 0;
790 /* First handle however many args we can fit into MT_1ST_ARGREG thru
792 for (i
= 0; i
< nargs
&& argreg
<= MT_LAST_ARGREG
; i
++)
795 typelen
= TYPE_LENGTH (value_type (args
[i
]));
802 regcache_cooked_write_unsigned (regcache
, argreg
++,
803 extract_unsigned_integer
804 (value_contents (args
[i
]),
805 wordsize
, byte_order
));
810 val
= value_contents (args
[i
]);
813 if (argreg
<= MT_LAST_ARGREG
)
815 /* This word of the argument is passed in a register. */
816 regcache_cooked_write_unsigned (regcache
, argreg
++,
817 extract_unsigned_integer
818 (val
, wordsize
, byte_order
));
824 /* Remainder of this arg must be passed on the stack
825 (deferred to do later). */
826 split_param_len
= typelen
;
827 memcpy (buf
, val
, typelen
);
828 break; /* No more args can be handled in regs. */
833 /* By reverse engineering of gcc output, args bigger than
834 16 bytes go on the stack, and their address is passed
836 stack_dest
-= typelen
;
837 write_memory (stack_dest
, value_contents (args
[i
]), typelen
);
838 regcache_cooked_write_unsigned (regcache
, argreg
++, stack_dest
);
843 /* Next, the rest of the arguments go onto the stack, in reverse order. */
844 for (j
= nargs
- 1; j
>= i
; j
--)
847 struct cleanup
*back_to
;
848 const gdb_byte
*contents
= value_contents (args
[j
]);
850 /* Right-justify the value in an aligned-length buffer. */
851 typelen
= TYPE_LENGTH (value_type (args
[j
]));
852 slacklen
= (wordsize
- (typelen
% wordsize
)) % wordsize
;
853 val
= xmalloc (typelen
+ slacklen
);
854 back_to
= make_cleanup (xfree
, val
);
855 memcpy (val
, contents
, typelen
);
856 memset (val
+ typelen
, 0, slacklen
);
857 /* Now write this data to the stack. */
858 stack_dest
-= typelen
+ slacklen
;
859 write_memory (stack_dest
, val
, typelen
+ slacklen
);
860 do_cleanups (back_to
);
863 /* Finally, if a param needs to be split between registers and stack,
864 write the second half to the stack now. */
865 if (split_param_len
!= 0)
867 stack_dest
-= split_param_len
;
868 write_memory (stack_dest
, buf
, split_param_len
);
871 /* Set up return address (provided to us as bp_addr). */
872 regcache_cooked_write_unsigned (regcache
, MT_RA_REGNUM
, bp_addr
);
874 /* Store struct return address, if given. */
875 if (struct_return
&& struct_addr
!= 0)
876 regcache_cooked_write_unsigned (regcache
, MT_R11_REGNUM
, struct_addr
);
878 /* Set aside 16 bytes for the callee to save regs 1-4. */
881 /* Update the stack pointer. */
882 regcache_cooked_write_unsigned (regcache
, MT_SP_REGNUM
, stack_dest
);
884 /* And that should do it. Return the new stack pointer. */
889 /* The 'unwind_cache' data structure. */
891 struct mt_unwind_cache
893 /* The previous frame's inner most stack address.
894 Used as this frame ID's stack_addr. */
896 CORE_ADDR frame_base
;
900 /* Table indicating the location of each and every register. */
901 struct trad_frame_saved_reg
*saved_regs
;
904 /* Initialize an unwind_cache. Build up the saved_regs table etc. for
907 static struct mt_unwind_cache
*
908 mt_frame_unwind_cache (struct frame_info
*this_frame
,
909 void **this_prologue_cache
)
911 struct gdbarch
*gdbarch
;
912 struct mt_unwind_cache
*info
;
913 CORE_ADDR next_addr
, start_addr
, end_addr
, prologue_end_addr
;
914 unsigned long instr
, upper_half
, delayed_store
= 0;
918 if ((*this_prologue_cache
))
919 return (*this_prologue_cache
);
921 gdbarch
= get_frame_arch (this_frame
);
922 info
= FRAME_OBSTACK_ZALLOC (struct mt_unwind_cache
);
923 (*this_prologue_cache
) = info
;
927 info
->frame_base
= 0;
928 info
->frameless_p
= 1;
929 info
->saved_regs
= trad_frame_alloc_saved_regs (this_frame
);
931 /* Grab the frame-relative values of SP and FP, needed below.
932 The frame_saved_register function will find them on the
933 stack or in the registers as appropriate. */
934 sp
= get_frame_register_unsigned (this_frame
, MT_SP_REGNUM
);
935 fp
= get_frame_register_unsigned (this_frame
, MT_FP_REGNUM
);
937 start_addr
= get_frame_func (this_frame
);
939 /* Return early if GDB couldn't find the function. */
943 end_addr
= get_frame_pc (this_frame
);
944 prologue_end_addr
= skip_prologue_using_sal (gdbarch
, start_addr
);
946 for (next_addr
= start_addr
; next_addr
< end_addr
; next_addr
+= 4)
948 instr
= get_frame_memory_unsigned (this_frame
, next_addr
, 4);
949 if (delayed_store
) /* Previous instr was a push. */
951 upper_half
= delayed_store
>> 16;
952 regnum
= upper_half
& 0xf;
953 offset
= delayed_store
& 0xffff;
954 switch (upper_half
& 0xfff0)
956 case 0x43c0: /* push using frame pointer. */
957 info
->saved_regs
[regnum
].addr
= offset
;
959 case 0x43d0: /* push using stack pointer. */
960 info
->saved_regs
[regnum
].addr
= offset
;
970 case 0x12000000: /* NO-OP */
972 case 0x12ddc000: /* copy sp into fp */
973 info
->frameless_p
= 0; /* Record that the frame
974 pointer is in use. */
977 upper_half
= instr
>> 16;
978 if (upper_half
== 0x05dd || /* subi sp, sp, imm */
979 upper_half
== 0x07dd) /* subui sp, sp, imm */
981 /* Record the frame size. */
982 info
->framesize
= instr
& 0xffff;
985 if ((upper_half
& 0xfff0) == 0x43c0 || /* frame push */
986 (upper_half
& 0xfff0) == 0x43d0) /* stack push */
988 /* Save this instruction, but don't record the
989 pushed register as 'saved' until we see the
990 next instruction. That's because of deferred stores
991 on this target -- GDB won't be able to read the register
992 from the stack until one instruction later. */
993 delayed_store
= instr
;
996 /* Not a prologue instruction. Is this the end of the prologue?
997 This is the most difficult decision; when to stop scanning.
999 If we have no line symbol, then the best thing we can do
1000 is to stop scanning when we encounter an instruction that
1001 is not likely to be a part of the prologue.
1003 But if we do have a line symbol, then we should
1004 keep scanning until we reach it (or we reach end_addr). */
1006 if (prologue_end_addr
&& (prologue_end_addr
> (next_addr
+ 4)))
1007 continue; /* Keep scanning, recording saved_regs etc. */
1009 break; /* Quit scanning: breakpoint can be set here. */
1013 /* Special handling for the "saved" address of the SP:
1014 The SP is of course never saved on the stack at all, so
1015 by convention what we put here is simply the previous
1016 _value_ of the SP (as opposed to an address where the
1017 previous value would have been pushed). This will also
1018 give us the frame base address. */
1020 if (info
->frameless_p
)
1022 info
->frame_base
= sp
+ info
->framesize
;
1023 info
->prev_sp
= sp
+ info
->framesize
;
1027 info
->frame_base
= fp
+ info
->framesize
;
1028 info
->prev_sp
= fp
+ info
->framesize
;
1030 /* Save prev_sp in saved_regs as a value, not as an address. */
1031 trad_frame_set_value (info
->saved_regs
, MT_SP_REGNUM
, info
->prev_sp
);
1033 /* Now convert frame offsets to actual addresses (not offsets). */
1034 for (regnum
= 0; regnum
< MT_NUM_REGS
; regnum
++)
1035 if (trad_frame_addr_p (info
->saved_regs
, regnum
))
1036 info
->saved_regs
[regnum
].addr
+= info
->frame_base
- info
->framesize
;
1038 /* The call instruction moves the caller's PC in the callee's RA reg.
1039 Since this is an unwind, do the reverse. Copy the location of RA
1040 into PC (the address / regnum) so that a request for PC will be
1041 converted into a request for the RA. */
1042 info
->saved_regs
[MT_PC_REGNUM
] = info
->saved_regs
[MT_RA_REGNUM
];
1048 mt_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
1052 pc
= frame_unwind_register_unsigned (next_frame
, MT_PC_REGNUM
);
1057 mt_unwind_sp (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
1061 sp
= frame_unwind_register_unsigned (next_frame
, MT_SP_REGNUM
);
1065 /* Assuming THIS_FRAME is a dummy, return the frame ID of that dummy
1066 frame. The frame ID's base needs to match the TOS value saved by
1067 save_dummy_frame_tos(), and the PC match the dummy frame's breakpoint. */
1069 static struct frame_id
1070 mt_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*this_frame
)
1072 CORE_ADDR sp
= get_frame_register_unsigned (this_frame
, MT_SP_REGNUM
);
1073 return frame_id_build (sp
, get_frame_pc (this_frame
));
1076 /* Given a GDB frame, determine the address of the calling function's
1077 frame. This will be used to create a new GDB frame struct. */
1080 mt_frame_this_id (struct frame_info
*this_frame
,
1081 void **this_prologue_cache
, struct frame_id
*this_id
)
1083 struct mt_unwind_cache
*info
=
1084 mt_frame_unwind_cache (this_frame
, this_prologue_cache
);
1086 if (!(info
== NULL
|| info
->prev_sp
== 0))
1087 (*this_id
) = frame_id_build (info
->prev_sp
, get_frame_func (this_frame
));
1092 static struct value
*
1093 mt_frame_prev_register (struct frame_info
*this_frame
,
1094 void **this_prologue_cache
, int regnum
)
1096 struct mt_unwind_cache
*info
=
1097 mt_frame_unwind_cache (this_frame
, this_prologue_cache
);
1099 return trad_frame_get_prev_register (this_frame
, info
->saved_regs
, regnum
);
1103 mt_frame_base_address (struct frame_info
*this_frame
,
1104 void **this_prologue_cache
)
1106 struct mt_unwind_cache
*info
=
1107 mt_frame_unwind_cache (this_frame
, this_prologue_cache
);
1109 return info
->frame_base
;
1112 /* This is a shared interface: the 'frame_unwind' object is what's
1113 returned by the 'sniffer' function, and in turn specifies how to
1114 get a frame's ID and prev_regs.
1116 This exports the 'prev_register' and 'this_id' methods. */
1118 static const struct frame_unwind mt_frame_unwind
= {
1120 default_frame_unwind_stop_reason
,
1122 mt_frame_prev_register
,
1124 default_frame_sniffer
1127 /* Another shared interface: the 'frame_base' object specifies how to
1128 unwind a frame and secure the base addresses for frame objects
1131 static struct frame_base mt_frame_base
= {
1133 mt_frame_base_address
,
1134 mt_frame_base_address
,
1135 mt_frame_base_address
1138 static struct gdbarch
*
1139 mt_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
1141 struct gdbarch
*gdbarch
;
1142 struct gdbarch_tdep
*tdep
;
1144 /* Find a candidate among the list of pre-declared architectures. */
1145 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
1147 return arches
->gdbarch
;
1149 /* None found, create a new architecture from the information
1151 tdep
= XCNEW (struct gdbarch_tdep
);
1152 gdbarch
= gdbarch_alloc (&info
, tdep
);
1154 set_gdbarch_float_format (gdbarch
, floatformats_ieee_single
);
1155 set_gdbarch_double_format (gdbarch
, floatformats_ieee_double
);
1156 set_gdbarch_long_double_format (gdbarch
, floatformats_ieee_double
);
1158 set_gdbarch_register_name (gdbarch
, mt_register_name
);
1159 set_gdbarch_num_regs (gdbarch
, MT_NUM_REGS
);
1160 set_gdbarch_num_pseudo_regs (gdbarch
, MT_NUM_PSEUDO_REGS
);
1161 set_gdbarch_pc_regnum (gdbarch
, MT_PC_REGNUM
);
1162 set_gdbarch_sp_regnum (gdbarch
, MT_SP_REGNUM
);
1163 set_gdbarch_pseudo_register_read (gdbarch
, mt_pseudo_register_read
);
1164 set_gdbarch_pseudo_register_write (gdbarch
, mt_pseudo_register_write
);
1165 set_gdbarch_skip_prologue (gdbarch
, mt_skip_prologue
);
1166 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
1167 set_gdbarch_breakpoint_from_pc (gdbarch
, mt_breakpoint_from_pc
);
1168 set_gdbarch_decr_pc_after_break (gdbarch
, 0);
1169 set_gdbarch_frame_args_skip (gdbarch
, 0);
1170 set_gdbarch_print_insn (gdbarch
, print_insn_mt
);
1171 set_gdbarch_register_type (gdbarch
, mt_register_type
);
1172 set_gdbarch_register_reggroup_p (gdbarch
, mt_register_reggroup_p
);
1174 set_gdbarch_return_value (gdbarch
, mt_return_value
);
1175 set_gdbarch_sp_regnum (gdbarch
, MT_SP_REGNUM
);
1177 set_gdbarch_frame_align (gdbarch
, mt_frame_align
);
1179 set_gdbarch_print_registers_info (gdbarch
, mt_registers_info
);
1181 set_gdbarch_push_dummy_call (gdbarch
, mt_push_dummy_call
);
1183 /* Target builtin data types. */
1184 set_gdbarch_short_bit (gdbarch
, 16);
1185 set_gdbarch_int_bit (gdbarch
, 32);
1186 set_gdbarch_long_bit (gdbarch
, 32);
1187 set_gdbarch_long_long_bit (gdbarch
, 64);
1188 set_gdbarch_float_bit (gdbarch
, 32);
1189 set_gdbarch_double_bit (gdbarch
, 64);
1190 set_gdbarch_long_double_bit (gdbarch
, 64);
1191 set_gdbarch_ptr_bit (gdbarch
, 32);
1193 /* Register the DWARF 2 sniffer first, and then the traditional prologue
1195 dwarf2_append_unwinders (gdbarch
);
1196 frame_unwind_append_unwinder (gdbarch
, &mt_frame_unwind
);
1197 frame_base_set_default (gdbarch
, &mt_frame_base
);
1199 /* Register the 'unwind_pc' method. */
1200 set_gdbarch_unwind_pc (gdbarch
, mt_unwind_pc
);
1201 set_gdbarch_unwind_sp (gdbarch
, mt_unwind_sp
);
1203 /* Methods for saving / extracting a dummy frame's ID.
1204 The ID's stack address must match the SP value returned by
1205 PUSH_DUMMY_CALL, and saved by generic_save_dummy_frame_tos. */
1206 set_gdbarch_dummy_id (gdbarch
, mt_dummy_id
);
1211 /* Provide a prototype to silence -Wmissing-prototypes. */
1212 extern initialize_file_ftype _initialize_mt_tdep
;
1215 _initialize_mt_tdep (void)
1217 register_gdbarch_init (bfd_arch_mt
, mt_gdbarch_init
);