gdb/rx-tdep.c

   1 /* Target-dependent code for the Renesas RX for GDB, the GNU debugger.
   2
   3    Copyright (C) 2008-2016 Free Software Foundation, Inc.
   4
   5    Contributed by Red Hat, 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 3 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, see <http://www.gnu.org/licenses/>.  */
  21
  22 #include "defs.h"
  23 #include "arch-utils.h"
  24 #include "prologue-value.h"
  25 #include "target.h"
  26 #include "regcache.h"
  27 #include "opcode/rx.h"
  28 #include "dis-asm.h"
  29 #include "gdbtypes.h"
  30 #include "frame.h"
  31 #include "frame-unwind.h"
  32 #include "frame-base.h"
  33 #include "value.h"
  34 #include "gdbcore.h"
  35 #include "dwarf2-frame.h"
  36
  37 #include "elf/rx.h"
  38 #include "elf-bfd.h"
  39
  40 /* Certain important register numbers.  */
  41 enum
  42 {
  43   RX_SP_REGNUM = 0,
  44   RX_R1_REGNUM = 1,
  45   RX_R4_REGNUM = 4,
  46   RX_FP_REGNUM = 6,
  47   RX_R15_REGNUM = 15,
  48   RX_USP_REGNUM = 16,
  49   RX_PSW_REGNUM = 18,
  50   RX_PC_REGNUM = 19,
  51   RX_BPSW_REGNUM = 21,
  52   RX_BPC_REGNUM = 22,
  53   RX_FPSW_REGNUM = 24,
  54   RX_ACC_REGNUM = 25,
  55   RX_NUM_REGS = 26
  56 };
  57
  58 /* RX frame types.  */
  59 enum rx_frame_type {
  60   RX_FRAME_TYPE_NORMAL,
  61   RX_FRAME_TYPE_EXCEPTION,
  62   RX_FRAME_TYPE_FAST_INTERRUPT
  63 };
  64
  65 /* Architecture specific data.  */
  66 struct gdbarch_tdep
  67 {
  68   /* The ELF header flags specify the multilib used.  */
  69   int elf_flags;
  70
  71   /* Type of PSW and BPSW.  */
  72   struct type *rx_psw_type;
  73
  74   /* Type of FPSW.  */
  75   struct type *rx_fpsw_type;
  76 };
  77
  78 /* This structure holds the results of a prologue analysis.  */
  79 struct rx_prologue
  80 {
  81   /* Frame type, either a normal frame or one of two types of exception
  82      frames.  */
  83   enum rx_frame_type frame_type;
  84
  85   /* The offset from the frame base to the stack pointer --- always
  86      zero or negative.
  87
  88      Calling this a "size" is a bit misleading, but given that the
  89      stack grows downwards, using offsets for everything keeps one
  90      from going completely sign-crazy: you never change anything's
  91      sign for an ADD instruction; always change the second operand's
  92      sign for a SUB instruction; and everything takes care of
  93      itself.  */
  94   int frame_size;
  95
  96   /* Non-zero if this function has initialized the frame pointer from
  97      the stack pointer, zero otherwise.  */
  98   int has_frame_ptr;
  99
 100   /* If has_frame_ptr is non-zero, this is the offset from the frame
 101      base to where the frame pointer points.  This is always zero or
 102      negative.  */
 103   int frame_ptr_offset;
 104
 105   /* The address of the first instruction at which the frame has been
 106      set up and the arguments are where the debug info says they are
 107      --- as best as we can tell.  */
 108   CORE_ADDR prologue_end;
 109
 110   /* reg_offset[R] is the offset from the CFA at which register R is
 111      saved, or 1 if register R has not been saved.  (Real values are
 112      always zero or negative.)  */
 113   int reg_offset[RX_NUM_REGS];
 114 };
 115
 116 /* Implement the "register_name" gdbarch method.  */
 117 static const char *
 118 rx_register_name (struct gdbarch *gdbarch, int regnr)
 119 {
 120   static const char *const reg_names[] = {
 121     "r0",
 122     "r1",
 123     "r2",
 124     "r3",
 125     "r4",
 126     "r5",
 127     "r6",
 128     "r7",
 129     "r8",
 130     "r9",
 131     "r10",
 132     "r11",
 133     "r12",
 134     "r13",
 135     "r14",
 136     "r15",
 137     "usp",
 138     "isp",
 139     "psw",
 140     "pc",
 141     "intb",
 142     "bpsw",
 143     "bpc",
 144     "fintv",
 145     "fpsw",
 146     "acc"
 147   };
 148
 149   return reg_names[regnr];
 150 }
 151
 152 /* Implement the "register_type" gdbarch method.  */
 153 static struct type *
 154 rx_register_type (struct gdbarch *gdbarch, int reg_nr)
 155 {
 156   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 157
 158   if (reg_nr == RX_PC_REGNUM)
 159     return builtin_type (gdbarch)->builtin_func_ptr;
 160   else if (reg_nr == RX_PSW_REGNUM || reg_nr == RX_BPSW_REGNUM)
 161     return tdep->rx_psw_type;
 162   else if (reg_nr == RX_FPSW_REGNUM)
 163     return tdep->rx_fpsw_type;
 164   else if (reg_nr == RX_ACC_REGNUM)
 165     return builtin_type (gdbarch)->builtin_unsigned_long_long;
 166   else
 167     return builtin_type (gdbarch)->builtin_unsigned_long;
 168 }
 169
 170
 171 /* Function for finding saved registers in a 'struct pv_area'; this
 172    function is passed to pv_area_scan.
 173
 174    If VALUE is a saved register, ADDR says it was saved at a constant
 175    offset from the frame base, and SIZE indicates that the whole
 176    register was saved, record its offset.  */
 177 static void
 178 check_for_saved (void *result_untyped, pv_t addr, CORE_ADDR size, pv_t value)
 179 {
 180   struct rx_prologue *result = (struct rx_prologue *) result_untyped;
 181
 182   if (value.kind == pvk_register
 183       && value.k == 0
 184       && pv_is_register (addr, RX_SP_REGNUM)
 185       && size == register_size (target_gdbarch (), value.reg))
 186     result->reg_offset[value.reg] = addr.k;
 187 }
 188
 189 /* Define a "handle" struct for fetching the next opcode.  */
 190 struct rx_get_opcode_byte_handle
 191 {
 192   CORE_ADDR pc;
 193 };
 194
 195 /* Fetch a byte on behalf of the opcode decoder.  HANDLE contains
 196    the memory address of the next byte to fetch.  If successful,
 197    the address in the handle is updated and the byte fetched is
 198    returned as the value of the function.  If not successful, -1
 199    is returned.  */
 200 static int
 201 rx_get_opcode_byte (void *handle)
 202 {
 203   struct rx_get_opcode_byte_handle *opcdata
 204     = (struct rx_get_opcode_byte_handle *) handle;
 205   int status;
 206   gdb_byte byte;
 207
 208   status = target_read_code (opcdata->pc, &byte, 1);
 209   if (status == 0)
 210     {
 211       opcdata->pc += 1;
 212       return byte;
 213     }
 214   else
 215     return -1;
 216 }
 217
 218 /* Analyze a prologue starting at START_PC, going no further than
 219    LIMIT_PC.  Fill in RESULT as appropriate.  */
 220
 221 static void
 222 rx_analyze_prologue (CORE_ADDR start_pc, CORE_ADDR limit_pc,
 223                      enum rx_frame_type frame_type,
 224                      struct rx_prologue *result)
 225 {
 226   CORE_ADDR pc, next_pc;
 227   int rn;
 228   pv_t reg[RX_NUM_REGS];
 229   struct pv_area *stack;
 230   struct cleanup *back_to;
 231   CORE_ADDR after_last_frame_setup_insn = start_pc;
 232
 233   memset (result, 0, sizeof (*result));
 234
 235   result->frame_type = frame_type;
 236
 237   for (rn = 0; rn < RX_NUM_REGS; rn++)
 238     {
 239       reg[rn] = pv_register (rn, 0);
 240       result->reg_offset[rn] = 1;
 241     }
 242
 243   stack = make_pv_area (RX_SP_REGNUM, gdbarch_addr_bit (target_gdbarch ()));
 244   back_to = make_cleanup_free_pv_area (stack);
 245
 246   if (frame_type == RX_FRAME_TYPE_FAST_INTERRUPT)
 247     {
 248       /* This code won't do anything useful at present, but this is
 249          what happens for fast interrupts.  */
 250       reg[RX_BPSW_REGNUM] = reg[RX_PSW_REGNUM];
 251       reg[RX_BPC_REGNUM] = reg[RX_PC_REGNUM];
 252     }
 253   else
 254     {
 255       /* When an exception occurs, the PSW is saved to the interrupt stack
 256          first.  */
 257       if (frame_type == RX_FRAME_TYPE_EXCEPTION)
 258         {
 259           reg[RX_SP_REGNUM] = pv_add_constant (reg[RX_SP_REGNUM], -4);
 260           pv_area_store (stack, reg[RX_SP_REGNUM], 4, reg[RX_PSW_REGNUM]);
 261         }
 262
 263       /* The call instruction (or an exception/interrupt) has saved the return
 264           address on the stack.  */
 265       reg[RX_SP_REGNUM] = pv_add_constant (reg[RX_SP_REGNUM], -4);
 266       pv_area_store (stack, reg[RX_SP_REGNUM], 4, reg[RX_PC_REGNUM]);
 267
 268     }
 269
 270
 271   pc = start_pc;
 272   while (pc < limit_pc)
 273     {
 274       int bytes_read;
 275       struct rx_get_opcode_byte_handle opcode_handle;
 276       RX_Opcode_Decoded opc;
 277
 278       opcode_handle.pc = pc;
 279       bytes_read = rx_decode_opcode (pc, &opc, rx_get_opcode_byte,
 280                                      &opcode_handle);
 281       next_pc = pc + bytes_read;
 282
 283       if (opc.id == RXO_pushm   /* pushm r1, r2 */
 284           && opc.op[1].type == RX_Operand_Register
 285           && opc.op[2].type == RX_Operand_Register)
 286         {
 287           int r1, r2;
 288           int r;
 289
 290           r1 = opc.op[1].reg;
 291           r2 = opc.op[2].reg;
 292           for (r = r2; r >= r1; r--)
 293             {
 294               reg[RX_SP_REGNUM] = pv_add_constant (reg[RX_SP_REGNUM], -4);
 295               pv_area_store (stack, reg[RX_SP_REGNUM], 4, reg[r]);
 296             }
 297           after_last_frame_setup_insn = next_pc;
 298         }
 299       else if (opc.id == RXO_mov        /* mov.l rdst, rsrc */
 300                && opc.op[0].type == RX_Operand_Register
 301                && opc.op[1].type == RX_Operand_Register
 302                && opc.size == RX_Long)
 303         {
 304           int rdst, rsrc;
 305
 306           rdst = opc.op[0].reg;
 307           rsrc = opc.op[1].reg;
 308           reg[rdst] = reg[rsrc];
 309           if (rdst == RX_FP_REGNUM && rsrc == RX_SP_REGNUM)
 310             after_last_frame_setup_insn = next_pc;
 311         }
 312       else if (opc.id == RXO_mov        /* mov.l rsrc, [-SP] */
 313                && opc.op[0].type == RX_Operand_Predec
 314                && opc.op[0].reg == RX_SP_REGNUM
 315                && opc.op[1].type == RX_Operand_Register
 316                && opc.size == RX_Long)
 317         {
 318           int rsrc;
 319
 320           rsrc = opc.op[1].reg;
 321           reg[RX_SP_REGNUM] = pv_add_constant (reg[RX_SP_REGNUM], -4);
 322           pv_area_store (stack, reg[RX_SP_REGNUM], 4, reg[rsrc]);
 323           after_last_frame_setup_insn = next_pc;
 324         }
 325       else if (opc.id == RXO_add        /* add #const, rsrc, rdst */
 326                && opc.op[0].type == RX_Operand_Register
 327                && opc.op[1].type == RX_Operand_Immediate
 328                && opc.op[2].type == RX_Operand_Register)
 329         {
 330           int rdst = opc.op[0].reg;
 331           int addend = opc.op[1].addend;
 332           int rsrc = opc.op[2].reg;
 333           reg[rdst] = pv_add_constant (reg[rsrc], addend);
 334           /* Negative adjustments to the stack pointer or frame pointer
 335              are (most likely) part of the prologue.  */
 336           if ((rdst == RX_SP_REGNUM || rdst == RX_FP_REGNUM) && addend < 0)
 337             after_last_frame_setup_insn = next_pc;
 338         }
 339       else if (opc.id == RXO_mov
 340                && opc.op[0].type == RX_Operand_Indirect
 341                && opc.op[1].type == RX_Operand_Register
 342                && opc.size == RX_Long
 343                && (opc.op[0].reg == RX_SP_REGNUM
 344                    || opc.op[0].reg == RX_FP_REGNUM)
 345                && (RX_R1_REGNUM <= opc.op[1].reg
 346                    && opc.op[1].reg <= RX_R4_REGNUM))
 347         {
 348           /* This moves an argument register to the stack.  Don't
 349              record it, but allow it to be a part of the prologue.  */
 350         }
 351       else if (opc.id == RXO_branch
 352                && opc.op[0].type == RX_Operand_Immediate
 353                && next_pc < opc.op[0].addend)
 354         {
 355           /* When a loop appears as the first statement of a function
 356              body, gcc 4.x will use a BRA instruction to branch to the
 357              loop condition checking code.  This BRA instruction is
 358              marked as part of the prologue.  We therefore set next_pc
 359              to this branch target and also stop the prologue scan.
 360              The instructions at and beyond the branch target should
 361              no longer be associated with the prologue.
 362
 363              Note that we only consider forward branches here.  We
 364              presume that a forward branch is being used to skip over
 365              a loop body.
 366
 367              A backwards branch is covered by the default case below.
 368              If we were to encounter a backwards branch, that would
 369              most likely mean that we've scanned through a loop body.
 370              We definitely want to stop the prologue scan when this
 371              happens and that is precisely what is done by the default
 372              case below.  */
 373
 374           after_last_frame_setup_insn = opc.op[0].addend;
 375           break;                /* Scan no further if we hit this case.  */
 376         }
 377       else
 378         {
 379           /* Terminate the prologue scan.  */
 380           break;
 381         }
 382
 383       pc = next_pc;
 384     }
 385
 386   /* Is the frame size (offset, really) a known constant?  */
 387   if (pv_is_register (reg[RX_SP_REGNUM], RX_SP_REGNUM))
 388     result->frame_size = reg[RX_SP_REGNUM].k;
 389
 390   /* Was the frame pointer initialized?  */
 391   if (pv_is_register (reg[RX_FP_REGNUM], RX_SP_REGNUM))
 392     {
 393       result->has_frame_ptr = 1;
 394       result->frame_ptr_offset = reg[RX_FP_REGNUM].k;
 395     }
 396
 397   /* Record where all the registers were saved.  */
 398   pv_area_scan (stack, check_for_saved, (void *) result);
 399
 400   result->prologue_end = after_last_frame_setup_insn;
 401
 402   do_cleanups (back_to);
 403 }
 404
 405
 406 /* Implement the "skip_prologue" gdbarch method.  */
 407 static CORE_ADDR
 408 rx_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
 409 {
 410   const char *name;
 411   CORE_ADDR func_addr, func_end;
 412   struct rx_prologue p;
 413
 414   /* Try to find the extent of the function that contains PC.  */
 415   if (!find_pc_partial_function (pc, &name, &func_addr, &func_end))
 416     return pc;
 417
 418   /* The frame type doesn't matter here, since we only care about
 419      where the prologue ends.  We'll use RX_FRAME_TYPE_NORMAL.  */
 420   rx_analyze_prologue (pc, func_end, RX_FRAME_TYPE_NORMAL, &p);
 421   return p.prologue_end;
 422 }
 423
 424 /* Given a frame described by THIS_FRAME, decode the prologue of its
 425    associated function if there is not cache entry as specified by
 426    THIS_PROLOGUE_CACHE.  Save the decoded prologue in the cache and
 427    return that struct as the value of this function.  */
 428
 429 static struct rx_prologue *
 430 rx_analyze_frame_prologue (struct frame_info *this_frame,
 431                            enum rx_frame_type frame_type,
 432                            void **this_prologue_cache)
 433 {
 434   if (!*this_prologue_cache)
 435     {
 436       CORE_ADDR func_start, stop_addr;
 437
 438       *this_prologue_cache = FRAME_OBSTACK_ZALLOC (struct rx_prologue);
 439
 440       func_start = get_frame_func (this_frame);
 441       stop_addr = get_frame_pc (this_frame);
 442
 443       /* If we couldn't find any function containing the PC, then
 444          just initialize the prologue cache, but don't do anything.  */
 445       if (!func_start)
 446         stop_addr = func_start;
 447
 448       rx_analyze_prologue (func_start, stop_addr, frame_type,
 449                            (struct rx_prologue *) *this_prologue_cache);
 450     }
 451
 452   return (struct rx_prologue *) *this_prologue_cache;
 453 }
 454
 455 /* Determine type of frame by scanning the function for a return
 456    instruction.  */
 457
 458 static enum rx_frame_type
 459 rx_frame_type (struct frame_info *this_frame, void **this_cache)
 460 {
 461   const char *name;
 462   CORE_ADDR pc, start_pc, lim_pc;
 463   int bytes_read;
 464   struct rx_get_opcode_byte_handle opcode_handle;
 465   RX_Opcode_Decoded opc;
 466
 467   gdb_assert (this_cache != NULL);
 468
 469   /* If we have a cached value, return it.  */
 470
 471   if (*this_cache != NULL)
 472     {
 473       struct rx_prologue *p = (struct rx_prologue *) *this_cache;
 474
 475       return p->frame_type;
 476     }
 477
 478   /* No cached value; scan the function.  The frame type is cached in
 479      rx_analyze_prologue / rx_analyze_frame_prologue.  */
 480
 481   pc = get_frame_pc (this_frame);
 482
 483   /* Attempt to find the last address in the function.  If it cannot
 484      be determined, set the limit to be a short ways past the frame's
 485      pc.  */
 486   if (!find_pc_partial_function (pc, &name, &start_pc, &lim_pc))
 487     lim_pc = pc + 20;
 488
 489   while (pc < lim_pc)
 490     {
 491       opcode_handle.pc = pc;
 492       bytes_read = rx_decode_opcode (pc, &opc, rx_get_opcode_byte,
 493                                      &opcode_handle);
 494
 495       if (bytes_read <= 0 || opc.id == RXO_rts)
 496         return RX_FRAME_TYPE_NORMAL;
 497       else if (opc.id == RXO_rtfi)
 498         return RX_FRAME_TYPE_FAST_INTERRUPT;
 499       else if (opc.id == RXO_rte)
 500         return RX_FRAME_TYPE_EXCEPTION;
 501
 502       pc += bytes_read;
 503     }
 504
 505   return RX_FRAME_TYPE_NORMAL;
 506 }
 507
 508
 509 /* Given the next frame and a prologue cache, return this frame's
 510    base.  */
 511
 512 static CORE_ADDR
 513 rx_frame_base (struct frame_info *this_frame, void **this_cache)
 514 {
 515   enum rx_frame_type frame_type = rx_frame_type (this_frame, this_cache);
 516   struct rx_prologue *p
 517     = rx_analyze_frame_prologue (this_frame, frame_type, this_cache);
 518
 519   /* In functions that use alloca, the distance between the stack
 520      pointer and the frame base varies dynamically, so we can't use
 521      the SP plus static information like prologue analysis to find the
 522      frame base.  However, such functions must have a frame pointer,
 523      to be able to restore the SP on exit.  So whenever we do have a
 524      frame pointer, use that to find the base.  */
 525   if (p->has_frame_ptr)
 526     {
 527       CORE_ADDR fp = get_frame_register_unsigned (this_frame, RX_FP_REGNUM);
 528       return fp - p->frame_ptr_offset;
 529     }
 530   else
 531     {
 532       CORE_ADDR sp = get_frame_register_unsigned (this_frame, RX_SP_REGNUM);
 533       return sp - p->frame_size;
 534     }
 535 }
 536
 537 /* Implement the "frame_this_id" method for unwinding frames.  */
 538
 539 static void
 540 rx_frame_this_id (struct frame_info *this_frame, void **this_cache,
 541                   struct frame_id *this_id)
 542 {
 543   *this_id = frame_id_build (rx_frame_base (this_frame, this_cache),
 544                              get_frame_func (this_frame));
 545 }
 546
 547 /* Implement the "frame_prev_register" method for unwinding frames.  */
 548
 549 static struct value *
 550 rx_frame_prev_register (struct frame_info *this_frame, void **this_cache,
 551                         int regnum)
 552 {
 553   enum rx_frame_type frame_type = rx_frame_type (this_frame, this_cache);
 554   struct rx_prologue *p
 555     = rx_analyze_frame_prologue (this_frame, frame_type, this_cache);
 556   CORE_ADDR frame_base = rx_frame_base (this_frame, this_cache);
 557
 558   if (regnum == RX_SP_REGNUM)
 559     {
 560       if (frame_type == RX_FRAME_TYPE_EXCEPTION)
 561         {
 562           struct value *psw_val;
 563           CORE_ADDR psw;
 564
 565           psw_val = rx_frame_prev_register (this_frame, this_cache,
 566                                             RX_PSW_REGNUM);
 567           psw = extract_unsigned_integer (value_contents_all (psw_val), 4,
 568                                           gdbarch_byte_order (
 569                                             get_frame_arch (this_frame)));
 570
 571           if ((psw & 0x20000 /* U bit */) != 0)
 572             return rx_frame_prev_register (this_frame, this_cache,
 573                                            RX_USP_REGNUM);
 574
 575           /* Fall through for the case where U bit is zero.  */
 576         }
 577
 578       return frame_unwind_got_constant (this_frame, regnum, frame_base);
 579     }
 580
 581   if (frame_type == RX_FRAME_TYPE_FAST_INTERRUPT)
 582     {
 583       if (regnum == RX_PC_REGNUM)
 584         return rx_frame_prev_register (this_frame, this_cache,
 585                                        RX_BPC_REGNUM);
 586       if (regnum == RX_PSW_REGNUM)
 587         return rx_frame_prev_register (this_frame, this_cache,
 588                                        RX_BPSW_REGNUM);
 589     }
 590
 591   /* If prologue analysis says we saved this register somewhere,
 592      return a description of the stack slot holding it.  */
 593   if (p->reg_offset[regnum] != 1)
 594     return frame_unwind_got_memory (this_frame, regnum,
 595                                     frame_base + p->reg_offset[regnum]);
 596
 597   /* Otherwise, presume we haven't changed the value of this
 598      register, and get it from the next frame.  */
 599   return frame_unwind_got_register (this_frame, regnum, regnum);
 600 }
 601
 602 /* Return TRUE if the frame indicated by FRAME_TYPE is a normal frame.  */
 603
 604 static int
 605 normal_frame_p (enum rx_frame_type frame_type)
 606 {
 607   return (frame_type == RX_FRAME_TYPE_NORMAL);
 608 }
 609
 610 /* Return TRUE if the frame indicated by FRAME_TYPE is an exception
 611    frame.  */
 612
 613 static int
 614 exception_frame_p (enum rx_frame_type frame_type)
 615 {
 616   return (frame_type == RX_FRAME_TYPE_EXCEPTION
 617           || frame_type == RX_FRAME_TYPE_FAST_INTERRUPT);
 618 }
 619
 620 /* Common code used by both normal and exception frame sniffers.  */
 621
 622 static int
 623 rx_frame_sniffer_common (const struct frame_unwind *self,
 624                          struct frame_info *this_frame,
 625                          void **this_cache,
 626                          int (*sniff_p)(enum rx_frame_type) )
 627 {
 628   gdb_assert (this_cache != NULL);
 629
 630   if (*this_cache == NULL)
 631     {
 632       enum rx_frame_type frame_type = rx_frame_type (this_frame, this_cache);
 633
 634       if (sniff_p (frame_type))
 635         {
 636           /* The call below will fill in the cache, including the frame
 637              type.  */
 638           (void) rx_analyze_frame_prologue (this_frame, frame_type, this_cache);
 639
 640           return 1;
 641         }
 642       else
 643         return 0;
 644     }
 645   else
 646     {
 647       struct rx_prologue *p = (struct rx_prologue *) *this_cache;
 648
 649       return sniff_p (p->frame_type);
 650     }
 651 }
 652
 653 /* Frame sniffer for normal (non-exception) frames.  */
 654
 655 static int
 656 rx_frame_sniffer (const struct frame_unwind *self,
 657                   struct frame_info *this_frame,
 658                   void **this_cache)
 659 {
 660   return rx_frame_sniffer_common (self, this_frame, this_cache,
 661                                   normal_frame_p);
 662 }
 663
 664 /* Frame sniffer for exception frames.  */
 665
 666 static int
 667 rx_exception_sniffer (const struct frame_unwind *self,
 668                              struct frame_info *this_frame,
 669                              void **this_cache)
 670 {
 671   return rx_frame_sniffer_common (self, this_frame, this_cache,
 672                                   exception_frame_p);
 673 }
 674
 675 /* Data structure for normal code using instruction-based prologue
 676    analyzer.  */
 677
 678 static const struct frame_unwind rx_frame_unwind = {
 679   NORMAL_FRAME,
 680   default_frame_unwind_stop_reason,
 681   rx_frame_this_id,
 682   rx_frame_prev_register,
 683   NULL,
 684   rx_frame_sniffer
 685 };
 686
 687 /* Data structure for exception code using instruction-based prologue
 688    analyzer.  */
 689
 690 static const struct frame_unwind rx_exception_unwind = {
 691   /* SIGTRAMP_FRAME could be used here, but backtraces are less informative.  */
 692   NORMAL_FRAME,
 693   default_frame_unwind_stop_reason,
 694   rx_frame_this_id,
 695   rx_frame_prev_register,
 696   NULL,
 697   rx_exception_sniffer
 698 };
 699
 700 /* Implement the "unwind_pc" gdbarch method.  */
 701 static CORE_ADDR
 702 rx_unwind_pc (struct gdbarch *gdbarch, struct frame_info *this_frame)
 703 {
 704   ULONGEST pc;
 705
 706   pc = frame_unwind_register_unsigned (this_frame, RX_PC_REGNUM);
 707   return pc;
 708 }
 709
 710 /* Implement the "unwind_sp" gdbarch method.  */
 711 static CORE_ADDR
 712 rx_unwind_sp (struct gdbarch *gdbarch, struct frame_info *this_frame)
 713 {
 714   ULONGEST sp;
 715
 716   sp = frame_unwind_register_unsigned (this_frame, RX_SP_REGNUM);
 717   return sp;
 718 }
 719
 720 /* Implement the "dummy_id" gdbarch method.  */
 721 static struct frame_id
 722 rx_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
 723 {
 724   return
 725     frame_id_build (get_frame_register_unsigned (this_frame, RX_SP_REGNUM),
 726                     get_frame_pc (this_frame));
 727 }
 728
 729 /* Implement the "push_dummy_call" gdbarch method.  */
 730 static CORE_ADDR
 731 rx_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 732                     struct regcache *regcache, CORE_ADDR bp_addr, int nargs,
 733                     struct value **args, CORE_ADDR sp, int struct_return,
 734                     CORE_ADDR struct_addr)
 735 {
 736   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 737   int write_pass;
 738   int sp_off = 0;
 739   CORE_ADDR cfa;
 740   int num_register_candidate_args;
 741
 742   struct type *func_type = value_type (function);
 743
 744   /* Dereference function pointer types.  */
 745   while (TYPE_CODE (func_type) == TYPE_CODE_PTR)
 746     func_type = TYPE_TARGET_TYPE (func_type);
 747
 748   /* The end result had better be a function or a method.  */
 749   gdb_assert (TYPE_CODE (func_type) == TYPE_CODE_FUNC
 750               || TYPE_CODE (func_type) == TYPE_CODE_METHOD);
 751
 752   /* Functions with a variable number of arguments have all of their
 753      variable arguments and the last non-variable argument passed
 754      on the stack.
 755
 756      Otherwise, we can pass up to four arguments on the stack.
 757
 758      Once computed, we leave this value alone.  I.e. we don't update
 759      it in case of a struct return going in a register or an argument
 760      requiring multiple registers, etc.  We rely instead on the value
 761      of the ``arg_reg'' variable to get these other details correct.  */
 762
 763   if (TYPE_VARARGS (func_type))
 764     num_register_candidate_args = TYPE_NFIELDS (func_type) - 1;
 765   else
 766     num_register_candidate_args = 4;
 767
 768   /* We make two passes; the first does the stack allocation,
 769      the second actually stores the arguments.  */
 770   for (write_pass = 0; write_pass <= 1; write_pass++)
 771     {
 772       int i;
 773       int arg_reg = RX_R1_REGNUM;
 774
 775       if (write_pass)
 776         sp = align_down (sp - sp_off, 4);
 777       sp_off = 0;
 778
 779       if (struct_return)
 780         {
 781           struct type *return_type = TYPE_TARGET_TYPE (func_type);
 782
 783           gdb_assert (TYPE_CODE (return_type) == TYPE_CODE_STRUCT
 784                       || TYPE_CODE (func_type) == TYPE_CODE_UNION);
 785
 786           if (TYPE_LENGTH (return_type) > 16
 787               || TYPE_LENGTH (return_type) % 4 != 0)
 788             {
 789               if (write_pass)
 790                 regcache_cooked_write_unsigned (regcache, RX_R15_REGNUM,
 791                                                 struct_addr);
 792             }
 793         }
 794
 795       /* Push the arguments.  */
 796       for (i = 0; i < nargs; i++)
 797         {
 798           struct value *arg = args[i];
 799           const gdb_byte *arg_bits = value_contents_all (arg);
 800           struct type *arg_type = check_typedef (value_type (arg));
 801           ULONGEST arg_size = TYPE_LENGTH (arg_type);
 802
 803           if (i == 0 && struct_addr != 0 && !struct_return
 804               && TYPE_CODE (arg_type) == TYPE_CODE_PTR
 805               && extract_unsigned_integer (arg_bits, 4,
 806                                            byte_order) == struct_addr)
 807             {
 808               /* This argument represents the address at which C++ (and
 809                  possibly other languages) store their return value.
 810                  Put this value in R15.  */
 811               if (write_pass)
 812                 regcache_cooked_write_unsigned (regcache, RX_R15_REGNUM,
 813                                                 struct_addr);
 814             }
 815           else if (TYPE_CODE (arg_type) != TYPE_CODE_STRUCT
 816                    && TYPE_CODE (arg_type) != TYPE_CODE_UNION
 817                    && arg_size <= 8)
 818             {
 819               /* Argument is a scalar.  */
 820               if (arg_size == 8)
 821                 {
 822                   if (i < num_register_candidate_args
 823                       && arg_reg <= RX_R4_REGNUM - 1)
 824                     {
 825                       /* If argument registers are going to be used to pass
 826                          an 8 byte scalar, the ABI specifies that two registers
 827                          must be available.  */
 828                       if (write_pass)
 829                         {
 830                           regcache_cooked_write_unsigned (regcache, arg_reg,
 831                                                           extract_unsigned_integer
 832                                                           (arg_bits, 4,
 833                                                            byte_order));
 834                           regcache_cooked_write_unsigned (regcache,
 835                                                           arg_reg + 1,
 836                                                           extract_unsigned_integer
 837                                                           (arg_bits + 4, 4,
 838                                                            byte_order));
 839                         }
 840                       arg_reg += 2;
 841                     }
 842                   else
 843                     {
 844                       sp_off = align_up (sp_off, 4);
 845                       /* Otherwise, pass the 8 byte scalar on the stack.  */
 846                       if (write_pass)
 847                         write_memory (sp + sp_off, arg_bits, 8);
 848                       sp_off += 8;
 849                     }
 850                 }
 851               else
 852                 {
 853                   ULONGEST u;
 854
 855                   gdb_assert (arg_size <= 4);
 856
 857                   u =
 858                     extract_unsigned_integer (arg_bits, arg_size, byte_order);
 859
 860                   if (i < num_register_candidate_args
 861                       && arg_reg <= RX_R4_REGNUM)
 862                     {
 863                       if (write_pass)
 864                         regcache_cooked_write_unsigned (regcache, arg_reg, u);
 865                       arg_reg += 1;
 866                     }
 867                   else
 868                     {
 869                       int p_arg_size = 4;
 870
 871                       if (TYPE_PROTOTYPED (func_type)
 872                           && i < TYPE_NFIELDS (func_type))
 873                         {
 874                           struct type *p_arg_type =
 875                             TYPE_FIELD_TYPE (func_type, i);
 876                           p_arg_size = TYPE_LENGTH (p_arg_type);
 877                         }
 878
 879                       sp_off = align_up (sp_off, p_arg_size);
 880
 881                       if (write_pass)
 882                         write_memory_unsigned_integer (sp + sp_off,
 883                                                        p_arg_size, byte_order,
 884                                                        u);
 885                       sp_off += p_arg_size;
 886                     }
 887                 }
 888             }
 889           else
 890             {
 891               /* Argument is a struct or union.  Pass as much of the struct
 892                  in registers, if possible.  Pass the rest on the stack.  */
 893               while (arg_size > 0)
 894                 {
 895                   if (i < num_register_candidate_args
 896                       && arg_reg <= RX_R4_REGNUM
 897                       && arg_size <= 4 * (RX_R4_REGNUM - arg_reg + 1)
 898                       && arg_size % 4 == 0)
 899                     {
 900                       int len = min (arg_size, 4);
 901
 902                       if (write_pass)
 903                         regcache_cooked_write_unsigned (regcache, arg_reg,
 904                                                         extract_unsigned_integer
 905                                                         (arg_bits, len,
 906                                                          byte_order));
 907                       arg_bits += len;
 908                       arg_size -= len;
 909                       arg_reg++;
 910                     }
 911                   else
 912                     {
 913                       sp_off = align_up (sp_off, 4);
 914                       if (write_pass)
 915                         write_memory (sp + sp_off, arg_bits, arg_size);
 916                       sp_off += align_up (arg_size, 4);
 917                       arg_size = 0;
 918                     }
 919                 }
 920             }
 921         }
 922     }
 923
 924   /* Keep track of the stack address prior to pushing the return address.
 925      This is the value that we'll return.  */
 926   cfa = sp;
 927
 928   /* Push the return address.  */
 929   sp = sp - 4;
 930   write_memory_unsigned_integer (sp, 4, byte_order, bp_addr);
 931
 932   /* Update the stack pointer.  */
 933   regcache_cooked_write_unsigned (regcache, RX_SP_REGNUM, sp);
 934
 935   return cfa;
 936 }
 937
 938 /* Implement the "return_value" gdbarch method.  */
 939 static enum return_value_convention
 940 rx_return_value (struct gdbarch *gdbarch,
 941                  struct value *function,
 942                  struct type *valtype,
 943                  struct regcache *regcache,
 944                  gdb_byte *readbuf, const gdb_byte *writebuf)
 945 {
 946   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 947   ULONGEST valtype_len = TYPE_LENGTH (valtype);
 948
 949   if (TYPE_LENGTH (valtype) > 16
 950       || ((TYPE_CODE (valtype) == TYPE_CODE_STRUCT
 951            || TYPE_CODE (valtype) == TYPE_CODE_UNION)
 952           && TYPE_LENGTH (valtype) % 4 != 0))
 953     return RETURN_VALUE_STRUCT_CONVENTION;
 954
 955   if (readbuf)
 956     {
 957       ULONGEST u;
 958       int argreg = RX_R1_REGNUM;
 959       int offset = 0;
 960
 961       while (valtype_len > 0)
 962         {
 963           int len = min (valtype_len, 4);
 964
 965           regcache_cooked_read_unsigned (regcache, argreg, &u);
 966           store_unsigned_integer (readbuf + offset, len, byte_order, u);
 967           valtype_len -= len;
 968           offset += len;
 969           argreg++;
 970         }
 971     }
 972
 973   if (writebuf)
 974     {
 975       ULONGEST u;
 976       int argreg = RX_R1_REGNUM;
 977       int offset = 0;
 978
 979       while (valtype_len > 0)
 980         {
 981           int len = min (valtype_len, 4);
 982
 983           u = extract_unsigned_integer (writebuf + offset, len, byte_order);
 984           regcache_cooked_write_unsigned (regcache, argreg, u);
 985           valtype_len -= len;
 986           offset += len;
 987           argreg++;
 988         }
 989     }
 990
 991   return RETURN_VALUE_REGISTER_CONVENTION;
 992 }
 993
 994 /* Implement the "breakpoint_from_pc" gdbarch method.  */
 995 static const gdb_byte *
 996 rx_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *lenptr)
 997 {
 998   static gdb_byte breakpoint[] = { 0x00 };
 999   *lenptr = sizeof breakpoint;
1000   return breakpoint;
1001 }
1002
1003 /* Implement the dwarf_reg_to_regnum" gdbarch method.  */
1004
1005 static int
1006 rx_dwarf_reg_to_regnum (struct gdbarch *gdbarch, int reg)
1007 {
1008   if (0 <= reg && reg <= 15)
1009     return reg;
1010   else if (reg == 16)
1011     return RX_PSW_REGNUM;
1012   else if (reg == 17)
1013     return RX_PC_REGNUM;
1014   else
1015     return -1;
1016 }
1017
1018 /* Allocate and initialize a gdbarch object.  */
1019 static struct gdbarch *
1020 rx_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
1021 {
1022   struct gdbarch *gdbarch;
1023   struct gdbarch_tdep *tdep;
1024   int elf_flags;
1025
1026   /* Extract the elf_flags if available.  */
1027   if (info.abfd != NULL
1028       && bfd_get_flavour (info.abfd) == bfd_target_elf_flavour)
1029     elf_flags = elf_elfheader (info.abfd)->e_flags;
1030   else
1031     elf_flags = 0;
1032
1033
1034   /* Try to find the architecture in the list of already defined
1035      architectures.  */
1036   for (arches = gdbarch_list_lookup_by_info (arches, &info);
1037        arches != NULL;
1038        arches = gdbarch_list_lookup_by_info (arches->next, &info))
1039     {
1040       if (gdbarch_tdep (arches->gdbarch)->elf_flags != elf_flags)
1041         continue;
1042
1043       return arches->gdbarch;
1044     }
1045
1046   /* None found, create a new architecture from the information
1047      provided.  */
1048   tdep = XNEW (struct gdbarch_tdep);
1049   gdbarch = gdbarch_alloc (&info, tdep);
1050   tdep->elf_flags = elf_flags;
1051
1052   /* Initialize the flags type for PSW and BPSW.  */
1053
1054   tdep->rx_psw_type = arch_flags_type (gdbarch, "rx_psw_type", 4);
1055   append_flags_type_flag (tdep->rx_psw_type, 0, "C");
1056   append_flags_type_flag (tdep->rx_psw_type, 1, "Z");
1057   append_flags_type_flag (tdep->rx_psw_type, 2, "S");
1058   append_flags_type_flag (tdep->rx_psw_type, 3, "O");
1059   append_flags_type_flag (tdep->rx_psw_type, 16, "I");
1060   append_flags_type_flag (tdep->rx_psw_type, 17, "U");
1061   append_flags_type_flag (tdep->rx_psw_type, 20, "PM");
1062   append_flags_type_flag (tdep->rx_psw_type, 24, "IPL0");
1063   append_flags_type_flag (tdep->rx_psw_type, 25, "IPL1");
1064   append_flags_type_flag (tdep->rx_psw_type, 26, "IPL2");
1065   append_flags_type_flag (tdep->rx_psw_type, 27, "IPL3");
1066
1067   /* Initialize flags type for FPSW.  */
1068
1069   tdep->rx_fpsw_type = arch_flags_type (gdbarch, "rx_fpsw_type", 4);
1070   append_flags_type_flag (tdep->rx_fpsw_type, 0, "RM0");
1071   append_flags_type_flag (tdep->rx_fpsw_type, 1, "RM1");
1072   append_flags_type_flag (tdep->rx_fpsw_type, 2, "CV");
1073   append_flags_type_flag (tdep->rx_fpsw_type, 3, "CO");
1074   append_flags_type_flag (tdep->rx_fpsw_type, 4, "CZ");
1075   append_flags_type_flag (tdep->rx_fpsw_type, 5, "CU");
1076   append_flags_type_flag (tdep->rx_fpsw_type, 6, "CX");
1077   append_flags_type_flag (tdep->rx_fpsw_type, 7, "CE");
1078   append_flags_type_flag (tdep->rx_fpsw_type, 8, "DN");
1079   append_flags_type_flag (tdep->rx_fpsw_type, 10, "EV");
1080   append_flags_type_flag (tdep->rx_fpsw_type, 11, "EO");
1081   append_flags_type_flag (tdep->rx_fpsw_type, 12, "EZ");
1082   append_flags_type_flag (tdep->rx_fpsw_type, 13, "EU");
1083   append_flags_type_flag (tdep->rx_fpsw_type, 14, "EX");
1084   append_flags_type_flag (tdep->rx_fpsw_type, 26, "FV");
1085   append_flags_type_flag (tdep->rx_fpsw_type, 27, "FO");
1086   append_flags_type_flag (tdep->rx_fpsw_type, 28, "FZ");
1087   append_flags_type_flag (tdep->rx_fpsw_type, 29, "FU");
1088   append_flags_type_flag (tdep->rx_fpsw_type, 30, "FX");
1089   append_flags_type_flag (tdep->rx_fpsw_type, 31, "FS");
1090
1091   set_gdbarch_num_regs (gdbarch, RX_NUM_REGS);
1092   set_gdbarch_num_pseudo_regs (gdbarch, 0);
1093   set_gdbarch_register_name (gdbarch, rx_register_name);
1094   set_gdbarch_register_type (gdbarch, rx_register_type);
1095   set_gdbarch_pc_regnum (gdbarch, RX_PC_REGNUM);
1096   set_gdbarch_sp_regnum (gdbarch, RX_SP_REGNUM);
1097   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
1098   set_gdbarch_decr_pc_after_break (gdbarch, 1);
1099   set_gdbarch_breakpoint_from_pc (gdbarch, rx_breakpoint_from_pc);
1100   set_gdbarch_skip_prologue (gdbarch, rx_skip_prologue);
1101
1102   set_gdbarch_print_insn (gdbarch, print_insn_rx);
1103
1104   set_gdbarch_unwind_pc (gdbarch, rx_unwind_pc);
1105   set_gdbarch_unwind_sp (gdbarch, rx_unwind_sp);
1106
1107   /* Target builtin data types.  */
1108   set_gdbarch_char_signed (gdbarch, 0);
1109   set_gdbarch_short_bit (gdbarch, 16);
1110   set_gdbarch_int_bit (gdbarch, 32);
1111   set_gdbarch_long_bit (gdbarch, 32);
1112   set_gdbarch_long_long_bit (gdbarch, 64);
1113   set_gdbarch_ptr_bit (gdbarch, 32);
1114   set_gdbarch_float_bit (gdbarch, 32);
1115   set_gdbarch_float_format (gdbarch, floatformats_ieee_single);
1116   if (elf_flags & E_FLAG_RX_64BIT_DOUBLES)
1117     {
1118       set_gdbarch_double_bit (gdbarch, 64);
1119       set_gdbarch_long_double_bit (gdbarch, 64);
1120       set_gdbarch_double_format (gdbarch, floatformats_ieee_double);
1121       set_gdbarch_long_double_format (gdbarch, floatformats_ieee_double);
1122     }
1123   else
1124     {
1125       set_gdbarch_double_bit (gdbarch, 32);
1126       set_gdbarch_long_double_bit (gdbarch, 32);
1127       set_gdbarch_double_format (gdbarch, floatformats_ieee_single);
1128       set_gdbarch_long_double_format (gdbarch, floatformats_ieee_single);
1129     }
1130
1131   /* DWARF register mapping.  */
1132   set_gdbarch_dwarf2_reg_to_regnum (gdbarch, rx_dwarf_reg_to_regnum);
1133
1134   /* Frame unwinding.  */
1135   frame_unwind_append_unwinder (gdbarch, &rx_exception_unwind);
1136   dwarf2_append_unwinders (gdbarch);
1137   frame_unwind_append_unwinder (gdbarch, &rx_frame_unwind);
1138
1139   /* Methods for saving / extracting a dummy frame's ID.
1140      The ID's stack address must match the SP value returned by
1141      PUSH_DUMMY_CALL, and saved by generic_save_dummy_frame_tos.  */
1142   set_gdbarch_dummy_id (gdbarch, rx_dummy_id);
1143   set_gdbarch_push_dummy_call (gdbarch, rx_push_dummy_call);
1144   set_gdbarch_return_value (gdbarch, rx_return_value);
1145
1146   /* Virtual tables.  */
1147   set_gdbarch_vbit_in_delta (gdbarch, 1);
1148
1149   return gdbarch;
1150 }
1151
1152 /* -Wmissing-prototypes */
1153 extern initialize_file_ftype _initialize_rx_tdep;
1154
1155 /* Register the above initialization routine.  */
1156
1157 void
1158 _initialize_rx_tdep (void)
1159 {
1160   register_gdbarch_init (bfd_arch_rx, rx_gdbarch_init);
1161 }