1 /* Target-dependent code for Moxie.
3 Copyright (C) 2009 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/>. */
22 #include "frame-unwind.h"
23 #include "frame-base.h"
28 #include "gdb_string.h"
35 #include "arch-utils.h"
37 #include "trad-frame.h"
41 #include "gdb_assert.h"
43 #include "moxie-tdep.h"
45 /* Local functions. */
47 extern void _initialize_moxie_tdep (void);
49 /* Use an invalid address value as 'not available' marker. */
50 enum { REG_UNAVAIL
= (CORE_ADDR
) -1 };
52 struct moxie_frame_cache
58 CORE_ADDR saved_regs
[MOXIE_NUM_REGS
];
62 /* Implement the "frame_align" gdbarch method. */
65 moxie_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR sp
)
67 /* Align to the size of an instruction (so that they can safely be
68 pushed onto the stack. */
72 /* Implement the "breakpoint_from_pc" gdbarch method. */
74 const static unsigned char *
75 moxie_breakpoint_from_pc (struct gdbarch
*gdbarch
,
76 CORE_ADDR
*pcptr
, int *lenptr
)
78 static unsigned char breakpoint
[] = { 0x35, 0x00 };
80 *lenptr
= sizeof (breakpoint
);
84 /* Moxie register names. */
86 char *moxie_register_names
[] = {
87 "$fp", "$sp", "$r0", "$r1", "$r2",
88 "$r3", "$r4", "$r5", "$r6", "$r7",
89 "$r8", "$r9", "$r10", "$r11", "$r12",
90 "$r13", "$pc", "$cc" };
92 /* Implement the "register_name" gdbarch method. */
95 moxie_register_name (struct gdbarch
*gdbarch
, int reg_nr
)
99 if (reg_nr
>= MOXIE_NUM_REGS
)
101 return moxie_register_names
[reg_nr
];
104 /* Implement the "register_type" gdbarch method. */
107 moxie_register_type (struct gdbarch
*gdbarch
, int reg_nr
)
109 if (reg_nr
== MOXIE_PC_REGNUM
)
110 return builtin_type (gdbarch
)->builtin_func_ptr
;
111 else if (reg_nr
== MOXIE_SP_REGNUM
|| reg_nr
== MOXIE_FP_REGNUM
)
112 return builtin_type (gdbarch
)->builtin_data_ptr
;
114 return builtin_type (gdbarch
)->builtin_int32
;
117 /* Write into appropriate registers a function return value
118 of type TYPE, given in virtual format. */
121 moxie_store_return_value (struct type
*type
, struct regcache
*regcache
,
124 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
125 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
127 int len
= TYPE_LENGTH (type
);
129 /* Things always get returned in RET1_REGNUM, RET2_REGNUM. */
130 regval
= extract_unsigned_integer (valbuf
, len
> 4 ? 4 : len
, byte_order
);
131 regcache_cooked_write_unsigned (regcache
, RET1_REGNUM
, regval
);
134 regval
= extract_unsigned_integer ((gdb_byte
*) valbuf
+ 4,
135 len
- 4, byte_order
);
136 regcache_cooked_write_unsigned (regcache
, RET1_REGNUM
+ 1, regval
);
140 /* Decode the instructions within the given address range. Decide
141 when we must have reached the end of the function prologue. If a
142 frame_info pointer is provided, fill in its saved_regs etc.
144 Returns the address of the first instruction after the prologue. */
147 moxie_analyze_prologue (CORE_ADDR start_addr
, CORE_ADDR end_addr
,
148 struct moxie_frame_cache
*cache
,
149 struct gdbarch
*gdbarch
)
151 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
153 ULONGEST inst
, inst2
;
157 /* Record where the jsra instruction saves the PC and FP. */
158 cache
->saved_regs
[MOXIE_PC_REGNUM
] = -4;
159 cache
->saved_regs
[MOXIE_FP_REGNUM
] = 0;
160 cache
->framesize
= 0;
162 if (start_addr
>= end_addr
)
165 for (next_addr
= start_addr
; next_addr
< end_addr
; )
167 inst
= read_memory_unsigned_integer (next_addr
, 2, byte_order
);
169 /* Match "push $rN" where N is between 2 and 13 inclusive. */
170 if (inst
>= 0x0614 && inst
<= 0x061f)
172 regnum
= inst
& 0x000f;
173 cache
->framesize
+= 4;
174 cache
->saved_regs
[regnum
] = cache
->framesize
;
179 inst
= read_memory_unsigned_integer (next_addr
, 2, byte_order
);
181 /* Optional stack allocation for args and local vars <= 4
183 if (inst
== 0x0170) /* ldi.l $r5, X */
185 offset
= read_memory_integer (next_addr
+ 2, 4, byte_order
);
186 inst2
= read_memory_unsigned_integer (next_addr
+ 6, 2, byte_order
);
188 if (inst2
== 0x0517) /* add.l $sp, $r5 */
190 cache
->framesize
+= offset
;
193 return (next_addr
+ 8);
195 else if ((inst
& 0xff00) == 0x91) /* dec $sp, X */
197 cache
->framesize
+= (inst
& 0x00ff);
200 while (next_addr
< end_addr
)
202 inst
= read_memory_unsigned_integer (next_addr
, 2, byte_order
);
203 if ((inst
& 0xff00) != 0x91) /* no more dec $sp, X */
205 cache
->framesize
+= (inst
& 0x00ff);
213 /* Find the end of function prologue. */
216 moxie_skip_prologue (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
218 CORE_ADDR func_addr
= 0, func_end
= 0;
221 /* See if we can determine the end of the prologue via the symbol table.
222 If so, then return either PC, or the PC after the prologue, whichever
224 if (find_pc_partial_function (pc
, &func_name
, &func_addr
, &func_end
))
226 CORE_ADDR post_prologue_pc
227 = skip_prologue_using_sal (gdbarch
, func_addr
);
228 if (post_prologue_pc
!= 0)
229 return max (pc
, post_prologue_pc
);
232 /* Can't determine prologue from the symbol table, need to examine
234 struct symtab_and_line sal
;
236 struct moxie_frame_cache cache
;
239 memset (&cache
, 0, sizeof cache
);
241 plg_end
= moxie_analyze_prologue (func_addr
,
242 func_end
, &cache
, gdbarch
);
243 /* Found a function. */
244 sym
= lookup_symbol (func_name
, NULL
, VAR_DOMAIN
, NULL
);
245 /* Don't use line number debug info for assembly source
247 if (sym
&& SYMBOL_LANGUAGE (sym
) != language_asm
)
249 sal
= find_pc_line (func_addr
, 0);
250 if (sal
.end
&& sal
.end
< func_end
)
252 /* Found a line number, use it as end of
257 /* No useable line symbol. Use result of prologue parsing
263 /* No function symbol -- just return the PC. */
264 return (CORE_ADDR
) pc
;
267 struct moxie_unwind_cache
269 /* The previous frame's inner most stack address. Used as this
270 frame ID's stack_addr. */
272 /* The frame's base, optionally used by the high-level debug info. */
275 /* How far the SP and r13 (FP) have been offset from the start of
276 the stack frame (as defined by the previous frame's stack
281 /* Table indicating the location of each and every register. */
282 struct trad_frame_saved_reg
*saved_regs
;
285 /* Implement the "read_pc" gdbarch method. */
288 moxie_read_pc (struct regcache
*regcache
)
292 regcache_cooked_read_unsigned (regcache
, MOXIE_PC_REGNUM
, &pc
);
296 /* Implement the "write_pc" gdbarch method. */
299 moxie_write_pc (struct regcache
*regcache
, CORE_ADDR val
)
301 regcache_cooked_write_unsigned (regcache
, MOXIE_PC_REGNUM
, val
);
304 /* Implement the "unwind_sp" gdbarch method. */
307 moxie_unwind_sp (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
309 return frame_unwind_register_unsigned (next_frame
, MOXIE_SP_REGNUM
);
312 /* Given a return value in `regbuf' with a type `valtype',
313 extract and copy its value into `valbuf'. */
316 moxie_extract_return_value (struct type
*type
, struct regcache
*regcache
,
319 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
320 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
321 bfd_byte
*valbuf
= dst
;
322 int len
= TYPE_LENGTH (type
);
325 /* By using store_unsigned_integer we avoid having to do
326 anything special for small big-endian values. */
327 regcache_cooked_read_unsigned (regcache
, RET1_REGNUM
, &tmp
);
328 store_unsigned_integer (valbuf
, (len
> 4 ? len
- 4 : len
), byte_order
, tmp
);
330 /* Ignore return values more than 8 bytes in size because the moxie
331 returns anything more than 8 bytes in the stack. */
334 regcache_cooked_read_unsigned (regcache
, RET1_REGNUM
+ 1, &tmp
);
335 store_unsigned_integer (valbuf
+ len
- 4, 4, byte_order
, tmp
);
339 /* Implement the "return_value" gdbarch method. */
341 static enum return_value_convention
342 moxie_return_value (struct gdbarch
*gdbarch
, struct type
*func_type
,
343 struct type
*valtype
, struct regcache
*regcache
,
344 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
346 if (TYPE_LENGTH (valtype
) > 8)
347 return RETURN_VALUE_STRUCT_CONVENTION
;
351 moxie_extract_return_value (valtype
, regcache
, readbuf
);
352 if (writebuf
!= NULL
)
353 moxie_store_return_value (valtype
, regcache
, writebuf
);
354 return RETURN_VALUE_REGISTER_CONVENTION
;
358 /* Allocate and initialize a moxie_frame_cache object. */
360 static struct moxie_frame_cache
*
361 moxie_alloc_frame_cache (void)
363 struct moxie_frame_cache
*cache
;
366 cache
= FRAME_OBSTACK_ZALLOC (struct moxie_frame_cache
);
371 cache
->framesize
= 0;
372 for (i
= 0; i
< MOXIE_NUM_REGS
; ++i
)
373 cache
->saved_regs
[i
] = REG_UNAVAIL
;
378 /* Populate a moxie_frame_cache object for this_frame. */
380 static struct moxie_frame_cache
*
381 moxie_frame_cache (struct frame_info
*this_frame
, void **this_cache
)
383 struct moxie_frame_cache
*cache
;
384 CORE_ADDR current_pc
;
390 cache
= moxie_alloc_frame_cache ();
393 cache
->base
= get_frame_register_unsigned (this_frame
, MOXIE_FP_REGNUM
);
394 if (cache
->base
== 0)
397 cache
->pc
= get_frame_func (this_frame
);
398 current_pc
= get_frame_pc (this_frame
);
401 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
402 moxie_analyze_prologue (cache
->pc
, current_pc
, cache
, gdbarch
);
405 cache
->saved_sp
= cache
->base
- cache
->framesize
;
407 for (i
= 0; i
< MOXIE_NUM_REGS
; ++i
)
408 if (cache
->saved_regs
[i
] != REG_UNAVAIL
)
409 cache
->saved_regs
[i
] = cache
->base
- cache
->saved_regs
[i
];
414 /* Implement the "unwind_pc" gdbarch method. */
417 moxie_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
419 return frame_unwind_register_unsigned (next_frame
, MOXIE_PC_REGNUM
);
422 /* Given a GDB frame, determine the address of the calling function's
423 frame. This will be used to create a new GDB frame struct. */
426 moxie_frame_this_id (struct frame_info
*this_frame
,
427 void **this_prologue_cache
, struct frame_id
*this_id
)
429 struct moxie_frame_cache
*cache
= moxie_frame_cache (this_frame
,
430 this_prologue_cache
);
432 /* This marks the outermost frame. */
433 if (cache
->base
== 0)
436 *this_id
= frame_id_build (cache
->saved_sp
, cache
->pc
);
439 /* Get the value of register regnum in the previous stack frame. */
441 static struct value
*
442 moxie_frame_prev_register (struct frame_info
*this_frame
,
443 void **this_prologue_cache
, int regnum
)
445 struct moxie_frame_cache
*cache
= moxie_frame_cache (this_frame
,
446 this_prologue_cache
);
448 gdb_assert (regnum
>= 0);
450 if (regnum
== MOXIE_SP_REGNUM
&& cache
->saved_sp
)
451 return frame_unwind_got_constant (this_frame
, regnum
, cache
->saved_sp
);
453 if (regnum
< MOXIE_NUM_REGS
&& cache
->saved_regs
[regnum
] != REG_UNAVAIL
)
454 return frame_unwind_got_memory (this_frame
, regnum
,
455 cache
->saved_regs
[regnum
]);
457 return frame_unwind_got_register (this_frame
, regnum
, regnum
);
460 static const struct frame_unwind moxie_frame_unwind
= {
463 moxie_frame_prev_register
,
465 default_frame_sniffer
468 /* Return the base address of this_frame. */
471 moxie_frame_base_address (struct frame_info
*this_frame
, void **this_cache
)
473 struct moxie_frame_cache
*cache
= moxie_frame_cache (this_frame
,
479 static const struct frame_base moxie_frame_base
= {
481 moxie_frame_base_address
,
482 moxie_frame_base_address
,
483 moxie_frame_base_address
486 static struct frame_id
487 moxie_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*this_frame
)
489 CORE_ADDR sp
= get_frame_register_unsigned (this_frame
, MOXIE_SP_REGNUM
);
491 return frame_id_build (sp
, get_frame_pc (this_frame
));
494 /* Read an unsigned integer from the inferior, and adjust
497 moxie_process_readu (CORE_ADDR addr
, char *buf
,
498 int length
, enum bfd_endian byte_order
)
500 if (target_read_memory (addr
, buf
, length
))
503 printf_unfiltered (_("Process record: error reading memory at "
504 "addr 0x%s len = %d.\n"),
505 paddress (target_gdbarch
, addr
), length
);
509 return extract_unsigned_integer (buf
, length
, byte_order
);
512 /* Parse the current instruction and record the values of the registers and
513 memory that will be changed in current instruction to "record_arch_list".
514 Return -1 if something wrong. */
517 moxie_process_record (struct gdbarch
*gdbarch
, struct regcache
*regcache
,
523 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
525 if (record_debug
> 1)
526 fprintf_unfiltered (gdb_stdlog
, "Process record: moxie_process_record "
528 paddress (target_gdbarch
, addr
));
530 inst
= (uint16_t) moxie_process_readu (addr
, buf
, 2, byte_order
);
532 /* Decode instruction. */
533 if (inst
& (1 << 15))
535 if (inst
& (1 << 14))
537 /* This is a Form 3 instruction. */
538 int opcode
= (inst
>> 10 & 0xf);
546 case 0x04: /* bltu */
547 case 0x05: /* bgtu */
550 case 0x08: /* bgeu */
551 case 0x09: /* bleu */
563 /* This is a Form 2 instruction. */
564 int opcode
= (inst
>> 12 & 0x3);
571 int reg
= (inst
>> 8) & 0xf;
572 if (record_arch_list_add_reg (regcache
, reg
))
578 /* Do nothing until GDB learns about moxie's special
590 /* This is a Form 1 instruction. */
591 int opcode
= inst
>> 8;
598 case 0x01: /* ldi.l (immediate) */
599 case 0x02: /* mov (register-to-register) */
601 int reg
= (inst
>> 4) & 0xf;
602 if (record_arch_list_add_reg (regcache
, reg
))
606 case 0x03: /* jsra */
608 regcache_raw_read (regcache
,
609 MOXIE_SP_REGNUM
, (gdb_byte
*) & tmpu32
);
610 tmpu32
= extract_unsigned_integer ((gdb_byte
*) & tmpu32
,
612 if (record_arch_list_add_reg (regcache
, MOXIE_FP_REGNUM
)
613 || (record_arch_list_add_reg (regcache
,
615 || record_arch_list_add_mem (tmpu32
- 12, 12))
621 if (record_arch_list_add_reg (regcache
, MOXIE_FP_REGNUM
)
622 || (record_arch_list_add_reg (regcache
,
627 case 0x05: /* add.l */
629 int reg
= (inst
>> 4) & 0xf;
630 if (record_arch_list_add_reg (regcache
, reg
))
634 case 0x06: /* push */
636 int reg
= (inst
>> 4) & 0xf;
637 regcache_raw_read (regcache
, reg
, (gdb_byte
*) & tmpu32
);
638 tmpu32
= extract_unsigned_integer ((gdb_byte
*) & tmpu32
,
640 if (record_arch_list_add_reg (regcache
, reg
)
641 || record_arch_list_add_mem (tmpu32
- 4, 4))
647 int a
= (inst
>> 4) & 0xf;
649 if (record_arch_list_add_reg (regcache
, a
)
650 || record_arch_list_add_reg (regcache
, b
))
654 case 0x08: /* lda.l */
656 int reg
= (inst
>> 4) & 0xf;
657 if (record_arch_list_add_reg (regcache
, reg
))
661 case 0x09: /* sta.l */
663 tmpu32
= (uint32_t) moxie_process_readu (addr
+2, buf
,
665 if (record_arch_list_add_mem (tmpu32
, 4))
669 case 0x0a: /* ld.l (register indirect) */
671 int reg
= (inst
>> 4) & 0xf;
672 if (record_arch_list_add_reg (regcache
, reg
))
676 case 0x0b: /* st.l */
678 int reg
= (inst
>> 4) & 0xf;
679 regcache_raw_read (regcache
, reg
, (gdb_byte
*) & tmpu32
);
680 tmpu32
= extract_unsigned_integer ((gdb_byte
*) & tmpu32
,
682 if (record_arch_list_add_mem (tmpu32
, 4))
686 case 0x0c: /* ldo.l */
688 int reg
= (inst
>> 4) & 0xf;
689 if (record_arch_list_add_reg (regcache
, reg
))
693 case 0x0d: /* sto.l */
695 int reg
= (inst
>> 4) & 0xf;
696 uint32_t offset
= (uint32_t) moxie_process_readu (addr
+2, buf
, 4,
698 regcache_raw_read (regcache
, reg
, (gdb_byte
*) & tmpu32
);
699 tmpu32
= extract_unsigned_integer ((gdb_byte
*) & tmpu32
,
702 if (record_arch_list_add_mem (tmpu32
, 4))
708 if (record_arch_list_add_reg (regcache
, MOXIE_CC_REGNUM
))
728 regcache_raw_read (regcache
,
729 MOXIE_SP_REGNUM
, (gdb_byte
*) & tmpu32
);
730 tmpu32
= extract_unsigned_integer ((gdb_byte
*) & tmpu32
,
732 if (record_arch_list_add_reg (regcache
, MOXIE_FP_REGNUM
)
733 || (record_arch_list_add_reg (regcache
,
735 || record_arch_list_add_mem (tmpu32
- 12, 12))
739 case 0x1a: /* jmpa */
744 case 0x1b: /* ldi.b (immediate) */
745 case 0x1c: /* ld.b (register indirect) */
746 case 0x1d: /* lda.b */
748 int reg
= (inst
>> 4) & 0xf;
749 if (record_arch_list_add_reg (regcache
, reg
))
753 case 0x1e: /* st.b */
755 int reg
= (inst
>> 4) & 0xf;
756 regcache_raw_read (regcache
, reg
, (gdb_byte
*) & tmpu32
);
757 tmpu32
= extract_unsigned_integer ((gdb_byte
*) & tmpu32
,
759 if (record_arch_list_add_mem (tmpu32
, 1))
763 case 0x1f: /* sta.b */
765 tmpu32
= moxie_process_readu (addr
+2, (char *) buf
,
767 if (record_arch_list_add_mem (tmpu32
, 1))
771 case 0x20: /* ldi.s (immediate) */
772 case 0x21: /* ld.s (register indirect) */
773 case 0x22: /* lda.s */
775 int reg
= (inst
>> 4) & 0xf;
776 if (record_arch_list_add_reg (regcache
, reg
))
780 case 0x23: /* st.s */
782 int reg
= (inst
>> 4) & 0xf;
783 regcache_raw_read (regcache
, reg
, (gdb_byte
*) & tmpu32
);
784 tmpu32
= extract_unsigned_integer ((gdb_byte
*) & tmpu32
,
786 if (record_arch_list_add_mem (tmpu32
, 2))
790 case 0x24: /* sta.s */
792 tmpu32
= moxie_process_readu (addr
+2, (char *) buf
,
794 if (record_arch_list_add_mem (tmpu32
, 2))
804 case 0x27: /* lshr */
805 case 0x28: /* ashl */
806 case 0x29: /* sub.l */
810 case 0x2d: /* ashr */
812 case 0x2f: /* mul.l */
814 int reg
= (inst
>> 4) & 0xf;
815 if (record_arch_list_add_reg (regcache
, reg
))
821 /* We currently implement support for libgloss'
824 int inum
= moxie_process_readu (addr
+2, (char *) buf
,
829 case 0x1: /* SYS_exit */
834 case 0x2: /* SYS_open */
836 if (record_arch_list_add_reg (regcache
, RET1_REGNUM
))
840 case 0x4: /* SYS_read */
842 uint32_t length
, ptr
;
844 /* Read buffer pointer is in $r1. */
845 regcache_raw_read (regcache
, 3, (gdb_byte
*) & ptr
);
846 ptr
= extract_unsigned_integer ((gdb_byte
*) & ptr
,
849 /* String length is at 0x12($fp) */
850 regcache_raw_read (regcache
,
851 MOXIE_FP_REGNUM
, (gdb_byte
*) & tmpu32
);
852 tmpu32
= extract_unsigned_integer ((gdb_byte
*) & tmpu32
,
854 length
= moxie_process_readu (tmpu32
+20, (char *) buf
,
857 if (record_arch_list_add_mem (ptr
, length
))
861 case 0x5: /* SYS_write */
863 if (record_arch_list_add_reg (regcache
, RET1_REGNUM
))
872 case 0x31: /* div.l */
873 case 0x32: /* udiv.l */
874 case 0x33: /* mod.l */
875 case 0x34: /* umod.l */
877 int reg
= (inst
>> 4) & 0xf;
878 if (record_arch_list_add_reg (regcache
, reg
))
885 case 0x36: /* ldo.b */
887 int reg
= (inst
>> 4) & 0xf;
888 if (record_arch_list_add_reg (regcache
, reg
))
892 case 0x37: /* sto.b */
894 int reg
= (inst
>> 4) & 0xf;
895 uint32_t offset
= (uint32_t) moxie_process_readu (addr
+2, buf
, 4,
897 regcache_raw_read (regcache
, reg
, (gdb_byte
*) & tmpu32
);
898 tmpu32
= extract_unsigned_integer ((gdb_byte
*) & tmpu32
,
901 if (record_arch_list_add_mem (tmpu32
, 1))
905 case 0x38: /* ldo.s */
907 int reg
= (inst
>> 4) & 0xf;
908 if (record_arch_list_add_reg (regcache
, reg
))
912 case 0x39: /* sto.s */
914 int reg
= (inst
>> 4) & 0xf;
915 uint32_t offset
= (uint32_t) moxie_process_readu (addr
+2, buf
, 4,
917 regcache_raw_read (regcache
, reg
, (gdb_byte
*) & tmpu32
);
918 tmpu32
= extract_unsigned_integer ((gdb_byte
*) & tmpu32
,
921 if (record_arch_list_add_mem (tmpu32
, 2))
931 if (record_arch_list_add_reg (regcache
, MOXIE_PC_REGNUM
))
933 if (record_arch_list_add_end ())
938 /* Allocate and initialize the moxie gdbarch object. */
940 static struct gdbarch
*
941 moxie_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
943 struct gdbarch
*gdbarch
;
944 struct gdbarch_tdep
*tdep
;
946 /* If there is already a candidate, use it. */
947 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
949 return arches
->gdbarch
;
951 /* Allocate space for the new architecture. */
952 tdep
= XMALLOC (struct gdbarch_tdep
);
953 gdbarch
= gdbarch_alloc (&info
, tdep
);
955 set_gdbarch_read_pc (gdbarch
, moxie_read_pc
);
956 set_gdbarch_write_pc (gdbarch
, moxie_write_pc
);
957 set_gdbarch_unwind_sp (gdbarch
, moxie_unwind_sp
);
959 set_gdbarch_num_regs (gdbarch
, MOXIE_NUM_REGS
);
960 set_gdbarch_sp_regnum (gdbarch
, MOXIE_SP_REGNUM
);
961 set_gdbarch_pc_regnum (gdbarch
, MOXIE_PC_REGNUM
);
962 set_gdbarch_register_name (gdbarch
, moxie_register_name
);
963 set_gdbarch_register_type (gdbarch
, moxie_register_type
);
965 set_gdbarch_return_value (gdbarch
, moxie_return_value
);
967 set_gdbarch_skip_prologue (gdbarch
, moxie_skip_prologue
);
968 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
969 set_gdbarch_breakpoint_from_pc (gdbarch
, moxie_breakpoint_from_pc
);
970 set_gdbarch_frame_align (gdbarch
, moxie_frame_align
);
972 frame_base_set_default (gdbarch
, &moxie_frame_base
);
974 /* Methods for saving / extracting a dummy frame's ID. The ID's
975 stack address must match the SP value returned by
976 PUSH_DUMMY_CALL, and saved by generic_save_dummy_frame_tos. */
977 set_gdbarch_dummy_id (gdbarch
, moxie_dummy_id
);
979 set_gdbarch_unwind_pc (gdbarch
, moxie_unwind_pc
);
981 set_gdbarch_print_insn (gdbarch
, print_insn_moxie
);
983 /* Hook in ABI-specific overrides, if they have been registered. */
984 gdbarch_init_osabi (info
, gdbarch
);
986 /* Hook in the default unwinders. */
987 frame_unwind_append_unwinder (gdbarch
, &moxie_frame_unwind
);
989 /* Support simple overlay manager. */
990 set_gdbarch_overlay_update (gdbarch
, simple_overlay_update
);
992 /* Support reverse debugging. */
993 set_gdbarch_process_record (gdbarch
, moxie_process_record
);
998 /* Register this machine's init routine. */
1001 _initialize_moxie_tdep (void)
1003 register_gdbarch_init (bfd_arch_moxie
, moxie_gdbarch_init
);