gdb/rx-tdep.c

   1 /* Target-dependent code for the Renesas RX for GDB, the GNU debugger.
   2
   3    Copyright (C) 2008, 2009, 2010 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_PC_REGNUM = 19,
  49   RX_ACC_REGNUM = 25,
  50   RX_NUM_REGS = 26
  51 };
  52
  53 /* Architecture specific data.  */
  54 struct gdbarch_tdep
  55 {
  56   /* The ELF header flags specify the multilib used.  */
  57   int elf_flags;
  58 };
  59
  60 /* This structure holds the results of a prologue analysis.  */
  61 struct rx_prologue
  62 {
  63   /* The offset from the frame base to the stack pointer --- always
  64      zero or negative.
  65
  66      Calling this a "size" is a bit misleading, but given that the
  67      stack grows downwards, using offsets for everything keeps one
  68      from going completely sign-crazy: you never change anything's
  69      sign for an ADD instruction; always change the second operand's
  70      sign for a SUB instruction; and everything takes care of
  71      itself.  */
  72   int frame_size;
  73
  74   /* Non-zero if this function has initialized the frame pointer from
  75      the stack pointer, zero otherwise.  */
  76   int has_frame_ptr;
  77
  78   /* If has_frame_ptr is non-zero, this is the offset from the frame
  79      base to where the frame pointer points.  This is always zero or
  80      negative.  */
  81   int frame_ptr_offset;
  82
  83   /* The address of the first instruction at which the frame has been
  84      set up and the arguments are where the debug info says they are
  85      --- as best as we can tell.  */
  86   CORE_ADDR prologue_end;
  87
  88   /* reg_offset[R] is the offset from the CFA at which register R is
  89      saved, or 1 if register R has not been saved.  (Real values are
  90      always zero or negative.)  */
  91   int reg_offset[RX_NUM_REGS];
  92 };
  93
  94 /* Implement the "register_name" gdbarch method.  */
  95 static const char *
  96 rx_register_name (struct gdbarch *gdbarch, int regnr)
  97 {
  98   static const char *const reg_names[] = {
  99     "r0",
 100     "r1",
 101     "r2",
 102     "r3",
 103     "r4",
 104     "r5",
 105     "r6",
 106     "r7",
 107     "r8",
 108     "r9",
 109     "r10",
 110     "r11",
 111     "r12",
 112     "r13",
 113     "r14",
 114     "r15",
 115     "usp",
 116     "isp",
 117     "psw",
 118     "pc",
 119     "intb",
 120     "bpsw",
 121     "bpc",
 122     "fintv",
 123     "fpsw",
 124     "acc"
 125   };
 126
 127   return reg_names[regnr];
 128 }
 129
 130 /* Implement the "register_type" gdbarch method.  */
 131 static struct type *
 132 rx_register_type (struct gdbarch *gdbarch, int reg_nr)
 133 {
 134   if (reg_nr == RX_PC_REGNUM)
 135     return builtin_type (gdbarch)->builtin_func_ptr;
 136   else if (reg_nr == RX_ACC_REGNUM)
 137     return builtin_type (gdbarch)->builtin_unsigned_long_long;
 138   else
 139     return builtin_type (gdbarch)->builtin_unsigned_long;
 140 }
 141
 142
 143 /* Function for finding saved registers in a 'struct pv_area'; this
 144    function is passed to pv_area_scan.
 145
 146    If VALUE is a saved register, ADDR says it was saved at a constant
 147    offset from the frame base, and SIZE indicates that the whole
 148    register was saved, record its offset.  */
 149 static void
 150 check_for_saved (void *result_untyped, pv_t addr, CORE_ADDR size, pv_t value)
 151 {
 152   struct rx_prologue *result = (struct rx_prologue *) result_untyped;
 153
 154   if (value.kind == pvk_register
 155       && value.k == 0
 156       && pv_is_register (addr, RX_SP_REGNUM)
 157       && size == register_size (target_gdbarch, value.reg))
 158     result->reg_offset[value.reg] = addr.k;
 159 }
 160
 161 /* Define a "handle" struct for fetching the next opcode.  */
 162 struct rx_get_opcode_byte_handle
 163 {
 164   CORE_ADDR pc;
 165 };
 166
 167 /* Fetch a byte on behalf of the opcode decoder.  HANDLE contains
 168    the memory address of the next byte to fetch.  If successful,
 169    the address in the handle is updated and the byte fetched is
 170    returned as the value of the function.  If not successful, -1
 171    is returned.  */
 172 static int
 173 rx_get_opcode_byte (void *handle)
 174 {
 175   struct rx_get_opcode_byte_handle *opcdata = handle;
 176   int status;
 177   gdb_byte byte;
 178
 179   status = target_read_memory (opcdata->pc, &byte, 1);
 180   if (status == 0)
 181     {
 182       opcdata->pc += 1;
 183       return byte;
 184     }
 185   else
 186     return -1;
 187 }
 188
 189 /* Analyze a prologue starting at START_PC, going no further than
 190    LIMIT_PC.  Fill in RESULT as appropriate.  */
 191 static void
 192 rx_analyze_prologue (CORE_ADDR start_pc,
 193                      CORE_ADDR limit_pc, struct rx_prologue *result)
 194 {
 195   CORE_ADDR pc, next_pc;
 196   int rn;
 197   pv_t reg[RX_NUM_REGS];
 198   struct pv_area *stack;
 199   struct cleanup *back_to;
 200   CORE_ADDR after_last_frame_setup_insn = start_pc;
 201
 202   memset (result, 0, sizeof (*result));
 203
 204   for (rn = 0; rn < RX_NUM_REGS; rn++)
 205     {
 206       reg[rn] = pv_register (rn, 0);
 207       result->reg_offset[rn] = 1;
 208     }
 209
 210   stack = make_pv_area (RX_SP_REGNUM, gdbarch_addr_bit (target_gdbarch));
 211   back_to = make_cleanup_free_pv_area (stack);
 212
 213   /* The call instruction has saved the return address on the stack.  */
 214   reg[RX_SP_REGNUM] = pv_add_constant (reg[RX_SP_REGNUM], -4);
 215   pv_area_store (stack, reg[RX_SP_REGNUM], 4, reg[RX_PC_REGNUM]);
 216
 217   pc = start_pc;
 218   while (pc < limit_pc)
 219     {
 220       int bytes_read;
 221       struct rx_get_opcode_byte_handle opcode_handle;
 222       RX_Opcode_Decoded opc;
 223
 224       opcode_handle.pc = pc;
 225       bytes_read = rx_decode_opcode (pc, &opc, rx_get_opcode_byte,
 226                                      &opcode_handle);
 227       next_pc = pc + bytes_read;
 228
 229       if (opc.id == RXO_pushm   /* pushm r1, r2 */
 230           && opc.op[1].type == RX_Operand_Register
 231           && opc.op[2].type == RX_Operand_Register)
 232         {
 233           int r1, r2;
 234           int r;
 235
 236           r1 = opc.op[1].reg;
 237           r2 = opc.op[2].reg;
 238           for (r = r2; r >= r1; r--)
 239             {
 240               reg[RX_SP_REGNUM] = pv_add_constant (reg[RX_SP_REGNUM], -4);
 241               pv_area_store (stack, reg[RX_SP_REGNUM], 4, reg[r]);
 242             }
 243           after_last_frame_setup_insn = next_pc;
 244         }
 245       else if (opc.id == RXO_mov        /* mov.l rdst, rsrc */
 246                && opc.op[0].type == RX_Operand_Register
 247                && opc.op[1].type == RX_Operand_Register
 248                && opc.size == RX_Long)
 249         {
 250           int rdst, rsrc;
 251
 252           rdst = opc.op[0].reg;
 253           rsrc = opc.op[1].reg;
 254           reg[rdst] = reg[rsrc];
 255           if (rdst == RX_FP_REGNUM && rsrc == RX_SP_REGNUM)
 256             after_last_frame_setup_insn = next_pc;
 257         }
 258       else if (opc.id == RXO_mov        /* mov.l rsrc, [-SP] */
 259                && opc.op[0].type == RX_Operand_Predec
 260                && opc.op[0].reg == RX_SP_REGNUM
 261                && opc.op[1].type == RX_Operand_Register
 262                && opc.size == RX_Long)
 263         {
 264           int rsrc;
 265
 266           rsrc = opc.op[1].reg;
 267           reg[RX_SP_REGNUM] = pv_add_constant (reg[RX_SP_REGNUM], -4);
 268           pv_area_store (stack, reg[RX_SP_REGNUM], 4, reg[rsrc]);
 269           after_last_frame_setup_insn = next_pc;
 270         }
 271       else if (opc.id == RXO_add        /* add #const, rsrc, rdst */
 272                && opc.op[0].type == RX_Operand_Register
 273                && opc.op[1].type == RX_Operand_Immediate
 274                && opc.op[2].type == RX_Operand_Register)
 275         {
 276           int rdst = opc.op[0].reg;
 277           int addend = opc.op[1].addend;
 278           int rsrc = opc.op[2].reg;
 279           reg[rdst] = pv_add_constant (reg[rsrc], addend);
 280           /* Negative adjustments to the stack pointer or frame pointer
 281              are (most likely) part of the prologue.  */
 282           if ((rdst == RX_SP_REGNUM || rdst == RX_FP_REGNUM) && addend < 0)
 283             after_last_frame_setup_insn = next_pc;
 284         }
 285       else if (opc.id == RXO_mov
 286                && opc.op[0].type == RX_Operand_Indirect
 287                && opc.op[1].type == RX_Operand_Register
 288                && opc.size == RX_Long
 289                && (opc.op[0].reg == RX_SP_REGNUM
 290                    || opc.op[0].reg == RX_FP_REGNUM)
 291                && (RX_R1_REGNUM <= opc.op[1].reg
 292                    && opc.op[1].reg <= RX_R4_REGNUM))
 293         {
 294           /* This moves an argument register to the stack.  Don't
 295              record it, but allow it to be a part of the prologue.  */
 296         }
 297       else if (opc.id == RXO_branch
 298                && opc.op[0].type == RX_Operand_Immediate
 299                && opc.op[1].type == RX_Operand_Condition
 300                && next_pc < opc.op[0].addend)
 301         {
 302           /* When a loop appears as the first statement of a function
 303              body, gcc 4.x will use a BRA instruction to branch to the
 304              loop condition checking code.  This BRA instruction is
 305              marked as part of the prologue.  We therefore set next_pc
 306              to this branch target and also stop the prologue scan.
 307              The instructions at and beyond the branch target should
 308              no longer be associated with the prologue.
 309
 310              Note that we only consider forward branches here.  We
 311              presume that a forward branch is being used to skip over
 312              a loop body.
 313
 314              A backwards branch is covered by the default case below.
 315              If we were to encounter a backwards branch, that would
 316              most likely mean that we've scanned through a loop body.
 317              We definitely want to stop the prologue scan when this
 318              happens and that is precisely what is done by the default
 319              case below.  */
 320
 321           after_last_frame_setup_insn = opc.op[0].addend;
 322           break;                /* Scan no further if we hit this case.  */
 323         }
 324       else
 325         {
 326           /* Terminate the prologue scan.  */
 327           break;
 328         }
 329
 330       pc = next_pc;
 331     }
 332
 333   /* Is the frame size (offset, really) a known constant?  */
 334   if (pv_is_register (reg[RX_SP_REGNUM], RX_SP_REGNUM))
 335     result->frame_size = reg[RX_SP_REGNUM].k;
 336
 337   /* Was the frame pointer initialized?  */
 338   if (pv_is_register (reg[RX_FP_REGNUM], RX_SP_REGNUM))
 339     {
 340       result->has_frame_ptr = 1;
 341       result->frame_ptr_offset = reg[RX_FP_REGNUM].k;
 342     }
 343
 344   /* Record where all the registers were saved.  */
 345   pv_area_scan (stack, check_for_saved, (void *) result);
 346
 347   result->prologue_end = after_last_frame_setup_insn;
 348
 349   do_cleanups (back_to);
 350 }
 351
 352
 353 /* Implement the "skip_prologue" gdbarch method.  */
 354 static CORE_ADDR
 355 rx_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
 356 {
 357   char *name;
 358   CORE_ADDR func_addr, func_end;
 359   struct rx_prologue p;
 360
 361   /* Try to find the extent of the function that contains PC.  */
 362   if (!find_pc_partial_function (pc, &name, &func_addr, &func_end))
 363     return pc;
 364
 365   rx_analyze_prologue (pc, func_end, &p);
 366   return p.prologue_end;
 367 }
 368
 369 /* Given a frame described by THIS_FRAME, decode the prologue of its
 370    associated function if there is not cache entry as specified by
 371    THIS_PROLOGUE_CACHE.  Save the decoded prologue in the cache and
 372    return that struct as the value of this function.  */
 373 static struct rx_prologue *
 374 rx_analyze_frame_prologue (struct frame_info *this_frame,
 375                            void **this_prologue_cache)
 376 {
 377   if (!*this_prologue_cache)
 378     {
 379       CORE_ADDR func_start, stop_addr;
 380
 381       *this_prologue_cache = FRAME_OBSTACK_ZALLOC (struct rx_prologue);
 382
 383       func_start = get_frame_func (this_frame);
 384       stop_addr = get_frame_pc (this_frame);
 385
 386       /* If we couldn't find any function containing the PC, then
 387          just initialize the prologue cache, but don't do anything.  */
 388       if (!func_start)
 389         stop_addr = func_start;
 390
 391       rx_analyze_prologue (func_start, stop_addr, *this_prologue_cache);
 392     }
 393
 394   return *this_prologue_cache;
 395 }
 396
 397 /* Given the next frame and a prologue cache, return this frame's
 398    base.  */
 399 static CORE_ADDR
 400 rx_frame_base (struct frame_info *this_frame, void **this_prologue_cache)
 401 {
 402   struct rx_prologue *p
 403     = rx_analyze_frame_prologue (this_frame, this_prologue_cache);
 404
 405   /* In functions that use alloca, the distance between the stack
 406      pointer and the frame base varies dynamically, so we can't use
 407      the SP plus static information like prologue analysis to find the
 408      frame base.  However, such functions must have a frame pointer,
 409      to be able to restore the SP on exit.  So whenever we do have a
 410      frame pointer, use that to find the base.  */
 411   if (p->has_frame_ptr)
 412     {
 413       CORE_ADDR fp = get_frame_register_unsigned (this_frame, RX_FP_REGNUM);
 414       return fp - p->frame_ptr_offset;
 415     }
 416   else
 417     {
 418       CORE_ADDR sp = get_frame_register_unsigned (this_frame, RX_SP_REGNUM);
 419       return sp - p->frame_size;
 420     }
 421 }
 422
 423 /* Implement the "frame_this_id" method for unwinding frames.  */
 424 static void
 425 rx_frame_this_id (struct frame_info *this_frame,
 426                   void **this_prologue_cache, struct frame_id *this_id)
 427 {
 428   *this_id = frame_id_build (rx_frame_base (this_frame, this_prologue_cache),
 429                              get_frame_func (this_frame));
 430 }
 431
 432 /* Implement the "frame_prev_register" method for unwinding frames.  */
 433 static struct value *
 434 rx_frame_prev_register (struct frame_info *this_frame,
 435                         void **this_prologue_cache, int regnum)
 436 {
 437   struct rx_prologue *p
 438     = rx_analyze_frame_prologue (this_frame, this_prologue_cache);
 439   CORE_ADDR frame_base = rx_frame_base (this_frame, this_prologue_cache);
 440   int reg_size = register_size (get_frame_arch (this_frame), regnum);
 441
 442   if (regnum == RX_SP_REGNUM)
 443     return frame_unwind_got_constant (this_frame, regnum, frame_base);
 444
 445   /* If prologue analysis says we saved this register somewhere,
 446      return a description of the stack slot holding it.  */
 447   else if (p->reg_offset[regnum] != 1)
 448     return frame_unwind_got_memory (this_frame, regnum,
 449                                     frame_base + p->reg_offset[regnum]);
 450
 451   /* Otherwise, presume we haven't changed the value of this
 452      register, and get it from the next frame.  */
 453   else
 454     return frame_unwind_got_register (this_frame, regnum, regnum);
 455 }
 456
 457 static const struct frame_unwind rx_frame_unwind = {
 458   NORMAL_FRAME,
 459   rx_frame_this_id,
 460   rx_frame_prev_register,
 461   NULL,
 462   default_frame_sniffer
 463 };
 464
 465 /* Implement the "unwind_pc" gdbarch method.  */
 466 static CORE_ADDR
 467 rx_unwind_pc (struct gdbarch *gdbarch, struct frame_info *this_frame)
 468 {
 469   ULONGEST pc;
 470
 471   pc = frame_unwind_register_unsigned (this_frame, RX_PC_REGNUM);
 472   return pc;
 473 }
 474
 475 /* Implement the "unwind_sp" gdbarch method.  */
 476 static CORE_ADDR
 477 rx_unwind_sp (struct gdbarch *gdbarch, struct frame_info *this_frame)
 478 {
 479   ULONGEST sp;
 480
 481   sp = frame_unwind_register_unsigned (this_frame, RX_SP_REGNUM);
 482   return sp;
 483 }
 484
 485 /* Implement the "dummy_id" gdbarch method.  */
 486 static struct frame_id
 487 rx_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
 488 {
 489   return
 490     frame_id_build (get_frame_register_unsigned (this_frame, RX_SP_REGNUM),
 491                     get_frame_pc (this_frame));
 492 }
 493
 494 /* Implement the "push_dummy_call" gdbarch method.  */
 495 static CORE_ADDR
 496 rx_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 497                     struct regcache *regcache, CORE_ADDR bp_addr, int nargs,
 498                     struct value **args, CORE_ADDR sp, int struct_return,
 499                     CORE_ADDR struct_addr)
 500 {
 501   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 502   int write_pass;
 503   int sp_off = 0;
 504   CORE_ADDR cfa;
 505   int num_register_candidate_args;
 506
 507   struct type *func_type = value_type (function);
 508
 509   /* Dereference function pointer types.  */
 510   while (TYPE_CODE (func_type) == TYPE_CODE_PTR)
 511     func_type = TYPE_TARGET_TYPE (func_type);
 512
 513   /* The end result had better be a function or a method.  */
 514   gdb_assert (TYPE_CODE (func_type) == TYPE_CODE_FUNC
 515               || TYPE_CODE (func_type) == TYPE_CODE_METHOD);
 516
 517   /* Functions with a variable number of arguments have all of their
 518      variable arguments and the last non-variable argument passed
 519      on the stack.
 520
 521      Otherwise, we can pass up to four arguments on the stack.
 522
 523      Once computed, we leave this value alone.  I.e. we don't update
 524      it in case of a struct return going in a register or an argument
 525      requiring multiple registers, etc.  We rely instead on the value
 526      of the ``arg_reg'' variable to get these other details correct.  */
 527
 528   if (TYPE_VARARGS (func_type))
 529     num_register_candidate_args = TYPE_NFIELDS (func_type) - 1;
 530   else
 531     num_register_candidate_args = 4;
 532
 533   /* We make two passes; the first does the stack allocation,
 534      the second actually stores the arguments.  */
 535   for (write_pass = 0; write_pass <= 1; write_pass++)
 536     {
 537       int i;
 538       int arg_reg = RX_R1_REGNUM;
 539
 540       if (write_pass)
 541         sp = align_down (sp - sp_off, 4);
 542       sp_off = 0;
 543
 544       if (struct_return)
 545         {
 546           struct type *return_type = TYPE_TARGET_TYPE (func_type);
 547
 548           gdb_assert (TYPE_CODE (return_type) == TYPE_CODE_STRUCT
 549                       || TYPE_CODE (func_type) == TYPE_CODE_UNION);
 550
 551           if (TYPE_LENGTH (return_type) > 16
 552               || TYPE_LENGTH (return_type) % 4 != 0)
 553             {
 554               if (write_pass)
 555                 regcache_cooked_write_unsigned (regcache, RX_R15_REGNUM,
 556                                                 struct_addr);
 557             }
 558         }
 559
 560       /* Push the arguments.  */
 561       for (i = 0; i < nargs; i++)
 562         {
 563           struct value *arg = args[i];
 564           const gdb_byte *arg_bits = value_contents_all (arg);
 565           struct type *arg_type = check_typedef (value_type (arg));
 566           ULONGEST arg_size = TYPE_LENGTH (arg_type);
 567
 568           if (i == 0 && struct_addr != 0 && !struct_return
 569               && TYPE_CODE (arg_type) == TYPE_CODE_PTR
 570               && extract_unsigned_integer (arg_bits, 4,
 571                                            byte_order) == struct_addr)
 572             {
 573               /* This argument represents the address at which C++ (and
 574                  possibly other languages) store their return value.
 575                  Put this value in R15.  */
 576               if (write_pass)
 577                 regcache_cooked_write_unsigned (regcache, RX_R15_REGNUM,
 578                                                 struct_addr);
 579             }
 580           else if (TYPE_CODE (arg_type) != TYPE_CODE_STRUCT
 581                    && TYPE_CODE (arg_type) != TYPE_CODE_UNION)
 582             {
 583               /* Argument is a scalar.  */
 584               if (arg_size == 8)
 585                 {
 586                   if (i < num_register_candidate_args
 587                       && arg_reg <= RX_R4_REGNUM - 1)
 588                     {
 589                       /* If argument registers are going to be used to pass
 590                          an 8 byte scalar, the ABI specifies that two registers
 591                          must be available.  */
 592                       if (write_pass)
 593                         {
 594                           regcache_cooked_write_unsigned (regcache, arg_reg,
 595                                                           extract_unsigned_integer
 596                                                           (arg_bits, 4,
 597                                                            byte_order));
 598                           regcache_cooked_write_unsigned (regcache,
 599                                                           arg_reg + 1,
 600                                                           extract_unsigned_integer
 601                                                           (arg_bits + 4, 4,
 602                                                            byte_order));
 603                         }
 604                       arg_reg += 2;
 605                     }
 606                   else
 607                     {
 608                       sp_off = align_up (sp_off, 4);
 609                       /* Otherwise, pass the 8 byte scalar on the stack.  */
 610                       if (write_pass)
 611                         write_memory (sp + sp_off, arg_bits, 8);
 612                       sp_off += 8;
 613                     }
 614                 }
 615               else
 616                 {
 617                   ULONGEST u;
 618
 619                   gdb_assert (arg_size <= 4);
 620
 621                   u =
 622                     extract_unsigned_integer (arg_bits, arg_size, byte_order);
 623
 624                   if (i < num_register_candidate_args
 625                       && arg_reg <= RX_R4_REGNUM)
 626                     {
 627                       if (write_pass)
 628                         regcache_cooked_write_unsigned (regcache, arg_reg, u);
 629                       arg_reg += 1;
 630                     }
 631                   else
 632                     {
 633                       int p_arg_size = 4;
 634
 635                       if (TYPE_PROTOTYPED (func_type)
 636                           && i < TYPE_NFIELDS (func_type))
 637                         {
 638                           struct type *p_arg_type =
 639                             TYPE_FIELD_TYPE (func_type, i);
 640                           p_arg_size = TYPE_LENGTH (p_arg_type);
 641                         }
 642
 643                       sp_off = align_up (sp_off, p_arg_size);
 644
 645                       if (write_pass)
 646                         write_memory_unsigned_integer (sp + sp_off,
 647                                                        p_arg_size, byte_order,
 648                                                        u);
 649                       sp_off += p_arg_size;
 650                     }
 651                 }
 652             }
 653           else
 654             {
 655               /* Argument is a struct or union.  Pass as much of the struct
 656                  in registers, if possible.  Pass the rest on the stack.  */
 657               while (arg_size > 0)
 658                 {
 659                   if (i < num_register_candidate_args
 660                       && arg_reg <= RX_R4_REGNUM
 661                       && arg_size <= 4 * (RX_R4_REGNUM - arg_reg + 1)
 662                       && arg_size % 4 == 0)
 663                     {
 664                       int len = min (arg_size, 4);
 665
 666                       if (write_pass)
 667                         regcache_cooked_write_unsigned (regcache, arg_reg,
 668                                                         extract_unsigned_integer
 669                                                         (arg_bits, len,
 670                                                          byte_order));
 671                       arg_bits += len;
 672                       arg_size -= len;
 673                       arg_reg++;
 674                     }
 675                   else
 676                     {
 677                       sp_off = align_up (sp_off, 4);
 678                       if (write_pass)
 679                         write_memory (sp + sp_off, arg_bits, arg_size);
 680                       sp_off += align_up (arg_size, 4);
 681                       arg_size = 0;
 682                     }
 683                 }
 684             }
 685         }
 686     }
 687
 688   /* Keep track of the stack address prior to pushing the return address.
 689      This is the value that we'll return.  */
 690   cfa = sp;
 691
 692   /* Push the return address.  */
 693   sp = sp - 4;
 694   write_memory_unsigned_integer (sp, 4, byte_order, bp_addr);
 695
 696   /* Update the stack pointer.  */
 697   regcache_cooked_write_unsigned (regcache, RX_SP_REGNUM, sp);
 698
 699   return cfa;
 700 }
 701
 702 /* Implement the "return_value" gdbarch method.  */
 703 static enum return_value_convention
 704 rx_return_value (struct gdbarch *gdbarch,
 705                  struct type *func_type,
 706                  struct type *valtype,
 707                  struct regcache *regcache,
 708                  gdb_byte *readbuf, const gdb_byte *writebuf)
 709 {
 710   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 711   ULONGEST valtype_len = TYPE_LENGTH (valtype);
 712
 713   if (TYPE_LENGTH (valtype) > 16
 714       || ((TYPE_CODE (valtype) == TYPE_CODE_STRUCT
 715            || TYPE_CODE (valtype) == TYPE_CODE_UNION)
 716           && TYPE_LENGTH (valtype) % 4 != 0))
 717     return RETURN_VALUE_STRUCT_CONVENTION;
 718
 719   if (readbuf)
 720     {
 721       ULONGEST u;
 722       int argreg = RX_R1_REGNUM;
 723       int offset = 0;
 724
 725       while (valtype_len > 0)
 726         {
 727           int len = min (valtype_len, 4);
 728
 729           regcache_cooked_read_unsigned (regcache, argreg, &u);
 730           store_unsigned_integer (readbuf + offset, len, byte_order, u);
 731           valtype_len -= len;
 732           offset += len;
 733           argreg++;
 734         }
 735     }
 736
 737   if (writebuf)
 738     {
 739       ULONGEST u;
 740       int argreg = RX_R1_REGNUM;
 741       int offset = 0;
 742
 743       while (valtype_len > 0)
 744         {
 745           int len = min (valtype_len, 4);
 746
 747           u = extract_unsigned_integer (writebuf + offset, len, byte_order);
 748           regcache_cooked_write_unsigned (regcache, argreg, u);
 749           valtype_len -= len;
 750           offset += len;
 751           argreg++;
 752         }
 753     }
 754
 755   return RETURN_VALUE_REGISTER_CONVENTION;
 756 }
 757
 758 /* Implement the "breakpoint_from_pc" gdbarch method.  */
 759 const gdb_byte *
 760 rx_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *lenptr)
 761 {
 762   static gdb_byte breakpoint[] = { 0x00 };
 763   *lenptr = sizeof breakpoint;
 764   return breakpoint;
 765 }
 766
 767 /* Allocate and initialize a gdbarch object.  */
 768 static struct gdbarch *
 769 rx_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
 770 {
 771   struct gdbarch *gdbarch;
 772   struct gdbarch_tdep *tdep;
 773   int elf_flags;
 774
 775   /* Extract the elf_flags if available.  */
 776   if (info.abfd != NULL
 777       && bfd_get_flavour (info.abfd) == bfd_target_elf_flavour)
 778     elf_flags = elf_elfheader (info.abfd)->e_flags;
 779   else
 780     elf_flags = 0;
 781
 782
 783   /* Try to find the architecture in the list of already defined
 784      architectures.  */
 785   for (arches = gdbarch_list_lookup_by_info (arches, &info);
 786        arches != NULL;
 787        arches = gdbarch_list_lookup_by_info (arches->next, &info))
 788     {
 789       if (gdbarch_tdep (arches->gdbarch)->elf_flags != elf_flags)
 790         continue;
 791
 792       return arches->gdbarch;
 793     }
 794
 795   /* None found, create a new architecture from the information
 796      provided.  */
 797   tdep = (struct gdbarch_tdep *) xmalloc (sizeof (struct gdbarch_tdep));
 798   gdbarch = gdbarch_alloc (&info, tdep);
 799   tdep->elf_flags = elf_flags;
 800
 801   set_gdbarch_num_regs (gdbarch, RX_NUM_REGS);
 802   set_gdbarch_num_pseudo_regs (gdbarch, 0);
 803   set_gdbarch_register_name (gdbarch, rx_register_name);
 804   set_gdbarch_register_type (gdbarch, rx_register_type);
 805   set_gdbarch_pc_regnum (gdbarch, RX_PC_REGNUM);
 806   set_gdbarch_sp_regnum (gdbarch, RX_SP_REGNUM);
 807   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
 808   set_gdbarch_decr_pc_after_break (gdbarch, 1);
 809   set_gdbarch_breakpoint_from_pc (gdbarch, rx_breakpoint_from_pc);
 810   set_gdbarch_skip_prologue (gdbarch, rx_skip_prologue);
 811
 812   set_gdbarch_print_insn (gdbarch, print_insn_rx);
 813
 814   set_gdbarch_unwind_pc (gdbarch, rx_unwind_pc);
 815   set_gdbarch_unwind_sp (gdbarch, rx_unwind_sp);
 816
 817   /* Target builtin data types.  */
 818   set_gdbarch_char_signed (gdbarch, 0);
 819   set_gdbarch_short_bit (gdbarch, 16);
 820   set_gdbarch_int_bit (gdbarch, 32);
 821   set_gdbarch_long_bit (gdbarch, 32);
 822   set_gdbarch_long_long_bit (gdbarch, 64);
 823   set_gdbarch_ptr_bit (gdbarch, 32);
 824   set_gdbarch_float_bit (gdbarch, 32);
 825   set_gdbarch_float_format (gdbarch, floatformats_ieee_single);
 826   if (elf_flags & E_FLAG_RX_64BIT_DOUBLES)
 827     {
 828       set_gdbarch_double_bit (gdbarch, 64);
 829       set_gdbarch_long_double_bit (gdbarch, 64);
 830       set_gdbarch_double_format (gdbarch, floatformats_ieee_double);
 831       set_gdbarch_long_double_format (gdbarch, floatformats_ieee_double);
 832     }
 833   else
 834     {
 835       set_gdbarch_double_bit (gdbarch, 32);
 836       set_gdbarch_long_double_bit (gdbarch, 32);
 837       set_gdbarch_double_format (gdbarch, floatformats_ieee_single);
 838       set_gdbarch_long_double_format (gdbarch, floatformats_ieee_single);
 839     }
 840
 841   /* Frame unwinding.  */
 842 #if 0
 843   /* Note: The test results are better with the dwarf2 unwinder disabled,
 844      so it's turned off for now.  */
 845   dwarf2_append_unwinders (gdbarch);
 846 #endif
 847   frame_unwind_append_unwinder (gdbarch, &rx_frame_unwind);
 848
 849   /* Methods for saving / extracting a dummy frame's ID.
 850      The ID's stack address must match the SP value returned by
 851      PUSH_DUMMY_CALL, and saved by generic_save_dummy_frame_tos.  */
 852   set_gdbarch_dummy_id (gdbarch, rx_dummy_id);
 853   set_gdbarch_push_dummy_call (gdbarch, rx_push_dummy_call);
 854   set_gdbarch_return_value (gdbarch, rx_return_value);
 855
 856   /* Virtual tables.  */
 857   set_gdbarch_vbit_in_delta (gdbarch, 1);
 858
 859   return gdbarch;
 860 }
 861
 862 /* Register the above initialization routine.  */
 863 void
 864 _initialize_rx_tdep (void)
 865 {
 866   register_gdbarch_init (bfd_arch_rx, rx_gdbarch_init);
 867 }