gdb/mn10300-prologue.c

   1 /* Target-dependent code for the Matsushita MN10300 for GDB, the GNU debugger.
   2    Prologue analysis module, extracted from mn10300-tdep.c, Oct. 1, 2004.
   3
   4    Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free
   5    Software Foundation, Inc.
   6
   7    This file is part of GDB.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 2 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program; if not, write to the Free Software
  21    Foundation, Inc., 59 Temple Place - Suite 330,
  22    Boston, MA 02111-1307, USA.  */
  23
  24 #include "defs.h"
  25 #include "symtab.h"
  26 #include "inferior.h"
  27 #include "gdbcore.h"
  28 #include "gdb_string.h"
  29 #include "trad-frame.h"
  30 #include "mn10300-tdep.h"
  31
  32 enum movm_register_bits {
  33   movm_exother_bit = 0x01,
  34   movm_exreg1_bit  = 0x02,
  35   movm_exreg0_bit  = 0x04,
  36   movm_other_bit   = 0x08,
  37   movm_a3_bit      = 0x10,
  38   movm_a2_bit      = 0x20,
  39   movm_d3_bit      = 0x40,
  40   movm_d2_bit      = 0x80
  41 };
  42
  43 /* Values for frame_info.status */
  44
  45 enum frame_kind {
  46   MY_FRAME_IN_SP = 0x1,
  47   MY_FRAME_IN_FP = 0x2,
  48   NO_MORE_FRAMES = 0x4
  49 };
  50
  51 /*
  52  * Frame Extra Info:
  53  *
  54  *   status -- actually frame type (SP, FP, or last frame)
  55  *   stack size -- offset to the next frame
  56  *
  57  * The former might ultimately be stored in the frame_base.
  58  * Seems like there'd be a way to store the later too.
  59  *
  60  * Temporarily supply empty stub functions as place holders.
  61  */
  62
  63 static void
  64 my_frame_is_in_sp (struct frame_info *fi, void **this_cache)
  65 {
  66   struct trad_frame_cache *cache = mn10300_frame_unwind_cache (fi, this_cache);
  67   trad_frame_set_this_base (cache,
  68                             frame_unwind_register_unsigned (fi,
  69                                                             E_SP_REGNUM));
  70 }
  71
  72 static void
  73 my_frame_is_in_fp (struct frame_info *fi, void **this_cache)
  74 {
  75   struct trad_frame_cache *cache = mn10300_frame_unwind_cache (fi, this_cache);
  76   trad_frame_set_this_base (cache,
  77                             frame_unwind_register_unsigned (fi,
  78                                                             E_A3_REGNUM));
  79 }
  80
  81 static void
  82 my_frame_is_last (struct frame_info *fi)
  83 {
  84 }
  85
  86 static int
  87 is_my_frame_in_sp (struct frame_info *fi)
  88 {
  89   return 0;
  90 }
  91
  92 static int
  93 is_my_frame_in_fp (struct frame_info *fi)
  94 {
  95   return 0;
  96 }
  97
  98 static int
  99 is_my_frame_last (struct frame_info *fi)
 100 {
 101   return 0;
 102 }
 103
 104 static void
 105 set_my_stack_size (struct frame_info *fi, CORE_ADDR size)
 106 {
 107 }
 108
 109
 110 /* Set offsets of registers saved by movm instruction.
 111    This is a helper function for mn10300_analyze_prologue.  */
 112
 113 static void
 114 set_movm_offsets (struct frame_info *fi,
 115                   void **this_cache,
 116                   int movm_args)
 117 {
 118   struct trad_frame_cache *cache;
 119   int offset = 0;
 120   CORE_ADDR base;
 121
 122   if (cache == NULL || fi == NULL)
 123     return;
 124
 125   cache = mn10300_frame_unwind_cache (fi, this_cache);
 126   base = trad_frame_get_this_base (cache);
 127   if (movm_args & movm_other_bit)
 128     {
 129       /* The `other' bit leaves a blank area of four bytes at the
 130          beginning of its block of saved registers, making it 32 bytes
 131          long in total.  */
 132       trad_frame_set_reg_addr (cache, E_LAR_REGNUM,    base + offset + 4);
 133       trad_frame_set_reg_addr (cache, E_LIR_REGNUM,    base + offset + 8);
 134       trad_frame_set_reg_addr (cache, E_MDR_REGNUM,    base + offset + 12);
 135       trad_frame_set_reg_addr (cache, E_A0_REGNUM + 1, base + offset + 16);
 136       trad_frame_set_reg_addr (cache, E_A0_REGNUM,     base + offset + 20);
 137       trad_frame_set_reg_addr (cache, E_D0_REGNUM + 1, base + offset + 24);
 138       trad_frame_set_reg_addr (cache, E_D0_REGNUM,     base + offset + 28);
 139       offset += 32;
 140     }
 141
 142   if (movm_args & movm_a3_bit)
 143     {
 144       trad_frame_set_reg_addr (cache, E_A3_REGNUM, base + offset);
 145       offset += 4;
 146     }
 147   if (movm_args & movm_a2_bit)
 148     {
 149       trad_frame_set_reg_addr (cache, E_A2_REGNUM, base + offset);
 150       offset += 4;
 151     }
 152   if (movm_args & movm_d3_bit)
 153     {
 154       trad_frame_set_reg_addr (cache, E_D3_REGNUM, base + offset);
 155       offset += 4;
 156     }
 157   if (movm_args & movm_d2_bit)
 158     {
 159       trad_frame_set_reg_addr (cache, E_D2_REGNUM, base + offset);
 160       offset += 4;
 161     }
 162   if (AM33_MODE)
 163     {
 164       if (movm_args & movm_exother_bit)
 165         {
 166           trad_frame_set_reg_addr (cache, E_MCVF_REGNUM, base + offset);
 167           trad_frame_set_reg_addr (cache, E_MCRL_REGNUM, base + offset + 4);
 168           trad_frame_set_reg_addr (cache, E_MCRH_REGNUM, base + offset + 8);
 169           trad_frame_set_reg_addr (cache, E_MDRQ_REGNUM, base + offset + 12);
 170           trad_frame_set_reg_addr (cache, E_E1_REGNUM,   base + offset + 16);
 171           trad_frame_set_reg_addr (cache, E_E0_REGNUM,   base + offset + 20);
 172           offset += 24;
 173         }
 174       if (movm_args & movm_exreg1_bit)
 175         {
 176           trad_frame_set_reg_addr (cache, E_E7_REGNUM, base + offset);
 177           trad_frame_set_reg_addr (cache, E_E6_REGNUM, base + offset + 4);
 178           trad_frame_set_reg_addr (cache, E_E5_REGNUM, base + offset + 8);
 179           trad_frame_set_reg_addr (cache, E_E4_REGNUM, base + offset + 12);
 180           offset += 16;
 181         }
 182       if (movm_args & movm_exreg0_bit)
 183         {
 184           trad_frame_set_reg_addr (cache, E_E3_REGNUM, base + offset);
 185           trad_frame_set_reg_addr (cache, E_E2_REGNUM, base + offset + 4);
 186           offset += 8;
 187         }
 188     }
 189   /* The last (or first) thing on the stack will be the PC.  */
 190   trad_frame_set_reg_addr (cache, E_PC_REGNUM, base + offset);
 191   /* Save the SP in the 'traditional' way.
 192      This will be the same location where the PC is saved.  */
 193   trad_frame_set_reg_value (cache, E_SP_REGNUM, base + offset);
 194 }
 195
 196 /* The main purpose of this file is dealing with prologues to extract
 197    information about stack frames and saved registers.
 198
 199    In gcc/config/mn13000/mn10300.c, the expand_prologue prologue
 200    function is pretty readable, and has a nice explanation of how the
 201    prologue is generated.  The prologues generated by that code will
 202    have the following form (NOTE: the current code doesn't handle all
 203    this!):
 204
 205    + If this is an old-style varargs function, then its arguments
 206      need to be flushed back to the stack:
 207
 208         mov d0,(4,sp)
 209         mov d1,(4,sp)
 210
 211    + If we use any of the callee-saved registers, save them now.
 212
 213         movm [some callee-saved registers],(sp)
 214
 215    + If we have any floating-point registers to save:
 216
 217      - Decrement the stack pointer to reserve space for the registers.
 218        If the function doesn't need a frame pointer, we may combine
 219        this with the adjustment that reserves space for the frame.
 220
 221         add -SIZE, sp
 222
 223      - Save the floating-point registers.  We have two possible
 224        strategies:
 225
 226        . Save them at fixed offset from the SP:
 227
 228         fmov fsN,(OFFSETN,sp)
 229         fmov fsM,(OFFSETM,sp)
 230         ...
 231
 232        Note that, if OFFSETN happens to be zero, you'll get the
 233        different opcode: fmov fsN,(sp)
 234
 235        . Or, set a0 to the start of the save area, and then use
 236        post-increment addressing to save the FP registers.
 237
 238         mov sp, a0
 239         add SIZE, a0
 240         fmov fsN,(a0+)
 241         fmov fsM,(a0+)
 242         ...
 243
 244    + If the function needs a frame pointer, we set it here.
 245
 246         mov sp, a3
 247
 248    + Now we reserve space for the stack frame proper.  This could be
 249      merged into the `add -SIZE, sp' instruction for FP saves up
 250      above, unless we needed to set the frame pointer in the previous
 251      step, or the frame is so large that allocating the whole thing at
 252      once would put the FP register save slots out of reach of the
 253      addressing mode (128 bytes).
 254
 255         add -SIZE, sp
 256
 257    One day we might keep the stack pointer constant, that won't
 258    change the code for prologues, but it will make the frame
 259    pointerless case much more common.  */
 260
 261 /* Analyze the prologue to determine where registers are saved,
 262    the end of the prologue, etc etc.  Return the end of the prologue
 263    scanned.
 264
 265    We store into FI (if non-null) several tidbits of information:
 266
 267    * stack_size -- size of this stack frame.  Note that if we stop in
 268    certain parts of the prologue/epilogue we may claim the size of the
 269    current frame is zero.  This happens when the current frame has
 270    not been allocated yet or has already been deallocated.
 271
 272    * fsr -- Addresses of registers saved in the stack by this frame.
 273
 274    * status -- A (relatively) generic status indicator.  It's a bitmask
 275    with the following bits:
 276
 277    MY_FRAME_IN_SP: The base of the current frame is actually in
 278    the stack pointer.  This can happen for frame pointerless
 279    functions, or cases where we're stopped in the prologue/epilogue
 280    itself.  For these cases mn10300_analyze_prologue will need up
 281    update fi->frame before returning or analyzing the register
 282    save instructions.
 283
 284    MY_FRAME_IN_FP: The base of the current frame is in the
 285    frame pointer register ($a3).
 286
 287    NO_MORE_FRAMES: Set this if the current frame is "start" or
 288    if the first instruction looks like mov <imm>,sp.  This tells
 289    frame chain to not bother trying to unwind past this frame.  */
 290
 291 CORE_ADDR
 292 mn10300_analyze_prologue (struct frame_info *fi,
 293                           void **this_cache,
 294                           CORE_ADDR pc)
 295 {
 296   CORE_ADDR func_addr, func_end, addr, stop;
 297   long      stack_size;
 298   int imm_size;
 299   unsigned char buf[4];
 300   int status, movm_args = 0;
 301   char *name;
 302
 303   /* Use the PC in the frame if it's provided to look up the
 304      start of this function.
 305
 306      Note: kevinb/2003-07-16: We used to do the following here:
 307         pc = (fi ? get_frame_pc (fi) : pc);
 308      But this is (now) badly broken when called from analyze_dummy_frame().
 309   */
 310   if (fi)
 311     {
 312       pc = (pc ? pc : get_frame_pc (fi));
 313       /* At the start of a function our frame is in the stack pointer.  */
 314       my_frame_is_in_sp (fi, this_cache);
 315     }
 316
 317   /* Find the start of this function.  */
 318   status = find_pc_partial_function (pc, &name, &func_addr, &func_end);
 319
 320   /* Do nothing if we couldn't find the start of this function
 321
 322      MVS: comment went on to say "or if we're stopped at the first
 323      instruction in the prologue" -- but code doesn't reflect that,
 324      and I don't want to do that anyway.  */
 325   if (status == 0)
 326     {
 327       return pc;
 328     }
 329
 330   /* If we're in start, then give up.  */
 331   if (strcmp (name, "start") == 0)
 332     {
 333       if (fi != NULL)
 334         my_frame_is_last (fi);
 335       return pc;
 336     }
 337
 338 #if 0
 339   /* Get the next two bytes into buf, we need two because rets is a two
 340      byte insn and the first isn't enough to uniquely identify it.  */
 341   status = deprecated_read_memory_nobpt (pc, buf, 2);
 342   if (status != 0)
 343     return pc;
 344
 345   /* Note: kevinb/2003-07-16: We shouldn't be making these sorts of
 346      changes to the frame in prologue examination code.  */
 347   /* If we're physically on an "rets" instruction, then our frame has
 348      already been deallocated.  Note this can also be true for retf
 349      and ret if they specify a size of zero.
 350
 351      In this case fi->frame is bogus, we need to fix it.  */
 352   if (fi && buf[0] == 0xf0 && buf[1] == 0xfc)
 353     {
 354       if (get_next_frame (fi) == NULL)
 355         deprecated_update_frame_base_hack (fi, read_sp ());
 356       return get_frame_pc (fi);
 357     }
 358
 359   /* Similarly if we're stopped on the first insn of a prologue as our
 360      frame hasn't been allocated yet.  */
 361   if (fi && get_frame_pc (fi) == func_addr)
 362     {
 363       if (get_next_frame (fi) == NULL)
 364         deprecated_update_frame_base_hack (fi, read_sp ());
 365       return get_frame_pc (fi);
 366     }
 367 #endif
 368
 369   /* NOTE: from here on, we don't want to return without jumping to
 370      finish_prologue.  */
 371
 372
 373   /* Figure out where to stop scanning.  */
 374   stop = fi ? pc : func_end;
 375
 376   /* Don't walk off the end of the function.  */
 377   stop = stop > func_end ? func_end : stop;
 378
 379   /* Start scanning on the first instruction of this function.  */
 380   addr = func_addr;
 381
 382   /* Suck in two bytes.  */
 383   if (addr + 2 >= stop
 384       || (status = deprecated_read_memory_nobpt (addr, buf, 2)) != 0)
 385     goto finish_prologue;
 386
 387   /* First see if this insn sets the stack pointer from a register; if
 388      so, it's probably the initialization of the stack pointer in _start,
 389      so mark this as the bottom-most frame.  */
 390   if (buf[0] == 0xf2 && (buf[1] & 0xf3) == 0xf0)
 391     {
 392       if (fi)
 393         my_frame_is_last (fi);
 394       goto finish_prologue;
 395     }
 396
 397   /* Now look for movm [regs],sp, which saves the callee saved registers.
 398
 399      At this time we don't know if fi->frame is valid, so we only note
 400      that we encountered a movm instruction.  Later, we'll set the entries
 401      in fsr.regs as needed.  */
 402   if (buf[0] == 0xcf)
 403     {
 404       /* Extract the register list for the movm instruction.  */
 405       movm_args = buf[1];
 406
 407       addr += 2;
 408
 409       /* Quit now if we're beyond the stop point.  */
 410       if (addr >= stop)
 411         goto finish_prologue;
 412
 413       /* Get the next two bytes so the prologue scan can continue.  */
 414       status = deprecated_read_memory_nobpt (addr, buf, 2);
 415       if (status != 0)
 416         goto finish_prologue;
 417     }
 418
 419   /* Now see if we set up a frame pointer via "mov sp,a3" */
 420   if (buf[0] == 0x3f)
 421     {
 422       addr += 1;
 423
 424       /* The frame pointer is now valid.  */
 425       if (fi)
 426         {
 427           my_frame_is_in_fp (fi, this_cache);
 428         }
 429
 430       /* Quit now if we're beyond the stop point.  */
 431       if (addr >= stop)
 432         goto finish_prologue;
 433
 434       /* Get two more bytes so scanning can continue.  */
 435       status = deprecated_read_memory_nobpt (addr, buf, 2);
 436       if (status != 0)
 437         goto finish_prologue;
 438     }
 439
 440   /* Next we should allocate the local frame.  No more prologue insns
 441      are found after allocating the local frame.
 442
 443      Search for add imm8,sp (0xf8feXX)
 444      or add imm16,sp (0xfafeXXXX)
 445      or add imm32,sp (0xfcfeXXXXXXXX).
 446
 447      If none of the above was found, then this prologue has no
 448      additional stack.  */
 449
 450   imm_size = 0;
 451   if (buf[0] == 0xf8 && buf[1] == 0xfe)
 452     imm_size = 1;
 453   else if (buf[0] == 0xfa && buf[1] == 0xfe)
 454     imm_size = 2;
 455   else if (buf[0] == 0xfc && buf[1] == 0xfe)
 456     imm_size = 4;
 457
 458   if (imm_size != 0)
 459     {
 460       /* Suck in imm_size more bytes, they'll hold the size of the
 461          current frame.  */
 462       status = deprecated_read_memory_nobpt (addr + 2, buf, imm_size);
 463       if (status != 0)
 464         goto finish_prologue;
 465
 466       /* Note the size of the stack in the frame info structure.  */
 467       stack_size = extract_signed_integer (buf, imm_size);
 468       if (fi)
 469         set_my_stack_size (fi, stack_size);
 470
 471       /* We just consumed 2 + imm_size bytes.  */
 472       addr += 2 + imm_size;
 473
 474       /* No more prologue insns follow, so begin preparation to return.  */
 475       goto finish_prologue;
 476     }
 477   /* Do the essentials and get out of here.  */
 478  finish_prologue:
 479   /* Note if/where callee saved registers were saved.  */
 480   if (fi)
 481     set_movm_offsets (fi, this_cache, movm_args);
 482   return addr;
 483 }
 484
 485