gdb/m88k-tdep.c - gdb

Global variables defined

Data types defined

Functions defined

Macros defined

Source code

  1. /* Target-dependent code for the Motorola 88000 series.

  3.    Copyright (C) 2004-2015 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/>.  */

  20. #include "defs.h"
  21. #include "arch-utils.h"
  22. #include "dis-asm.h"
  23. #include "frame.h"
  24. #include "frame-base.h"
  25. #include "frame-unwind.h"
  26. #include "gdbcore.h"
  27. #include "gdbtypes.h"
  28. #include "regcache.h"
  29. #include "regset.h"
  30. #include "symtab.h"
  31. #include "trad-frame.h"
  32. #include "value.h"

  34. #include "m88k-tdep.h"

  36. /* Fetch the instruction at PC.  */

  38. static unsigned long
  39. ‌m88k_fetch_instruction (CORE_ADDR pc, enum bfd_endian byte_order)
  40. {
  41.   return read_memory_unsigned_integer (pc, 4, byte_order);
  42. }

  44. /* Register information.  */

  46. /* Return the name of register REGNUM.  */

  48. static const char *
  49. ‌m88k_register_name (struct gdbarch *gdbarch, int regnum)
  50. {
  51.   static char *register_names[] =
  52.   {
  53.     "r0",  "r1",  "r2",  "r3",  "r4",  "r5",  "r6",  "r7",
  54.     "r8",  "r9",  "r10", "r11", "r12", "r13", "r14", "r15",
  55.     "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
  56.     "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
  57.     "epsr", "fpsr", "fpcr", "sxip", "snip", "sfip"
  58.   };

  60.   if (regnum >= 0 && regnum < ARRAY_SIZE (register_names))
  61.     return register_names[regnum];

  63.   return NULL;
  64. }

  66. /* Return the GDB type object for the "standard" data type of data in
  67.    register REGNUM.  */

  69. static struct type *
  70. ‌m88k_register_type (struct gdbarch *gdbarch, int regnum)
  71. {
  72.   /* SXIP, SNIP, SFIP and R1 contain code addresses.  */
  73.   if ((regnum >= M88K_SXIP_REGNUM && regnum <= M88K_SFIP_REGNUM)
  74.       || regnum == M88K_R1_REGNUM)
  75.     return builtin_type (gdbarch)->builtin_func_ptr;

  77.   /* R30 and R31 typically contains data addresses.  */
  78.   if (regnum == M88K_R30_REGNUM || regnum == M88K_R31_REGNUM)
  79.     return builtin_type (gdbarch)->builtin_data_ptr;

  81.   return builtin_type (gdbarch)->builtin_int32;
  82. }


  85. static CORE_ADDR
  86. ‌m88k_addr_bits_remove (struct gdbarch *gdbarch, CORE_ADDR addr)
  87. {
  88.   /* All instructures are 4-byte aligned.  The lower 2 bits of SXIP,
  89.      SNIP and SFIP are used for special purposes: bit 0 is the
  90.      exception bit and bit 1 is the valid bit.  */
  91.   return addr & ~0x3;
  92. }

  94. /* Use the program counter to determine the contents and size of a
  95.    breakpoint instruction.  Return a pointer to a string of bytes that
  96.    encode a breakpoint instruction, store the length of the string in
  97.    *LEN and optionally adjust *PC to point to the correct memory
  98.    location for inserting the breakpoint.  */

  100. static const gdb_byte *
  101. ‌m88k_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pc, int *len)
  102. {
  103.   /* tb 0,r0,511 */
  104.   static gdb_byte break_insn[] = { 0xf0, 0x00, 0xd1, 0xff };

  106.   *len = sizeof (break_insn);
  107.   return break_insn;
  108. }

  110. static CORE_ADDR
  111. ‌m88k_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
  112. {
  113.   CORE_ADDR pc;

  115.   pc = frame_unwind_register_unsigned (next_frame, M88K_SXIP_REGNUM);
  116.   return m88k_addr_bits_remove (gdbarch, pc);
  117. }

  119. static void
  120. ‌m88k_write_pc (struct regcache *regcache, CORE_ADDR pc)
  121. {
  122.   /* According to the MC88100 RISC Microprocessor User's Manual,
  123.      section 6.4.3.1.2:

  125.      "... can be made to return to a particular instruction by placing
  126.      a valid instruction address in the SNIP and the next sequential
  127.      instruction address in the SFIP (with V bits set and E bits
  128.      clear).  The rte resumes execution at the instruction pointed to
  129.      by the SNIP, then the SFIP."

  131.      The E bit is the least significant bit (bit 0).  The V (valid)
  132.      bit is bit 1.  This is why we logical or 2 into the values we are
  133.      writing below.  It turns out that SXIP plays no role when
  134.      returning from an exception so nothing special has to be done
  135.      with it.  We could even (presumably) give it a totally bogus
  136.      value.  */

  138.   regcache_cooked_write_unsigned (regcache, M88K_SXIP_REGNUM, pc);
  139.   regcache_cooked_write_unsigned (regcache, M88K_SNIP_REGNUM, pc | 2);
  140.   regcache_cooked_write_unsigned (regcache, M88K_SFIP_REGNUM, (pc + 4) | 2);
  141. }


  144. /* The functions on this page are intended to be used to classify
  145.    function arguments.  */

  147. /* Check whether TYPE is "Integral or Pointer".  */

  149. static int
  150. ‌m88k_integral_or_pointer_p (const struct type *type)
  151. {
  152.   switch (TYPE_CODE (type))
  153.     {
  154.     case TYPE_CODE_INT:
  155.     case TYPE_CODE_BOOL:
  156.     case TYPE_CODE_CHAR:
  157.     case TYPE_CODE_ENUM:
  158.     case TYPE_CODE_RANGE:
  159.       {
  160.         /* We have byte, half-word, word and extended-word/doubleword
  161.            integral types.  */
  162.         int len = TYPE_LENGTH (type);
  163.         return (len == 1 || len == 2 || len == 4 || len == 8);
  164.       }
  165.       return 1;
  166.     case TYPE_CODE_PTR:
  167.     case TYPE_CODE_REF:
  168.       {
  169.         /* Allow only 32-bit pointers.  */
  170.         return (TYPE_LENGTH (type) == 4);
  171.       }
  172.       return 1;
  173.     default:
  174.       break;
  175.     }

  177.   return 0;
  178. }

  180. /* Check whether TYPE is "Floating".  */

  182. static int
  183. ‌m88k_floating_p (const struct type *type)
  184. {
  185.   switch (TYPE_CODE (type))
  186.     {
  187.     case TYPE_CODE_FLT:
  188.       {
  189.         int len = TYPE_LENGTH (type);
  190.         return (len == 4 || len == 8);
  191.       }
  192.     default:
  193.       break;
  194.     }

  196.   return 0;
  197. }

  199. /* Check whether TYPE is "Structure or Union".  */

  201. static int
  202. ‌m88k_structure_or_union_p (const struct type *type)
  203. {
  204.   switch (TYPE_CODE (type))
  205.     {
  206.     case TYPE_CODE_STRUCT:
  207.     case TYPE_CODE_UNION:
  208.       return 1;
  209.     default:
  210.       break;
  211.     }

  213.   return 0;
  214. }

  216. /* Check whether TYPE has 8-byte alignment.  */

  218. static int
  219. ‌m88k_8_byte_align_p (struct type *type)
  220. {
  221.   if (m88k_structure_or_union_p (type))
  222.     {
  223.       int i;

  225.       for (i = 0; i < TYPE_NFIELDS (type); i++)
  226.         {
  227.           struct type *subtype = check_typedef (TYPE_FIELD_TYPE (type, i));

  229.           if (m88k_8_byte_align_p (subtype))
  230.             return 1;
  231.         }
  232.     }

  234.   if (m88k_integral_or_pointer_p (type) || m88k_floating_p (type))
  235.     return (TYPE_LENGTH (type) == 8);

  237.   return 0;
  238. }

  240. /* Check whether TYPE can be passed in a register.  */

  242. static int
  243. ‌m88k_in_register_p (struct type *type)
  244. {
  245.   if (m88k_integral_or_pointer_p (type) || m88k_floating_p (type))
  246.     return 1;

  248.   if (m88k_structure_or_union_p (type) && TYPE_LENGTH (type) == 4)
  249.     return 1;

  251.   return 0;
  252. }

  254. static CORE_ADDR
  255. ‌m88k_store_arguments (struct regcache *regcache, int nargs,
  256.                       struct value **args, CORE_ADDR sp)
  257. {
  258.   struct gdbarch *gdbarch = get_regcache_arch (regcache);
  259.   int num_register_words = 0;
  260.   int num_stack_words = 0;
  261.   int i;

  263.   for (i = 0; i < nargs; i++)
  264.     {
  265.       struct type *type = value_type (args[i]);
  266.       int len = TYPE_LENGTH (type);

  268.       if (m88k_integral_or_pointer_p (type) && len < 4)
  269.         {
  270.           args[i] = value_cast (builtin_type (gdbarch)->builtin_int32,
  271.                                 args[i]);
  272.           type = value_type (args[i]);
  273.           len = TYPE_LENGTH (type);
  274.         }

  276.       if (m88k_in_register_p (type))
  277.         {
  278.           int num_words = 0;

  280.           if (num_register_words % 2 == 1 && m88k_8_byte_align_p (type))
  281.             num_words++;

  283.           num_words += ((len + 3) / 4);
  284.           if (num_register_words + num_words <= 8)
  285.             {
  286.               num_register_words += num_words;
  287.               continue;
  288.             }

  290.           /* We've run out of available registers.  Pass the argument
  291.              on the stack.  */
  292.         }

  294.       if (num_stack_words % 2 == 1 && m88k_8_byte_align_p (type))
  295.         num_stack_words++;

  297.       num_stack_words += ((len + 3) / 4);
  298.     }

  300.   /* Allocate stack space.  */
  301.   sp = align_down (sp - 32 - num_stack_words * 4, 16);
  302.   num_stack_words = num_register_words = 0;

  304.   for (i = 0; i < nargs; i++)
  305.     {
  306.       const bfd_byte *valbuf = value_contents (args[i]);
  307.       struct type *type = value_type (args[i]);
  308.       int len = TYPE_LENGTH (type);
  309.       int stack_word = num_stack_words;

  311.       if (m88k_in_register_p (type))
  312.         {
  313.           int register_word = num_register_words;

  315.           if (register_word % 2 == 1 && m88k_8_byte_align_p (type))
  316.             register_word++;

  318.           gdb_assert (len == 4 || len == 8);

  320.           if (register_word + len / 8 < 8)
  321.             {
  322.               int regnum = M88K_R2_REGNUM + register_word;

  324.               regcache_raw_write (regcache, regnum, valbuf);
  325.               if (len > 4)
  326.                 regcache_raw_write (regcache, regnum + 1, valbuf + 4);

  328.               num_register_words = (register_word + len / 4);
  329.               continue;
  330.             }
  331.         }

  333.       if (stack_word % 2 == -1 && m88k_8_byte_align_p (type))
  334.         stack_word++;

  336.       write_memory (sp + stack_word * 4, valbuf, len);
  337.       num_stack_words = (stack_word + (len + 3) / 4);
  338.     }

  340.   return sp;
  341. }

  343. static CORE_ADDR
  344. ‌m88k_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
  345.                       struct regcache *regcache, CORE_ADDR bp_addr, int nargs,
  346.                       struct value **args, CORE_ADDR sp, int struct_return,
  347.                       CORE_ADDR struct_addr)
  348. {
  349.   /* Set up the function arguments.  */
  350.   sp = m88k_store_arguments (regcache, nargs, args, sp);
  351.   gdb_assert (sp % 16 == 0);

  353.   /* Store return value address.  */
  354.   if (struct_return)
  355.     regcache_raw_write_unsigned (regcache, M88K_R12_REGNUM, struct_addr);

  357.   /* Store the stack pointer and return address in the appropriate
  358.      registers.  */
  359.   regcache_raw_write_unsigned (regcache, M88K_R31_REGNUM, sp);
  360.   regcache_raw_write_unsigned (regcache, M88K_R1_REGNUM, bp_addr);

  362.   /* Return the stack pointer.  */
  363.   return sp;
  364. }

  366. static struct frame_id
  367. ‌m88k_dummy_id (struct gdbarch *arch, struct frame_info *this_frame)
  368. {
  369.   CORE_ADDR sp;

  371.   sp = get_frame_register_unsigned (this_frame, M88K_R31_REGNUM);
  372.   return frame_id_build (sp, get_frame_pc (this_frame));
  373. }


  376. /* Determine, for architecture GDBARCH, how a return value of TYPE
  377.    should be returned.  If it is supposed to be returned in registers,
  378.    and READBUF is non-zero, read the appropriate value from REGCACHE,
  379.    and copy it into READBUF.  If WRITEBUF is non-zero, write the value
  380.    from WRITEBUF into REGCACHE.  */

  382. static enum return_value_convention
  383. ‌m88k_return_value (struct gdbarch *gdbarch, struct value *function,
  384.                    struct type *type, struct regcache *regcache,
  385.                    gdb_byte *readbuf, const gdb_byte *writebuf)
  386. {
  387.   int len = TYPE_LENGTH (type);
  388.   gdb_byte buf[8];

  390.   if (!m88k_integral_or_pointer_p (type) && !m88k_floating_p (type))
  391.     return RETURN_VALUE_STRUCT_CONVENTION;

  393.   if (readbuf)
  394.     {
  395.       /* Read the contents of R2 and (if necessary) R3.  */
  396.       regcache_cooked_read (regcache, M88K_R2_REGNUM, buf);
  397.       if (len > 4)
  398.         {
  399.           regcache_cooked_read (regcache, M88K_R3_REGNUM, buf + 4);
  400.           gdb_assert (len == 8);
  401.           memcpy (readbuf, buf, len);
  402.         }
  403.       else
  404.         {
  405.           /* Just stripping off any unused bytes should preserve the
  406.              signed-ness just fine.  */
  407.           memcpy (readbuf, buf + 4 - len, len);
  408.         }
  409.     }

  411.   if (writebuf)
  412.     {
  413.       /* Read the contents to R2 and (if necessary) R3.  */
  414.       if (len > 4)
  415.         {
  416.           gdb_assert (len == 8);
  417.           memcpy (buf, writebuf, 8);
  418.           regcache_cooked_write (regcache, M88K_R3_REGNUM, buf + 4);
  419.         }
  420.       else
  421.         {
  422.           /* ??? Do we need to do any sign-extension here?  */
  423.           memcpy (buf + 4 - len, writebuf, len);
  424.         }
  425.       regcache_cooked_write (regcache, M88K_R2_REGNUM, buf);
  426.     }

  428.   return RETURN_VALUE_REGISTER_CONVENTION;
  429. }

  431. /* Default frame unwinder.  */

  433. ‌struct m88k_frame_cache
  434. {
  435.   /* Base address.  */
  436.   CORE_ADDR base;
  437.   CORE_ADDR pc;

  439.   int sp_offset;
  440.   int fp_offset;

  442.   /* Table of saved registers.  */
  443.   struct trad_frame_saved_reg *saved_regs;
  444. };

  446. /* Prologue analysis.  */

  448. /* Macros for extracting fields from instructions.  */

  450. ‌#define BITMASK(pos, width) (((0x1 << (width)) - 1) << (pos))
  451. ‌#define EXTRACT_FIELD(val, pos, width) ((val) >> (pos) & BITMASK (0, width))
  452. ‌#define        SUBU_OFFSET(x)        ((unsigned)(x & 0xFFFF))
  453. ‌#define        ST_OFFSET(x)        ((unsigned)((x) & 0xFFFF))
  454. ‌#define        ST_SRC(x)        EXTRACT_FIELD ((x), 21, 5)
  455. ‌#define        ADDU_OFFSET(x)        ((unsigned)(x & 0xFFFF))

  457. /* Possible actions to be taken by the prologue analyzer for the
  458.    instructions it encounters.  */

  460. ‌enum m88k_prologue_insn_action
  461. {
  462.   M88K_PIA_SKIP,                /* Ignore.  */
  463.   M88K_PIA_NOTE_ST,                /* Note register store.  */
  464.   M88K_PIA_NOTE_STD,                /* Note register pair store.  */
  465.   M88K_PIA_NOTE_SP_ADJUSTMENT,        /* Note stack pointer adjustment.  */
  466.   M88K_PIA_NOTE_FP_ASSIGNMENT,        /* Note frame pointer assignment.  */
  467.   M88K_PIA_NOTE_BRANCH,                /* Note branch.  */
  468.   M88K_PIA_NOTE_PROLOGUE_END        /* Note end of prologue.  */
  469. };

  471. /* Table of instructions that may comprise a function prologue.  */

  473. ‌struct m88k_prologue_insn
  474. {
  475.   unsigned long insn;
  476.   unsigned long mask;
  477.   enum m88k_prologue_insn_action action;
  478. };

  480. ‌struct m88k_prologue_insn m88k_prologue_insn_table[] =
  481. {
  482.   /* Various register move instructions.  */
  483.   { 0x58000000, 0xf800ffff, M88K_PIA_SKIP },     /* or/or.u with immed of 0 */
  484.   { 0xf4005800, 0xfc1fffe0, M88K_PIA_SKIP },     /* or rd,r0,rs */
  485.   { 0xf4005800, 0xfc00ffff, M88K_PIA_SKIP },     /* or rd,rs,r0 */

  487.   /* Various other instructions.  */
  488.   { 0x58000000, 0xf8000000, M88K_PIA_SKIP },     /* or/or.u */

  490.   /* Stack pointer setup: "subu sp,sp,n" where n is a multiple of 8.  */
  491.   { 0x67ff0000, 0xffff0007, M88K_PIA_NOTE_SP_ADJUSTMENT },

  493.   /* Frame pointer assignment: "addu r30,r31,n".  */
  494.   { 0x63df0000, 0xffff0000, M88K_PIA_NOTE_FP_ASSIGNMENT },

  496.   /* Store to stack instructions; either "st rx,sp,n" or "st.d rx,sp,n".  */
  497.   { 0x241f0000, 0xfc1f0000, M88K_PIA_NOTE_ST },  /* st rx,sp,n */
  498.   { 0x201f0000, 0xfc1f0000, M88K_PIA_NOTE_STD }, /* st.d rs,sp,n */

  500.   /* Instructions needed for setting up r25 for pic code.  */
  501.   { 0x5f200000, 0xffff0000, M88K_PIA_SKIP },     /* or.u r25,r0,offset_high */
  502.   { 0xcc000002, 0xffffffff, M88K_PIA_SKIP },     /* bsr.n Lab */
  503.   { 0x5b390000, 0xffff0000, M88K_PIA_SKIP },     /* or r25,r25,offset_low */
  504.   { 0xf7396001, 0xffffffff, M88K_PIA_SKIP },     /* Lab: addu r25,r25,r1 */

  506.   /* Various branch or jump instructions which have a delay slot --
  507.      these do not form part of the prologue, but the instruction in
  508.      the delay slot might be a store instruction which should be
  509.      noted.  */
  510.   { 0xc4000000, 0xe4000000, M88K_PIA_NOTE_BRANCH },
  511.                                       /* br.n, bsr.n, bb0.n, or bb1.n */
  512.   { 0xec000000, 0xfc000000, M88K_PIA_NOTE_BRANCH }, /* bcnd.n */
  513.   { 0xf400c400, 0xfffff7e0, M88K_PIA_NOTE_BRANCH }, /* jmp.n or jsr.n */

  515.   /* Catch all.  Ends prologue analysis.  */
  516.   { 0x00000000, 0x00000000, M88K_PIA_NOTE_PROLOGUE_END }
  517. };

  519. /* Do a full analysis of the function prologue at PC and update CACHE
  520.    accordingly.  Bail out early if LIMIT is reached.  Return the
  521.    address where the analysis stopped.  If LIMIT points beyond the
  522.    function prologue, the return address should be the end of the
  523.    prologue.  */

  525. static CORE_ADDR
  526. ‌m88k_analyze_prologue (struct gdbarch *gdbarch,
  527.                        CORE_ADDR pc, CORE_ADDR limit,
  528.                        struct m88k_frame_cache *cache)
  529. {
  530.   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
  531.   CORE_ADDR end = limit;

  533.   /* Provide a dummy cache if necessary.  */
  534.   if (cache == NULL)
  535.     {
  536.       size_t sizeof_saved_regs =
  537.         (M88K_R31_REGNUM + 1) * sizeof (struct trad_frame_saved_reg);

  539.       cache = alloca (sizeof (struct m88k_frame_cache));
  540.       cache->saved_regs = alloca (sizeof_saved_regs);

  542.       /* We only initialize the members we care about.  */
  543.       cache->saved_regs[M88K_R1_REGNUM].addr = -1;
  544.       cache->fp_offset = -1;
  545.     }

  547.   while (pc < limit)
  548.     {
  549.       struct m88k_prologue_insn *pi = m88k_prologue_insn_table;
  550.       unsigned long insn = m88k_fetch_instruction (pc, byte_order);

  552.       while ((insn & pi->mask) != pi->insn)
  553.         pi++;

  555.       switch (pi->action)
  556.         {
  557.         case M88K_PIA_SKIP:
  558.           /* If we have a frame pointer, and R1 has been saved,
  559.              consider this instruction as not being part of the
  560.              prologue.  */
  561.           if (cache->fp_offset != -1
  562.               && cache->saved_regs[M88K_R1_REGNUM].addr != -1)
  563.             return min (pc, end);
  564.           break;

  566.         case M88K_PIA_NOTE_ST:
  567.         case M88K_PIA_NOTE_STD:
  568.           /* If no frame has been allocated, the stores aren't part of
  569.              the prologue.  */
  570.           if (cache->sp_offset == 0)
  571.             return min (pc, end);

  573.           /* Record location of saved registers.  */
  574.           {
  575.             int regnum = ST_SRC (insn) + M88K_R0_REGNUM;
  576.             ULONGEST offset = ST_OFFSET (insn);

  578.             cache->saved_regs[regnum].addr = offset;
  579.             if (pi->action == M88K_PIA_NOTE_STD && regnum < M88K_R31_REGNUM)
  580.               cache->saved_regs[regnum + 1].addr = offset + 4;
  581.           }
  582.           break;

  584.         case M88K_PIA_NOTE_SP_ADJUSTMENT:
  585.           /* A second stack pointer adjustment isn't part of the
  586.              prologue.  */
  587.           if (cache->sp_offset != 0)
  588.             return min (pc, end);

  590.           /* Store stack pointer adjustment.  */
  591.           cache->sp_offset = -SUBU_OFFSET (insn);
  592.           break;

  594.         case M88K_PIA_NOTE_FP_ASSIGNMENT:
  595.           /* A second frame pointer assignment isn't part of the
  596.              prologue.  */
  597.           if (cache->fp_offset != -1)
  598.             return min (pc, end);

  600.           /* Record frame pointer assignment.  */
  601.           cache->fp_offset = ADDU_OFFSET (insn);
  602.           break;

  604.         case M88K_PIA_NOTE_BRANCH:
  605.           /* The branch instruction isn't part of the prologue, but
  606.              the instruction in the delay slot might be.  Limit the
  607.              prologue analysis to the delay slot and record the branch
  608.              instruction as the end of the prologue.  */
  609.           limit = min (limit, pc + 2 * M88K_INSN_SIZE);
  610.           end = pc;
  611.           break;

  613.         case M88K_PIA_NOTE_PROLOGUE_END:
  614.           return min (pc, end);
  615.         }

  617.       pc += M88K_INSN_SIZE;
  618.     }

  620.   return end;
  621. }

  623. /* An upper limit to the size of the prologue.  */
  624. ‌const int m88k_max_prologue_size = 128 * M88K_INSN_SIZE;

  626. /* Return the address of first real instruction of the function
  627.    starting at PC.  */

  629. static CORE_ADDR
  630. ‌m88k_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
  631. {
  632.   struct symtab_and_line sal;
  633.   CORE_ADDR func_start, func_end;

  635.   /* This is the preferred method, find the end of the prologue by
  636.      using the debugging information.  */
  637.   if (find_pc_partial_function (pc, NULL, &func_start, &func_end))
  638.     {
  639.       sal = find_pc_line (func_start, 0);

  641.       if (sal.end < func_end && pc <= sal.end)
  642.         return sal.end;
  643.     }

  645.   return m88k_analyze_prologue (gdbarch, pc, pc + m88k_max_prologue_size,
  646.                                 NULL);
  647. }

  649. static struct m88k_frame_cache *
  650. ‌m88k_frame_cache (struct frame_info *this_frame, void **this_cache)
  651. {
  652.   struct gdbarch *gdbarch = get_frame_arch (this_frame);
  653.   struct m88k_frame_cache *cache;
  654.   CORE_ADDR frame_sp;

  656.   if (*this_cache)
  657.     return *this_cache;

  659.   cache = FRAME_OBSTACK_ZALLOC (struct m88k_frame_cache);
  660.   cache->saved_regs = trad_frame_alloc_saved_regs (this_frame);
  661.   cache->fp_offset = -1;

  663.   cache->pc = get_frame_func (this_frame);
  664.   if (cache->pc != 0)
  665.     m88k_analyze_prologue (gdbarch, cache->pc, get_frame_pc (this_frame),
  666.                            cache);

  668.   /* Calculate the stack pointer used in the prologue.  */
  669.   if (cache->fp_offset != -1)
  670.     {
  671.       CORE_ADDR fp;

  673.       fp = get_frame_register_unsigned (this_frame, M88K_R30_REGNUM);
  674.       frame_sp = fp - cache->fp_offset;
  675.     }
  676.   else
  677.     {
  678.       /* If we know where the return address is saved, we can take a
  679.          solid guess at what the frame pointer should be.  */
  680.       if (cache->saved_regs[M88K_R1_REGNUM].addr != -1)
  681.         cache->fp_offset = cache->saved_regs[M88K_R1_REGNUM].addr - 4;
  682.       frame_sp = get_frame_register_unsigned (this_frame, M88K_R31_REGNUM);
  683.     }

  685.   /* Now that we know the stack pointer, adjust the location of the
  686.      saved registers.  */
  687.   {
  688.     int regnum;

  690.     for (regnum = M88K_R0_REGNUM; regnum < M88K_R31_REGNUM; regnum ++)
  691.       if (cache->saved_regs[regnum].addr != -1)
  692.         cache->saved_regs[regnum].addr += frame_sp;
  693.   }

  695.   /* Calculate the frame's base.  */
  696.   cache->base = frame_sp - cache->sp_offset;
  697.   trad_frame_set_value (cache->saved_regs, M88K_R31_REGNUM, cache->base);

  699.   /* Identify SXIP with the return address in R1.  */
  700.   cache->saved_regs[M88K_SXIP_REGNUM] = cache->saved_regs[M88K_R1_REGNUM];

  702.   *this_cache = cache;
  703.   return cache;
  704. }

  706. static void
  707. ‌m88k_frame_this_id (struct frame_info *this_frame, void **this_cache,
  708.                     struct frame_id *this_id)
  709. {
  710.   struct m88k_frame_cache *cache = m88k_frame_cache (this_frame, this_cache);

  712.   /* This marks the outermost frame.  */
  713.   if (cache->base == 0)
  714.     return;

  716.   (*this_id) = frame_id_build (cache->base, cache->pc);
  717. }

  719. static struct value *
  720. ‌m88k_frame_prev_register (struct frame_info *this_frame,
  721.                           void **this_cache, int regnum)
  722. {
  723.   struct m88k_frame_cache *cache = m88k_frame_cache (this_frame, this_cache);

  725.   if (regnum == M88K_SNIP_REGNUM || regnum == M88K_SFIP_REGNUM)
  726.     {
  727.       struct value *value;
  728.       CORE_ADDR pc;

  730.       value = trad_frame_get_prev_register (this_frame, cache->saved_regs,
  731.                                             M88K_SXIP_REGNUM);
  732.       pc = value_as_long (value);
  733.       release_value (value);
  734.       value_free (value);

  736.       if (regnum == M88K_SFIP_REGNUM)
  737.         pc += 4;

  739.       return frame_unwind_got_constant (this_frame, regnum, pc + 4);
  740.     }

  742.   return trad_frame_get_prev_register (this_frame, cache->saved_regs, regnum);
  743. }

  745. ‌static const struct frame_unwind m88k_frame_unwind =
  746. {
  747.   NORMAL_FRAME,
  748.   default_frame_unwind_stop_reason,
  749.   m88k_frame_this_id,
  750.   m88k_frame_prev_register,
  751.   NULL,
  752.   default_frame_sniffer
  753. };


  756. static CORE_ADDR
  757. ‌m88k_frame_base_address (struct frame_info *this_frame, void **this_cache)
  758. {
  759.   struct m88k_frame_cache *cache = m88k_frame_cache (this_frame, this_cache);

  761.   if (cache->fp_offset != -1)
  762.     return cache->base + cache->sp_offset + cache->fp_offset;

  764.   return 0;
  765. }

  767. ‌static const struct frame_base m88k_frame_base =
  768. {
  769.   &m88k_frame_unwind,
  770.   m88k_frame_base_address,
  771.   m88k_frame_base_address,
  772.   m88k_frame_base_address
  773. };


  776. /* Core file support.  */

  778. /* Supply register REGNUM from the buffer specified by GREGS and LEN
  779.    in the general-purpose register set REGSET to register cache
  780.    REGCACHE.  If REGNUM is -1, do this for all registers in REGSET.  */

  782. static void
  783. ‌m88k_supply_gregset (const struct regset *regset,
  784.                      struct regcache *regcache,
  785.                      int regnum, const void *gregs, size_t len)
  786. {
  787.   const gdb_byte *regs = gregs;
  788.   int i;

  790.   for (i = 0; i < M88K_NUM_REGS; i++)
  791.     {
  792.       if (regnum == i || regnum == -1)
  793.         regcache_raw_supply (regcache, i, regs + i * 4);
  794.     }
  795. }

  797. /* Motorola 88000 register set.  */

  799. ‌static const struct regset m88k_gregset =
  800. {
  801.   NULL,
  802.   m88k_supply_gregset
  803. };

  805. /* Iterate over supported core file register note sections. */

  807. static void
  808. ‌m88k_iterate_over_regset_sections (struct gdbarch *gdbarch,
  809.                                    iterate_over_regset_sections_cb *cb,
  810.                                    void *cb_data,
  811.                                    const struct regcache *regcache)
  812. {
  813.   cb (".reg", M88K_NUM_REGS * 4, &m88k_gregset, NULL, cb_data);
  814. }


  817. static struct gdbarch *
  818. ‌m88k_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
  819. {
  820.   struct gdbarch *gdbarch;

  822.   /* If there is already a candidate, use it.  */
  823.   arches = gdbarch_list_lookup_by_info (arches, &info);
  824.   if (arches != NULL)
  825.     return arches->gdbarch;

  827.   /* Allocate space for the new architecture.  */
  828.   gdbarch = gdbarch_alloc (&info, NULL);

  830.   /* There is no real `long double'.  */
  831.   set_gdbarch_long_double_bit (gdbarch, 64);
  832.   set_gdbarch_long_double_format (gdbarch, floatformats_ieee_double);

  834.   set_gdbarch_num_regs (gdbarch, M88K_NUM_REGS);
  835.   set_gdbarch_register_name (gdbarch, m88k_register_name);
  836.   set_gdbarch_register_type (gdbarch, m88k_register_type);

  838.   /* Register numbers of various important registers.  */
  839.   set_gdbarch_sp_regnum (gdbarch, M88K_R31_REGNUM);
  840.   set_gdbarch_pc_regnum (gdbarch, M88K_SXIP_REGNUM);

  842.   /* Core file support.  */
  843.   set_gdbarch_iterate_over_regset_sections
  844.     (gdbarch, m88k_iterate_over_regset_sections);

  846.   set_gdbarch_print_insn (gdbarch, print_insn_m88k);

  848.   set_gdbarch_skip_prologue (gdbarch, m88k_skip_prologue);

  850.   /* Stack grows downward.  */
  851.   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);

  853.   /* Call dummy code.  */
  854.   set_gdbarch_push_dummy_call (gdbarch, m88k_push_dummy_call);
  855.   set_gdbarch_dummy_id (gdbarch, m88k_dummy_id);

  857.   /* Return value info.  */
  858.   set_gdbarch_return_value (gdbarch, m88k_return_value);

  860.   set_gdbarch_addr_bits_remove (gdbarch, m88k_addr_bits_remove);
  861.   set_gdbarch_breakpoint_from_pc (gdbarch, m88k_breakpoint_from_pc);
  862.   set_gdbarch_unwind_pc (gdbarch, m88k_unwind_pc);
  863.   set_gdbarch_write_pc (gdbarch, m88k_write_pc);

  865.   frame_base_set_default (gdbarch, &m88k_frame_base);
  866.   frame_unwind_append_unwinder (gdbarch, &m88k_frame_unwind);

  868.   return gdbarch;
  869. }


  872. /* Provide a prototype to silence -Wmissing-prototypes.  */
  873. void _initialize_m88k_tdep (void);

  875. void
  876. ‌_initialize_m88k_tdep (void)
  877. {
  878.   gdbarch_register (bfd_arch_m88k, m88k_gdbarch_init, NULL);
  879. }