gdb/fr30-tdep.c

   1 /* Target-dependent code for the Fujitsu FR30.
   2    Copyright 1999, 2000, 2001 Free Software Foundation, Inc.
   3
   4    This file is part of GDB.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 2 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, Inc., 59 Temple Place - Suite 330,
  19    Boston, MA 02111-1307, USA.  */
  20
  21 #include "defs.h"
  22 #include "frame.h"
  23 #include "inferior.h"
  24 #include "obstack.h"
  25 #include "target.h"
  26 #include "value.h"
  27 #include "bfd.h"
  28 #include "gdb_string.h"
  29 #include "gdbcore.h"
  30 #include "symfile.h"
  31 #include "regcache.h"
  32
  33 /* An expression that tells us whether the function invocation represented
  34    by FI does not have a frame on the stack associated with it.  */
  35 int
  36 fr30_frameless_function_invocation (struct frame_info *fi)
  37 {
  38   int frameless;
  39   CORE_ADDR func_start, after_prologue;
  40   func_start = (get_pc_function_start ((fi)->pc) +
  41                 FUNCTION_START_OFFSET);
  42   after_prologue = func_start;
  43   after_prologue = SKIP_PROLOGUE (after_prologue);
  44   frameless = (after_prologue == func_start);
  45   return frameless;
  46 }
  47
  48 /* Function: pop_frame
  49    This routine gets called when either the user uses the `return'
  50    command, or the call dummy breakpoint gets hit.  */
  51
  52 void
  53 fr30_pop_frame (void)
  54 {
  55   struct frame_info *frame = get_current_frame ();
  56   int regnum;
  57   CORE_ADDR sp = read_register (SP_REGNUM);
  58
  59   if (PC_IN_CALL_DUMMY (frame->pc, frame->frame, frame->frame))
  60     generic_pop_dummy_frame ();
  61   else
  62     {
  63       write_register (PC_REGNUM, FRAME_SAVED_PC (frame));
  64
  65       for (regnum = 0; regnum < NUM_REGS; regnum++)
  66         if (frame->fsr.regs[regnum] != 0)
  67           {
  68             write_register (regnum,
  69                       read_memory_unsigned_integer (frame->fsr.regs[regnum],
  70                                                REGISTER_RAW_SIZE (regnum)));
  71           }
  72       write_register (SP_REGNUM, sp + frame->framesize);
  73     }
  74   flush_cached_frames ();
  75 }
  76
  77
  78 /* Function: fr30_store_return_value
  79    Put a value where a caller expects to see it.  Used by the 'return'
  80    command.  */
  81 void
  82 fr30_store_return_value (struct type *type,
  83                          char *valbuf)
  84 {
  85   /* Here's how the FR30 returns values (gleaned from gcc/config/
  86      fr30/fr30.h):
  87
  88      If the return value is 32 bits long or less, it goes in r4.
  89
  90      If the return value is 64 bits long or less, it goes in r4 (most
  91      significant word) and r5 (least significant word.
  92
  93      If the function returns a structure, of any size, the caller
  94      passes the function an invisible first argument where the callee
  95      should store the value.  But GDB doesn't let you do that anyway.
  96
  97      If you're returning a value smaller than a word, it's not really
  98      necessary to zero the upper bytes of the register; the caller is
  99      supposed to ignore them.  However, the FR30 typically keeps its
 100      values extended to the full register width, so we should emulate
 101      that.  */
 102
 103   /* The FR30 is big-endian, so if we return a small value (like a
 104      short or a char), we need to position it correctly within the
 105      register.  We round the size up to a register boundary, and then
 106      adjust the offset so as to place the value at the right end.  */
 107   int value_size = TYPE_LENGTH (type);
 108   int returned_size = (value_size + FR30_REGSIZE - 1) & ~(FR30_REGSIZE - 1);
 109   int offset = (REGISTER_BYTE (RETVAL_REG)
 110                 + (returned_size - value_size));
 111   char *zeros = alloca (returned_size);
 112   memset (zeros, 0, returned_size);
 113
 114   write_register_bytes (REGISTER_BYTE (RETVAL_REG), zeros, returned_size);
 115   write_register_bytes (offset, valbuf, value_size);
 116 }
 117
 118
 119 /* Function: skip_prologue
 120    Return the address of the first code past the prologue of the function.  */
 121
 122 CORE_ADDR
 123 fr30_skip_prologue (CORE_ADDR pc)
 124 {
 125   CORE_ADDR func_addr, func_end;
 126
 127   /* See what the symbol table says */
 128
 129   if (find_pc_partial_function (pc, NULL, &func_addr, &func_end))
 130     {
 131       struct symtab_and_line sal;
 132
 133       sal = find_pc_line (func_addr, 0);
 134
 135       if (sal.line != 0 && sal.end < func_end)
 136         {
 137           return sal.end;
 138         }
 139     }
 140
 141 /* Either we didn't find the start of this function (nothing we can do),
 142    or there's no line info, or the line after the prologue is after
 143    the end of the function (there probably isn't a prologue). */
 144
 145   return pc;
 146 }
 147
 148
 149 /* Function: push_arguments
 150    Setup arguments and RP for a call to the target.  First four args
 151    go in FIRST_ARGREG -> LAST_ARGREG, subsequent args go on stack...
 152    Structs are passed by reference.  XXX not right now Z.R.
 153    64 bit quantities (doubles and long longs) may be split between
 154    the regs and the stack.
 155    When calling a function that returns a struct, a pointer to the struct
 156    is passed in as a secret first argument (always in FIRST_ARGREG).
 157
 158    Stack space for the args has NOT been allocated: that job is up to us.
 159  */
 160
 161 CORE_ADDR
 162 fr30_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
 163                      int struct_return, CORE_ADDR struct_addr)
 164 {
 165   int argreg;
 166   int argnum;
 167   int stack_offset;
 168   struct stack_arg
 169     {
 170       char *val;
 171       int len;
 172       int offset;
 173     };
 174   struct stack_arg *stack_args =
 175   (struct stack_arg *) alloca (nargs * sizeof (struct stack_arg));
 176   int nstack_args = 0;
 177
 178   argreg = FIRST_ARGREG;
 179
 180   /* the struct_return pointer occupies the first parameter-passing reg */
 181   if (struct_return)
 182     write_register (argreg++, struct_addr);
 183
 184   stack_offset = 0;
 185
 186   /* Process args from left to right.  Store as many as allowed in
 187      registers, save the rest to be pushed on the stack */
 188   for (argnum = 0; argnum < nargs; argnum++)
 189     {
 190       char *val;
 191       struct value *arg = args[argnum];
 192       struct type *arg_type = check_typedef (VALUE_TYPE (arg));
 193       struct type *target_type = TYPE_TARGET_TYPE (arg_type);
 194       int len = TYPE_LENGTH (arg_type);
 195       enum type_code typecode = TYPE_CODE (arg_type);
 196       CORE_ADDR regval;
 197       int newarg;
 198
 199       val = (char *) VALUE_CONTENTS (arg);
 200
 201       {
 202         /* Copy the argument to general registers or the stack in
 203            register-sized pieces.  Large arguments are split between
 204            registers and stack.  */
 205         while (len > 0)
 206           {
 207             if (argreg <= LAST_ARGREG)
 208               {
 209                 int partial_len = len < REGISTER_SIZE ? len : REGISTER_SIZE;
 210                 regval = extract_address (val, partial_len);
 211
 212                 /* It's a simple argument being passed in a general
 213                    register.  */
 214                 write_register (argreg, regval);
 215                 argreg++;
 216                 len -= partial_len;
 217                 val += partial_len;
 218               }
 219             else
 220               {
 221                 /* keep for later pushing */
 222                 stack_args[nstack_args].val = val;
 223                 stack_args[nstack_args++].len = len;
 224                 break;
 225               }
 226           }
 227       }
 228     }
 229   /* now do the real stack pushing, process args right to left */
 230   while (nstack_args--)
 231     {
 232       sp -= stack_args[nstack_args].len;
 233       write_memory (sp, stack_args[nstack_args].val,
 234                     stack_args[nstack_args].len);
 235     }
 236
 237   /* Return adjusted stack pointer.  */
 238   return sp;
 239 }
 240
 241 void _initialize_fr30_tdep (void);
 242
 243 void
 244 _initialize_fr30_tdep (void)
 245 {
 246   extern int print_insn_fr30 (bfd_vma, disassemble_info *);
 247   tm_print_insn = print_insn_fr30;
 248 }
 249
 250 /* Function: check_prologue_cache
 251    Check if prologue for this frame's PC has already been scanned.
 252    If it has, copy the relevant information about that prologue and
 253    return non-zero.  Otherwise do not copy anything and return zero.
 254
 255    The information saved in the cache includes:
 256    * the frame register number;
 257    * the size of the stack frame;
 258    * the offsets of saved regs (relative to the old SP); and
 259    * the offset from the stack pointer to the frame pointer
 260
 261    The cache contains only one entry, since this is adequate
 262    for the typical sequence of prologue scan requests we get.
 263    When performing a backtrace, GDB will usually ask to scan
 264    the same function twice in a row (once to get the frame chain,
 265    and once to fill in the extra frame information).
 266  */
 267
 268 static struct frame_info prologue_cache;
 269
 270 static int
 271 check_prologue_cache (struct frame_info *fi)
 272 {
 273   int i;
 274
 275   if (fi->pc == prologue_cache.pc)
 276     {
 277       fi->framereg = prologue_cache.framereg;
 278       fi->framesize = prologue_cache.framesize;
 279       fi->frameoffset = prologue_cache.frameoffset;
 280       for (i = 0; i <= NUM_REGS; i++)
 281         fi->fsr.regs[i] = prologue_cache.fsr.regs[i];
 282       return 1;
 283     }
 284   else
 285     return 0;
 286 }
 287
 288
 289 /* Function: save_prologue_cache
 290    Copy the prologue information from fi to the prologue cache.
 291  */
 292
 293 static void
 294 save_prologue_cache (struct frame_info *fi)
 295 {
 296   int i;
 297
 298   prologue_cache.pc = fi->pc;
 299   prologue_cache.framereg = fi->framereg;
 300   prologue_cache.framesize = fi->framesize;
 301   prologue_cache.frameoffset = fi->frameoffset;
 302
 303   for (i = 0; i <= NUM_REGS; i++)
 304     {
 305       prologue_cache.fsr.regs[i] = fi->fsr.regs[i];
 306     }
 307 }
 308
 309
 310 /* Function: scan_prologue
 311    Scan the prologue of the function that contains PC, and record what
 312    we find in PI.  PI->fsr must be zeroed by the called.  Returns the
 313    pc after the prologue.  Note that the addresses saved in pi->fsr
 314    are actually just frame relative (negative offsets from the frame
 315    pointer).  This is because we don't know the actual value of the
 316    frame pointer yet.  In some circumstances, the frame pointer can't
 317    be determined till after we have scanned the prologue.  */
 318
 319 static void
 320 fr30_scan_prologue (struct frame_info *fi)
 321 {
 322   int sp_offset, fp_offset;
 323   CORE_ADDR prologue_start, prologue_end, current_pc;
 324
 325   /* Check if this function is already in the cache of frame information. */
 326   if (check_prologue_cache (fi))
 327     return;
 328
 329   /* Assume there is no frame until proven otherwise.  */
 330   fi->framereg = SP_REGNUM;
 331   fi->framesize = 0;
 332   fi->frameoffset = 0;
 333
 334   /* Find the function prologue.  If we can't find the function in
 335      the symbol table, peek in the stack frame to find the PC.  */
 336   if (find_pc_partial_function (fi->pc, NULL, &prologue_start, &prologue_end))
 337     {
 338       /* Assume the prologue is everything between the first instruction
 339          in the function and the first source line.  */
 340       struct symtab_and_line sal = find_pc_line (prologue_start, 0);
 341
 342       if (sal.line == 0)        /* no line info, use current PC */
 343         prologue_end = fi->pc;
 344       else if (sal.end < prologue_end)  /* next line begins after fn end */
 345         prologue_end = sal.end; /* (probably means no prologue)  */
 346     }
 347   else
 348     {
 349       /* XXX Z.R. What now??? The following is entirely bogus */
 350       prologue_start = (read_memory_integer (fi->frame, 4) & 0x03fffffc) - 12;
 351       prologue_end = prologue_start + 40;
 352     }
 353
 354   /* Now search the prologue looking for instructions that set up the
 355      frame pointer, adjust the stack pointer, and save registers.  */
 356
 357   sp_offset = fp_offset = 0;
 358   for (current_pc = prologue_start; current_pc < prologue_end; current_pc += 2)
 359     {
 360       unsigned int insn;
 361
 362       insn = read_memory_unsigned_integer (current_pc, 2);
 363
 364       if ((insn & 0xfe00) == 0x8e00)    /* stm0 or stm1 */
 365         {
 366           int reg, mask = insn & 0xff;
 367
 368           /* scan in one sweep - create virtual 16-bit mask from either insn's mask */
 369           if ((insn & 0x0100) == 0)
 370             {
 371               mask <<= 8;       /* stm0 - move to upper byte in virtual mask */
 372             }
 373
 374           /* Calculate offsets of saved registers (to be turned later into addresses). */
 375           for (reg = R4_REGNUM; reg <= R11_REGNUM; reg++)
 376             if (mask & (1 << (15 - reg)))
 377               {
 378                 sp_offset -= 4;
 379                 fi->fsr.regs[reg] = sp_offset;
 380               }
 381         }
 382       else if ((insn & 0xfff0) == 0x1700)       /* st rx,@-r15 */
 383         {
 384           int reg = insn & 0xf;
 385
 386           sp_offset -= 4;
 387           fi->fsr.regs[reg] = sp_offset;
 388         }
 389       else if ((insn & 0xff00) == 0x0f00)       /* enter */
 390         {
 391           fp_offset = fi->fsr.regs[FP_REGNUM] = sp_offset - 4;
 392           sp_offset -= 4 * (insn & 0xff);
 393           fi->framereg = FP_REGNUM;
 394         }
 395       else if (insn == 0x1781)  /* st rp,@-sp */
 396         {
 397           sp_offset -= 4;
 398           fi->fsr.regs[RP_REGNUM] = sp_offset;
 399         }
 400       else if (insn == 0x170e)  /* st fp,@-sp */
 401         {
 402           sp_offset -= 4;
 403           fi->fsr.regs[FP_REGNUM] = sp_offset;
 404         }
 405       else if (insn == 0x8bfe)  /* mov sp,fp */
 406         {
 407           fi->framereg = FP_REGNUM;
 408         }
 409       else if ((insn & 0xff00) == 0xa300)       /* addsp xx */
 410         {
 411           sp_offset += 4 * (signed char) (insn & 0xff);
 412         }
 413       else if ((insn & 0xff0f) == 0x9b00 &&     /* ldi:20 xx,r0 */
 414                read_memory_unsigned_integer (current_pc + 4, 2)
 415                == 0xac0f)       /* sub r0,sp */
 416         {
 417           /* large stack adjustment */
 418           sp_offset -= (((insn & 0xf0) << 12) | read_memory_unsigned_integer (current_pc + 2, 2));
 419           current_pc += 4;
 420         }
 421       else if (insn == 0x9f80 &&        /* ldi:32 xx,r0 */
 422                read_memory_unsigned_integer (current_pc + 6, 2)
 423                == 0xac0f)       /* sub r0,sp */
 424         {
 425           /* large stack adjustment */
 426           sp_offset -=
 427             (read_memory_unsigned_integer (current_pc + 2, 2) << 16 |
 428              read_memory_unsigned_integer (current_pc + 4, 2));
 429           current_pc += 6;
 430         }
 431     }
 432
 433   /* The frame size is just the negative of the offset (from the original SP)
 434      of the last thing thing we pushed on the stack.  The frame offset is
 435      [new FP] - [new SP].  */
 436   fi->framesize = -sp_offset;
 437   fi->frameoffset = fp_offset - sp_offset;
 438
 439   save_prologue_cache (fi);
 440 }
 441
 442 /* Function: init_extra_frame_info
 443    Setup the frame's frame pointer, pc, and frame addresses for saved
 444    registers.  Most of the work is done in scan_prologue().
 445
 446    Note that when we are called for the last frame (currently active frame),
 447    that fi->pc and fi->frame will already be setup.  However, fi->frame will
 448    be valid only if this routine uses FP.  For previous frames, fi-frame will
 449    always be correct (since that is derived from fr30_frame_chain ()).
 450
 451    We can be called with the PC in the call dummy under two circumstances.
 452    First, during normal backtracing, second, while figuring out the frame
 453    pointer just prior to calling the target function (see run_stack_dummy).  */
 454
 455 void
 456 fr30_init_extra_frame_info (struct frame_info *fi)
 457 {
 458   int reg;
 459
 460   if (fi->next)
 461     fi->pc = FRAME_SAVED_PC (fi->next);
 462
 463   memset (fi->fsr.regs, '\000', sizeof fi->fsr.regs);
 464
 465   if (PC_IN_CALL_DUMMY (fi->pc, fi->frame, fi->frame))
 466     {
 467       /* We need to setup fi->frame here because run_stack_dummy gets it wrong
 468          by assuming it's always FP.  */
 469       fi->frame = generic_read_register_dummy (fi->pc, fi->frame, SP_REGNUM);
 470       fi->framesize = 0;
 471       fi->frameoffset = 0;
 472       return;
 473     }
 474   fr30_scan_prologue (fi);
 475
 476   if (!fi->next)                /* this is the innermost frame? */
 477     fi->frame = read_register (fi->framereg);
 478   else
 479     /* not the innermost frame */
 480     /* If we have an FP,  the callee saved it. */
 481     if (fi->framereg == FP_REGNUM)
 482       if (fi->next->fsr.regs[fi->framereg] != 0)
 483         fi->frame = read_memory_integer (fi->next->fsr.regs[fi->framereg], 4);
 484
 485   /* Calculate actual addresses of saved registers using offsets determined
 486      by fr30_scan_prologue.  */
 487   for (reg = 0; reg < NUM_REGS; reg++)
 488     if (fi->fsr.regs[reg] != 0)
 489       {
 490         fi->fsr.regs[reg] += fi->frame + fi->framesize - fi->frameoffset;
 491       }
 492 }
 493
 494 /* Function: find_callers_reg
 495    Find REGNUM on the stack.  Otherwise, it's in an active register.
 496    One thing we might want to do here is to check REGNUM against the
 497    clobber mask, and somehow flag it as invalid if it isn't saved on
 498    the stack somewhere.  This would provide a graceful failure mode
 499    when trying to get the value of caller-saves registers for an inner
 500    frame.  */
 501
 502 CORE_ADDR
 503 fr30_find_callers_reg (struct frame_info *fi, int regnum)
 504 {
 505   for (; fi; fi = fi->next)
 506     if (PC_IN_CALL_DUMMY (fi->pc, fi->frame, fi->frame))
 507       return generic_read_register_dummy (fi->pc, fi->frame, regnum);
 508     else if (fi->fsr.regs[regnum] != 0)
 509       return read_memory_unsigned_integer (fi->fsr.regs[regnum],
 510                                            REGISTER_RAW_SIZE (regnum));
 511
 512   return read_register (regnum);
 513 }
 514
 515
 516 /* Function: frame_chain
 517    Figure out the frame prior to FI.  Unfortunately, this involves
 518    scanning the prologue of the caller, which will also be done
 519    shortly by fr30_init_extra_frame_info.  For the dummy frame, we
 520    just return the stack pointer that was in use at the time the
 521    function call was made.  */
 522
 523
 524 CORE_ADDR
 525 fr30_frame_chain (struct frame_info *fi)
 526 {
 527   CORE_ADDR fn_start, callers_pc, fp;
 528   struct frame_info caller_fi;
 529   int framereg;
 530
 531   /* is this a dummy frame? */
 532   if (PC_IN_CALL_DUMMY (fi->pc, fi->frame, fi->frame))
 533     return fi->frame;           /* dummy frame same as caller's frame */
 534
 535   /* is caller-of-this a dummy frame? */
 536   callers_pc = FRAME_SAVED_PC (fi);     /* find out who called us: */
 537   fp = fr30_find_callers_reg (fi, FP_REGNUM);
 538   if (PC_IN_CALL_DUMMY (callers_pc, fp, fp))
 539     return fp;                  /* dummy frame's frame may bear no relation to ours */
 540
 541   if (find_pc_partial_function (fi->pc, 0, &fn_start, 0))
 542     if (fn_start == entry_point_address ())
 543       return 0;                 /* in _start fn, don't chain further */
 544
 545   framereg = fi->framereg;
 546
 547   /* If the caller is the startup code, we're at the end of the chain.  */
 548   if (find_pc_partial_function (callers_pc, 0, &fn_start, 0))
 549     if (fn_start == entry_point_address ())
 550       return 0;
 551
 552   memset (&caller_fi, 0, sizeof (caller_fi));
 553   caller_fi.pc = callers_pc;
 554   fr30_scan_prologue (&caller_fi);
 555   framereg = caller_fi.framereg;
 556
 557   /* If the caller used a frame register, return its value.
 558      Otherwise, return the caller's stack pointer.  */
 559   if (framereg == FP_REGNUM)
 560     return fr30_find_callers_reg (fi, framereg);
 561   else
 562     return fi->frame + fi->framesize;
 563 }
 564
 565 /* Function: frame_saved_pc
 566    Find the caller of this frame.  We do this by seeing if RP_REGNUM
 567    is saved in the stack anywhere, otherwise we get it from the
 568    registers.  If the inner frame is a dummy frame, return its PC
 569    instead of RP, because that's where "caller" of the dummy-frame
 570    will be found.  */
 571
 572 CORE_ADDR
 573 fr30_frame_saved_pc (struct frame_info *fi)
 574 {
 575   if (PC_IN_CALL_DUMMY (fi->pc, fi->frame, fi->frame))
 576     return generic_read_register_dummy (fi->pc, fi->frame, PC_REGNUM);
 577   else
 578     return fr30_find_callers_reg (fi, RP_REGNUM);
 579 }
 580
 581 /* Function: fix_call_dummy
 582    Pokes the callee function's address into the CALL_DUMMY assembly stub.
 583    Assumes that the CALL_DUMMY looks like this:
 584    jarl <offset24>, r31
 585    trap
 586  */
 587
 588 int
 589 fr30_fix_call_dummy (char *dummy, CORE_ADDR sp, CORE_ADDR fun, int nargs,
 590                      struct value **args, struct type *type, int gcc_p)
 591 {
 592   long offset24;
 593
 594   offset24 = (long) fun - (long) entry_point_address ();
 595   offset24 &= 0x3fffff;
 596   offset24 |= 0xff800000;       /* jarl <offset24>, r31 */
 597
 598   store_unsigned_integer ((unsigned int *) &dummy[2], 2, offset24 & 0xffff);
 599   store_unsigned_integer ((unsigned int *) &dummy[0], 2, offset24 >> 16);
 600   return 0;
 601 }