gdb/h8300-tdep.c

   1 /* Target-machine dependent code for Hitachi H8/300, for GDB.
   2
   3    Copyright 1988, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1998,
   4    1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 59 Temple Place - Suite 330,
  21    Boston, MA 02111-1307, USA.  */
  22
  23 /*
  24    Contributed by Steve Chamberlain
  25    sac@cygnus.com
  26  */
  27
  28 #include "defs.h"
  29 #include "value.h"
  30 #include "inferior.h"
  31 #include "symfile.h"
  32 #include "arch-utils.h"
  33 #include "regcache.h"
  34 #include "gdbcore.h"
  35 #include "objfiles.h"
  36 #include "gdbcmd.h"
  37 #include "gdb_assert.h"
  38
  39 /* Extra info which is saved in each frame_info. */
  40 struct frame_extra_info
  41 {
  42   CORE_ADDR from_pc;
  43 };
  44
  45 enum
  46 {
  47   h8300_reg_size = 2,
  48   h8300h_reg_size = 4,
  49   h8300_max_reg_size = 4,
  50 };
  51 #define BINWORD (h8300hmode ? h8300h_reg_size : h8300_reg_size)
  52
  53 enum gdb_regnum
  54 {
  55   E_R0_REGNUM, E_ER0_REGNUM = E_R0_REGNUM, E_ARG0_REGNUM = E_R0_REGNUM,
  56                                            E_RET0_REGNUM = E_R0_REGNUM,
  57   E_R1_REGNUM, E_ER1_REGNUM = E_R1_REGNUM, E_RET1_REGNUM = E_R1_REGNUM,
  58   E_R2_REGNUM, E_ER2_REGNUM = E_R2_REGNUM, E_ARGLAST_REGNUM = E_R2_REGNUM,
  59   E_R3_REGNUM, E_ER3_REGNUM = E_R3_REGNUM,
  60   E_R4_REGNUM, E_ER4_REGNUM = E_R4_REGNUM,
  61   E_R5_REGNUM, E_ER5_REGNUM = E_R5_REGNUM,
  62   E_R6_REGNUM, E_ER6_REGNUM = E_R6_REGNUM, E_FP_REGNUM = E_R6_REGNUM,
  63   E_SP_REGNUM,
  64   E_CCR_REGNUM,
  65   E_PC_REGNUM,
  66   E_CYCLES_REGNUM,
  67   E_TICK_REGNUM, E_EXR_REGNUM = E_TICK_REGNUM,
  68   E_INST_REGNUM, E_TICKS_REGNUM = E_INST_REGNUM,
  69   E_INSTS_REGNUM,
  70   E_MACH_REGNUM,
  71   E_MACL_REGNUM,
  72   E_SBR_REGNUM,
  73   E_VBR_REGNUM
  74 };
  75
  76 #define E_PSEUDO_CCR_REGNUM (NUM_REGS)
  77 #define E_PSEUDO_EXR_REGNUM (NUM_REGS+1)
  78
  79 #define UNSIGNED_SHORT(X) ((X) & 0xffff)
  80
  81 #define IS_PUSH(x) ((x & 0xfff0)==0x6df0)
  82 #define IS_PUSH_FP(x) (x == 0x6df6)
  83 #define IS_MOVE_FP(x) (x == 0x0d76 || x == 0x0ff6)
  84 #define IS_MOV_SP_FP(x) (x == 0x0d76 || x == 0x0ff6)
  85 #define IS_SUB2_SP(x) (x==0x1b87)
  86 #define IS_SUB4_SP(x) (x==0x1b97)
  87 #define IS_SUBL_SP(x) (x==0x7a37)
  88 #define IS_MOVK_R5(x) (x==0x7905)
  89 #define IS_SUB_R5SP(x) (x==0x1957)
  90
  91 /* If the instruction at PC is an argument register spill, return its
  92    length.  Otherwise, return zero.
  93
  94    An argument register spill is an instruction that moves an argument
  95    from the register in which it was passed to the stack slot in which
  96    it really lives.  It is a byte, word, or longword move from an
  97    argument register to a negative offset from the frame pointer.
  98
  99    CV, 2003-06-16: Or, in optimized code or when the `register' qualifier
 100    is used, it could be a byte, word or long move to registers r3-r5.  */
 101
 102 static int
 103 h8300_is_argument_spill (CORE_ADDR pc)
 104 {
 105   int w = read_memory_unsigned_integer (pc, 2);
 106
 107   if (((w & 0xff88) == 0x0c88                 /* mov.b Rsl, Rdl */
 108        || (w & 0xff88) == 0x0d00              /* mov.w Rs, Rd */
 109        || (w & 0xff88) == 0x0f80)             /* mov.l Rs, Rd */
 110       && (w & 0x70) <= 0x20                   /* Rs is R0, R1 or R2 */
 111       && (w & 0x7) >= 0x3 && (w & 0x7) <= 0x5)/* Rd is R3, R4 or R5 */
 112     return 2;
 113
 114   if ((w & 0xfff0) == 0x6ee0                  /* mov.b Rs,@(d:16,er6) */
 115       && 8 <= (w & 0xf) && (w & 0xf) <= 10)   /* Rs is R0L, R1L, or R2L  */
 116     {
 117       int w2 = read_memory_integer (pc + 2, 2);
 118
 119       /* ... and d:16 is negative.  */
 120       if (w2 < 0)
 121         return 4;
 122     }
 123   else if (w == 0x7860)
 124     {
 125       int w2 = read_memory_integer (pc + 2, 2);
 126
 127       if ((w2 & 0xfff0) == 0x6aa0)              /* mov.b Rs, @(d:24,er6) */
 128         {
 129           LONGEST disp = read_memory_integer (pc + 4, 4);
 130
 131           /* ... and d:24 is negative.  */
 132           if (disp < 0 && disp > 0xffffff)
 133             return 8;
 134         }
 135     }
 136   else if ((w & 0xfff0) == 0x6fe0             /* mov.w Rs,@(d:16,er6) */
 137            && (w & 0xf) <= 2)                 /* Rs is R0, R1, or R2 */
 138     {
 139       int w2 = read_memory_integer (pc + 2, 2);
 140
 141       /* ... and d:16 is negative.  */
 142       if (w2 < 0)
 143         return 4;
 144     }
 145   else if (w == 0x78e0)
 146     {
 147       int w2 = read_memory_integer (pc + 2, 2);
 148
 149       if ((w2 & 0xfff0) == 0x6ba0)              /* mov.b Rs, @(d:24,er6) */
 150         {
 151           LONGEST disp = read_memory_integer (pc + 4, 4);
 152
 153           /* ... and d:24 is negative.  */
 154           if (disp < 0 && disp > 0xffffff)
 155             return 8;
 156         }
 157     }
 158   else if (w == 0x0100)
 159     {
 160       int w2 = read_memory_integer (pc + 2, 2);
 161
 162       if ((w2 & 0xfff0) == 0x6fe0             /* mov.l Rs,@(d:16,er6) */
 163           && (w2 & 0xf) <= 2)                /* Rs is ER0, ER1, or ER2 */
 164         {
 165           int w3 = read_memory_integer (pc + 4, 2);
 166
 167           /* ... and d:16 is negative.  */
 168           if (w3 < 0)
 169             return 6;
 170         }
 171       else if (w2 == 0x78e0)
 172         {
 173           int w3 = read_memory_integer (pc + 4, 2);
 174
 175           if ((w3 & 0xfff0) == 0x6ba0)          /* mov.l Rs, @(d:24,er6) */
 176             {
 177               LONGEST disp = read_memory_integer (pc + 6, 4);
 178
 179               /* ... and d:24 is negative.  */
 180               if (disp < 0 && disp > 0xffffff)
 181                 return 10;
 182             }
 183         }
 184     }
 185
 186   return 0;
 187 }
 188
 189 static CORE_ADDR
 190 h8300_skip_prologue (CORE_ADDR start_pc)
 191 {
 192   short int w;
 193   int adjust = 0;
 194
 195   /* Skip past all push and stm insns.  */
 196   while (1)
 197     {
 198       w = read_memory_unsigned_integer (start_pc, 2);
 199       /* First look for push insns.  */
 200       if (w == 0x0100 || w == 0x0110 || w == 0x0120 || w == 0x0130)
 201         {
 202           w = read_memory_unsigned_integer (start_pc + 2, 2);
 203           adjust = 2;
 204         }
 205
 206       if (IS_PUSH (w))
 207         {
 208           start_pc += 2 + adjust;
 209           w = read_memory_unsigned_integer (start_pc, 2);
 210           continue;
 211         }
 212       adjust = 0;
 213       break;
 214     }
 215
 216   /* Skip past a move to FP, either word or long sized */
 217   w = read_memory_unsigned_integer (start_pc, 2);
 218   if (w == 0x0100)
 219     {
 220       w = read_memory_unsigned_integer (start_pc + 2, 2);
 221       adjust += 2;
 222     }
 223
 224   if (IS_MOVE_FP (w))
 225     {
 226       start_pc += 2 + adjust;
 227       w = read_memory_unsigned_integer (start_pc, 2);
 228     }
 229
 230   /* Check for loading either a word constant into r5;
 231      long versions are handled by the SUBL_SP below.  */
 232   if (IS_MOVK_R5 (w))
 233     {
 234       start_pc += 2;
 235       w = read_memory_unsigned_integer (start_pc, 2);
 236     }
 237
 238   /* Now check for subtracting r5 from sp, word sized only.  */
 239   if (IS_SUB_R5SP (w))
 240     {
 241       start_pc += 2 + adjust;
 242       w = read_memory_unsigned_integer (start_pc, 2);
 243     }
 244
 245   /* Check for subs #2 and subs #4. */
 246   while (IS_SUB2_SP (w) || IS_SUB4_SP (w))
 247     {
 248       start_pc += 2 + adjust;
 249       w = read_memory_unsigned_integer (start_pc, 2);
 250     }
 251
 252   /* Check for a 32bit subtract.  */
 253   if (IS_SUBL_SP (w))
 254     start_pc += 6 + adjust;
 255
 256   /* Skip past another possible stm insn for registers R3 to R5 (possibly used
 257      for register qualified arguments.  */
 258   w = read_memory_unsigned_integer (start_pc, 2);
 259   /* First look for push insns.  */
 260   if (w == 0x0110 || w == 0x0120 || w == 0x0130)
 261     {
 262       w = read_memory_unsigned_integer (start_pc + 2, 2);
 263       if (IS_PUSH (w) && (w & 0xf) >= 0x3 && (w & 0xf) <= 0x5)
 264         start_pc += 4;
 265     }
 266
 267   /* Check for spilling an argument register to the stack frame.
 268      This could also be an initializing store from non-prologue code,
 269      but I don't think there's any harm in skipping that.  */
 270   for (;;)
 271     {
 272       int spill_size = h8300_is_argument_spill (start_pc);
 273       if (spill_size == 0)
 274         break;
 275       start_pc += spill_size;
 276     }
 277
 278   return start_pc;
 279 }
 280
 281 /* Fetch the instruction at ADDR, returning 0 if ADDR is beyond LIM or
 282    is not the address of a valid instruction, the address of the next
 283    instruction beyond ADDR otherwise.  *PWORD1 receives the first word
 284    of the instruction. */
 285
 286 static CORE_ADDR
 287 h8300_next_prologue_insn (CORE_ADDR addr,
 288                           CORE_ADDR lim,
 289                           unsigned short* pword1)
 290 {
 291   char buf[2];
 292   if (addr < lim + 8)
 293     {
 294       read_memory (addr, buf, 2);
 295       *pword1 = extract_signed_integer (buf, 2);
 296
 297       return addr + 2;
 298     }
 299   return 0;
 300 }
 301
 302 /* Examine the prologue of a function.  `ip' points to the first instruction.
 303    `limit' is the limit of the prologue (e.g. the addr of the first
 304    linenumber, or perhaps the program counter if we're stepping through).
 305    `frame_sp' is the stack pointer value in use in this frame.
 306    `fsr' is a pointer to a frame_saved_regs structure into which we put
 307    info about the registers saved by this frame.
 308    `fi' is a struct frame_info pointer; we fill in various fields in it
 309    to reflect the offsets of the arg pointer and the locals pointer.  */
 310
 311 /* Any function with a frame looks like this
 312    SECOND ARG
 313    FIRST ARG
 314    RET PC
 315    SAVED R2
 316    SAVED R3
 317    SAVED FP   <-FP POINTS HERE
 318    LOCALS0
 319    LOCALS1    <-SP POINTS HERE
 320  */
 321
 322 static CORE_ADDR
 323 h8300_examine_prologue (register CORE_ADDR ip, register CORE_ADDR limit,
 324                         CORE_ADDR after_prolog_fp, CORE_ADDR *fsr,
 325                         struct frame_info *fi)
 326 {
 327   register CORE_ADDR next_ip;
 328   int r;
 329   int have_fp = 0;
 330   unsigned short insn_word;
 331   /* Number of things pushed onto stack, starts at 2/4, 'cause the
 332      PC is already there */
 333   unsigned int reg_save_depth = BINWORD;
 334
 335   unsigned int auto_depth = 0;  /* Number of bytes of autos */
 336
 337   char in_frame[11];            /* One for each reg */
 338
 339   int adjust = 0;
 340
 341   memset (in_frame, 1, 11);
 342   for (r = 0; r < 8; r++)
 343     {
 344       fsr[r] = 0;
 345     }
 346   if (after_prolog_fp == 0)
 347     {
 348       after_prolog_fp = read_register (E_SP_REGNUM);
 349     }
 350
 351   /* If the PC isn't valid, quit now.  */
 352   if (ip == 0 || ip & (h8300hmode ? ~0xffffff : ~0xffff))
 353     return 0;
 354
 355   next_ip = h8300_next_prologue_insn (ip, limit, &insn_word);
 356
 357   if (insn_word == 0x0100)      /* mov.l */
 358     {
 359       insn_word = read_memory_unsigned_integer (ip + 2, 2);
 360       adjust = 2;
 361     }
 362
 363   /* Skip over any fp push instructions */
 364   fsr[E_FP_REGNUM] = after_prolog_fp;
 365   while (next_ip && IS_PUSH_FP (insn_word))
 366     {
 367       ip = next_ip + adjust;
 368
 369       in_frame[insn_word & 0x7] = reg_save_depth;
 370       next_ip = h8300_next_prologue_insn (ip, limit, &insn_word);
 371       reg_save_depth += 2 + adjust;
 372     }
 373
 374   /* Is this a move into the fp */
 375   if (next_ip && IS_MOV_SP_FP (insn_word))
 376     {
 377       ip = next_ip;
 378       next_ip = h8300_next_prologue_insn (ip, limit, &insn_word);
 379       have_fp = 1;
 380     }
 381
 382   /* Skip over any stack adjustment, happens either with a number of
 383      sub#2,sp or a mov #x,r5 sub r5,sp */
 384
 385   if (next_ip && (IS_SUB2_SP (insn_word) || IS_SUB4_SP (insn_word)))
 386     {
 387       while (next_ip && (IS_SUB2_SP (insn_word) || IS_SUB4_SP (insn_word)))
 388         {
 389           auto_depth += IS_SUB2_SP (insn_word) ? 2 : 4;
 390           ip = next_ip;
 391           next_ip = h8300_next_prologue_insn (ip, limit, &insn_word);
 392         }
 393     }
 394   else
 395     {
 396       if (next_ip && IS_MOVK_R5 (insn_word))
 397         {
 398           ip = next_ip;
 399           next_ip = h8300_next_prologue_insn (ip, limit, &insn_word);
 400           auto_depth += insn_word;
 401
 402           next_ip = h8300_next_prologue_insn (next_ip, limit, &insn_word);
 403           auto_depth += insn_word;
 404         }
 405       if (next_ip && IS_SUBL_SP (insn_word))
 406         {
 407           ip = next_ip;
 408           auto_depth += read_memory_unsigned_integer (ip, 4);
 409           ip += 4;
 410
 411           next_ip = h8300_next_prologue_insn (ip, limit, &insn_word);
 412         }
 413     }
 414
 415   /* Now examine the push insns to determine where everything lives
 416      on the stack.  */
 417   while (1)
 418     {
 419       adjust = 0;
 420       if (!next_ip)
 421         break;
 422
 423       if (insn_word == 0x0100)
 424         {
 425           ip = next_ip;
 426           next_ip = h8300_next_prologue_insn (ip, limit, &insn_word);
 427           adjust = 2;
 428         }
 429
 430       if (IS_PUSH (insn_word))
 431         {
 432           auto_depth += 2 + adjust;
 433           fsr[insn_word & 0x7] = after_prolog_fp - auto_depth;
 434           ip = next_ip;
 435           next_ip = h8300_next_prologue_insn (ip, limit, &insn_word);
 436           continue;
 437         }
 438
 439       /* Now check for push multiple insns.  */
 440       if (insn_word == 0x0110 || insn_word == 0x0120 || insn_word == 0x0130)
 441         {
 442           int count = ((insn_word >> 4) & 0xf) + 1;
 443           int start, i;
 444
 445           ip = next_ip;
 446           next_ip = h8300_next_prologue_insn (ip, limit, &insn_word);
 447           start = insn_word & 0x7;
 448
 449           for (i = start; i < start + count; i++)
 450             {
 451               auto_depth += 4;
 452               fsr[i] = after_prolog_fp - auto_depth;
 453             }
 454         }
 455       break;
 456     }
 457
 458   /* The PC is at a known place */
 459   get_frame_extra_info (fi)->from_pc =
 460     read_memory_unsigned_integer (after_prolog_fp + BINWORD, BINWORD);
 461
 462   /* Rememeber any others too */
 463   in_frame[E_PC_REGNUM] = 0;
 464
 465   if (have_fp)
 466     /* We keep the old FP in the SP spot */
 467     fsr[E_SP_REGNUM] = read_memory_unsigned_integer (fsr[E_FP_REGNUM],
 468                                                      BINWORD);
 469   else
 470     fsr[E_SP_REGNUM] = after_prolog_fp + auto_depth;
 471
 472   return (ip);
 473 }
 474
 475 static void
 476 h8300_frame_init_saved_regs (struct frame_info *fi)
 477 {
 478   CORE_ADDR func_addr, func_end;
 479
 480   if (!get_frame_saved_regs (fi))
 481     {
 482       frame_saved_regs_zalloc (fi);
 483
 484       /* Find the beginning of this function, so we can analyze its
 485          prologue. */
 486       if (find_pc_partial_function (get_frame_pc (fi), NULL,
 487                                     &func_addr, &func_end))
 488         {
 489           struct symtab_and_line sal = find_pc_line (func_addr, 0);
 490           CORE_ADDR limit = (sal.end && sal.end < get_frame_pc (fi))
 491             ? sal.end : get_frame_pc (fi);
 492           /* This will fill in fields in fi. */
 493           h8300_examine_prologue (func_addr, limit, get_frame_base (fi),
 494                                   get_frame_saved_regs (fi), fi);
 495         }
 496       /* Else we're out of luck (can't debug completely stripped code).
 497          FIXME. */
 498     }
 499 }
 500
 501 /* Given a GDB frame, determine the address of the calling function's
 502    frame.  This will be used to create a new GDB frame struct, and
 503    then DEPRECATED_INIT_EXTRA_FRAME_INFO and DEPRECATED_INIT_FRAME_PC
 504    will be called for the new frame.
 505
 506    For us, the frame address is its stack pointer value, so we look up
 507    the function prologue to determine the caller's sp value, and
 508    return it.  */
 509
 510 static CORE_ADDR
 511 h8300_frame_chain (struct frame_info *thisframe)
 512 {
 513   if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (thisframe),
 514                                    get_frame_base (thisframe),
 515                                    get_frame_base (thisframe)))
 516     {                           /* initialize the from_pc now */
 517       get_frame_extra_info (thisframe)->from_pc =
 518         deprecated_read_register_dummy (get_frame_pc (thisframe),
 519                                         get_frame_base (thisframe),
 520                                         E_PC_REGNUM);
 521       return get_frame_base (thisframe);
 522     }
 523   return get_frame_saved_regs (thisframe)[E_SP_REGNUM];
 524 }
 525
 526 /* Return the saved PC from this frame.
 527
 528    If the frame has a memory copy of SRP_REGNUM, use that.  If not,
 529    just use the register SRP_REGNUM itself.  */
 530
 531 static CORE_ADDR
 532 h8300_frame_saved_pc (struct frame_info *frame)
 533 {
 534   if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (frame),
 535                                    get_frame_base (frame),
 536                                    get_frame_base (frame)))
 537     return deprecated_read_register_dummy (get_frame_pc (frame),
 538                                            get_frame_base (frame),
 539                                            E_PC_REGNUM);
 540   else
 541     return get_frame_extra_info (frame)->from_pc;
 542 }
 543
 544 static void
 545 h8300_init_extra_frame_info (int fromleaf, struct frame_info *fi)
 546 {
 547   if (!get_frame_extra_info (fi))
 548     {
 549       frame_extra_info_zalloc (fi, sizeof (struct frame_extra_info));
 550       get_frame_extra_info (fi)->from_pc = 0;
 551
 552       if (!get_frame_pc (fi))
 553         {
 554           if (get_next_frame (fi))
 555             deprecated_update_frame_pc_hack (fi, h8300_frame_saved_pc (get_next_frame (fi)));
 556         }
 557       h8300_frame_init_saved_regs (fi);
 558     }
 559 }
 560
 561 /* Round N up or down to the nearest multiple of UNIT.
 562    Evaluate N only once, UNIT several times.
 563    UNIT must be a power of two.  */
 564 #define round_up(n, unit)   (((n) + (unit) - 1) & -(unit))
 565 #define round_down(n, unit) ((n) & -(unit))
 566
 567 /* Function: push_arguments
 568    Setup the function arguments for calling a function in the inferior.
 569    In this discussion, a `word' is 16 bits on the H8/300s, and 32 bits
 570    on the H8/300H.
 571
 572    There are actually two ABI's here: -mquickcall (the default) and
 573    -mno-quickcall.  With -mno-quickcall, all arguments are passed on
 574    the stack after the return address, word-aligned.  With
 575    -mquickcall, GCC tries to use r0 -- r2 to pass registers.  Since
 576    GCC doesn't indicate in the object file which ABI was used to
 577    compile it, GDB only supports the default --- -mquickcall.
 578
 579    Here are the rules for -mquickcall, in detail:
 580
 581    Each argument, whether scalar or aggregate, is padded to occupy a
 582    whole number of words.  Arguments smaller than a word are padded at
 583    the most significant end; those larger than a word are padded at
 584    the least significant end.
 585
 586    The initial arguments are passed in r0 -- r2.  Earlier arguments go in
 587    lower-numbered registers.  Multi-word arguments are passed in
 588    consecutive registers, with the most significant end in the
 589    lower-numbered register.
 590
 591    If an argument doesn't fit entirely in the remaining registers, it
 592    is passed entirely on the stack.  Stack arguments begin just after
 593    the return address.  Once an argument has overflowed onto the stack
 594    this way, all subsequent arguments are passed on the stack.
 595
 596    The above rule has odd consequences.  For example, on the h8/300s,
 597    if a function takes two longs and an int as arguments:
 598    - the first long will be passed in r0/r1,
 599    - the second long will be passed entirely on the stack, since it
 600      doesn't fit in r2,
 601    - and the int will be passed on the stack, even though it could fit
 602      in r2.
 603
 604    A weird exception: if an argument is larger than a word, but not a
 605    whole number of words in length (before padding), it is passed on
 606    the stack following the rules for stack arguments above, even if
 607    there are sufficient registers available to hold it.  Stranger
 608    still, the argument registers are still `used up' --- even though
 609    there's nothing in them.
 610
 611    So, for example, on the h8/300s, if a function expects a three-byte
 612    structure and an int, the structure will go on the stack, and the
 613    int will go in r2, not r0.
 614
 615    If the function returns an aggregate type (struct, union, or class)
 616    by value, the caller must allocate space to hold the return value,
 617    and pass the callee a pointer to this space as an invisible first
 618    argument, in R0.
 619
 620    For varargs functions, the last fixed argument and all the variable
 621    arguments are always passed on the stack.  This means that calls to
 622    varargs functions don't work properly unless there is a prototype
 623    in scope.
 624
 625    Basically, this ABI is not good, for the following reasons:
 626    - You can't call vararg functions properly unless a prototype is in scope.
 627    - Structure passing is inconsistent, to no purpose I can see.
 628    - It often wastes argument registers, of which there are only three
 629      to begin with.  */
 630
 631 static CORE_ADDR
 632 h8300_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
 633                       int struct_return, CORE_ADDR struct_addr)
 634 {
 635   int stack_align, stack_alloc, stack_offset;
 636   int wordsize = BINWORD;
 637   int reg;
 638   int argument;
 639
 640   /* First, make sure the stack is properly aligned.  */
 641   sp = round_down (sp, wordsize);
 642
 643   /* Now make sure there's space on the stack for the arguments.  We
 644      may over-allocate a little here, but that won't hurt anything.  */
 645   stack_alloc = 0;
 646   for (argument = 0; argument < nargs; argument++)
 647     stack_alloc += round_up (TYPE_LENGTH (VALUE_TYPE (args[argument])),
 648                              wordsize);
 649   sp -= stack_alloc;
 650
 651   /* Now load as many arguments as possible into registers, and push
 652      the rest onto the stack.  */
 653   reg = E_ARG0_REGNUM;
 654   stack_offset = 0;
 655
 656   /* If we're returning a structure by value, then we must pass a
 657      pointer to the buffer for the return value as an invisible first
 658      argument.  */
 659   if (struct_return)
 660     write_register (reg++, struct_addr);
 661
 662   for (argument = 0; argument < nargs; argument++)
 663     {
 664       struct type *type = VALUE_TYPE (args[argument]);
 665       int len = TYPE_LENGTH (type);
 666       char *contents = (char *) VALUE_CONTENTS (args[argument]);
 667
 668       /* Pad the argument appropriately.  */
 669       int padded_len = round_up (len, wordsize);
 670       char *padded = alloca (padded_len);
 671
 672       memset (padded, 0, padded_len);
 673       memcpy (len < wordsize ? padded + padded_len - len : padded,
 674               contents, len);
 675
 676       /* Could the argument fit in the remaining registers?  */
 677       if (padded_len <= (E_ARGLAST_REGNUM - reg + 1) * wordsize)
 678         {
 679           /* Are we going to pass it on the stack anyway, for no good
 680              reason?  */
 681           if (len > wordsize && len % wordsize)
 682             {
 683               /* I feel so unclean.  */
 684               write_memory (sp + stack_offset, padded, padded_len);
 685               stack_offset += padded_len;
 686
 687               /* That's right --- even though we passed the argument
 688                  on the stack, we consume the registers anyway!  Love
 689                  me, love my dog.  */
 690               reg += padded_len / wordsize;
 691             }
 692           else
 693             {
 694               /* Heavens to Betsy --- it's really going in registers!
 695                  It would be nice if we could use write_register_bytes
 696                  here, but on the h8/300s, there are gaps between
 697                  the registers in the register file.  */
 698               int offset;
 699
 700               for (offset = 0; offset < padded_len; offset += wordsize)
 701                 {
 702                   ULONGEST word = extract_unsigned_integer (padded + offset,
 703                                                             wordsize);
 704                   write_register (reg++, word);
 705                 }
 706             }
 707         }
 708       else
 709         {
 710           /* It doesn't fit in registers!  Onto the stack it goes.  */
 711           write_memory (sp + stack_offset, padded, padded_len);
 712           stack_offset += padded_len;
 713
 714           /* Once one argument has spilled onto the stack, all
 715              subsequent arguments go on the stack.  */
 716           reg = E_ARGLAST_REGNUM + 1;
 717         }
 718     }
 719
 720   return sp;
 721 }
 722
 723 /* Function: push_return_address
 724    Setup the return address for a dummy frame, as called by
 725    call_function_by_hand.  Only necessary when you are using an
 726    empty CALL_DUMMY, ie. the target will not actually be executing
 727    a JSR/BSR instruction.  */
 728
 729 static CORE_ADDR
 730 h8300_push_return_address (CORE_ADDR pc, CORE_ADDR sp)
 731 {
 732   unsigned char buf[4];
 733   int wordsize = BINWORD;
 734
 735   sp -= wordsize;
 736   store_unsigned_integer (buf, wordsize, CALL_DUMMY_ADDRESS ());
 737   write_memory (sp, buf, wordsize);
 738   return sp;
 739 }
 740
 741 /* Function: h8300_pop_frame
 742    Restore the machine to the state it had before the current frame
 743    was created.  Usually used either by the "RETURN" command, or by
 744    call_function_by_hand after the dummy_frame is finished. */
 745
 746 static void
 747 h8300_pop_frame (void)
 748 {
 749   unsigned regno;
 750   struct frame_info *frame = get_current_frame ();
 751
 752   if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (frame),
 753                                    get_frame_base (frame),
 754                                    get_frame_base (frame)))
 755     {
 756       generic_pop_dummy_frame ();
 757     }
 758   else
 759     {
 760       for (regno = 0; regno < 8; regno++)
 761         {
 762           /* Don't forget E_SP_REGNUM is a frame_saved_regs struct is the
 763              actual value we want, not the address of the value we want.  */
 764           if (get_frame_saved_regs (frame)[regno] && regno != E_SP_REGNUM)
 765             write_register (regno,
 766                             read_memory_integer
 767                             (get_frame_saved_regs (frame)[regno], BINWORD));
 768           else if (get_frame_saved_regs (frame)[regno] && regno == E_SP_REGNUM)
 769             write_register (regno, get_frame_base (frame) + 2 * BINWORD);
 770         }
 771
 772       /* Don't forget to update the PC too!  */
 773       write_register (E_PC_REGNUM, get_frame_extra_info (frame)->from_pc);
 774     }
 775   flush_cached_frames ();
 776 }
 777
 778 /* Function: extract_return_value
 779    Figure out where in REGBUF the called function has left its return value.
 780    Copy that into VALBUF.  Be sure to account for CPU type.   */
 781
 782 static void
 783 h8300_extract_return_value (struct type *type, struct regcache *regcache,
 784                             void *valbuf)
 785 {
 786   int len = TYPE_LENGTH (type);
 787   ULONGEST c;
 788
 789   switch (len)
 790     {
 791       case 1:
 792       case 2:
 793         regcache_cooked_read_unsigned (regcache, E_RET0_REGNUM, &c);
 794         store_unsigned_integer (valbuf, len, c);
 795         break;
 796       case 4:   /* Needs two registers on plain H8/300 */
 797         regcache_cooked_read_unsigned (regcache, E_RET0_REGNUM, &c);
 798         store_unsigned_integer (valbuf, 2, c);
 799         regcache_cooked_read_unsigned (regcache, E_RET1_REGNUM, &c);
 800         store_unsigned_integer ((void*)((char *)valbuf + 2), 2, c);
 801         break;
 802       case 8:           /* long long, double and long double are all defined
 803                            as 4 byte types so far so this shouldn't happen. */
 804         error ("I don't know how a 8 byte value is returned.");
 805         break;
 806     }
 807 }
 808
 809 static void
 810 h8300h_extract_return_value (struct type *type, struct regcache *regcache,
 811                             void *valbuf)
 812 {
 813   int len = TYPE_LENGTH (type);
 814   ULONGEST c;
 815
 816   switch (len)
 817     {
 818       case 1:
 819       case 2:
 820       case 4:
 821         regcache_cooked_read_unsigned (regcache, E_RET0_REGNUM, &c);
 822         store_unsigned_integer (valbuf, len, c);
 823         break;
 824       case 8:           /* long long, double and long double are all defined
 825                            as 4 byte types so far so this shouldn't happen. */
 826         error ("I don't know how a 8 byte value is returned.");
 827         break;
 828     }
 829 }
 830
 831
 832 /* Function: store_return_value
 833    Place the appropriate value in the appropriate registers.
 834    Primarily used by the RETURN command.  */
 835
 836 static void
 837 h8300_store_return_value (struct type *type, struct regcache *regcache,
 838                           const void *valbuf)
 839 {
 840   int len = TYPE_LENGTH (type);
 841   ULONGEST val;
 842
 843   switch (len)
 844     {
 845       case 1:
 846       case 2:
 847         val = extract_unsigned_integer (valbuf, len);
 848         regcache_cooked_write_unsigned (regcache, E_RET0_REGNUM, val);
 849         break;
 850       case 4:                   /* long, float */
 851         val = extract_unsigned_integer (valbuf, len);
 852         regcache_cooked_write_unsigned (regcache, E_RET0_REGNUM,
 853                                         (val >> 16) &0xffff);
 854         regcache_cooked_write_unsigned (regcache, E_RET1_REGNUM, val & 0xffff);
 855         break;
 856       case 8:           /* long long, double and long double are all defined
 857                              as 4 byte types so far so this shouldn't happen. */
 858         error ("I don't know how to return a 8 byte value.");
 859         break;
 860     }
 861 }
 862
 863 static void
 864 h8300h_store_return_value (struct type *type, struct regcache *regcache,
 865                            const void *valbuf)
 866 {
 867   int len = TYPE_LENGTH (type);
 868   ULONGEST val;
 869
 870   switch (len)
 871     {
 872       case 1:
 873       case 2:
 874       case 4:                   /* long, float */
 875         val = extract_unsigned_integer (valbuf, len);
 876         regcache_cooked_write_unsigned (regcache, E_RET0_REGNUM, val);
 877         break;
 878       case 8:           /* long long, double and long double are all defined
 879                              as 4 byte types so far so this shouldn't happen. */
 880         error ("I don't know how to return a 8 byte value.");
 881         break;
 882     }
 883 }
 884
 885 static struct cmd_list_element *setmachinelist;
 886
 887 static const char *
 888 h8300_register_name (int regno)
 889 {
 890   /* The register names change depending on which h8300 processor
 891      type is selected. */
 892   static char *register_names[] = {
 893     "r0", "r1", "r2", "r3", "r4", "r5", "r6",
 894     "sp", "","pc","cycles", "tick", "inst",
 895     "ccr", /* pseudo register */
 896   };
 897   if (regno < 0
 898       || regno >= (sizeof (register_names) / sizeof (*register_names)))
 899     internal_error (__FILE__, __LINE__,
 900                     "h8300_register_name: illegal register number %d", regno);
 901   else
 902     return register_names[regno];
 903 }
 904
 905 static const char *
 906 h8300s_register_name (int regno)
 907 {
 908   static char *register_names[] = {
 909     "er0", "er1", "er2", "er3", "er4", "er5", "er6",
 910     "sp", "", "pc", "cycles", "", "tick", "inst",
 911     //"mach", "macl",
 912     "ccr", "exr" /* pseudo registers */
 913   };
 914   if (regno < 0
 915       || regno >= (sizeof (register_names) / sizeof (*register_names)))
 916     internal_error (__FILE__, __LINE__,
 917                     "h8300s_register_name: illegal register number %d", regno);
 918   else
 919     return register_names[regno];
 920 }
 921
 922 static const char *
 923 h8300sx_register_name (int regno)
 924 {
 925   static char *register_names[] = {
 926     "er0", "er1", "er2", "er3", "er4", "er5", "er6",
 927     "sp", "", "pc", "cycles", "", "tick", "inst",
 928     "mach", "macl", "sbr", "vbr",
 929     "ccr", "exr" /* pseudo registers */
 930   };
 931   if (regno < 0
 932       || regno >= (sizeof (register_names) / sizeof (*register_names)))
 933     internal_error (__FILE__, __LINE__,
 934                     "h8300sx_register_name: illegal register number %d", regno);
 935   else
 936     return register_names[regno];
 937 }
 938
 939 static void
 940 h8300_print_register (struct gdbarch *gdbarch, struct ui_file *file,
 941                       struct frame_info *frame, int regno)
 942 {
 943   LONGEST rval;
 944   const char *name = gdbarch_register_name (gdbarch, regno);
 945
 946   if (!name || !*name)
 947     return;
 948
 949   frame_read_signed_register (frame, regno, &rval);
 950
 951   fprintf_filtered (file, "%-14s ", name);
 952   if (regno == E_PSEUDO_CCR_REGNUM || (regno == E_PSEUDO_EXR_REGNUM && h8300smode))
 953     {
 954       fprintf_filtered (file, "0x%02x        ", (unsigned char)rval);
 955       print_longest (file, 'u', 1, rval);
 956     }
 957   else
 958     {
 959       fprintf_filtered (file, "0x%s  ", phex ((ULONGEST)rval, BINWORD));
 960       print_longest (file, 'd', 1, rval);
 961     }
 962   if (regno == E_PSEUDO_CCR_REGNUM)
 963     {
 964       /* CCR register */
 965       int C, Z, N, V;
 966       unsigned char l = rval & 0xff;
 967       fprintf_filtered (file, "\t");
 968       fprintf_filtered (file, "I-%d ", (l & 0x80) != 0);
 969       fprintf_filtered (file, "UI-%d ", (l & 0x40) != 0);
 970       fprintf_filtered (file, "H-%d ", (l & 0x20) != 0);
 971       fprintf_filtered (file, "U-%d ", (l & 0x10) != 0);
 972       N = (l & 0x8) != 0;
 973       Z = (l & 0x4) != 0;
 974       V = (l & 0x2) != 0;
 975       C = (l & 0x1) != 0;
 976       fprintf_filtered (file, "N-%d ", N);
 977       fprintf_filtered (file, "Z-%d ", Z);
 978       fprintf_filtered (file, "V-%d ", V);
 979       fprintf_filtered (file, "C-%d ", C);
 980       if ((C | Z) == 0)
 981         fprintf_filtered (file, "u> ");
 982       if ((C | Z) == 1)
 983         fprintf_filtered (file, "u<= ");
 984       if ((C == 0))
 985         fprintf_filtered (file, "u>= ");
 986       if (C == 1)
 987         fprintf_filtered (file, "u< ");
 988       if (Z == 0)
 989         fprintf_filtered (file, "!= ");
 990       if (Z == 1)
 991         fprintf_filtered (file, "== ");
 992       if ((N ^ V) == 0)
 993         fprintf_filtered (file, ">= ");
 994       if ((N ^ V) == 1)
 995         fprintf_filtered (file, "< ");
 996       if ((Z | (N ^ V)) == 0)
 997         fprintf_filtered (file, "> ");
 998       if ((Z | (N ^ V)) == 1)
 999         fprintf_filtered (file, "<= ");
1000     }
1001   else if (regno == E_PSEUDO_EXR_REGNUM && h8300smode)
1002     {
1003       /* EXR register */
1004       unsigned char l = rval & 0xff;
1005       fprintf_filtered (file, "\t");
1006       fprintf_filtered (file, "T-%d - - - ", (l & 0x80) != 0);
1007       fprintf_filtered (file, "I2-%d ", (l & 4) != 0);
1008       fprintf_filtered (file, "I1-%d ", (l & 2) != 0);
1009       fprintf_filtered (file, "I0-%d", (l & 1) != 0);
1010     }
1011   fprintf_filtered (file, "\n");
1012 }
1013
1014 static void
1015 h8300_print_registers_info (struct gdbarch *gdbarch, struct ui_file *file,
1016                             struct frame_info *frame, int regno, int cpregs)
1017 {
1018   if (regno < 0)
1019     {
1020       for (regno = E_R0_REGNUM; regno <= E_SP_REGNUM; ++regno)
1021         h8300_print_register (gdbarch, file, frame, regno);
1022       h8300_print_register (gdbarch, file, frame, E_PSEUDO_CCR_REGNUM);
1023       h8300_print_register (gdbarch, file, frame, E_PC_REGNUM);
1024       if (h8300smode)
1025         {
1026           h8300_print_register (gdbarch, file, frame, E_PSEUDO_EXR_REGNUM);
1027           if (h8300sxmode)
1028             {
1029               h8300_print_register (gdbarch, file, frame, E_SBR_REGNUM);
1030               h8300_print_register (gdbarch, file, frame, E_VBR_REGNUM);
1031               h8300_print_register (gdbarch, file, frame, E_MACH_REGNUM);
1032               h8300_print_register (gdbarch, file, frame, E_MACL_REGNUM);
1033             }
1034           h8300_print_register (gdbarch, file, frame, E_CYCLES_REGNUM);
1035           h8300_print_register (gdbarch, file, frame, E_TICKS_REGNUM);
1036           h8300_print_register (gdbarch, file, frame, E_INSTS_REGNUM);
1037         }
1038       else
1039         {
1040           h8300_print_register (gdbarch, file, frame, E_CYCLES_REGNUM);
1041           h8300_print_register (gdbarch, file, frame, E_TICK_REGNUM);
1042           h8300_print_register (gdbarch, file, frame, E_INST_REGNUM);
1043         }
1044     }
1045   else
1046     {
1047       if (regno == E_CCR_REGNUM)
1048         h8300_print_register (gdbarch, file, frame, E_PSEUDO_CCR_REGNUM);
1049       else if (regno == E_PSEUDO_EXR_REGNUM && h8300smode)
1050         h8300_print_register (gdbarch, file, frame, E_PSEUDO_EXR_REGNUM);
1051       else
1052         h8300_print_register (gdbarch, file, frame, regno);
1053     }
1054 }
1055
1056 static CORE_ADDR
1057 h8300_saved_pc_after_call (struct frame_info *ignore)
1058 {
1059   return read_memory_unsigned_integer (read_register (E_SP_REGNUM), BINWORD);
1060 }
1061
1062 static struct type *
1063 h8300_register_type (struct gdbarch *gdbarch, int regno)
1064 {
1065   if (regno < 0 || regno >= NUM_REGS + NUM_PSEUDO_REGS)
1066     internal_error (__FILE__, __LINE__,
1067                     "h8300_register_type: illegal register number %d",
1068                     regno);
1069   else
1070     {
1071       switch (regno)
1072         {
1073           case E_PC_REGNUM:
1074             return builtin_type_void_func_ptr;
1075           case E_SP_REGNUM:
1076           case E_FP_REGNUM:
1077             return builtin_type_void_data_ptr;
1078           default:
1079             if (regno == E_PSEUDO_CCR_REGNUM)
1080               return builtin_type_uint8;
1081             else if (regno == E_PSEUDO_EXR_REGNUM)
1082               return builtin_type_uint8;
1083             else if (h8300hmode)
1084               return builtin_type_int32;
1085             else
1086               return builtin_type_int16;
1087         }
1088     }
1089 }
1090
1091 static void
1092 h8300_pseudo_register_read (struct gdbarch *gdbarch, struct regcache *regcache,
1093                             int regno, void *buf)
1094 {
1095   if (regno == E_PSEUDO_CCR_REGNUM)
1096     regcache_raw_read (regcache, E_CCR_REGNUM, buf);
1097   else if (regno == E_PSEUDO_EXR_REGNUM)
1098     regcache_raw_read (regcache, E_EXR_REGNUM, buf);
1099   else
1100     regcache_raw_read (regcache, regno, buf);
1101 }
1102
1103 static void
1104 h8300_pseudo_register_write (struct gdbarch *gdbarch, struct regcache *regcache,
1105                              int regno, const void *buf)
1106 {
1107   if (regno == E_PSEUDO_CCR_REGNUM)
1108     regcache_raw_write (regcache, E_CCR_REGNUM, buf);
1109   else if (regno == E_PSEUDO_EXR_REGNUM)
1110     regcache_raw_write (regcache, E_EXR_REGNUM, buf);
1111   else
1112     regcache_raw_write (regcache, regno, buf);
1113 }
1114
1115 static int
1116 h8300_dbg_reg_to_regnum (int regno)
1117 {
1118   if (regno == E_CCR_REGNUM)
1119     return E_PSEUDO_CCR_REGNUM;
1120   return regno;
1121 }
1122
1123 static int
1124 h8300s_dbg_reg_to_regnum (int regno)
1125 {
1126   if (regno == E_CCR_REGNUM)
1127     return E_PSEUDO_CCR_REGNUM;
1128   if (regno == E_EXR_REGNUM)
1129     return E_PSEUDO_EXR_REGNUM;
1130   return regno;
1131 }
1132
1133 static CORE_ADDR
1134 h8300_extract_struct_value_address (struct regcache *regcache)
1135 {
1136   ULONGEST addr;
1137   regcache_cooked_read_unsigned (regcache, E_RET0_REGNUM, &addr);
1138   return addr;
1139 }
1140
1141 const static unsigned char *
1142 h8300_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr)
1143 {
1144   /*static unsigned char breakpoint[] = { 0x7A, 0xFF };*/       /* ??? */
1145   static unsigned char breakpoint[] = { 0x01, 0x80 };           /* Sleep */
1146
1147   *lenptr = sizeof (breakpoint);
1148   return breakpoint;
1149 }
1150
1151 static CORE_ADDR
1152 h8300_push_dummy_code (struct gdbarch *gdbarch,
1153                        CORE_ADDR sp, CORE_ADDR funaddr, int using_gcc,
1154                        struct value **args, int nargs,
1155                        struct type *value_type,
1156                        CORE_ADDR *real_pc, CORE_ADDR *bp_addr)
1157 {
1158   /* Allocate space sufficient for a breakpoint.  */
1159   sp = (sp - 2) & ~1;
1160   /* Store the address of that breakpoint */
1161   *bp_addr = sp;
1162   /* h8300 always starts the call at the callee's entry point.  */
1163   *real_pc = funaddr;
1164   return sp;
1165 }
1166
1167 static void
1168 h8300_print_float_info (struct gdbarch *gdbarch, struct ui_file *file,
1169                         struct frame_info *frame, const char *args)
1170 {
1171   fprintf_filtered (file, "\
1172 No floating-point info available for this processor.\n");
1173 }
1174
1175 static struct gdbarch *
1176 h8300_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
1177 {
1178   struct gdbarch_tdep *tdep = NULL;
1179   struct gdbarch *gdbarch;
1180
1181   arches = gdbarch_list_lookup_by_info (arches, &info);
1182   if (arches != NULL)
1183     return arches->gdbarch;
1184
1185 #if 0
1186   tdep = (struct gdbarch_tdep *) xmalloc (sizeof (struct gdbarch_tdep));
1187 #endif
1188
1189   if (info.bfd_arch_info->arch != bfd_arch_h8300)
1190     return NULL;
1191
1192   gdbarch = gdbarch_alloc (&info, 0);
1193
1194   switch (info.bfd_arch_info->mach)
1195     {
1196     case bfd_mach_h8300:
1197       h8300sxmode = 0;
1198       h8300smode = 0;
1199       h8300hmode = 0;
1200       set_gdbarch_num_regs (gdbarch, 13);
1201       set_gdbarch_num_pseudo_regs (gdbarch, 1);
1202       set_gdbarch_ecoff_reg_to_regnum (gdbarch, h8300_dbg_reg_to_regnum);
1203       set_gdbarch_dwarf_reg_to_regnum (gdbarch, h8300_dbg_reg_to_regnum);
1204       set_gdbarch_dwarf2_reg_to_regnum (gdbarch, h8300_dbg_reg_to_regnum);
1205       set_gdbarch_stab_reg_to_regnum (gdbarch, h8300_dbg_reg_to_regnum);
1206       set_gdbarch_register_name (gdbarch, h8300_register_name);
1207       set_gdbarch_ptr_bit (gdbarch, 2 * TARGET_CHAR_BIT);
1208       set_gdbarch_addr_bit (gdbarch, 2 * TARGET_CHAR_BIT);
1209       set_gdbarch_extract_return_value (gdbarch, h8300_extract_return_value);
1210       set_gdbarch_store_return_value (gdbarch, h8300_store_return_value);
1211       set_gdbarch_print_insn (gdbarch, print_insn_h8300);
1212       break;
1213     case bfd_mach_h8300h:
1214     case bfd_mach_h8300hn:
1215       h8300sxmode = 0;
1216       h8300smode = 0;
1217       h8300hmode = 1;
1218       set_gdbarch_num_regs (gdbarch, 13);
1219       set_gdbarch_num_pseudo_regs (gdbarch, 1);
1220       set_gdbarch_ecoff_reg_to_regnum (gdbarch, h8300_dbg_reg_to_regnum);
1221       set_gdbarch_dwarf_reg_to_regnum (gdbarch, h8300_dbg_reg_to_regnum);
1222       set_gdbarch_dwarf2_reg_to_regnum (gdbarch, h8300_dbg_reg_to_regnum);
1223       set_gdbarch_stab_reg_to_regnum (gdbarch, h8300_dbg_reg_to_regnum);
1224       set_gdbarch_register_name (gdbarch, h8300_register_name);
1225       set_gdbarch_ptr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
1226       set_gdbarch_addr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
1227       set_gdbarch_extract_return_value (gdbarch, h8300h_extract_return_value);
1228       set_gdbarch_store_return_value (gdbarch, h8300h_store_return_value);
1229       set_gdbarch_print_insn (gdbarch, print_insn_h8300h);
1230       break;
1231     case bfd_mach_h8300s:
1232     case bfd_mach_h8300sn:
1233       h8300sxmode = 0;
1234       h8300smode = 1;
1235       h8300hmode = 1;
1236       set_gdbarch_num_regs (gdbarch, 14);
1237       set_gdbarch_num_pseudo_regs (gdbarch, 2);
1238       set_gdbarch_ecoff_reg_to_regnum (gdbarch, h8300s_dbg_reg_to_regnum);
1239       set_gdbarch_dwarf_reg_to_regnum (gdbarch, h8300s_dbg_reg_to_regnum);
1240       set_gdbarch_dwarf2_reg_to_regnum (gdbarch, h8300s_dbg_reg_to_regnum);
1241       set_gdbarch_stab_reg_to_regnum (gdbarch, h8300s_dbg_reg_to_regnum);
1242       set_gdbarch_register_name (gdbarch, h8300s_register_name);
1243       set_gdbarch_ptr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
1244       set_gdbarch_addr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
1245       set_gdbarch_extract_return_value (gdbarch, h8300h_extract_return_value);
1246       set_gdbarch_store_return_value (gdbarch, h8300h_store_return_value);
1247       set_gdbarch_print_insn (gdbarch, print_insn_h8300s);
1248       break;
1249     case bfd_mach_h8300sx:
1250     case bfd_mach_h8300sxn:
1251       h8300sxmode = 1;
1252       h8300smode = 1;
1253       h8300hmode = 1;
1254       set_gdbarch_num_regs (gdbarch, 18);
1255       set_gdbarch_num_pseudo_regs (gdbarch, 2);
1256       set_gdbarch_ecoff_reg_to_regnum (gdbarch, h8300s_dbg_reg_to_regnum);
1257       set_gdbarch_dwarf_reg_to_regnum (gdbarch, h8300s_dbg_reg_to_regnum);
1258       set_gdbarch_dwarf2_reg_to_regnum (gdbarch, h8300s_dbg_reg_to_regnum);
1259       set_gdbarch_stab_reg_to_regnum (gdbarch, h8300s_dbg_reg_to_regnum);
1260       set_gdbarch_register_name (gdbarch, h8300sx_register_name);
1261       set_gdbarch_ptr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
1262       set_gdbarch_addr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
1263       set_gdbarch_extract_return_value (gdbarch, h8300h_extract_return_value);
1264       set_gdbarch_store_return_value (gdbarch, h8300h_store_return_value);
1265       set_gdbarch_print_insn (gdbarch, print_insn_h8300s);
1266       break;
1267     }
1268
1269   set_gdbarch_pseudo_register_read (gdbarch, h8300_pseudo_register_read);
1270   set_gdbarch_pseudo_register_write (gdbarch, h8300_pseudo_register_write);
1271
1272   /* NOTE: cagney/2002-12-06: This can be deleted when this arch is
1273      ready to unwind the PC first (see frame.c:get_prev_frame()).  */
1274   set_gdbarch_deprecated_init_frame_pc (gdbarch, init_frame_pc_default);
1275
1276   /*
1277    * Basic register fields and methods.
1278    */
1279
1280   set_gdbarch_sp_regnum (gdbarch, E_SP_REGNUM);
1281   set_gdbarch_deprecated_fp_regnum (gdbarch, E_FP_REGNUM);
1282   set_gdbarch_pc_regnum (gdbarch, E_PC_REGNUM);
1283   set_gdbarch_register_type (gdbarch, h8300_register_type);
1284   set_gdbarch_print_registers_info (gdbarch, h8300_print_registers_info);
1285   set_gdbarch_print_float_info (gdbarch, h8300_print_float_info);
1286
1287   /*
1288    * Frame Info
1289    */
1290   set_gdbarch_skip_prologue (gdbarch, h8300_skip_prologue);
1291
1292   set_gdbarch_deprecated_frame_init_saved_regs (gdbarch,
1293                                                 h8300_frame_init_saved_regs);
1294   set_gdbarch_deprecated_init_extra_frame_info (gdbarch,
1295                                                 h8300_init_extra_frame_info);
1296   set_gdbarch_deprecated_frame_chain (gdbarch, h8300_frame_chain);
1297   set_gdbarch_deprecated_saved_pc_after_call (gdbarch,
1298                                               h8300_saved_pc_after_call);
1299   set_gdbarch_deprecated_frame_saved_pc (gdbarch, h8300_frame_saved_pc);
1300
1301   /*
1302    * Miscelany
1303    */
1304   /* Stack grows up. */
1305   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
1306   /* PC stops zero byte after a trap instruction
1307      (which means: exactly on trap instruction). */
1308   set_gdbarch_decr_pc_after_break (gdbarch, 0);
1309   /* This value is almost never non-zero... */
1310   set_gdbarch_function_start_offset (gdbarch, 0);
1311   /* This value is almost never non-zero... */
1312   set_gdbarch_frame_args_skip (gdbarch, 0);
1313   set_gdbarch_frameless_function_invocation (gdbarch,
1314                                              frameless_look_for_prologue);
1315
1316   set_gdbarch_extract_struct_value_address (gdbarch,
1317                                             h8300_extract_struct_value_address);
1318   set_gdbarch_use_struct_convention (gdbarch, always_use_struct_convention);
1319   set_gdbarch_breakpoint_from_pc (gdbarch, h8300_breakpoint_from_pc);
1320   set_gdbarch_push_dummy_code (gdbarch, h8300_push_dummy_code);
1321
1322   set_gdbarch_int_bit (gdbarch, 2 * TARGET_CHAR_BIT);
1323   set_gdbarch_long_bit (gdbarch, 4 * TARGET_CHAR_BIT);
1324   set_gdbarch_long_long_bit (gdbarch, 4 * TARGET_CHAR_BIT);
1325   set_gdbarch_double_bit (gdbarch, 4 * TARGET_CHAR_BIT);
1326   set_gdbarch_long_double_bit (gdbarch, 4 * TARGET_CHAR_BIT);
1327
1328   /* set_gdbarch_stack_align (gdbarch, SOME_stack_align); */
1329   set_gdbarch_believe_pcc_promotion (gdbarch, 1);
1330
1331   /*
1332    * Call Dummies
1333    *
1334    * These values and methods are used when gdb calls a target function.  */
1335   /* Can all be replaced by push_dummy_call */
1336   set_gdbarch_deprecated_push_return_address (gdbarch,
1337                                               h8300_push_return_address);
1338   set_gdbarch_deprecated_push_arguments (gdbarch, h8300_push_arguments);
1339   set_gdbarch_deprecated_pop_frame (gdbarch, h8300_pop_frame);
1340   set_gdbarch_deprecated_dummy_write_sp (gdbarch, deprecated_write_sp);
1341
1342
1343   return gdbarch;
1344 }
1345
1346 extern initialize_file_ftype _initialize_h8300_tdep; /* -Wmissing-prototypes */
1347
1348 void
1349 _initialize_h8300_tdep (void)
1350 {
1351   register_gdbarch_init (bfd_arch_h8300, h8300_gdbarch_init);
1352 }