gdb/rx-tdep.c

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