1 /* Target-dependent code for Moxie.
2
3 Copyright (C) 2009-2013 Free Software Foundation, Inc.
4
5 This file is part of GDB.
6
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.
11
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.
16
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/>. */
19
20 #include "defs.h"
21 #include "frame.h"
22 #include "frame-unwind.h"
23 #include "frame-base.h"
24 #include "symtab.h"
25 #include "gdbtypes.h"
26 #include "gdbcmd.h"
27 #include "gdbcore.h"
28 #include "gdb_string.h"
29 #include "value.h"
30 #include "inferior.h"
31 #include "symfile.h"
32 #include "objfiles.h"
33 #include "osabi.h"
34 #include "language.h"
35 #include "arch-utils.h"
36 #include "regcache.h"
37 #include "trad-frame.h"
38 #include "dis-asm.h"
39 #include "record.h"
40 #include "record-full.h"
41
42 #include "gdb_assert.h"
43
44 #include "moxie-tdep.h"
45
46 /* Local functions. */
47
48 extern void _initialize_moxie_tdep (void);
49
50 /* Use an invalid address value as 'not available' marker. */
51 enum { REG_UNAVAIL = (CORE_ADDR) -1 };
52
53 struct moxie_frame_cache
54 {
55 /* Base address. */
56 CORE_ADDR base;
57 CORE_ADDR pc;
58 LONGEST framesize;
59 CORE_ADDR saved_regs[MOXIE_NUM_REGS];
60 CORE_ADDR saved_sp;
61 };
62
63 /* Implement the "frame_align" gdbarch method. */
64
65 static CORE_ADDR
moxie_frame_align(struct gdbarch * gdbarch,CORE_ADDR sp)66 moxie_frame_align (struct gdbarch *gdbarch, CORE_ADDR sp)
67 {
68 /* Align to the size of an instruction (so that they can safely be
69 pushed onto the stack. */
70 return sp & ~1;
71 }
72
73 /* Implement the "breakpoint_from_pc" gdbarch method. */
74
75 const static unsigned char *
moxie_breakpoint_from_pc(struct gdbarch * gdbarch,CORE_ADDR * pcptr,int * lenptr)76 moxie_breakpoint_from_pc (struct gdbarch *gdbarch,
77 CORE_ADDR *pcptr, int *lenptr)
78 {
79 static unsigned char breakpoint[] = { 0x35, 0x00 };
80
81 *lenptr = sizeof (breakpoint);
82 return breakpoint;
83 }
84
85 /* Moxie register names. */
86
87 char *moxie_register_names[] = {
88 "$fp", "$sp", "$r0", "$r1", "$r2",
89 "$r3", "$r4", "$r5", "$r6", "$r7",
90 "$r8", "$r9", "$r10", "$r11", "$r12",
91 "$r13", "$pc", "$cc" };
92
93 /* Implement the "register_name" gdbarch method. */
94
95 static const char *
moxie_register_name(struct gdbarch * gdbarch,int reg_nr)96 moxie_register_name (struct gdbarch *gdbarch, int reg_nr)
97 {
98 if (reg_nr < 0)
99 return NULL;
100 if (reg_nr >= MOXIE_NUM_REGS)
101 return NULL;
102 return moxie_register_names[reg_nr];
103 }
104
105 /* Implement the "register_type" gdbarch method. */
106
107 static struct type *
moxie_register_type(struct gdbarch * gdbarch,int reg_nr)108 moxie_register_type (struct gdbarch *gdbarch, int reg_nr)
109 {
110 if (reg_nr == MOXIE_PC_REGNUM)
111 return builtin_type (gdbarch)->builtin_func_ptr;
112 else if (reg_nr == MOXIE_SP_REGNUM || reg_nr == MOXIE_FP_REGNUM)
113 return builtin_type (gdbarch)->builtin_data_ptr;
114 else
115 return builtin_type (gdbarch)->builtin_int32;
116 }
117
118 /* Write into appropriate registers a function return value
119 of type TYPE, given in virtual format. */
120
121 static void
moxie_store_return_value(struct type * type,struct regcache * regcache,const void * valbuf)122 moxie_store_return_value (struct type *type, struct regcache *regcache,
123 const void *valbuf)
124 {
125 struct gdbarch *gdbarch = get_regcache_arch (regcache);
126 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
127 CORE_ADDR regval;
128 int len = TYPE_LENGTH (type);
129
130 /* Things always get returned in RET1_REGNUM, RET2_REGNUM. */
131 regval = extract_unsigned_integer (valbuf, len > 4 ? 4 : len, byte_order);
132 regcache_cooked_write_unsigned (regcache, RET1_REGNUM, regval);
133 if (len > 4)
134 {
135 regval = extract_unsigned_integer ((gdb_byte *) valbuf + 4,
136 len - 4, byte_order);
137 regcache_cooked_write_unsigned (regcache, RET1_REGNUM + 1, regval);
138 }
139 }
140
141 /* Decode the instructions within the given address range. Decide
142 when we must have reached the end of the function prologue. If a
143 frame_info pointer is provided, fill in its saved_regs etc.
144
145 Returns the address of the first instruction after the prologue. */
146
147 static CORE_ADDR
moxie_analyze_prologue(CORE_ADDR start_addr,CORE_ADDR end_addr,struct moxie_frame_cache * cache,struct gdbarch * gdbarch)148 moxie_analyze_prologue (CORE_ADDR start_addr, CORE_ADDR end_addr,
149 struct moxie_frame_cache *cache,
150 struct gdbarch *gdbarch)
151 {
152 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
153 CORE_ADDR next_addr;
154 ULONGEST inst, inst2;
155 LONGEST offset;
156 int regnum;
157
158 /* Record where the jsra instruction saves the PC and FP. */
159 cache->saved_regs[MOXIE_PC_REGNUM] = -4;
160 cache->saved_regs[MOXIE_FP_REGNUM] = 0;
161 cache->framesize = 0;
162
163 if (start_addr >= end_addr)
164 return end_addr;
165
166 for (next_addr = start_addr; next_addr < end_addr; )
167 {
168 inst = read_memory_unsigned_integer (next_addr, 2, byte_order);
169
170 /* Match "push $sp $rN" where N is between 0 and 13 inclusive. */
171 if (inst >= 0x0612 && inst <= 0x061f)
172 {
173 regnum = inst & 0x000f;
174 cache->framesize += 4;
175 cache->saved_regs[regnum] = cache->framesize;
176 next_addr += 2;
177 }
178 else
179 break;
180 }
181
182 inst = read_memory_unsigned_integer (next_addr, 2, byte_order);
183
184 /* Optional stack allocation for args and local vars <= 4
185 byte. */
186 if (inst == 0x01e0) /* ldi.l $r12, X */
187 {
188 offset = read_memory_integer (next_addr + 2, 4, byte_order);
189 inst2 = read_memory_unsigned_integer (next_addr + 6, 2, byte_order);
190
191 if (inst2 == 0x291e) /* sub.l $sp, $r12 */
192 {
193 cache->framesize += offset;
194 }
195
196 return (next_addr + 8);
197 }
198 else if ((inst & 0xff00) == 0x9100) /* dec $sp, X */
199 {
200 cache->framesize += (inst & 0x00ff);
201 next_addr += 2;
202
203 while (next_addr < end_addr)
204 {
205 inst = read_memory_unsigned_integer (next_addr, 2, byte_order);
206 if ((inst & 0xff00) != 0x9100) /* no more dec $sp, X */
207 break;
208 cache->framesize += (inst & 0x00ff);
209 next_addr += 2;
210 }
211 }
212
213 return next_addr;
214 }
215
216 /* Find the end of function prologue. */
217
218 static CORE_ADDR
moxie_skip_prologue(struct gdbarch * gdbarch,CORE_ADDR pc)219 moxie_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
220 {
221 CORE_ADDR func_addr = 0, func_end = 0;
222 const char *func_name;
223
224 /* See if we can determine the end of the prologue via the symbol table.
225 If so, then return either PC, or the PC after the prologue, whichever
226 is greater. */
227 if (find_pc_partial_function (pc, &func_name, &func_addr, &func_end))
228 {
229 CORE_ADDR post_prologue_pc
230 = skip_prologue_using_sal (gdbarch, func_addr);
231 if (post_prologue_pc != 0)
232 return max (pc, post_prologue_pc);
233 else
234 {
235 /* Can't determine prologue from the symbol table, need to examine
236 instructions. */
237 struct symtab_and_line sal;
238 struct symbol *sym;
239 struct moxie_frame_cache cache;
240 CORE_ADDR plg_end;
241
242 memset (&cache, 0, sizeof cache);
243
244 plg_end = moxie_analyze_prologue (func_addr,
245 func_end, &cache, gdbarch);
246 /* Found a function. */
247 sym = lookup_symbol (func_name, NULL, VAR_DOMAIN, NULL);
248 /* Don't use line number debug info for assembly source
249 files. */
250 if (sym && SYMBOL_LANGUAGE (sym) != language_asm)
251 {
252 sal = find_pc_line (func_addr, 0);
253 if (sal.end && sal.end < func_end)
254 {
255 /* Found a line number, use it as end of
256 prologue. */
257 return sal.end;
258 }
259 }
260 /* No useable line symbol. Use result of prologue parsing
261 method. */
262 return plg_end;
263 }
264 }
265
266 /* No function symbol -- just return the PC. */
267 return (CORE_ADDR) pc;
268 }
269
270 struct moxie_unwind_cache
271 {
272 /* The previous frame's inner most stack address. Used as this
273 frame ID's stack_addr. */
274 CORE_ADDR prev_sp;
275 /* The frame's base, optionally used by the high-level debug info. */
276 CORE_ADDR base;
277 int size;
278 /* How far the SP and r13 (FP) have been offset from the start of
279 the stack frame (as defined by the previous frame's stack
280 pointer). */
281 LONGEST sp_offset;
282 LONGEST r13_offset;
283 int uses_frame;
284 /* Table indicating the location of each and every register. */
285 struct trad_frame_saved_reg *saved_regs;
286 };
287
288 /* Implement the "read_pc" gdbarch method. */
289
290 static CORE_ADDR
moxie_read_pc(struct regcache * regcache)291 moxie_read_pc (struct regcache *regcache)
292 {
293 ULONGEST pc;
294
295 regcache_cooked_read_unsigned (regcache, MOXIE_PC_REGNUM, &pc);
296 return pc;
297 }
298
299 /* Implement the "write_pc" gdbarch method. */
300
301 static void
moxie_write_pc(struct regcache * regcache,CORE_ADDR val)302 moxie_write_pc (struct regcache *regcache, CORE_ADDR val)
303 {
304 regcache_cooked_write_unsigned (regcache, MOXIE_PC_REGNUM, val);
305 }
306
307 /* Implement the "unwind_sp" gdbarch method. */
308
309 static CORE_ADDR
moxie_unwind_sp(struct gdbarch * gdbarch,struct frame_info * next_frame)310 moxie_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
311 {
312 return frame_unwind_register_unsigned (next_frame, MOXIE_SP_REGNUM);
313 }
314
315 /* Given a return value in `regbuf' with a type `valtype',
316 extract and copy its value into `valbuf'. */
317
318 static void
moxie_extract_return_value(struct type * type,struct regcache * regcache,void * dst)319 moxie_extract_return_value (struct type *type, struct regcache *regcache,
320 void *dst)
321 {
322 struct gdbarch *gdbarch = get_regcache_arch (regcache);
323 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
324 bfd_byte *valbuf = dst;
325 int len = TYPE_LENGTH (type);
326 ULONGEST tmp;
327
328 /* By using store_unsigned_integer we avoid having to do
329 anything special for small big-endian values. */
330 regcache_cooked_read_unsigned (regcache, RET1_REGNUM, &tmp);
331 store_unsigned_integer (valbuf, (len > 4 ? len - 4 : len), byte_order, tmp);
332
333 /* Ignore return values more than 8 bytes in size because the moxie
334 returns anything more than 8 bytes in the stack. */
335 if (len > 4)
336 {
337 regcache_cooked_read_unsigned (regcache, RET1_REGNUM + 1, &tmp);
338 store_unsigned_integer (valbuf + len - 4, 4, byte_order, tmp);
339 }
340 }
341
342 /* Implement the "return_value" gdbarch method. */
343
344 static enum return_value_convention
moxie_return_value(struct gdbarch * gdbarch,struct value * function,struct type * valtype,struct regcache * regcache,gdb_byte * readbuf,const gdb_byte * writebuf)345 moxie_return_value (struct gdbarch *gdbarch, struct value *function,
346 struct type *valtype, struct regcache *regcache,
347 gdb_byte *readbuf, const gdb_byte *writebuf)
348 {
349 if (TYPE_LENGTH (valtype) > 8)
350 return RETURN_VALUE_STRUCT_CONVENTION;
351 else
352 {
353 if (readbuf != NULL)
354 moxie_extract_return_value (valtype, regcache, readbuf);
355 if (writebuf != NULL)
356 moxie_store_return_value (valtype, regcache, writebuf);
357 return RETURN_VALUE_REGISTER_CONVENTION;
358 }
359 }
360
361 /* Allocate and initialize a moxie_frame_cache object. */
362
363 static struct moxie_frame_cache *
moxie_alloc_frame_cache(void)364 moxie_alloc_frame_cache (void)
365 {
366 struct moxie_frame_cache *cache;
367 int i;
368
369 cache = FRAME_OBSTACK_ZALLOC (struct moxie_frame_cache);
370
371 cache->base = 0;
372 cache->saved_sp = 0;
373 cache->pc = 0;
374 cache->framesize = 0;
375 for (i = 0; i < MOXIE_NUM_REGS; ++i)
376 cache->saved_regs[i] = REG_UNAVAIL;
377
378 return cache;
379 }
380
381 /* Populate a moxie_frame_cache object for this_frame. */
382
383 static struct moxie_frame_cache *
moxie_frame_cache(struct frame_info * this_frame,void ** this_cache)384 moxie_frame_cache (struct frame_info *this_frame, void **this_cache)
385 {
386 struct moxie_frame_cache *cache;
387 CORE_ADDR current_pc;
388 int i;
389
390 if (*this_cache)
391 return *this_cache;
392
393 cache = moxie_alloc_frame_cache ();
394 *this_cache = cache;
395
396 cache->base = get_frame_register_unsigned (this_frame, MOXIE_FP_REGNUM);
397 if (cache->base == 0)
398 return cache;
399
400 cache->pc = get_frame_func (this_frame);
401 current_pc = get_frame_pc (this_frame);
402 if (cache->pc)
403 {
404 struct gdbarch *gdbarch = get_frame_arch (this_frame);
405 moxie_analyze_prologue (cache->pc, current_pc, cache, gdbarch);
406 }
407
408 cache->saved_sp = cache->base - cache->framesize;
409
410 for (i = 0; i < MOXIE_NUM_REGS; ++i)
411 if (cache->saved_regs[i] != REG_UNAVAIL)
412 cache->saved_regs[i] = cache->base - cache->saved_regs[i];
413
414 return cache;
415 }
416
417 /* Implement the "unwind_pc" gdbarch method. */
418
419 static CORE_ADDR
moxie_unwind_pc(struct gdbarch * gdbarch,struct frame_info * next_frame)420 moxie_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
421 {
422 return frame_unwind_register_unsigned (next_frame, MOXIE_PC_REGNUM);
423 }
424
425 /* Given a GDB frame, determine the address of the calling function's
426 frame. This will be used to create a new GDB frame struct. */
427
428 static void
moxie_frame_this_id(struct frame_info * this_frame,void ** this_prologue_cache,struct frame_id * this_id)429 moxie_frame_this_id (struct frame_info *this_frame,
430 void **this_prologue_cache, struct frame_id *this_id)
431 {
432 struct moxie_frame_cache *cache = moxie_frame_cache (this_frame,
433 this_prologue_cache);
434
435 /* This marks the outermost frame. */
436 if (cache->base == 0)
437 return;
438
439 *this_id = frame_id_build (cache->saved_sp, cache->pc);
440 }
441
442 /* Get the value of register regnum in the previous stack frame. */
443
444 static struct value *
moxie_frame_prev_register(struct frame_info * this_frame,void ** this_prologue_cache,int regnum)445 moxie_frame_prev_register (struct frame_info *this_frame,
446 void **this_prologue_cache, int regnum)
447 {
448 struct moxie_frame_cache *cache = moxie_frame_cache (this_frame,
449 this_prologue_cache);
450
451 gdb_assert (regnum >= 0);
452
453 if (regnum == MOXIE_SP_REGNUM && cache->saved_sp)
454 return frame_unwind_got_constant (this_frame, regnum, cache->saved_sp);
455
456 if (regnum < MOXIE_NUM_REGS && cache->saved_regs[regnum] != REG_UNAVAIL)
457 return frame_unwind_got_memory (this_frame, regnum,
458 cache->saved_regs[regnum]);
459
460 return frame_unwind_got_register (this_frame, regnum, regnum);
461 }
462
463 static const struct frame_unwind moxie_frame_unwind = {
464 NORMAL_FRAME,
465 default_frame_unwind_stop_reason,
466 moxie_frame_this_id,
467 moxie_frame_prev_register,
468 NULL,
469 default_frame_sniffer
470 };
471
472 /* Return the base address of this_frame. */
473
474 static CORE_ADDR
moxie_frame_base_address(struct frame_info * this_frame,void ** this_cache)475 moxie_frame_base_address (struct frame_info *this_frame, void **this_cache)
476 {
477 struct moxie_frame_cache *cache = moxie_frame_cache (this_frame,
478 this_cache);
479
480 return cache->base;
481 }
482
483 static const struct frame_base moxie_frame_base = {
484 &moxie_frame_unwind,
485 moxie_frame_base_address,
486 moxie_frame_base_address,
487 moxie_frame_base_address
488 };
489
490 static struct frame_id
moxie_dummy_id(struct gdbarch * gdbarch,struct frame_info * this_frame)491 moxie_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
492 {
493 CORE_ADDR sp = get_frame_register_unsigned (this_frame, MOXIE_SP_REGNUM);
494
495 return frame_id_build (sp, get_frame_pc (this_frame));
496 }
497
498 /* Read an unsigned integer from the inferior, and adjust
499 endianess. */
500 static ULONGEST
moxie_process_readu(CORE_ADDR addr,char * buf,int length,enum bfd_endian byte_order)501 moxie_process_readu (CORE_ADDR addr, char *buf,
502 int length, enum bfd_endian byte_order)
503 {
504 if (target_read_memory (addr, buf, length))
505 {
506 if (record_debug)
507 printf_unfiltered (_("Process record: error reading memory at "
508 "addr 0x%s len = %d.\n"),
509 paddress (target_gdbarch (), addr), length);
510 return -1;
511 }
512
513 return extract_unsigned_integer (buf, length, byte_order);
514 }
515
516 /* Parse the current instruction and record the values of the registers and
517 memory that will be changed in current instruction to "record_arch_list".
518 Return -1 if something wrong. */
519
520 static int
moxie_process_record(struct gdbarch * gdbarch,struct regcache * regcache,CORE_ADDR addr)521 moxie_process_record (struct gdbarch *gdbarch, struct regcache *regcache,
522 CORE_ADDR addr)
523 {
524 gdb_byte buf[4];
525 uint16_t inst;
526 uint32_t tmpu32;
527 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
528
529 if (record_debug > 1)
530 fprintf_unfiltered (gdb_stdlog, "Process record: moxie_process_record "
531 "addr = 0x%s\n",
532 paddress (target_gdbarch (), addr));
533
534 inst = (uint16_t) moxie_process_readu (addr, buf, 2, byte_order);
535
536 /* Decode instruction. */
537 if (inst & (1 << 15))
538 {
539 if (inst & (1 << 14))
540 {
541 /* This is a Form 3 instruction. */
542 int opcode = (inst >> 10 & 0xf);
543
544 switch (opcode)
545 {
546 case 0x00: /* beq */
547 case 0x01: /* bne */
548 case 0x02: /* blt */
549 case 0x03: /* bgt */
550 case 0x04: /* bltu */
551 case 0x05: /* bgtu */
552 case 0x06: /* bge */
553 case 0x07: /* ble */
554 case 0x08: /* bgeu */
555 case 0x09: /* bleu */
556 /* Do nothing. */
557 break;
558 default:
559 {
560 /* Do nothing. */
561 break;
562 }
563 }
564 }
565 else
566 {
567 /* This is a Form 2 instruction. */
568 int opcode = (inst >> 12 & 0x3);
569 switch (opcode)
570 {
571 case 0x00: /* inc */
572 case 0x01: /* dec */
573 case 0x02: /* gsr */
574 {
575 int reg = (inst >> 8) & 0xf;
576 if (record_full_arch_list_add_reg (regcache, reg))
577 return -1;
578 }
579 break;
580 case 0x03: /* ssr */
581 {
582 /* Do nothing until GDB learns about moxie's special
583 registers. */
584 }
585 break;
586 default:
587 /* Do nothing. */
588 break;
589 }
590 }
591 }
592 else
593 {
594 /* This is a Form 1 instruction. */
595 int opcode = inst >> 8;
596
597 switch (opcode)
598 {
599 case 0x00: /* nop */
600 /* Do nothing. */
601 break;
602 case 0x01: /* ldi.l (immediate) */
603 case 0x02: /* mov (register-to-register) */
604 {
605 int reg = (inst >> 4) & 0xf;
606 if (record_full_arch_list_add_reg (regcache, reg))
607 return -1;
608 }
609 break;
610 case 0x03: /* jsra */
611 {
612 regcache_raw_read (regcache,
613 MOXIE_SP_REGNUM, (gdb_byte *) & tmpu32);
614 tmpu32 = extract_unsigned_integer ((gdb_byte *) & tmpu32,
615 4, byte_order);
616 if (record_full_arch_list_add_reg (regcache, MOXIE_FP_REGNUM)
617 || (record_full_arch_list_add_reg (regcache,
618 MOXIE_SP_REGNUM))
619 || record_full_arch_list_add_mem (tmpu32 - 12, 12))
620 return -1;
621 }
622 break;
623 case 0x04: /* ret */
624 {
625 if (record_full_arch_list_add_reg (regcache, MOXIE_FP_REGNUM)
626 || (record_full_arch_list_add_reg (regcache,
627 MOXIE_SP_REGNUM)))
628 return -1;
629 }
630 break;
631 case 0x05: /* add.l */
632 {
633 int reg = (inst >> 4) & 0xf;
634 if (record_full_arch_list_add_reg (regcache, reg))
635 return -1;
636 }
637 break;
638 case 0x06: /* push */
639 {
640 int reg = (inst >> 4) & 0xf;
641 regcache_raw_read (regcache, reg, (gdb_byte *) & tmpu32);
642 tmpu32 = extract_unsigned_integer ((gdb_byte *) & tmpu32,
643 4, byte_order);
644 if (record_full_arch_list_add_reg (regcache, reg)
645 || record_full_arch_list_add_mem (tmpu32 - 4, 4))
646 return -1;
647 }
648 break;
649 case 0x07: /* pop */
650 {
651 int a = (inst >> 4) & 0xf;
652 int b = inst & 0xf;
653 if (record_full_arch_list_add_reg (regcache, a)
654 || record_full_arch_list_add_reg (regcache, b))
655 return -1;
656 }
657 break;
658 case 0x08: /* lda.l */
659 {
660 int reg = (inst >> 4) & 0xf;
661 if (record_full_arch_list_add_reg (regcache, reg))
662 return -1;
663 }
664 break;
665 case 0x09: /* sta.l */
666 {
667 tmpu32 = (uint32_t) moxie_process_readu (addr+2, buf,
668 4, byte_order);
669 if (record_full_arch_list_add_mem (tmpu32, 4))
670 return -1;
671 }
672 break;
673 case 0x0a: /* ld.l (register indirect) */
674 {
675 int reg = (inst >> 4) & 0xf;
676 if (record_full_arch_list_add_reg (regcache, reg))
677 return -1;
678 }
679 break;
680 case 0x0b: /* st.l */
681 {
682 int reg = (inst >> 4) & 0xf;
683 regcache_raw_read (regcache, reg, (gdb_byte *) & tmpu32);
684 tmpu32 = extract_unsigned_integer ((gdb_byte *) & tmpu32,
685 4, byte_order);
686 if (record_full_arch_list_add_mem (tmpu32, 4))
687 return -1;
688 }
689 break;
690 case 0x0c: /* ldo.l */
691 {
692 int reg = (inst >> 4) & 0xf;
693 if (record_full_arch_list_add_reg (regcache, reg))
694 return -1;
695 }
696 break;
697 case 0x0d: /* sto.l */
698 {
699 int reg = (inst >> 4) & 0xf;
700 uint32_t offset = (uint32_t) moxie_process_readu (addr+2, buf, 4,
701 byte_order);
702 regcache_raw_read (regcache, reg, (gdb_byte *) & tmpu32);
703 tmpu32 = extract_unsigned_integer ((gdb_byte *) & tmpu32,
704 4, byte_order);
705 tmpu32 += offset;
706 if (record_full_arch_list_add_mem (tmpu32, 4))
707 return -1;
708 }
709 break;
710 case 0x0e: /* cmp */
711 {
712 if (record_full_arch_list_add_reg (regcache, MOXIE_CC_REGNUM))
713 return -1;
714 }
715 break;
716 case 0x0f:
717 case 0x10:
718 case 0x11:
719 case 0x12:
720 case 0x13:
721 case 0x14:
722 case 0x15:
723 case 0x16:
724 case 0x17:
725 case 0x18:
726 {
727 /* Do nothing. */
728 break;
729 }
730 case 0x19: /* jsr */
731 {
732 regcache_raw_read (regcache,
733 MOXIE_SP_REGNUM, (gdb_byte *) & tmpu32);
734 tmpu32 = extract_unsigned_integer ((gdb_byte *) & tmpu32,
735 4, byte_order);
736 if (record_full_arch_list_add_reg (regcache, MOXIE_FP_REGNUM)
737 || (record_full_arch_list_add_reg (regcache,
738 MOXIE_SP_REGNUM))
739 || record_full_arch_list_add_mem (tmpu32 - 12, 12))
740 return -1;
741 }
742 break;
743 case 0x1a: /* jmpa */
744 {
745 /* Do nothing. */
746 }
747 break;
748 case 0x1b: /* ldi.b (immediate) */
749 case 0x1c: /* ld.b (register indirect) */
750 case 0x1d: /* lda.b */
751 {
752 int reg = (inst >> 4) & 0xf;
753 if (record_full_arch_list_add_reg (regcache, reg))
754 return -1;
755 }
756 break;
757 case 0x1e: /* st.b */
758 {
759 int reg = (inst >> 4) & 0xf;
760 regcache_raw_read (regcache, reg, (gdb_byte *) & tmpu32);
761 tmpu32 = extract_unsigned_integer ((gdb_byte *) & tmpu32,
762 4, byte_order);
763 if (record_full_arch_list_add_mem (tmpu32, 1))
764 return -1;
765 }
766 break;
767 case 0x1f: /* sta.b */
768 {
769 tmpu32 = moxie_process_readu (addr+2, (char *) buf,
770 4, byte_order);
771 if (record_full_arch_list_add_mem (tmpu32, 1))
772 return -1;
773 }
774 break;
775 case 0x20: /* ldi.s (immediate) */
776 case 0x21: /* ld.s (register indirect) */
777 case 0x22: /* lda.s */
778 {
779 int reg = (inst >> 4) & 0xf;
780 if (record_full_arch_list_add_reg (regcache, reg))
781 return -1;
782 }
783 break;
784 case 0x23: /* st.s */
785 {
786 int reg = (inst >> 4) & 0xf;
787 regcache_raw_read (regcache, reg, (gdb_byte *) & tmpu32);
788 tmpu32 = extract_unsigned_integer ((gdb_byte *) & tmpu32,
789 4, byte_order);
790 if (record_full_arch_list_add_mem (tmpu32, 2))
791 return -1;
792 }
793 break;
794 case 0x24: /* sta.s */
795 {
796 tmpu32 = moxie_process_readu (addr+2, (char *) buf,
797 4, byte_order);
798 if (record_full_arch_list_add_mem (tmpu32, 2))
799 return -1;
800 }
801 break;
802 case 0x25: /* jmp */
803 {
804 /* Do nothing. */
805 }
806 break;
807 case 0x26: /* and */
808 case 0x27: /* lshr */
809 case 0x28: /* ashl */
810 case 0x29: /* sub.l */
811 case 0x2a: /* neg */
812 case 0x2b: /* or */
813 case 0x2c: /* not */
814 case 0x2d: /* ashr */
815 case 0x2e: /* xor */
816 case 0x2f: /* mul.l */
817 {
818 int reg = (inst >> 4) & 0xf;
819 if (record_full_arch_list_add_reg (regcache, reg))
820 return -1;
821 }
822 break;
823 case 0x30: /* swi */
824 {
825 /* We currently implement support for libgloss'
826 system calls. */
827
828 int inum = moxie_process_readu (addr+2, (char *) buf,
829 4, byte_order);
830
831 switch (inum)
832 {
833 case 0x1: /* SYS_exit */
834 {
835 /* Do nothing. */
836 }
837 break;
838 case 0x2: /* SYS_open */
839 {
840 if (record_full_arch_list_add_reg (regcache, RET1_REGNUM))
841 return -1;
842 }
843 break;
844 case 0x4: /* SYS_read */
845 {
846 uint32_t length, ptr;
847
848 /* Read buffer pointer is in $r1. */
849 regcache_raw_read (regcache, 3, (gdb_byte *) & ptr);
850 ptr = extract_unsigned_integer ((gdb_byte *) & ptr,
851 4, byte_order);
852
853 /* String length is at 0x12($fp). */
854 regcache_raw_read (regcache,
855 MOXIE_FP_REGNUM, (gdb_byte *) & tmpu32);
856 tmpu32 = extract_unsigned_integer ((gdb_byte *) & tmpu32,
857 4, byte_order);
858 length = moxie_process_readu (tmpu32+20, (char *) buf,
859 4, byte_order);
860
861 if (record_full_arch_list_add_mem (ptr, length))
862 return -1;
863 }
864 break;
865 case 0x5: /* SYS_write */
866 {
867 if (record_full_arch_list_add_reg (regcache, RET1_REGNUM))
868 return -1;
869 }
870 break;
871 default:
872 break;
873 }
874 }
875 break;
876 case 0x31: /* div.l */
877 case 0x32: /* udiv.l */
878 case 0x33: /* mod.l */
879 case 0x34: /* umod.l */
880 {
881 int reg = (inst >> 4) & 0xf;
882 if (record_full_arch_list_add_reg (regcache, reg))
883 return -1;
884 }
885 break;
886 case 0x35: /* brk */
887 /* Do nothing. */
888 break;
889 case 0x36: /* ldo.b */
890 {
891 int reg = (inst >> 4) & 0xf;
892 if (record_full_arch_list_add_reg (regcache, reg))
893 return -1;
894 }
895 break;
896 case 0x37: /* sto.b */
897 {
898 int reg = (inst >> 4) & 0xf;
899 uint32_t offset = (uint32_t) moxie_process_readu (addr+2, buf, 4,
900 byte_order);
901 regcache_raw_read (regcache, reg, (gdb_byte *) & tmpu32);
902 tmpu32 = extract_unsigned_integer ((gdb_byte *) & tmpu32,
903 4, byte_order);
904 tmpu32 += offset;
905 if (record_full_arch_list_add_mem (tmpu32, 1))
906 return -1;
907 }
908 break;
909 case 0x38: /* ldo.s */
910 {
911 int reg = (inst >> 4) & 0xf;
912 if (record_full_arch_list_add_reg (regcache, reg))
913 return -1;
914 }
915 break;
916 case 0x39: /* sto.s */
917 {
918 int reg = (inst >> 4) & 0xf;
919 uint32_t offset = (uint32_t) moxie_process_readu (addr+2, buf, 4,
920 byte_order);
921 regcache_raw_read (regcache, reg, (gdb_byte *) & tmpu32);
922 tmpu32 = extract_unsigned_integer ((gdb_byte *) & tmpu32,
923 4, byte_order);
924 tmpu32 += offset;
925 if (record_full_arch_list_add_mem (tmpu32, 2))
926 return -1;
927 }
928 break;
929 default:
930 /* Do nothing. */
931 break;
932 }
933 }
934
935 if (record_full_arch_list_add_reg (regcache, MOXIE_PC_REGNUM))
936 return -1;
937 if (record_full_arch_list_add_end ())
938 return -1;
939 return 0;
940 }
941
942 /* Allocate and initialize the moxie gdbarch object. */
943
944 static struct gdbarch *
moxie_gdbarch_init(struct gdbarch_info info,struct gdbarch_list * arches)945 moxie_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
946 {
947 struct gdbarch *gdbarch;
948 struct gdbarch_tdep *tdep;
949
950 /* If there is already a candidate, use it. */
951 arches = gdbarch_list_lookup_by_info (arches, &info);
952 if (arches != NULL)
953 return arches->gdbarch;
954
955 /* Allocate space for the new architecture. */
956 tdep = XMALLOC (struct gdbarch_tdep);
957 gdbarch = gdbarch_alloc (&info, tdep);
958
959 set_gdbarch_read_pc (gdbarch, moxie_read_pc);
960 set_gdbarch_write_pc (gdbarch, moxie_write_pc);
961 set_gdbarch_unwind_sp (gdbarch, moxie_unwind_sp);
962
963 set_gdbarch_num_regs (gdbarch, MOXIE_NUM_REGS);
964 set_gdbarch_sp_regnum (gdbarch, MOXIE_SP_REGNUM);
965 set_gdbarch_pc_regnum (gdbarch, MOXIE_PC_REGNUM);
966 set_gdbarch_register_name (gdbarch, moxie_register_name);
967 set_gdbarch_register_type (gdbarch, moxie_register_type);
968
969 set_gdbarch_return_value (gdbarch, moxie_return_value);
970
971 set_gdbarch_skip_prologue (gdbarch, moxie_skip_prologue);
972 set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
973 set_gdbarch_breakpoint_from_pc (gdbarch, moxie_breakpoint_from_pc);
974 set_gdbarch_frame_align (gdbarch, moxie_frame_align);
975
976 frame_base_set_default (gdbarch, &moxie_frame_base);
977
978 /* Methods for saving / extracting a dummy frame's ID. The ID's
979 stack address must match the SP value returned by
980 PUSH_DUMMY_CALL, and saved by generic_save_dummy_frame_tos. */
981 set_gdbarch_dummy_id (gdbarch, moxie_dummy_id);
982
983 set_gdbarch_unwind_pc (gdbarch, moxie_unwind_pc);
984
985 set_gdbarch_print_insn (gdbarch, print_insn_moxie);
986
987 /* Hook in ABI-specific overrides, if they have been registered. */
988 gdbarch_init_osabi (info, gdbarch);
989
990 /* Hook in the default unwinders. */
991 frame_unwind_append_unwinder (gdbarch, &moxie_frame_unwind);
992
993 /* Support simple overlay manager. */
994 set_gdbarch_overlay_update (gdbarch, simple_overlay_update);
995
996 /* Support reverse debugging. */
997 set_gdbarch_process_record (gdbarch, moxie_process_record);
998
999 return gdbarch;
1000 }
1001
1002 /* Register this machine's init routine. */
1003
1004 void
_initialize_moxie_tdep(void)1005 _initialize_moxie_tdep (void)
1006 {
1007 register_gdbarch_init (bfd_arch_moxie, moxie_gdbarch_init);
1008 }
1009