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 regcache *regcache)
305 struct gdbarch *gdbarch = get_regcache_arch (regcache);
311 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
312 VEC (CORE_ADDR) *next_pcs = NULL;
314 addr = regcache_read_pc (regcache);
316 inst = (uint16_t) moxie_process_readu (addr, buf, 2, byte_order);
318 /* Decode instruction. */
319 if (inst & (1 << 15))
321 if (inst & (1 << 14))
323 /* This is a Form 3 instruction. */
324 int opcode = (inst >> 10 & 0xf);
332 case 0x04: /* bltu */
333 case 0x05: /* bgtu */
336 case 0x08: /* bgeu */
337 case 0x09: /* bleu */
338 /* Insert breaks on both branches, because we can't currently tell
339 which way things will go. */
340 VEC_safe_push (CORE_ADDR, next_pcs, addr + 2);
341 VEC_safe_push (CORE_ADDR, next_pcs,
342 addr + 2 + INST2OFFSET(inst));
353 /* This is a Form 2 instruction. They are all 16 bits. */
354 VEC_safe_push (CORE_ADDR, next_pcs, addr + 2);
359 /* This is a Form 1 instruction. */
360 int opcode = inst >> 8;
364 /* 16-bit instructions. */
366 case 0x02: /* mov (register-to-register) */
367 case 0x05: /* add.l */
368 case 0x06: /* push */
370 case 0x0a: /* ld.l (register indirect) */
371 case 0x0b: /* st.l */
374 case 0x10: /* sex.b */
375 case 0x11: /* sex.s */
376 case 0x12: /* zex.b */
377 case 0x13: /* zex.s */
378 case 0x14: /* umul.x */
379 case 0x15: /* mul.x */
383 case 0x1c: /* ld.b (register indirect) */
384 case 0x1e: /* st.b */
385 case 0x21: /* ld.s (register indirect) */
386 case 0x23: /* st.s */
388 case 0x27: /* lshr */
389 case 0x28: /* ashl */
390 case 0x29: /* sub.l */
394 case 0x2d: /* ashr */
396 case 0x2f: /* mul.l */
397 case 0x31: /* div.l */
398 case 0x32: /* udiv.l */
399 case 0x33: /* mod.l */
400 case 0x34: /* umod.l */
401 VEC_safe_push (CORE_ADDR, next_pcs, addr + 2);
404 /* 32-bit instructions. */
405 case 0x0c: /* ldo.l */
406 case 0x0d: /* sto.l */
407 case 0x36: /* ldo.b */
408 case 0x37: /* sto.b */
409 case 0x38: /* ldo.s */
410 case 0x39: /* sto.s */
411 VEC_safe_push (CORE_ADDR, next_pcs, addr + 4);
414 /* 48-bit instructions. */
415 case 0x01: /* ldi.l (immediate) */
416 case 0x08: /* lda.l */
417 case 0x09: /* sta.l */
418 case 0x1b: /* ldi.b (immediate) */
419 case 0x1d: /* lda.b */
420 case 0x1f: /* sta.b */
421 case 0x20: /* ldi.s (immediate) */
422 case 0x22: /* lda.s */
423 case 0x24: /* sta.s */
424 VEC_safe_push (CORE_ADDR, next_pcs, addr + 6);
427 /* Control flow instructions. */
428 case 0x03: /* jsra */
429 case 0x1a: /* jmpa */
430 VEC_safe_push (CORE_ADDR, next_pcs,
431 moxie_process_readu (addr + 2, buf, 4, byte_order));
435 regcache_cooked_read_unsigned (regcache, MOXIE_FP_REGNUM, &fp);
436 VEC_safe_push (CORE_ADDR, next_pcs,
437 moxie_process_readu (fp + 4, buf, 4, byte_order));
442 regcache_raw_read (regcache,
443 (inst >> 4) & 0xf, (gdb_byte *) & tmpu32);
444 VEC_safe_push (CORE_ADDR, next_pcs, tmpu32);
449 /* Unsupported, for now. */
457 /* Implement the "read_pc" gdbarch method. */
460 moxie_read_pc (struct regcache *regcache)
464 regcache_cooked_read_unsigned (regcache, MOXIE_PC_REGNUM, &pc);
468 /* Implement the "write_pc" gdbarch method. */
471 moxie_write_pc (struct regcache *regcache, CORE_ADDR val)
473 regcache_cooked_write_unsigned (regcache, MOXIE_PC_REGNUM, val);
476 /* Implement the "unwind_sp" gdbarch method. */
479 moxie_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
481 return frame_unwind_register_unsigned (next_frame, MOXIE_SP_REGNUM);
484 /* Given a return value in `regbuf' with a type `valtype',
485 extract and copy its value into `valbuf'. */
488 moxie_extract_return_value (struct type *type, struct regcache *regcache,
491 struct gdbarch *gdbarch = get_regcache_arch (regcache);
492 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
493 int len = TYPE_LENGTH (type);
496 /* By using store_unsigned_integer we avoid having to do
497 anything special for small big-endian values. */
498 regcache_cooked_read_unsigned (regcache, RET1_REGNUM, &tmp);
499 store_unsigned_integer (dst, (len > 4 ? len - 4 : len), byte_order, tmp);
501 /* Ignore return values more than 8 bytes in size because the moxie
502 returns anything more than 8 bytes in the stack. */
505 regcache_cooked_read_unsigned (regcache, RET1_REGNUM + 1, &tmp);
506 store_unsigned_integer (dst + len - 4, 4, byte_order, tmp);
510 /* Implement the "return_value" gdbarch method. */
512 static enum return_value_convention
513 moxie_return_value (struct gdbarch *gdbarch, struct value *function,
514 struct type *valtype, struct regcache *regcache,
515 gdb_byte *readbuf, const gdb_byte *writebuf)
517 if (TYPE_LENGTH (valtype) > 8)
518 return RETURN_VALUE_STRUCT_CONVENTION;
522 moxie_extract_return_value (valtype, regcache, readbuf);
523 if (writebuf != NULL)
524 moxie_store_return_value (valtype, regcache, writebuf);
525 return RETURN_VALUE_REGISTER_CONVENTION;
529 /* Allocate and initialize a moxie_frame_cache object. */
531 static struct moxie_frame_cache *
532 moxie_alloc_frame_cache (void)
534 struct moxie_frame_cache *cache;
537 cache = FRAME_OBSTACK_ZALLOC (struct moxie_frame_cache);
542 cache->framesize = 0;
543 for (i = 0; i < MOXIE_NUM_REGS; ++i)
544 cache->saved_regs[i] = REG_UNAVAIL;
549 /* Populate a moxie_frame_cache object for this_frame. */
551 static struct moxie_frame_cache *
552 moxie_frame_cache (struct frame_info *this_frame, void **this_cache)
554 struct moxie_frame_cache *cache;
555 CORE_ADDR current_pc;
559 return (struct moxie_frame_cache *) *this_cache;
561 cache = moxie_alloc_frame_cache ();
564 cache->base = get_frame_register_unsigned (this_frame, MOXIE_FP_REGNUM);
565 if (cache->base == 0)
568 cache->pc = get_frame_func (this_frame);
569 current_pc = get_frame_pc (this_frame);
572 struct gdbarch *gdbarch = get_frame_arch (this_frame);
573 moxie_analyze_prologue (cache->pc, current_pc, cache, gdbarch);
576 cache->saved_sp = cache->base - cache->framesize;
578 for (i = 0; i < MOXIE_NUM_REGS; ++i)
579 if (cache->saved_regs[i] != REG_UNAVAIL)
580 cache->saved_regs[i] = cache->base - cache->saved_regs[i];
585 /* Implement the "unwind_pc" gdbarch method. */
588 moxie_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
590 return frame_unwind_register_unsigned (next_frame, MOXIE_PC_REGNUM);
593 /* Given a GDB frame, determine the address of the calling function's
594 frame. This will be used to create a new GDB frame struct. */
597 moxie_frame_this_id (struct frame_info *this_frame,
598 void **this_prologue_cache, struct frame_id *this_id)
600 struct moxie_frame_cache *cache = moxie_frame_cache (this_frame,
601 this_prologue_cache);
603 /* This marks the outermost frame. */
604 if (cache->base == 0)
607 *this_id = frame_id_build (cache->saved_sp, cache->pc);
610 /* Get the value of register regnum in the previous stack frame. */
612 static struct value *
613 moxie_frame_prev_register (struct frame_info *this_frame,
614 void **this_prologue_cache, int regnum)
616 struct moxie_frame_cache *cache = moxie_frame_cache (this_frame,
617 this_prologue_cache);
619 gdb_assert (regnum >= 0);
621 if (regnum == MOXIE_SP_REGNUM && cache->saved_sp)
622 return frame_unwind_got_constant (this_frame, regnum, cache->saved_sp);
624 if (regnum < MOXIE_NUM_REGS && cache->saved_regs[regnum] != REG_UNAVAIL)
625 return frame_unwind_got_memory (this_frame, regnum,
626 cache->saved_regs[regnum]);
628 return frame_unwind_got_register (this_frame, regnum, regnum);
631 static const struct frame_unwind moxie_frame_unwind = {
633 default_frame_unwind_stop_reason,
635 moxie_frame_prev_register,
637 default_frame_sniffer
640 /* Return the base address of this_frame. */
643 moxie_frame_base_address (struct frame_info *this_frame, void **this_cache)
645 struct moxie_frame_cache *cache = moxie_frame_cache (this_frame,
651 static const struct frame_base moxie_frame_base = {
653 moxie_frame_base_address,
654 moxie_frame_base_address,
655 moxie_frame_base_address
658 static struct frame_id
659 moxie_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
661 CORE_ADDR sp = get_frame_register_unsigned (this_frame, MOXIE_SP_REGNUM);
663 return frame_id_build (sp, get_frame_pc (this_frame));
666 /* Parse the current instruction and record the values of the registers and
667 memory that will be changed in current instruction to "record_arch_list".
668 Return -1 if something wrong. */
671 moxie_process_record (struct gdbarch *gdbarch, struct regcache *regcache,
677 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
679 if (record_debug > 1)
680 fprintf_unfiltered (gdb_stdlog, "Process record: moxie_process_record "
682 paddress (target_gdbarch (), addr));
684 inst = (uint16_t) moxie_process_readu (addr, buf, 2, byte_order);
686 /* Decode instruction. */
687 if (inst & (1 << 15))
689 if (inst & (1 << 14))
691 /* This is a Form 3 instruction. */
692 int opcode = (inst >> 10 & 0xf);
700 case 0x04: /* bltu */
701 case 0x05: /* bgtu */
704 case 0x08: /* bgeu */
705 case 0x09: /* bleu */
717 /* This is a Form 2 instruction. */
718 int opcode = (inst >> 12 & 0x3);
725 int reg = (inst >> 8) & 0xf;
726 if (record_full_arch_list_add_reg (regcache, reg))
732 /* Do nothing until GDB learns about moxie's special
744 /* This is a Form 1 instruction. */
745 int opcode = inst >> 8;
752 case 0x01: /* ldi.l (immediate) */
753 case 0x02: /* mov (register-to-register) */
755 int reg = (inst >> 4) & 0xf;
756 if (record_full_arch_list_add_reg (regcache, reg))
760 case 0x03: /* jsra */
762 regcache_raw_read (regcache,
763 MOXIE_SP_REGNUM, (gdb_byte *) & tmpu32);
764 tmpu32 = extract_unsigned_integer ((gdb_byte *) & tmpu32,
766 if (record_full_arch_list_add_reg (regcache, MOXIE_FP_REGNUM)
767 || (record_full_arch_list_add_reg (regcache,
769 || record_full_arch_list_add_mem (tmpu32 - 12, 12))
775 if (record_full_arch_list_add_reg (regcache, MOXIE_FP_REGNUM)
776 || (record_full_arch_list_add_reg (regcache,
781 case 0x05: /* add.l */
783 int reg = (inst >> 4) & 0xf;
784 if (record_full_arch_list_add_reg (regcache, reg))
788 case 0x06: /* push */
790 int reg = (inst >> 4) & 0xf;
791 regcache_raw_read (regcache, reg, (gdb_byte *) & tmpu32);
792 tmpu32 = extract_unsigned_integer ((gdb_byte *) & tmpu32,
794 if (record_full_arch_list_add_reg (regcache, reg)
795 || record_full_arch_list_add_mem (tmpu32 - 4, 4))
801 int a = (inst >> 4) & 0xf;
803 if (record_full_arch_list_add_reg (regcache, a)
804 || record_full_arch_list_add_reg (regcache, b))
808 case 0x08: /* lda.l */
810 int reg = (inst >> 4) & 0xf;
811 if (record_full_arch_list_add_reg (regcache, reg))
815 case 0x09: /* sta.l */
817 tmpu32 = (uint32_t) moxie_process_readu (addr+2, buf,
819 if (record_full_arch_list_add_mem (tmpu32, 4))
823 case 0x0a: /* ld.l (register indirect) */
825 int reg = (inst >> 4) & 0xf;
826 if (record_full_arch_list_add_reg (regcache, reg))
830 case 0x0b: /* st.l */
832 int reg = (inst >> 4) & 0xf;
833 regcache_raw_read (regcache, reg, (gdb_byte *) & tmpu32);
834 tmpu32 = extract_unsigned_integer ((gdb_byte *) & tmpu32,
836 if (record_full_arch_list_add_mem (tmpu32, 4))
840 case 0x0c: /* ldo.l */
842 int reg = (inst >> 4) & 0xf;
843 if (record_full_arch_list_add_reg (regcache, reg))
847 case 0x0d: /* sto.l */
849 int reg = (inst >> 4) & 0xf;
850 uint32_t offset = (((int16_t) moxie_process_readu (addr+2, buf, 2,
851 byte_order)) << 16 ) >> 16;
852 regcache_raw_read (regcache, reg, (gdb_byte *) & tmpu32);
853 tmpu32 = extract_unsigned_integer ((gdb_byte *) & tmpu32,
856 if (record_full_arch_list_add_mem (tmpu32, 4))
862 if (record_full_arch_list_add_reg (regcache, MOXIE_CC_REGNUM))
871 case 0x10: /* sex.b */
872 case 0x11: /* sex.s */
873 case 0x12: /* zex.b */
874 case 0x13: /* zex.s */
875 case 0x14: /* umul.x */
876 case 0x15: /* mul.x */
878 int reg = (inst >> 4) & 0xf;
879 if (record_full_arch_list_add_reg (regcache, reg))
892 regcache_raw_read (regcache,
893 MOXIE_SP_REGNUM, (gdb_byte *) & tmpu32);
894 tmpu32 = extract_unsigned_integer ((gdb_byte *) & tmpu32,
896 if (record_full_arch_list_add_reg (regcache, MOXIE_FP_REGNUM)
897 || (record_full_arch_list_add_reg (regcache,
899 || record_full_arch_list_add_mem (tmpu32 - 12, 12))
903 case 0x1a: /* jmpa */
908 case 0x1b: /* ldi.b (immediate) */
909 case 0x1c: /* ld.b (register indirect) */
910 case 0x1d: /* lda.b */
912 int reg = (inst >> 4) & 0xf;
913 if (record_full_arch_list_add_reg (regcache, reg))
917 case 0x1e: /* st.b */
919 int reg = (inst >> 4) & 0xf;
920 regcache_raw_read (regcache, reg, (gdb_byte *) & tmpu32);
921 tmpu32 = extract_unsigned_integer ((gdb_byte *) & tmpu32,
923 if (record_full_arch_list_add_mem (tmpu32, 1))
927 case 0x1f: /* sta.b */
929 tmpu32 = moxie_process_readu (addr+2, buf, 4, byte_order);
930 if (record_full_arch_list_add_mem (tmpu32, 1))
934 case 0x20: /* ldi.s (immediate) */
935 case 0x21: /* ld.s (register indirect) */
936 case 0x22: /* lda.s */
938 int reg = (inst >> 4) & 0xf;
939 if (record_full_arch_list_add_reg (regcache, reg))
943 case 0x23: /* st.s */
945 int reg = (inst >> 4) & 0xf;
946 regcache_raw_read (regcache, reg, (gdb_byte *) & tmpu32);
947 tmpu32 = extract_unsigned_integer ((gdb_byte *) & tmpu32,
949 if (record_full_arch_list_add_mem (tmpu32, 2))
953 case 0x24: /* sta.s */
955 tmpu32 = moxie_process_readu (addr+2, buf, 4, byte_order);
956 if (record_full_arch_list_add_mem (tmpu32, 2))
966 case 0x27: /* lshr */
967 case 0x28: /* ashl */
972 case 0x2d: /* ashr */
976 int reg = (inst >> 4) & 0xf;
977 if (record_full_arch_list_add_reg (regcache, reg))
983 /* We currently implement support for libgloss'
986 int inum = moxie_process_readu (addr+2, buf, 4, byte_order);
990 case 0x1: /* SYS_exit */
995 case 0x2: /* SYS_open */
997 if (record_full_arch_list_add_reg (regcache, RET1_REGNUM))
1001 case 0x4: /* SYS_read */
1003 uint32_t length, ptr;
1005 /* Read buffer pointer is in $r1. */
1006 regcache_raw_read (regcache, 3, (gdb_byte *) & ptr);
1007 ptr = extract_unsigned_integer ((gdb_byte *) & ptr,
1010 /* String length is at 0x12($fp). */
1011 regcache_raw_read (regcache,
1012 MOXIE_FP_REGNUM, (gdb_byte *) & tmpu32);
1013 tmpu32 = extract_unsigned_integer ((gdb_byte *) & tmpu32,
1015 length = moxie_process_readu (tmpu32+20, buf, 4, byte_order);
1017 if (record_full_arch_list_add_mem (ptr, length))
1021 case 0x5: /* SYS_write */
1023 if (record_full_arch_list_add_reg (regcache, RET1_REGNUM))
1032 case 0x31: /* div.l */
1033 case 0x32: /* udiv.l */
1034 case 0x33: /* mod.l */
1035 case 0x34: /* umod.l */
1037 int reg = (inst >> 4) & 0xf;
1038 if (record_full_arch_list_add_reg (regcache, reg))
1042 case 0x35: /* brk */
1045 case 0x36: /* ldo.b */
1047 int reg = (inst >> 4) & 0xf;
1048 if (record_full_arch_list_add_reg (regcache, reg))
1052 case 0x37: /* sto.b */
1054 int reg = (inst >> 4) & 0xf;
1055 uint32_t offset = (((int16_t) moxie_process_readu (addr+2, buf, 2,
1056 byte_order)) << 16 ) >> 16;
1057 regcache_raw_read (regcache, reg, (gdb_byte *) & tmpu32);
1058 tmpu32 = extract_unsigned_integer ((gdb_byte *) & tmpu32,
1061 if (record_full_arch_list_add_mem (tmpu32, 1))
1065 case 0x38: /* ldo.s */
1067 int reg = (inst >> 4) & 0xf;
1068 if (record_full_arch_list_add_reg (regcache, reg))
1072 case 0x39: /* sto.s */
1074 int reg = (inst >> 4) & 0xf;
1075 uint32_t offset = (((int16_t) moxie_process_readu (addr+2, buf, 2,
1076 byte_order)) << 16 ) >> 16;
1077 regcache_raw_read (regcache, reg, (gdb_byte *) & tmpu32);
1078 tmpu32 = extract_unsigned_integer ((gdb_byte *) & tmpu32,
1081 if (record_full_arch_list_add_mem (tmpu32, 2))
1091 if (record_full_arch_list_add_reg (regcache, MOXIE_PC_REGNUM))
1093 if (record_full_arch_list_add_end ())
1098 /* Allocate and initialize the moxie gdbarch object. */
1100 static struct gdbarch *
1101 moxie_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
1103 struct gdbarch *gdbarch;
1104 struct gdbarch_tdep *tdep;
1106 /* If there is already a candidate, use it. */
1107 arches = gdbarch_list_lookup_by_info (arches, &info);
1109 return arches->gdbarch;
1111 /* Allocate space for the new architecture. */
1112 tdep = XNEW (struct gdbarch_tdep);
1113 gdbarch = gdbarch_alloc (&info, tdep);
1115 set_gdbarch_read_pc (gdbarch, moxie_read_pc);
1116 set_gdbarch_write_pc (gdbarch, moxie_write_pc);
1117 set_gdbarch_unwind_sp (gdbarch, moxie_unwind_sp);
1119 set_gdbarch_num_regs (gdbarch, MOXIE_NUM_REGS);
1120 set_gdbarch_sp_regnum (gdbarch, MOXIE_SP_REGNUM);
1121 set_gdbarch_pc_regnum (gdbarch, MOXIE_PC_REGNUM);
1122 set_gdbarch_register_name (gdbarch, moxie_register_name);
1123 set_gdbarch_register_type (gdbarch, moxie_register_type);
1125 set_gdbarch_return_value (gdbarch, moxie_return_value);
1127 set_gdbarch_skip_prologue (gdbarch, moxie_skip_prologue);
1128 set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
1129 set_gdbarch_breakpoint_kind_from_pc (gdbarch,
1130 moxie_breakpoint::kind_from_pc);
1131 set_gdbarch_sw_breakpoint_from_kind (gdbarch,
1132 moxie_breakpoint::bp_from_kind);
1133 set_gdbarch_frame_align (gdbarch, moxie_frame_align);
1135 frame_base_set_default (gdbarch, &moxie_frame_base);
1137 /* Methods for saving / extracting a dummy frame's ID. The ID's
1138 stack address must match the SP value returned by
1139 PUSH_DUMMY_CALL, and saved by generic_save_dummy_frame_tos. */
1140 set_gdbarch_dummy_id (gdbarch, moxie_dummy_id);
1142 set_gdbarch_unwind_pc (gdbarch, moxie_unwind_pc);
1144 set_gdbarch_print_insn (gdbarch, print_insn_moxie);
1146 /* Hook in ABI-specific overrides, if they have been registered. */
1147 gdbarch_init_osabi (info, gdbarch);
1149 /* Hook in the default unwinders. */
1150 frame_unwind_append_unwinder (gdbarch, &moxie_frame_unwind);
1152 /* Single stepping. */
1153 set_gdbarch_software_single_step (gdbarch, moxie_software_single_step);
1155 /* Support simple overlay manager. */
1156 set_gdbarch_overlay_update (gdbarch, simple_overlay_update);
1158 /* Support reverse debugging. */
1159 set_gdbarch_process_record (gdbarch, moxie_process_record);
1164 /* Register this machine's init routine. */
1167 _initialize_moxie_tdep (void)
1169 register_gdbarch_init (bfd_arch_moxie, moxie_gdbarch_init);