gdb/rx-tdep.c

   1 /* Target-dependent code for the Renesas RX for GDB, the GNU debugger.
   2
   3    Copyright (C) 2008, 2009, 2010, 2011 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                && next_pc < opc.op[0].addend)
 300         {
 301           /* When a loop appears as the first statement of a function
 302              body, gcc 4.x will use a BRA instruction to branch to the
 303              loop condition checking code.  This BRA instruction is
 304              marked as part of the prologue.  We therefore set next_pc
 305              to this branch target and also stop the prologue scan.
 306              The instructions at and beyond the branch target should
 307              no longer be associated with the prologue.
 308
 309              Note that we only consider forward branches here.  We
 310              presume that a forward branch is being used to skip over
 311              a loop body.
 312
 313              A backwards branch is covered by the default case below.
 314              If we were to encounter a backwards branch, that would
 315              most likely mean that we've scanned through a loop body.
 316              We definitely want to stop the prologue scan when this
 317              happens and that is precisely what is done by the default
 318              case below.  */
 319
 320           after_last_frame_setup_insn = opc.op[0].addend;
 321           break;                /* Scan no further if we hit this case.  */
 322         }
 323       else
 324         {
 325           /* Terminate the prologue scan.  */
 326           break;
 327         }
 328
 329       pc = next_pc;
 330     }
 331
 332   /* Is the frame size (offset, really) a known constant?  */
 333   if (pv_is_register (reg[RX_SP_REGNUM], RX_SP_REGNUM))
 334     result->frame_size = reg[RX_SP_REGNUM].k;
 335
 336   /* Was the frame pointer initialized?  */
 337   if (pv_is_register (reg[RX_FP_REGNUM], RX_SP_REGNUM))
 338     {
 339       result->has_frame_ptr = 1;
 340       result->frame_ptr_offset = reg[RX_FP_REGNUM].k;
 341     }
 342
 343   /* Record where all the registers were saved.  */
 344   pv_area_scan (stack, check_for_saved, (void *) result);
 345
 346   result->prologue_end = after_last_frame_setup_insn;
 347
 348   do_cleanups (back_to);
 349 }
 350
 351
 352 /* Implement the "skip_prologue" gdbarch method.  */
 353 static CORE_ADDR
 354 rx_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
 355 {
 356   char *name;
 357   CORE_ADDR func_addr, func_end;
 358   struct rx_prologue p;
 359
 360   /* Try to find the extent of the function that contains PC.  */
 361   if (!find_pc_partial_function (pc, &name, &func_addr, &func_end))
 362     return pc;
 363
 364   rx_analyze_prologue (pc, func_end, &p);
 365   return p.prologue_end;
 366 }
 367
 368 /* Given a frame described by THIS_FRAME, decode the prologue of its
 369    associated function if there is not cache entry as specified by
 370    THIS_PROLOGUE_CACHE.  Save the decoded prologue in the cache and
 371    return that struct as the value of this function.  */
 372 static struct rx_prologue *
 373 rx_analyze_frame_prologue (struct frame_info *this_frame,
 374                            void **this_prologue_cache)
 375 {
 376   if (!*this_prologue_cache)
 377     {
 378       CORE_ADDR func_start, stop_addr;
 379
 380       *this_prologue_cache = FRAME_OBSTACK_ZALLOC (struct rx_prologue);
 381
 382       func_start = get_frame_func (this_frame);
 383       stop_addr = get_frame_pc (this_frame);
 384
 385       /* If we couldn't find any function containing the PC, then
 386          just initialize the prologue cache, but don't do anything.  */
 387       if (!func_start)
 388         stop_addr = func_start;
 389
 390       rx_analyze_prologue (func_start, stop_addr, *this_prologue_cache);
 391     }
 392
 393   return *this_prologue_cache;
 394 }
 395
 396 /* Given the next frame and a prologue cache, return this frame's
 397    base.  */
 398 static CORE_ADDR
 399 rx_frame_base (struct frame_info *this_frame, void **this_prologue_cache)
 400 {
 401   struct rx_prologue *p
 402     = rx_analyze_frame_prologue (this_frame, this_prologue_cache);
 403
 404   /* In functions that use alloca, the distance between the stack
 405      pointer and the frame base varies dynamically, so we can't use
 406      the SP plus static information like prologue analysis to find the
 407      frame base.  However, such functions must have a frame pointer,
 408      to be able to restore the SP on exit.  So whenever we do have a
 409      frame pointer, use that to find the base.  */
 410   if (p->has_frame_ptr)
 411     {
 412       CORE_ADDR fp = get_frame_register_unsigned (this_frame, RX_FP_REGNUM);
 413       return fp - p->frame_ptr_offset;
 414     }
 415   else
 416     {
 417       CORE_ADDR sp = get_frame_register_unsigned (this_frame, RX_SP_REGNUM);
 418       return sp - p->frame_size;
 419     }
 420 }
 421
 422 /* Implement the "frame_this_id" method for unwinding frames.  */
 423 static void
 424 rx_frame_this_id (struct frame_info *this_frame,
 425                   void **this_prologue_cache, struct frame_id *this_id)
 426 {
 427   *this_id = frame_id_build (rx_frame_base (this_frame, this_prologue_cache),
 428                              get_frame_func (this_frame));
 429 }
 430
 431 /* Implement the "frame_prev_register" method for unwinding frames.  */
 432 static struct value *
 433 rx_frame_prev_register (struct frame_info *this_frame,
 434                         void **this_prologue_cache, int regnum)
 435 {
 436   struct rx_prologue *p
 437     = rx_analyze_frame_prologue (this_frame, this_prologue_cache);
 438   CORE_ADDR frame_base = rx_frame_base (this_frame, this_prologue_cache);
 439   int reg_size = register_size (get_frame_arch (this_frame), regnum);
 440
 441   if (regnum == RX_SP_REGNUM)
 442     return frame_unwind_got_constant (this_frame, regnum, frame_base);
 443
 444   /* If prologue analysis says we saved this register somewhere,
 445      return a description of the stack slot holding it.  */
 446   else if (p->reg_offset[regnum] != 1)
 447     return frame_unwind_got_memory (this_frame, regnum,
 448                                     frame_base + p->reg_offset[regnum]);
 449
 450   /* Otherwise, presume we haven't changed the value of this
 451      register, and get it from the next frame.  */
 452   else
 453     return frame_unwind_got_register (this_frame, regnum, regnum);
 454 }
 455
 456 static const struct frame_unwind rx_frame_unwind = {
 457   NORMAL_FRAME,
 458   rx_frame_this_id,
 459   rx_frame_prev_register,
 460   NULL,
 461   default_frame_sniffer
 462 };
 463
 464 /* Implement the "unwind_pc" gdbarch method.  */
 465 static CORE_ADDR
 466 rx_unwind_pc (struct gdbarch *gdbarch, struct frame_info *this_frame)
 467 {
 468   ULONGEST pc;
 469
 470   pc = frame_unwind_register_unsigned (this_frame, RX_PC_REGNUM);
 471   return pc;
 472 }
 473
 474 /* Implement the "unwind_sp" gdbarch method.  */
 475 static CORE_ADDR
 476 rx_unwind_sp (struct gdbarch *gdbarch, struct frame_info *this_frame)
 477 {
 478   ULONGEST sp;
 479
 480   sp = frame_unwind_register_unsigned (this_frame, RX_SP_REGNUM);
 481   return sp;
 482 }
 483
 484 /* Implement the "dummy_id" gdbarch method.  */
 485 static struct frame_id
 486 rx_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
 487 {
 488   return
 489     frame_id_build (get_frame_register_unsigned (this_frame, RX_SP_REGNUM),
 490                     get_frame_pc (this_frame));
 491 }
 492
 493 /* Implement the "push_dummy_call" gdbarch method.  */
 494 static CORE_ADDR
 495 rx_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 496                     struct regcache *regcache, CORE_ADDR bp_addr, int nargs,
 497                     struct value **args, CORE_ADDR sp, int struct_return,
 498                     CORE_ADDR struct_addr)
 499 {
 500   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 501   int write_pass;
 502   int sp_off = 0;
 503   CORE_ADDR cfa;
 504   int num_register_candidate_args;
 505
 506   struct type *func_type = value_type (function);
 507
 508   /* Dereference function pointer types.  */
 509   while (TYPE_CODE (func_type) == TYPE_CODE_PTR)
 510     func_type = TYPE_TARGET_TYPE (func_type);
 511
 512   /* The end result had better be a function or a method.  */
 513   gdb_assert (TYPE_CODE (func_type) == TYPE_CODE_FUNC
 514               || TYPE_CODE (func_type) == TYPE_CODE_METHOD);
 515
 516   /* Functions with a variable number of arguments have all of their
 517      variable arguments and the last non-variable argument passed
 518      on the stack.
 519
 520      Otherwise, we can pass up to four arguments on the stack.
 521
 522      Once computed, we leave this value alone.  I.e. we don't update
 523      it in case of a struct return going in a register or an argument
 524      requiring multiple registers, etc.  We rely instead on the value
 525      of the ``arg_reg'' variable to get these other details correct.  */
 526
 527   if (TYPE_VARARGS (func_type))
 528     num_register_candidate_args = TYPE_NFIELDS (func_type) - 1;
 529   else
 530     num_register_candidate_args = 4;
 531
 532   /* We make two passes; the first does the stack allocation,
 533      the second actually stores the arguments.  */
 534   for (write_pass = 0; write_pass <= 1; write_pass++)
 535     {
 536       int i;
 537       int arg_reg = RX_R1_REGNUM;
 538
 539       if (write_pass)
 540         sp = align_down (sp - sp_off, 4);
 541       sp_off = 0;
 542
 543       if (struct_return)
 544         {
 545           struct type *return_type = TYPE_TARGET_TYPE (func_type);
 546
 547           gdb_assert (TYPE_CODE (return_type) == TYPE_CODE_STRUCT
 548                       || TYPE_CODE (func_type) == TYPE_CODE_UNION);
 549
 550           if (TYPE_LENGTH (return_type) > 16
 551               || TYPE_LENGTH (return_type) % 4 != 0)
 552             {
 553               if (write_pass)
 554                 regcache_cooked_write_unsigned (regcache, RX_R15_REGNUM,
 555                                                 struct_addr);
 556             }
 557         }
 558
 559       /* Push the arguments.  */
 560       for (i = 0; i < nargs; i++)
 561         {
 562           struct value *arg = args[i];
 563           const gdb_byte *arg_bits = value_contents_all (arg);
 564           struct type *arg_type = check_typedef (value_type (arg));
 565           ULONGEST arg_size = TYPE_LENGTH (arg_type);
 566
 567           if (i == 0 && struct_addr != 0 && !struct_return
 568               && TYPE_CODE (arg_type) == TYPE_CODE_PTR
 569               && extract_unsigned_integer (arg_bits, 4,
 570                                            byte_order) == struct_addr)
 571             {
 572               /* This argument represents the address at which C++ (and
 573                  possibly other languages) store their return value.
 574                  Put this value in R15.  */
 575               if (write_pass)
 576                 regcache_cooked_write_unsigned (regcache, RX_R15_REGNUM,
 577                                                 struct_addr);
 578             }
 579           else if (TYPE_CODE (arg_type) != TYPE_CODE_STRUCT
 580                    && TYPE_CODE (arg_type) != TYPE_CODE_UNION)
 581             {
 582               /* Argument is a scalar.  */
 583               if (arg_size == 8)
 584                 {
 585                   if (i < num_register_candidate_args
 586                       && arg_reg <= RX_R4_REGNUM - 1)
 587                     {
 588                       /* If argument registers are going to be used to pass
 589                          an 8 byte scalar, the ABI specifies that two registers
 590                          must be available.  */
 591                       if (write_pass)
 592                         {
 593                           regcache_cooked_write_unsigned (regcache, arg_reg,
 594                                                           extract_unsigned_integer
 595                                                           (arg_bits, 4,
 596                                                            byte_order));
 597                           regcache_cooked_write_unsigned (regcache,
 598                                                           arg_reg + 1,
 599                                                           extract_unsigned_integer
 600                                                           (arg_bits + 4, 4,
 601                                                            byte_order));
 602                         }
 603                       arg_reg += 2;
 604                     }
 605                   else
 606                     {
 607                       sp_off = align_up (sp_off, 4);
 608                       /* Otherwise, pass the 8 byte scalar on the stack.  */
 609                       if (write_pass)
 610                         write_memory (sp + sp_off, arg_bits, 8);
 611                       sp_off += 8;
 612                     }
 613                 }
 614               else
 615                 {
 616                   ULONGEST u;
 617
 618                   gdb_assert (arg_size <= 4);
 619
 620                   u =
 621                     extract_unsigned_integer (arg_bits, arg_size, byte_order);
 622
 623                   if (i < num_register_candidate_args
 624                       && arg_reg <= RX_R4_REGNUM)
 625                     {
 626                       if (write_pass)
 627                         regcache_cooked_write_unsigned (regcache, arg_reg, u);
 628                       arg_reg += 1;
 629                     }
 630                   else
 631                     {
 632                       int p_arg_size = 4;
 633
 634                       if (TYPE_PROTOTYPED (func_type)
 635                           && i < TYPE_NFIELDS (func_type))
 636                         {
 637                           struct type *p_arg_type =
 638                             TYPE_FIELD_TYPE (func_type, i);
 639                           p_arg_size = TYPE_LENGTH (p_arg_type);
 640                         }
 641
 642                       sp_off = align_up (sp_off, p_arg_size);
 643
 644                       if (write_pass)
 645                         write_memory_unsigned_integer (sp + sp_off,
 646                                                        p_arg_size, byte_order,
 647                                                        u);
 648                       sp_off += p_arg_size;
 649                     }
 650                 }
 651             }
 652           else
 653             {
 654               /* Argument is a struct or union.  Pass as much of the struct
 655                  in registers, if possible.  Pass the rest on the stack.  */
 656               while (arg_size > 0)
 657                 {
 658                   if (i < num_register_candidate_args
 659                       && arg_reg <= RX_R4_REGNUM
 660                       && arg_size <= 4 * (RX_R4_REGNUM - arg_reg + 1)
 661                       && arg_size % 4 == 0)
 662                     {
 663                       int len = min (arg_size, 4);
 664
 665                       if (write_pass)
 666                         regcache_cooked_write_unsigned (regcache, arg_reg,
 667                                                         extract_unsigned_integer
 668                                                         (arg_bits, len,
 669                                                          byte_order));
 670                       arg_bits += len;
 671                       arg_size -= len;
 672                       arg_reg++;
 673                     }
 674                   else
 675                     {
 676                       sp_off = align_up (sp_off, 4);
 677                       if (write_pass)
 678                         write_memory (sp + sp_off, arg_bits, arg_size);
 679                       sp_off += align_up (arg_size, 4);
 680                       arg_size = 0;
 681                     }
 682                 }
 683             }
 684         }
 685     }
 686
 687   /* Keep track of the stack address prior to pushing the return address.
 688      This is the value that we'll return.  */
 689   cfa = sp;
 690
 691   /* Push the return address.  */
 692   sp = sp - 4;
 693   write_memory_unsigned_integer (sp, 4, byte_order, bp_addr);
 694
 695   /* Update the stack pointer.  */
 696   regcache_cooked_write_unsigned (regcache, RX_SP_REGNUM, sp);
 697
 698   return cfa;
 699 }
 700
 701 /* Implement the "return_value" gdbarch method.  */
 702 static enum return_value_convention
 703 rx_return_value (struct gdbarch *gdbarch,
 704                  struct type *func_type,
 705                  struct type *valtype,
 706                  struct regcache *regcache,
 707                  gdb_byte *readbuf, const gdb_byte *writebuf)
 708 {
 709   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 710   ULONGEST valtype_len = TYPE_LENGTH (valtype);
 711
 712   if (TYPE_LENGTH (valtype) > 16
 713       || ((TYPE_CODE (valtype) == TYPE_CODE_STRUCT
 714            || TYPE_CODE (valtype) == TYPE_CODE_UNION)
 715           && TYPE_LENGTH (valtype) % 4 != 0))
 716     return RETURN_VALUE_STRUCT_CONVENTION;
 717
 718   if (readbuf)
 719     {
 720       ULONGEST u;
 721       int argreg = RX_R1_REGNUM;
 722       int offset = 0;
 723
 724       while (valtype_len > 0)
 725         {
 726           int len = min (valtype_len, 4);
 727
 728           regcache_cooked_read_unsigned (regcache, argreg, &u);
 729           store_unsigned_integer (readbuf + offset, len, byte_order, u);
 730           valtype_len -= len;
 731           offset += len;
 732           argreg++;
 733         }
 734     }
 735
 736   if (writebuf)
 737     {
 738       ULONGEST u;
 739       int argreg = RX_R1_REGNUM;
 740       int offset = 0;
 741
 742       while (valtype_len > 0)
 743         {
 744           int len = min (valtype_len, 4);
 745
 746           u = extract_unsigned_integer (writebuf + offset, len, byte_order);
 747           regcache_cooked_write_unsigned (regcache, argreg, u);
 748           valtype_len -= len;
 749           offset += len;
 750           argreg++;
 751         }
 752     }
 753
 754   return RETURN_VALUE_REGISTER_CONVENTION;
 755 }
 756
 757 /* Implement the "breakpoint_from_pc" gdbarch method.  */
 758 const gdb_byte *
 759 rx_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *lenptr)
 760 {
 761   static gdb_byte breakpoint[] = { 0x00 };
 762   *lenptr = sizeof breakpoint;
 763   return breakpoint;
 764 }
 765
 766 /* Allocate and initialize a gdbarch object.  */
 767 static struct gdbarch *
 768 rx_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
 769 {
 770   struct gdbarch *gdbarch;
 771   struct gdbarch_tdep *tdep;
 772   int elf_flags;
 773
 774   /* Extract the elf_flags if available.  */
 775   if (info.abfd != NULL
 776       && bfd_get_flavour (info.abfd) == bfd_target_elf_flavour)
 777     elf_flags = elf_elfheader (info.abfd)->e_flags;
 778   else
 779     elf_flags = 0;
 780
 781
 782   /* Try to find the architecture in the list of already defined
 783      architectures.  */
 784   for (arches = gdbarch_list_lookup_by_info (arches, &info);
 785        arches != NULL;
 786        arches = gdbarch_list_lookup_by_info (arches->next, &info))
 787     {
 788       if (gdbarch_tdep (arches->gdbarch)->elf_flags != elf_flags)
 789         continue;
 790
 791       return arches->gdbarch;
 792     }
 793
 794   /* None found, create a new architecture from the information
 795      provided.  */
 796   tdep = (struct gdbarch_tdep *) xmalloc (sizeof (struct gdbarch_tdep));
 797   gdbarch = gdbarch_alloc (&info, tdep);
 798   tdep->elf_flags = elf_flags;
 799
 800   set_gdbarch_num_regs (gdbarch, RX_NUM_REGS);
 801   set_gdbarch_num_pseudo_regs (gdbarch, 0);
 802   set_gdbarch_register_name (gdbarch, rx_register_name);
 803   set_gdbarch_register_type (gdbarch, rx_register_type);
 804   set_gdbarch_pc_regnum (gdbarch, RX_PC_REGNUM);
 805   set_gdbarch_sp_regnum (gdbarch, RX_SP_REGNUM);
 806   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
 807   set_gdbarch_decr_pc_after_break (gdbarch, 1);
 808   set_gdbarch_breakpoint_from_pc (gdbarch, rx_breakpoint_from_pc);
 809   set_gdbarch_skip_prologue (gdbarch, rx_skip_prologue);
 810
 811   set_gdbarch_print_insn (gdbarch, print_insn_rx);
 812
 813   set_gdbarch_unwind_pc (gdbarch, rx_unwind_pc);
 814   set_gdbarch_unwind_sp (gdbarch, rx_unwind_sp);
 815
 816   /* Target builtin data types.  */
 817   set_gdbarch_char_signed (gdbarch, 0);
 818   set_gdbarch_short_bit (gdbarch, 16);
 819   set_gdbarch_int_bit (gdbarch, 32);
 820   set_gdbarch_long_bit (gdbarch, 32);
 821   set_gdbarch_long_long_bit (gdbarch, 64);
 822   set_gdbarch_ptr_bit (gdbarch, 32);
 823   set_gdbarch_float_bit (gdbarch, 32);
 824   set_gdbarch_float_format (gdbarch, floatformats_ieee_single);
 825   if (elf_flags & E_FLAG_RX_64BIT_DOUBLES)
 826     {
 827       set_gdbarch_double_bit (gdbarch, 64);
 828       set_gdbarch_long_double_bit (gdbarch, 64);
 829       set_gdbarch_double_format (gdbarch, floatformats_ieee_double);
 830       set_gdbarch_long_double_format (gdbarch, floatformats_ieee_double);
 831     }
 832   else
 833     {
 834       set_gdbarch_double_bit (gdbarch, 32);
 835       set_gdbarch_long_double_bit (gdbarch, 32);
 836       set_gdbarch_double_format (gdbarch, floatformats_ieee_single);
 837       set_gdbarch_long_double_format (gdbarch, floatformats_ieee_single);
 838     }
 839
 840   /* Frame unwinding.  */
 841 #if 0
 842   /* Note: The test results are better with the dwarf2 unwinder disabled,
 843      so it's turned off for now.  */
 844   dwarf2_append_unwinders (gdbarch);
 845 #endif
 846   frame_unwind_append_unwinder (gdbarch, &rx_frame_unwind);
 847
 848   /* Methods for saving / extracting a dummy frame's ID.
 849      The ID's stack address must match the SP value returned by
 850      PUSH_DUMMY_CALL, and saved by generic_save_dummy_frame_tos.  */
 851   set_gdbarch_dummy_id (gdbarch, rx_dummy_id);
 852   set_gdbarch_push_dummy_call (gdbarch, rx_push_dummy_call);
 853   set_gdbarch_return_value (gdbarch, rx_return_value);
 854
 855   /* Virtual tables.  */
 856   set_gdbarch_vbit_in_delta (gdbarch, 1);
 857
 858   return gdbarch;
 859 }
 860
 861 /* Register the above initialization routine.  */
 862 void
 863 _initialize_rx_tdep (void)
 864 {
 865   register_gdbarch_init (bfd_arch_rx, rx_gdbarch_init);
 866 }