gdb/moxie-tdep.c

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