1 /* Target-dependent code for Moxie.
3 Copyright (C) 2009-2016 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"
34 #include "arch-utils.h"
36 #include "trad-frame.h"
39 #include "record-full.h"
41 #include "moxie-tdep.h"
44 /* Local functions. */
46 extern void _initialize_moxie_tdep (void);
48 /* Use an invalid address value as 'not available' marker. */
49 enum { REG_UNAVAIL
= (CORE_ADDR
) -1 };
51 struct moxie_frame_cache
57 CORE_ADDR saved_regs
[MOXIE_NUM_REGS
];
61 /* Implement the "frame_align" gdbarch method. */
64 moxie_frame_align (struct gdbarch
*gdbarch
, CORE_ADDR sp
)
66 /* Align to the size of an instruction (so that they can safely be
67 pushed onto the stack. */
71 constexpr gdb_byte moxie_break_insn
[] = { 0x35, 0x00 };
73 typedef BP_MANIPULATION (moxie_break_insn
) moxie_breakpoint
;
75 /* Moxie register names. */
77 char *moxie_register_names
[] = {
78 "$fp", "$sp", "$r0", "$r1", "$r2",
79 "$r3", "$r4", "$r5", "$r6", "$r7",
80 "$r8", "$r9", "$r10", "$r11", "$r12",
81 "$r13", "$pc", "$cc" };
83 /* Implement the "register_name" gdbarch method. */
86 moxie_register_name (struct gdbarch
*gdbarch
, int reg_nr
)
90 if (reg_nr
>= MOXIE_NUM_REGS
)
92 return moxie_register_names
[reg_nr
];
95 /* Implement the "register_type" gdbarch method. */
98 moxie_register_type (struct gdbarch
*gdbarch
, int reg_nr
)
100 if (reg_nr
== MOXIE_PC_REGNUM
)
101 return builtin_type (gdbarch
)->builtin_func_ptr
;
102 else if (reg_nr
== MOXIE_SP_REGNUM
|| reg_nr
== MOXIE_FP_REGNUM
)
103 return builtin_type (gdbarch
)->builtin_data_ptr
;
105 return builtin_type (gdbarch
)->builtin_int32
;
108 /* Write into appropriate registers a function return value
109 of type TYPE, given in virtual format. */
112 moxie_store_return_value (struct type
*type
, struct regcache
*regcache
,
113 const gdb_byte
*valbuf
)
115 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
116 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
118 int len
= TYPE_LENGTH (type
);
120 /* Things always get returned in RET1_REGNUM, RET2_REGNUM. */
121 regval
= extract_unsigned_integer (valbuf
, len
> 4 ? 4 : len
, byte_order
);
122 regcache_cooked_write_unsigned (regcache
, RET1_REGNUM
, regval
);
125 regval
= extract_unsigned_integer (valbuf
+ 4, len
- 4, byte_order
);
126 regcache_cooked_write_unsigned (regcache
, RET1_REGNUM
+ 1, regval
);
130 /* Decode the instructions within the given address range. Decide
131 when we must have reached the end of the function prologue. If a
132 frame_info pointer is provided, fill in its saved_regs etc.
134 Returns the address of the first instruction after the prologue. */
137 moxie_analyze_prologue (CORE_ADDR start_addr
, CORE_ADDR end_addr
,
138 struct moxie_frame_cache
*cache
,
139 struct gdbarch
*gdbarch
)
141 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
143 ULONGEST inst
, inst2
;
147 /* Record where the jsra instruction saves the PC and FP. */
148 cache
->saved_regs
[MOXIE_PC_REGNUM
] = -4;
149 cache
->saved_regs
[MOXIE_FP_REGNUM
] = 0;
150 cache
->framesize
= 0;
152 if (start_addr
>= end_addr
)
155 for (next_addr
= start_addr
; next_addr
< end_addr
; )
157 inst
= read_memory_unsigned_integer (next_addr
, 2, byte_order
);
159 /* Match "push $sp $rN" where N is between 0 and 13 inclusive. */
160 if (inst
>= 0x0612 && inst
<= 0x061f)
162 regnum
= inst
& 0x000f;
163 cache
->framesize
+= 4;
164 cache
->saved_regs
[regnum
] = cache
->framesize
;
171 inst
= read_memory_unsigned_integer (next_addr
, 2, byte_order
);
173 /* Optional stack allocation for args and local vars <= 4
175 if (inst
== 0x01e0) /* ldi.l $r12, X */
177 offset
= read_memory_integer (next_addr
+ 2, 4, byte_order
);
178 inst2
= read_memory_unsigned_integer (next_addr
+ 6, 2, byte_order
);
180 if (inst2
== 0x291e) /* sub.l $sp, $r12 */
182 cache
->framesize
+= offset
;
185 return (next_addr
+ 8);
187 else if ((inst
& 0xff00) == 0x9100) /* dec $sp, X */
189 cache
->framesize
+= (inst
& 0x00ff);
192 while (next_addr
< end_addr
)
194 inst
= read_memory_unsigned_integer (next_addr
, 2, byte_order
);
195 if ((inst
& 0xff00) != 0x9100) /* no more dec $sp, X */
197 cache
->framesize
+= (inst
& 0x00ff);
205 /* Find the end of function prologue. */
208 moxie_skip_prologue (struct gdbarch
*gdbarch
, CORE_ADDR pc
)
210 CORE_ADDR func_addr
= 0, func_end
= 0;
211 const char *func_name
;
213 /* See if we can determine the end of the prologue via the symbol table.
214 If so, then return either PC, or the PC after the prologue, whichever
216 if (find_pc_partial_function (pc
, &func_name
, &func_addr
, &func_end
))
218 CORE_ADDR post_prologue_pc
219 = skip_prologue_using_sal (gdbarch
, func_addr
);
220 if (post_prologue_pc
!= 0)
221 return std::max (pc
, post_prologue_pc
);
224 /* Can't determine prologue from the symbol table, need to examine
226 struct symtab_and_line sal
;
228 struct moxie_frame_cache cache
;
231 memset (&cache
, 0, sizeof cache
);
233 plg_end
= moxie_analyze_prologue (func_addr
,
234 func_end
, &cache
, gdbarch
);
235 /* Found a function. */
236 sym
= lookup_symbol (func_name
, NULL
, VAR_DOMAIN
, NULL
).symbol
;
237 /* Don't use line number debug info for assembly source
239 if (sym
&& SYMBOL_LANGUAGE (sym
) != language_asm
)
241 sal
= find_pc_line (func_addr
, 0);
242 if (sal
.end
&& sal
.end
< func_end
)
244 /* Found a line number, use it as end of
249 /* No useable line symbol. Use result of prologue parsing
255 /* No function symbol -- just return the PC. */
256 return (CORE_ADDR
) pc
;
259 struct moxie_unwind_cache
261 /* The previous frame's inner most stack address. Used as this
262 frame ID's stack_addr. */
264 /* The frame's base, optionally used by the high-level debug info. */
267 /* How far the SP and r13 (FP) have been offset from the start of
268 the stack frame (as defined by the previous frame's stack
273 /* Table indicating the location of each and every register. */
274 struct trad_frame_saved_reg
*saved_regs
;
277 /* Read an unsigned integer from the inferior, and adjust
280 moxie_process_readu (CORE_ADDR addr
, gdb_byte
*buf
,
281 int length
, enum bfd_endian byte_order
)
283 if (target_read_memory (addr
, buf
, length
))
286 printf_unfiltered (_("Process record: error reading memory at "
287 "addr 0x%s len = %d.\n"),
288 paddress (target_gdbarch (), addr
), length
);
292 return extract_unsigned_integer (buf
, length
, byte_order
);
296 /* Helper macro to extract the signed 10-bit offset from a 16-bit
297 branch instruction. */
298 #define INST2OFFSET(o) ((((signed short)((o & ((1<<10)-1))<<6))>>6)<<1)
300 /* Insert a single step breakpoint. */
302 static VEC (CORE_ADDR
) *
303 moxie_software_single_step (struct frame_info
*frame
)
305 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
311 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
312 struct regcache
*regcache
= get_current_regcache ();
313 VEC (CORE_ADDR
) *next_pcs
= NULL
;
315 addr
= get_frame_pc (frame
);
317 inst
= (uint16_t) moxie_process_readu (addr
, buf
, 2, byte_order
);
319 /* Decode instruction. */
320 if (inst
& (1 << 15))
322 if (inst
& (1 << 14))
324 /* This is a Form 3 instruction. */
325 int opcode
= (inst
>> 10 & 0xf);
333 case 0x04: /* bltu */
334 case 0x05: /* bgtu */
337 case 0x08: /* bgeu */
338 case 0x09: /* bleu */
339 /* Insert breaks on both branches, because we can't currently tell
340 which way things will go. */
341 VEC_safe_push (CORE_ADDR
, next_pcs
, addr
+ 2);
342 VEC_safe_push (CORE_ADDR
, next_pcs
,
343 addr
+ 2 + INST2OFFSET(inst
));
354 /* This is a Form 2 instruction. They are all 16 bits. */
355 VEC_safe_push (CORE_ADDR
, next_pcs
, addr
+ 2);
360 /* This is a Form 1 instruction. */
361 int opcode
= inst
>> 8;
365 /* 16-bit instructions. */
367 case 0x02: /* mov (register-to-register) */
368 case 0x05: /* add.l */
369 case 0x06: /* push */
371 case 0x0a: /* ld.l (register indirect) */
372 case 0x0b: /* st.l */
375 case 0x10: /* sex.b */
376 case 0x11: /* sex.s */
377 case 0x12: /* zex.b */
378 case 0x13: /* zex.s */
379 case 0x14: /* umul.x */
380 case 0x15: /* mul.x */
384 case 0x1c: /* ld.b (register indirect) */
385 case 0x1e: /* st.b */
386 case 0x21: /* ld.s (register indirect) */
387 case 0x23: /* st.s */
389 case 0x27: /* lshr */
390 case 0x28: /* ashl */
391 case 0x29: /* sub.l */
395 case 0x2d: /* ashr */
397 case 0x2f: /* mul.l */
398 case 0x31: /* div.l */
399 case 0x32: /* udiv.l */
400 case 0x33: /* mod.l */
401 case 0x34: /* umod.l */
402 VEC_safe_push (CORE_ADDR
, next_pcs
, addr
+ 2);
405 /* 32-bit instructions. */
406 case 0x0c: /* ldo.l */
407 case 0x0d: /* sto.l */
408 case 0x36: /* ldo.b */
409 case 0x37: /* sto.b */
410 case 0x38: /* ldo.s */
411 case 0x39: /* sto.s */
412 VEC_safe_push (CORE_ADDR
, next_pcs
, addr
+ 4);
415 /* 48-bit instructions. */
416 case 0x01: /* ldi.l (immediate) */
417 case 0x08: /* lda.l */
418 case 0x09: /* sta.l */
419 case 0x1b: /* ldi.b (immediate) */
420 case 0x1d: /* lda.b */
421 case 0x1f: /* sta.b */
422 case 0x20: /* ldi.s (immediate) */
423 case 0x22: /* lda.s */
424 case 0x24: /* sta.s */
425 VEC_safe_push (CORE_ADDR
, next_pcs
, addr
+ 6);
428 /* Control flow instructions. */
429 case 0x03: /* jsra */
430 case 0x1a: /* jmpa */
431 VEC_safe_push (CORE_ADDR
, next_pcs
,
432 moxie_process_readu (addr
+ 2, buf
, 4, byte_order
));
436 regcache_cooked_read_unsigned (regcache
, MOXIE_FP_REGNUM
, &fp
);
437 VEC_safe_push (CORE_ADDR
, next_pcs
,
438 moxie_process_readu (fp
+ 4, buf
, 4, byte_order
));
443 regcache_raw_read (regcache
,
444 (inst
>> 4) & 0xf, (gdb_byte
*) & tmpu32
);
445 VEC_safe_push (CORE_ADDR
, next_pcs
, tmpu32
);
450 /* Unsupported, for now. */
458 /* Implement the "read_pc" gdbarch method. */
461 moxie_read_pc (struct regcache
*regcache
)
465 regcache_cooked_read_unsigned (regcache
, MOXIE_PC_REGNUM
, &pc
);
469 /* Implement the "write_pc" gdbarch method. */
472 moxie_write_pc (struct regcache
*regcache
, CORE_ADDR val
)
474 regcache_cooked_write_unsigned (regcache
, MOXIE_PC_REGNUM
, val
);
477 /* Implement the "unwind_sp" gdbarch method. */
480 moxie_unwind_sp (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
482 return frame_unwind_register_unsigned (next_frame
, MOXIE_SP_REGNUM
);
485 /* Given a return value in `regbuf' with a type `valtype',
486 extract and copy its value into `valbuf'. */
489 moxie_extract_return_value (struct type
*type
, struct regcache
*regcache
,
492 struct gdbarch
*gdbarch
= get_regcache_arch (regcache
);
493 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
494 int len
= TYPE_LENGTH (type
);
497 /* By using store_unsigned_integer we avoid having to do
498 anything special for small big-endian values. */
499 regcache_cooked_read_unsigned (regcache
, RET1_REGNUM
, &tmp
);
500 store_unsigned_integer (dst
, (len
> 4 ? len
- 4 : len
), byte_order
, tmp
);
502 /* Ignore return values more than 8 bytes in size because the moxie
503 returns anything more than 8 bytes in the stack. */
506 regcache_cooked_read_unsigned (regcache
, RET1_REGNUM
+ 1, &tmp
);
507 store_unsigned_integer (dst
+ len
- 4, 4, byte_order
, tmp
);
511 /* Implement the "return_value" gdbarch method. */
513 static enum return_value_convention
514 moxie_return_value (struct gdbarch
*gdbarch
, struct value
*function
,
515 struct type
*valtype
, struct regcache
*regcache
,
516 gdb_byte
*readbuf
, const gdb_byte
*writebuf
)
518 if (TYPE_LENGTH (valtype
) > 8)
519 return RETURN_VALUE_STRUCT_CONVENTION
;
523 moxie_extract_return_value (valtype
, regcache
, readbuf
);
524 if (writebuf
!= NULL
)
525 moxie_store_return_value (valtype
, regcache
, writebuf
);
526 return RETURN_VALUE_REGISTER_CONVENTION
;
530 /* Allocate and initialize a moxie_frame_cache object. */
532 static struct moxie_frame_cache
*
533 moxie_alloc_frame_cache (void)
535 struct moxie_frame_cache
*cache
;
538 cache
= FRAME_OBSTACK_ZALLOC (struct moxie_frame_cache
);
543 cache
->framesize
= 0;
544 for (i
= 0; i
< MOXIE_NUM_REGS
; ++i
)
545 cache
->saved_regs
[i
] = REG_UNAVAIL
;
550 /* Populate a moxie_frame_cache object for this_frame. */
552 static struct moxie_frame_cache
*
553 moxie_frame_cache (struct frame_info
*this_frame
, void **this_cache
)
555 struct moxie_frame_cache
*cache
;
556 CORE_ADDR current_pc
;
560 return (struct moxie_frame_cache
*) *this_cache
;
562 cache
= moxie_alloc_frame_cache ();
565 cache
->base
= get_frame_register_unsigned (this_frame
, MOXIE_FP_REGNUM
);
566 if (cache
->base
== 0)
569 cache
->pc
= get_frame_func (this_frame
);
570 current_pc
= get_frame_pc (this_frame
);
573 struct gdbarch
*gdbarch
= get_frame_arch (this_frame
);
574 moxie_analyze_prologue (cache
->pc
, current_pc
, cache
, gdbarch
);
577 cache
->saved_sp
= cache
->base
- cache
->framesize
;
579 for (i
= 0; i
< MOXIE_NUM_REGS
; ++i
)
580 if (cache
->saved_regs
[i
] != REG_UNAVAIL
)
581 cache
->saved_regs
[i
] = cache
->base
- cache
->saved_regs
[i
];
586 /* Implement the "unwind_pc" gdbarch method. */
589 moxie_unwind_pc (struct gdbarch
*gdbarch
, struct frame_info
*next_frame
)
591 return frame_unwind_register_unsigned (next_frame
, MOXIE_PC_REGNUM
);
594 /* Given a GDB frame, determine the address of the calling function's
595 frame. This will be used to create a new GDB frame struct. */
598 moxie_frame_this_id (struct frame_info
*this_frame
,
599 void **this_prologue_cache
, struct frame_id
*this_id
)
601 struct moxie_frame_cache
*cache
= moxie_frame_cache (this_frame
,
602 this_prologue_cache
);
604 /* This marks the outermost frame. */
605 if (cache
->base
== 0)
608 *this_id
= frame_id_build (cache
->saved_sp
, cache
->pc
);
611 /* Get the value of register regnum in the previous stack frame. */
613 static struct value
*
614 moxie_frame_prev_register (struct frame_info
*this_frame
,
615 void **this_prologue_cache
, int regnum
)
617 struct moxie_frame_cache
*cache
= moxie_frame_cache (this_frame
,
618 this_prologue_cache
);
620 gdb_assert (regnum
>= 0);
622 if (regnum
== MOXIE_SP_REGNUM
&& cache
->saved_sp
)
623 return frame_unwind_got_constant (this_frame
, regnum
, cache
->saved_sp
);
625 if (regnum
< MOXIE_NUM_REGS
&& cache
->saved_regs
[regnum
] != REG_UNAVAIL
)
626 return frame_unwind_got_memory (this_frame
, regnum
,
627 cache
->saved_regs
[regnum
]);
629 return frame_unwind_got_register (this_frame
, regnum
, regnum
);
632 static const struct frame_unwind moxie_frame_unwind
= {
634 default_frame_unwind_stop_reason
,
636 moxie_frame_prev_register
,
638 default_frame_sniffer
641 /* Return the base address of this_frame. */
644 moxie_frame_base_address (struct frame_info
*this_frame
, void **this_cache
)
646 struct moxie_frame_cache
*cache
= moxie_frame_cache (this_frame
,
652 static const struct frame_base moxie_frame_base
= {
654 moxie_frame_base_address
,
655 moxie_frame_base_address
,
656 moxie_frame_base_address
659 static struct frame_id
660 moxie_dummy_id (struct gdbarch
*gdbarch
, struct frame_info
*this_frame
)
662 CORE_ADDR sp
= get_frame_register_unsigned (this_frame
, MOXIE_SP_REGNUM
);
664 return frame_id_build (sp
, get_frame_pc (this_frame
));
667 /* Parse the current instruction and record the values of the registers and
668 memory that will be changed in current instruction to "record_arch_list".
669 Return -1 if something wrong. */
672 moxie_process_record (struct gdbarch
*gdbarch
, struct regcache
*regcache
,
678 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
680 if (record_debug
> 1)
681 fprintf_unfiltered (gdb_stdlog
, "Process record: moxie_process_record "
683 paddress (target_gdbarch (), addr
));
685 inst
= (uint16_t) moxie_process_readu (addr
, buf
, 2, byte_order
);
687 /* Decode instruction. */
688 if (inst
& (1 << 15))
690 if (inst
& (1 << 14))
692 /* This is a Form 3 instruction. */
693 int opcode
= (inst
>> 10 & 0xf);
701 case 0x04: /* bltu */
702 case 0x05: /* bgtu */
705 case 0x08: /* bgeu */
706 case 0x09: /* bleu */
718 /* This is a Form 2 instruction. */
719 int opcode
= (inst
>> 12 & 0x3);
726 int reg
= (inst
>> 8) & 0xf;
727 if (record_full_arch_list_add_reg (regcache
, reg
))
733 /* Do nothing until GDB learns about moxie's special
745 /* This is a Form 1 instruction. */
746 int opcode
= inst
>> 8;
753 case 0x01: /* ldi.l (immediate) */
754 case 0x02: /* mov (register-to-register) */
756 int reg
= (inst
>> 4) & 0xf;
757 if (record_full_arch_list_add_reg (regcache
, reg
))
761 case 0x03: /* jsra */
763 regcache_raw_read (regcache
,
764 MOXIE_SP_REGNUM
, (gdb_byte
*) & tmpu32
);
765 tmpu32
= extract_unsigned_integer ((gdb_byte
*) & tmpu32
,
767 if (record_full_arch_list_add_reg (regcache
, MOXIE_FP_REGNUM
)
768 || (record_full_arch_list_add_reg (regcache
,
770 || record_full_arch_list_add_mem (tmpu32
- 12, 12))
776 if (record_full_arch_list_add_reg (regcache
, MOXIE_FP_REGNUM
)
777 || (record_full_arch_list_add_reg (regcache
,
782 case 0x05: /* add.l */
784 int reg
= (inst
>> 4) & 0xf;
785 if (record_full_arch_list_add_reg (regcache
, reg
))
789 case 0x06: /* push */
791 int reg
= (inst
>> 4) & 0xf;
792 regcache_raw_read (regcache
, reg
, (gdb_byte
*) & tmpu32
);
793 tmpu32
= extract_unsigned_integer ((gdb_byte
*) & tmpu32
,
795 if (record_full_arch_list_add_reg (regcache
, reg
)
796 || record_full_arch_list_add_mem (tmpu32
- 4, 4))
802 int a
= (inst
>> 4) & 0xf;
804 if (record_full_arch_list_add_reg (regcache
, a
)
805 || record_full_arch_list_add_reg (regcache
, b
))
809 case 0x08: /* lda.l */
811 int reg
= (inst
>> 4) & 0xf;
812 if (record_full_arch_list_add_reg (regcache
, reg
))
816 case 0x09: /* sta.l */
818 tmpu32
= (uint32_t) moxie_process_readu (addr
+2, buf
,
820 if (record_full_arch_list_add_mem (tmpu32
, 4))
824 case 0x0a: /* ld.l (register indirect) */
826 int reg
= (inst
>> 4) & 0xf;
827 if (record_full_arch_list_add_reg (regcache
, reg
))
831 case 0x0b: /* st.l */
833 int reg
= (inst
>> 4) & 0xf;
834 regcache_raw_read (regcache
, reg
, (gdb_byte
*) & tmpu32
);
835 tmpu32
= extract_unsigned_integer ((gdb_byte
*) & tmpu32
,
837 if (record_full_arch_list_add_mem (tmpu32
, 4))
841 case 0x0c: /* ldo.l */
843 int reg
= (inst
>> 4) & 0xf;
844 if (record_full_arch_list_add_reg (regcache
, reg
))
848 case 0x0d: /* sto.l */
850 int reg
= (inst
>> 4) & 0xf;
851 uint32_t offset
= (((int16_t) moxie_process_readu (addr
+2, buf
, 2,
852 byte_order
)) << 16 ) >> 16;
853 regcache_raw_read (regcache
, reg
, (gdb_byte
*) & tmpu32
);
854 tmpu32
= extract_unsigned_integer ((gdb_byte
*) & tmpu32
,
857 if (record_full_arch_list_add_mem (tmpu32
, 4))
863 if (record_full_arch_list_add_reg (regcache
, MOXIE_CC_REGNUM
))
872 case 0x10: /* sex.b */
873 case 0x11: /* sex.s */
874 case 0x12: /* zex.b */
875 case 0x13: /* zex.s */
876 case 0x14: /* umul.x */
877 case 0x15: /* mul.x */
879 int reg
= (inst
>> 4) & 0xf;
880 if (record_full_arch_list_add_reg (regcache
, reg
))
893 regcache_raw_read (regcache
,
894 MOXIE_SP_REGNUM
, (gdb_byte
*) & tmpu32
);
895 tmpu32
= extract_unsigned_integer ((gdb_byte
*) & tmpu32
,
897 if (record_full_arch_list_add_reg (regcache
, MOXIE_FP_REGNUM
)
898 || (record_full_arch_list_add_reg (regcache
,
900 || record_full_arch_list_add_mem (tmpu32
- 12, 12))
904 case 0x1a: /* jmpa */
909 case 0x1b: /* ldi.b (immediate) */
910 case 0x1c: /* ld.b (register indirect) */
911 case 0x1d: /* lda.b */
913 int reg
= (inst
>> 4) & 0xf;
914 if (record_full_arch_list_add_reg (regcache
, reg
))
918 case 0x1e: /* st.b */
920 int reg
= (inst
>> 4) & 0xf;
921 regcache_raw_read (regcache
, reg
, (gdb_byte
*) & tmpu32
);
922 tmpu32
= extract_unsigned_integer ((gdb_byte
*) & tmpu32
,
924 if (record_full_arch_list_add_mem (tmpu32
, 1))
928 case 0x1f: /* sta.b */
930 tmpu32
= moxie_process_readu (addr
+2, buf
, 4, byte_order
);
931 if (record_full_arch_list_add_mem (tmpu32
, 1))
935 case 0x20: /* ldi.s (immediate) */
936 case 0x21: /* ld.s (register indirect) */
937 case 0x22: /* lda.s */
939 int reg
= (inst
>> 4) & 0xf;
940 if (record_full_arch_list_add_reg (regcache
, reg
))
944 case 0x23: /* st.s */
946 int reg
= (inst
>> 4) & 0xf;
947 regcache_raw_read (regcache
, reg
, (gdb_byte
*) & tmpu32
);
948 tmpu32
= extract_unsigned_integer ((gdb_byte
*) & tmpu32
,
950 if (record_full_arch_list_add_mem (tmpu32
, 2))
954 case 0x24: /* sta.s */
956 tmpu32
= moxie_process_readu (addr
+2, buf
, 4, byte_order
);
957 if (record_full_arch_list_add_mem (tmpu32
, 2))
967 case 0x27: /* lshr */
968 case 0x28: /* ashl */
973 case 0x2d: /* ashr */
977 int reg
= (inst
>> 4) & 0xf;
978 if (record_full_arch_list_add_reg (regcache
, reg
))
984 /* We currently implement support for libgloss'
987 int inum
= moxie_process_readu (addr
+2, buf
, 4, byte_order
);
991 case 0x1: /* SYS_exit */
996 case 0x2: /* SYS_open */
998 if (record_full_arch_list_add_reg (regcache
, RET1_REGNUM
))
1002 case 0x4: /* SYS_read */
1004 uint32_t length
, ptr
;
1006 /* Read buffer pointer is in $r1. */
1007 regcache_raw_read (regcache
, 3, (gdb_byte
*) & ptr
);
1008 ptr
= extract_unsigned_integer ((gdb_byte
*) & ptr
,
1011 /* String length is at 0x12($fp). */
1012 regcache_raw_read (regcache
,
1013 MOXIE_FP_REGNUM
, (gdb_byte
*) & tmpu32
);
1014 tmpu32
= extract_unsigned_integer ((gdb_byte
*) & tmpu32
,
1016 length
= moxie_process_readu (tmpu32
+20, buf
, 4, byte_order
);
1018 if (record_full_arch_list_add_mem (ptr
, length
))
1022 case 0x5: /* SYS_write */
1024 if (record_full_arch_list_add_reg (regcache
, RET1_REGNUM
))
1033 case 0x31: /* div.l */
1034 case 0x32: /* udiv.l */
1035 case 0x33: /* mod.l */
1036 case 0x34: /* umod.l */
1038 int reg
= (inst
>> 4) & 0xf;
1039 if (record_full_arch_list_add_reg (regcache
, reg
))
1043 case 0x35: /* brk */
1046 case 0x36: /* ldo.b */
1048 int reg
= (inst
>> 4) & 0xf;
1049 if (record_full_arch_list_add_reg (regcache
, reg
))
1053 case 0x37: /* sto.b */
1055 int reg
= (inst
>> 4) & 0xf;
1056 uint32_t offset
= (((int16_t) moxie_process_readu (addr
+2, buf
, 2,
1057 byte_order
)) << 16 ) >> 16;
1058 regcache_raw_read (regcache
, reg
, (gdb_byte
*) & tmpu32
);
1059 tmpu32
= extract_unsigned_integer ((gdb_byte
*) & tmpu32
,
1062 if (record_full_arch_list_add_mem (tmpu32
, 1))
1066 case 0x38: /* ldo.s */
1068 int reg
= (inst
>> 4) & 0xf;
1069 if (record_full_arch_list_add_reg (regcache
, reg
))
1073 case 0x39: /* sto.s */
1075 int reg
= (inst
>> 4) & 0xf;
1076 uint32_t offset
= (((int16_t) moxie_process_readu (addr
+2, buf
, 2,
1077 byte_order
)) << 16 ) >> 16;
1078 regcache_raw_read (regcache
, reg
, (gdb_byte
*) & tmpu32
);
1079 tmpu32
= extract_unsigned_integer ((gdb_byte
*) & tmpu32
,
1082 if (record_full_arch_list_add_mem (tmpu32
, 2))
1092 if (record_full_arch_list_add_reg (regcache
, MOXIE_PC_REGNUM
))
1094 if (record_full_arch_list_add_end ())
1099 /* Allocate and initialize the moxie gdbarch object. */
1101 static struct gdbarch
*
1102 moxie_gdbarch_init (struct gdbarch_info info
, struct gdbarch_list
*arches
)
1104 struct gdbarch
*gdbarch
;
1105 struct gdbarch_tdep
*tdep
;
1107 /* If there is already a candidate, use it. */
1108 arches
= gdbarch_list_lookup_by_info (arches
, &info
);
1110 return arches
->gdbarch
;
1112 /* Allocate space for the new architecture. */
1113 tdep
= XNEW (struct gdbarch_tdep
);
1114 gdbarch
= gdbarch_alloc (&info
, tdep
);
1116 set_gdbarch_read_pc (gdbarch
, moxie_read_pc
);
1117 set_gdbarch_write_pc (gdbarch
, moxie_write_pc
);
1118 set_gdbarch_unwind_sp (gdbarch
, moxie_unwind_sp
);
1120 set_gdbarch_num_regs (gdbarch
, MOXIE_NUM_REGS
);
1121 set_gdbarch_sp_regnum (gdbarch
, MOXIE_SP_REGNUM
);
1122 set_gdbarch_pc_regnum (gdbarch
, MOXIE_PC_REGNUM
);
1123 set_gdbarch_register_name (gdbarch
, moxie_register_name
);
1124 set_gdbarch_register_type (gdbarch
, moxie_register_type
);
1126 set_gdbarch_return_value (gdbarch
, moxie_return_value
);
1128 set_gdbarch_skip_prologue (gdbarch
, moxie_skip_prologue
);
1129 set_gdbarch_inner_than (gdbarch
, core_addr_lessthan
);
1130 set_gdbarch_breakpoint_kind_from_pc (gdbarch
,
1131 moxie_breakpoint::kind_from_pc
);
1132 set_gdbarch_sw_breakpoint_from_kind (gdbarch
,
1133 moxie_breakpoint::bp_from_kind
);
1134 set_gdbarch_frame_align (gdbarch
, moxie_frame_align
);
1136 frame_base_set_default (gdbarch
, &moxie_frame_base
);
1138 /* Methods for saving / extracting a dummy frame's ID. The ID's
1139 stack address must match the SP value returned by
1140 PUSH_DUMMY_CALL, and saved by generic_save_dummy_frame_tos. */
1141 set_gdbarch_dummy_id (gdbarch
, moxie_dummy_id
);
1143 set_gdbarch_unwind_pc (gdbarch
, moxie_unwind_pc
);
1145 set_gdbarch_print_insn (gdbarch
, print_insn_moxie
);
1147 /* Hook in ABI-specific overrides, if they have been registered. */
1148 gdbarch_init_osabi (info
, gdbarch
);
1150 /* Hook in the default unwinders. */
1151 frame_unwind_append_unwinder (gdbarch
, &moxie_frame_unwind
);
1153 /* Single stepping. */
1154 set_gdbarch_software_single_step (gdbarch
, moxie_software_single_step
);
1156 /* Support simple overlay manager. */
1157 set_gdbarch_overlay_update (gdbarch
, simple_overlay_update
);
1159 /* Support reverse debugging. */
1160 set_gdbarch_process_record (gdbarch
, moxie_process_record
);
1165 /* Register this machine's init routine. */
1168 _initialize_moxie_tdep (void)
1170 register_gdbarch_init (bfd_arch_moxie
, moxie_gdbarch_init
);