gdb/h8300-tdep.c

   1 /* Target-machine dependent code for Renesas H8/300, for GDB.
   2
   3    Copyright (C) 1988, 1990-1996, 1998-2003, 2005, 2007-2012 Free
   4    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 3 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, see <http://www.gnu.org/licenses/>.  */
  20
  21 /*
  22    Contributed by Steve Chamberlain
  23    sac@cygnus.com
  24  */
  25
  26 #include "defs.h"
  27 #include "value.h"
  28 #include "arch-utils.h"
  29 #include "regcache.h"
  30 #include "gdbcore.h"
  31 #include "objfiles.h"
  32 #include "gdb_assert.h"
  33 #include "dis-asm.h"
  34 #include "dwarf2-frame.h"
  35 #include "frame-base.h"
  36 #include "frame-unwind.h"
  37
  38 enum gdb_regnum
  39 {
  40   E_R0_REGNUM, E_ER0_REGNUM = E_R0_REGNUM, E_ARG0_REGNUM = E_R0_REGNUM,
  41   E_RET0_REGNUM = E_R0_REGNUM,
  42   E_R1_REGNUM, E_ER1_REGNUM = E_R1_REGNUM, E_RET1_REGNUM = E_R1_REGNUM,
  43   E_R2_REGNUM, E_ER2_REGNUM = E_R2_REGNUM, E_ARGLAST_REGNUM = E_R2_REGNUM,
  44   E_R3_REGNUM, E_ER3_REGNUM = E_R3_REGNUM,
  45   E_R4_REGNUM, E_ER4_REGNUM = E_R4_REGNUM,
  46   E_R5_REGNUM, E_ER5_REGNUM = E_R5_REGNUM,
  47   E_R6_REGNUM, E_ER6_REGNUM = E_R6_REGNUM, E_FP_REGNUM = E_R6_REGNUM,
  48   E_SP_REGNUM,
  49   E_CCR_REGNUM,
  50   E_PC_REGNUM,
  51   E_CYCLES_REGNUM,
  52   E_TICK_REGNUM, E_EXR_REGNUM = E_TICK_REGNUM,
  53   E_INST_REGNUM, E_TICKS_REGNUM = E_INST_REGNUM,
  54   E_INSTS_REGNUM,
  55   E_MACH_REGNUM,
  56   E_MACL_REGNUM,
  57   E_SBR_REGNUM,
  58   E_VBR_REGNUM
  59 };
  60
  61 #define H8300_MAX_NUM_REGS 18
  62
  63 #define E_PSEUDO_CCR_REGNUM(gdbarch) (gdbarch_num_regs (gdbarch))
  64 #define E_PSEUDO_EXR_REGNUM(gdbarch) (gdbarch_num_regs (gdbarch)+1)
  65
  66 struct h8300_frame_cache
  67 {
  68   /* Base address.  */
  69   CORE_ADDR base;
  70   CORE_ADDR sp_offset;
  71   CORE_ADDR pc;
  72
  73   /* Flag showing that a frame has been created in the prologue code.  */
  74   int uses_fp;
  75
  76   /* Saved registers.  */
  77   CORE_ADDR saved_regs[H8300_MAX_NUM_REGS];
  78   CORE_ADDR saved_sp;
  79 };
  80
  81 enum
  82 {
  83   h8300_reg_size = 2,
  84   h8300h_reg_size = 4,
  85   h8300_max_reg_size = 4,
  86 };
  87
  88 static int is_h8300hmode (struct gdbarch *gdbarch);
  89 static int is_h8300smode (struct gdbarch *gdbarch);
  90 static int is_h8300sxmode (struct gdbarch *gdbarch);
  91 static int is_h8300_normal_mode (struct gdbarch *gdbarch);
  92
  93 #define BINWORD(gdbarch) ((is_h8300hmode (gdbarch) \
  94                   && !is_h8300_normal_mode (gdbarch)) \
  95                  ? h8300h_reg_size : h8300_reg_size)
  96
  97 static CORE_ADDR
  98 h8300_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
  99 {
 100   return frame_unwind_register_unsigned (next_frame, E_PC_REGNUM);
 101 }
 102
 103 static CORE_ADDR
 104 h8300_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
 105 {
 106   return frame_unwind_register_unsigned (next_frame, E_SP_REGNUM);
 107 }
 108
 109 static struct frame_id
 110 h8300_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
 111 {
 112   CORE_ADDR sp = get_frame_register_unsigned (this_frame, E_SP_REGNUM);
 113   return frame_id_build (sp, get_frame_pc (this_frame));
 114 }
 115
 116 /* Normal frames.  */
 117
 118 /* Allocate and initialize a frame cache.  */
 119
 120 static void
 121 h8300_init_frame_cache (struct gdbarch *gdbarch,
 122                         struct h8300_frame_cache *cache)
 123 {
 124   int i;
 125
 126   /* Base address.  */
 127   cache->base = 0;
 128   cache->sp_offset = 0;
 129   cache->pc = 0;
 130
 131   /* Frameless until proven otherwise.  */
 132   cache->uses_fp = 0;
 133
 134   /* Saved registers.  We initialize these to -1 since zero is a valid
 135      offset (that's where %fp is supposed to be stored).  */
 136   for (i = 0; i < gdbarch_num_regs (gdbarch); i++)
 137     cache->saved_regs[i] = -1;
 138 }
 139
 140 #define IS_MOVB_RnRm(x)         (((x) & 0xff88) == 0x0c88)
 141 #define IS_MOVW_RnRm(x)         (((x) & 0xff88) == 0x0d00)
 142 #define IS_MOVL_RnRm(x)         (((x) & 0xff88) == 0x0f80)
 143 #define IS_MOVB_Rn16_SP(x)      (((x) & 0xfff0) == 0x6ee0)
 144 #define IS_MOVB_EXT(x)          ((x) == 0x7860)
 145 #define IS_MOVB_Rn24_SP(x)      (((x) & 0xfff0) == 0x6aa0)
 146 #define IS_MOVW_Rn16_SP(x)      (((x) & 0xfff0) == 0x6fe0)
 147 #define IS_MOVW_EXT(x)          ((x) == 0x78e0)
 148 #define IS_MOVW_Rn24_SP(x)      (((x) & 0xfff0) == 0x6ba0)
 149 /* Same instructions as mov.w, just prefixed with 0x0100.  */
 150 #define IS_MOVL_PRE(x)          ((x) == 0x0100)
 151 #define IS_MOVL_Rn16_SP(x)      (((x) & 0xfff0) == 0x6fe0)
 152 #define IS_MOVL_EXT(x)          ((x) == 0x78e0)
 153 #define IS_MOVL_Rn24_SP(x)      (((x) & 0xfff0) == 0x6ba0)
 154
 155 #define IS_PUSHFP_MOVESPFP(x)   ((x) == 0x6df60d76)
 156 #define IS_PUSH_FP(x)           ((x) == 0x01006df6)
 157 #define IS_MOV_SP_FP(x)         ((x) == 0x0ff6)
 158 #define IS_SUB2_SP(x)           ((x) == 0x1b87)
 159 #define IS_SUB4_SP(x)           ((x) == 0x1b97)
 160 #define IS_ADD_IMM_SP(x)        ((x) == 0x7a1f)
 161 #define IS_SUB_IMM_SP(x)        ((x) == 0x7a3f)
 162 #define IS_SUBL4_SP(x)          ((x) == 0x1acf)
 163 #define IS_MOV_IMM_Rn(x)        (((x) & 0xfff0) == 0x7905)
 164 #define IS_SUB_RnSP(x)          (((x) & 0xff0f) == 0x1907)
 165 #define IS_ADD_RnSP(x)          (((x) & 0xff0f) == 0x0907)
 166 #define IS_PUSH(x)              (((x) & 0xfff0) == 0x6df0)
 167
 168 /* If the instruction at PC is an argument register spill, return its
 169    length.  Otherwise, return zero.
 170
 171    An argument register spill is an instruction that moves an argument
 172    from the register in which it was passed to the stack slot in which
 173    it really lives.  It is a byte, word, or longword move from an
 174    argument register to a negative offset from the frame pointer.
 175
 176    CV, 2003-06-16: Or, in optimized code or when the `register' qualifier
 177    is used, it could be a byte, word or long move to registers r3-r5.  */
 178
 179 static int
 180 h8300_is_argument_spill (struct gdbarch *gdbarch, CORE_ADDR pc)
 181 {
 182   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 183   int w = read_memory_unsigned_integer (pc, 2, byte_order);
 184
 185   if ((IS_MOVB_RnRm (w) || IS_MOVW_RnRm (w) || IS_MOVL_RnRm (w))
 186       && (w & 0x70) <= 0x20     /* Rs is R0, R1 or R2 */
 187       && (w & 0x7) >= 0x3 && (w & 0x7) <= 0x5)  /* Rd is R3, R4 or R5 */
 188     return 2;
 189
 190   if (IS_MOVB_Rn16_SP (w)
 191       && 8 <= (w & 0xf) && (w & 0xf) <= 10)     /* Rs is R0L, R1L, or R2L  */
 192     {
 193       /* ... and d:16 is negative.  */
 194       if (read_memory_integer (pc + 2, 2, byte_order) < 0)
 195         return 4;
 196     }
 197   else if (IS_MOVB_EXT (w))
 198     {
 199       if (IS_MOVB_Rn24_SP (read_memory_unsigned_integer (pc + 2,
 200                                                          2, byte_order)))
 201         {
 202           LONGEST disp = read_memory_integer (pc + 4, 4, byte_order);
 203
 204           /* ... and d:24 is negative.  */
 205           if (disp < 0 && disp > 0xffffff)
 206             return 8;
 207         }
 208     }
 209   else if (IS_MOVW_Rn16_SP (w)
 210            && (w & 0xf) <= 2)   /* Rs is R0, R1, or R2 */
 211     {
 212       /* ... and d:16 is negative.  */
 213       if (read_memory_integer (pc + 2, 2, byte_order) < 0)
 214         return 4;
 215     }
 216   else if (IS_MOVW_EXT (w))
 217     {
 218       if (IS_MOVW_Rn24_SP (read_memory_unsigned_integer (pc + 2,
 219                                                          2, byte_order)))
 220         {
 221           LONGEST disp = read_memory_integer (pc + 4, 4, byte_order);
 222
 223           /* ... and d:24 is negative.  */
 224           if (disp < 0 && disp > 0xffffff)
 225             return 8;
 226         }
 227     }
 228   else if (IS_MOVL_PRE (w))
 229     {
 230       int w2 = read_memory_integer (pc + 2, 2, byte_order);
 231
 232       if (IS_MOVL_Rn16_SP (w2)
 233           && (w2 & 0xf) <= 2)   /* Rs is ER0, ER1, or ER2 */
 234         {
 235           /* ... and d:16 is negative.  */
 236           if (read_memory_integer (pc + 4, 2, byte_order) < 0)
 237             return 6;
 238         }
 239       else if (IS_MOVL_EXT (w2))
 240         {
 241           int w3 = read_memory_integer (pc + 4, 2, byte_order);
 242
 243           if (IS_MOVL_Rn24_SP (read_memory_integer (pc + 4, 2, byte_order)))
 244             {
 245               LONGEST disp = read_memory_integer (pc + 6, 4, byte_order);
 246
 247               /* ... and d:24 is negative.  */
 248               if (disp < 0 && disp > 0xffffff)
 249                 return 10;
 250             }
 251         }
 252     }
 253
 254   return 0;
 255 }
 256
 257 /* Do a full analysis of the prologue at PC and update CACHE
 258    accordingly.  Bail out early if CURRENT_PC is reached.  Return the
 259    address where the analysis stopped.
 260
 261    We handle all cases that can be generated by gcc.
 262
 263    For allocating a stack frame:
 264
 265    mov.w r6,@-sp
 266    mov.w sp,r6
 267    mov.w #-n,rN
 268    add.w rN,sp
 269
 270    mov.w r6,@-sp
 271    mov.w sp,r6
 272    subs  #2,sp
 273    (repeat)
 274
 275    mov.l er6,@-sp
 276    mov.l sp,er6
 277    add.l #-n,sp
 278
 279    mov.w r6,@-sp
 280    mov.w sp,r6
 281    subs  #4,sp
 282    (repeat)
 283
 284    For saving registers:
 285
 286    mov.w rN,@-sp
 287    mov.l erN,@-sp
 288    stm.l reglist,@-sp
 289
 290    */
 291
 292 static CORE_ADDR
 293 h8300_analyze_prologue (struct gdbarch *gdbarch,
 294                         CORE_ADDR pc, CORE_ADDR current_pc,
 295                         struct h8300_frame_cache *cache)
 296 {
 297   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 298   unsigned int op;
 299   int regno, i, spill_size;
 300
 301   cache->sp_offset = 0;
 302
 303   if (pc >= current_pc)
 304     return current_pc;
 305
 306   op = read_memory_unsigned_integer (pc, 4, byte_order);
 307
 308   if (IS_PUSHFP_MOVESPFP (op))
 309     {
 310       cache->saved_regs[E_FP_REGNUM] = 0;
 311       cache->uses_fp = 1;
 312       pc += 4;
 313     }
 314   else if (IS_PUSH_FP (op))
 315     {
 316       cache->saved_regs[E_FP_REGNUM] = 0;
 317       pc += 4;
 318       if (pc >= current_pc)
 319         return current_pc;
 320       op = read_memory_unsigned_integer (pc, 2, byte_order);
 321       if (IS_MOV_SP_FP (op))
 322         {
 323           cache->uses_fp = 1;
 324           pc += 2;
 325         }
 326     }
 327
 328   while (pc < current_pc)
 329     {
 330       op = read_memory_unsigned_integer (pc, 2, byte_order);
 331       if (IS_SUB2_SP (op))
 332         {
 333           cache->sp_offset += 2;
 334           pc += 2;
 335         }
 336       else if (IS_SUB4_SP (op))
 337         {
 338           cache->sp_offset += 4;
 339           pc += 2;
 340         }
 341       else if (IS_ADD_IMM_SP (op))
 342         {
 343           cache->sp_offset += -read_memory_integer (pc + 2, 2, byte_order);
 344           pc += 4;
 345         }
 346       else if (IS_SUB_IMM_SP (op))
 347         {
 348           cache->sp_offset += read_memory_integer (pc + 2, 2, byte_order);
 349           pc += 4;
 350         }
 351       else if (IS_SUBL4_SP (op))
 352         {
 353           cache->sp_offset += 4;
 354           pc += 2;
 355         }
 356       else if (IS_MOV_IMM_Rn (op))
 357         {
 358           int offset = read_memory_integer (pc + 2, 2, byte_order);
 359           regno = op & 0x000f;
 360           op = read_memory_unsigned_integer (pc + 4, 2, byte_order);
 361           if (IS_ADD_RnSP (op) && (op & 0x00f0) == regno)
 362             {
 363               cache->sp_offset -= offset;
 364               pc += 6;
 365             }
 366           else if (IS_SUB_RnSP (op) && (op & 0x00f0) == regno)
 367             {
 368               cache->sp_offset += offset;
 369               pc += 6;
 370             }
 371           else
 372             break;
 373         }
 374       else if (IS_PUSH (op))
 375         {
 376           regno = op & 0x000f;
 377           cache->sp_offset += 2;
 378           cache->saved_regs[regno] = cache->sp_offset;
 379           pc += 2;
 380         }
 381       else if (op == 0x0100)
 382         {
 383           op = read_memory_unsigned_integer (pc + 2, 2, byte_order);
 384           if (IS_PUSH (op))
 385             {
 386               regno = op & 0x000f;
 387               cache->sp_offset += 4;
 388               cache->saved_regs[regno] = cache->sp_offset;
 389               pc += 4;
 390             }
 391           else
 392             break;
 393         }
 394       else if ((op & 0xffcf) == 0x0100)
 395         {
 396           int op1;
 397           op1 = read_memory_unsigned_integer (pc + 2, 2, byte_order);
 398           if (IS_PUSH (op1))
 399             {
 400               /* Since the prefix is 0x01x0, this is not a simple pushm but a
 401                  stm.l reglist,@-sp */
 402               i = ((op & 0x0030) >> 4) + 1;
 403               regno = op1 & 0x000f;
 404               for (; i > 0; regno++, --i)
 405                 {
 406                   cache->sp_offset += 4;
 407                   cache->saved_regs[regno] = cache->sp_offset;
 408                 }
 409               pc += 4;
 410             }
 411           else
 412             break;
 413         }
 414       else
 415         break;
 416     }
 417
 418   /* Check for spilling an argument register to the stack frame.
 419      This could also be an initializing store from non-prologue code,
 420      but I don't think there's any harm in skipping that.  */
 421   while ((spill_size = h8300_is_argument_spill (gdbarch, pc)) > 0
 422          && pc + spill_size <= current_pc)
 423     pc += spill_size;
 424
 425   return pc;
 426 }
 427
 428 static struct h8300_frame_cache *
 429 h8300_frame_cache (struct frame_info *this_frame, void **this_cache)
 430 {
 431   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 432   struct h8300_frame_cache *cache;
 433   int i;
 434   CORE_ADDR current_pc;
 435
 436   if (*this_cache)
 437     return *this_cache;
 438
 439   cache = FRAME_OBSTACK_ZALLOC (struct h8300_frame_cache);
 440   h8300_init_frame_cache (gdbarch, cache);
 441   *this_cache = cache;
 442
 443   /* In principle, for normal frames, %fp holds the frame pointer,
 444      which holds the base address for the current stack frame.
 445      However, for functions that don't need it, the frame pointer is
 446      optional.  For these "frameless" functions the frame pointer is
 447      actually the frame pointer of the calling frame.  */
 448
 449   cache->base = get_frame_register_unsigned (this_frame, E_FP_REGNUM);
 450   if (cache->base == 0)
 451     return cache;
 452
 453   cache->saved_regs[E_PC_REGNUM] = -BINWORD (gdbarch);
 454
 455   cache->pc = get_frame_func (this_frame);
 456   current_pc = get_frame_pc (this_frame);
 457   if (cache->pc != 0)
 458     h8300_analyze_prologue (gdbarch, cache->pc, current_pc, cache);
 459
 460   if (!cache->uses_fp)
 461     {
 462       /* We didn't find a valid frame, which means that CACHE->base
 463          currently holds the frame pointer for our calling frame.  If
 464          we're at the start of a function, or somewhere half-way its
 465          prologue, the function's frame probably hasn't been fully
 466          setup yet.  Try to reconstruct the base address for the stack
 467          frame by looking at the stack pointer.  For truly "frameless"
 468          functions this might work too.  */
 469
 470       cache->base = get_frame_register_unsigned (this_frame, E_SP_REGNUM)
 471                     + cache->sp_offset;
 472       cache->saved_sp = cache->base + BINWORD (gdbarch);
 473       cache->saved_regs[E_PC_REGNUM] = 0;
 474     }
 475   else
 476     {
 477       cache->saved_sp = cache->base + 2 * BINWORD (gdbarch);
 478       cache->saved_regs[E_PC_REGNUM] = -BINWORD (gdbarch);
 479     }
 480
 481   /* Adjust all the saved registers such that they contain addresses
 482      instead of offsets.  */
 483   for (i = 0; i < gdbarch_num_regs (gdbarch); i++)
 484     if (cache->saved_regs[i] != -1)
 485       cache->saved_regs[i] = cache->base - cache->saved_regs[i];
 486
 487   return cache;
 488 }
 489
 490 static void
 491 h8300_frame_this_id (struct frame_info *this_frame, void **this_cache,
 492                      struct frame_id *this_id)
 493 {
 494   struct h8300_frame_cache *cache =
 495     h8300_frame_cache (this_frame, this_cache);
 496
 497   /* This marks the outermost frame.  */
 498   if (cache->base == 0)
 499     return;
 500
 501   *this_id = frame_id_build (cache->saved_sp, cache->pc);
 502 }
 503
 504 static struct value *
 505 h8300_frame_prev_register (struct frame_info *this_frame, void **this_cache,
 506                            int regnum)
 507 {
 508   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 509   struct h8300_frame_cache *cache =
 510     h8300_frame_cache (this_frame, this_cache);
 511
 512   gdb_assert (regnum >= 0);
 513
 514   if (regnum == E_SP_REGNUM && cache->saved_sp)
 515     return frame_unwind_got_constant (this_frame, regnum, cache->saved_sp);
 516
 517   if (regnum < gdbarch_num_regs (gdbarch)
 518       && cache->saved_regs[regnum] != -1)
 519     return frame_unwind_got_memory (this_frame, regnum,
 520                                     cache->saved_regs[regnum]);
 521
 522   return frame_unwind_got_register (this_frame, regnum, regnum);
 523 }
 524
 525 static const struct frame_unwind h8300_frame_unwind = {
 526   NORMAL_FRAME,
 527   default_frame_unwind_stop_reason,
 528   h8300_frame_this_id,
 529   h8300_frame_prev_register,
 530   NULL,
 531   default_frame_sniffer
 532 };
 533
 534 static CORE_ADDR
 535 h8300_frame_base_address (struct frame_info *this_frame, void **this_cache)
 536 {
 537   struct h8300_frame_cache *cache = h8300_frame_cache (this_frame, this_cache);
 538   return cache->base;
 539 }
 540
 541 static const struct frame_base h8300_frame_base = {
 542   &h8300_frame_unwind,
 543   h8300_frame_base_address,
 544   h8300_frame_base_address,
 545   h8300_frame_base_address
 546 };
 547
 548 static CORE_ADDR
 549 h8300_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
 550 {
 551   CORE_ADDR func_addr = 0 , func_end = 0;
 552
 553   if (find_pc_partial_function (pc, NULL, &func_addr, &func_end))
 554     {
 555       struct symtab_and_line sal;
 556       struct h8300_frame_cache cache;
 557
 558       /* Found a function.  */
 559       sal = find_pc_line (func_addr, 0);
 560       if (sal.end && sal.end < func_end)
 561         /* Found a line number, use it as end of prologue.  */
 562         return sal.end;
 563
 564       /* No useable line symbol.  Use prologue parsing method.  */
 565       h8300_init_frame_cache (gdbarch, &cache);
 566       return h8300_analyze_prologue (gdbarch, func_addr, func_end, &cache);
 567     }
 568
 569   /* No function symbol -- just return the PC.  */
 570   return (CORE_ADDR) pc;
 571 }
 572
 573 /* Function: push_dummy_call
 574    Setup the function arguments for calling a function in the inferior.
 575    In this discussion, a `word' is 16 bits on the H8/300s, and 32 bits
 576    on the H8/300H.
 577
 578    There are actually two ABI's here: -mquickcall (the default) and
 579    -mno-quickcall.  With -mno-quickcall, all arguments are passed on
 580    the stack after the return address, word-aligned.  With
 581    -mquickcall, GCC tries to use r0 -- r2 to pass registers.  Since
 582    GCC doesn't indicate in the object file which ABI was used to
 583    compile it, GDB only supports the default --- -mquickcall.
 584
 585    Here are the rules for -mquickcall, in detail:
 586
 587    Each argument, whether scalar or aggregate, is padded to occupy a
 588    whole number of words.  Arguments smaller than a word are padded at
 589    the most significant end; those larger than a word are padded at
 590    the least significant end.
 591
 592    The initial arguments are passed in r0 -- r2.  Earlier arguments go in
 593    lower-numbered registers.  Multi-word arguments are passed in
 594    consecutive registers, with the most significant end in the
 595    lower-numbered register.
 596
 597    If an argument doesn't fit entirely in the remaining registers, it
 598    is passed entirely on the stack.  Stack arguments begin just after
 599    the return address.  Once an argument has overflowed onto the stack
 600    this way, all subsequent arguments are passed on the stack.
 601
 602    The above rule has odd consequences.  For example, on the h8/300s,
 603    if a function takes two longs and an int as arguments:
 604    - the first long will be passed in r0/r1,
 605    - the second long will be passed entirely on the stack, since it
 606      doesn't fit in r2,
 607    - and the int will be passed on the stack, even though it could fit
 608      in r2.
 609
 610    A weird exception: if an argument is larger than a word, but not a
 611    whole number of words in length (before padding), it is passed on
 612    the stack following the rules for stack arguments above, even if
 613    there are sufficient registers available to hold it.  Stranger
 614    still, the argument registers are still `used up' --- even though
 615    there's nothing in them.
 616
 617    So, for example, on the h8/300s, if a function expects a three-byte
 618    structure and an int, the structure will go on the stack, and the
 619    int will go in r2, not r0.
 620
 621    If the function returns an aggregate type (struct, union, or class)
 622    by value, the caller must allocate space to hold the return value,
 623    and pass the callee a pointer to this space as an invisible first
 624    argument, in R0.
 625
 626    For varargs functions, the last fixed argument and all the variable
 627    arguments are always passed on the stack.  This means that calls to
 628    varargs functions don't work properly unless there is a prototype
 629    in scope.
 630
 631    Basically, this ABI is not good, for the following reasons:
 632    - You can't call vararg functions properly unless a prototype is in scope.
 633    - Structure passing is inconsistent, to no purpose I can see.
 634    - It often wastes argument registers, of which there are only three
 635      to begin with.  */
 636
 637 static CORE_ADDR
 638 h8300_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 639                        struct regcache *regcache, CORE_ADDR bp_addr,
 640                        int nargs, struct value **args, CORE_ADDR sp,
 641                        int struct_return, CORE_ADDR struct_addr)
 642 {
 643   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 644   int stack_alloc = 0, stack_offset = 0;
 645   int wordsize = BINWORD (gdbarch);
 646   int reg = E_ARG0_REGNUM;
 647   int argument;
 648
 649   /* First, make sure the stack is properly aligned.  */
 650   sp = align_down (sp, wordsize);
 651
 652   /* Now make sure there's space on the stack for the arguments.  We
 653      may over-allocate a little here, but that won't hurt anything.  */
 654   for (argument = 0; argument < nargs; argument++)
 655     stack_alloc += align_up (TYPE_LENGTH (value_type (args[argument])),
 656                              wordsize);
 657   sp -= stack_alloc;
 658
 659   /* Now load as many arguments as possible into registers, and push
 660      the rest onto the stack.
 661      If we're returning a structure by value, then we must pass a
 662      pointer to the buffer for the return value as an invisible first
 663      argument.  */
 664   if (struct_return)
 665     regcache_cooked_write_unsigned (regcache, reg++, struct_addr);
 666
 667   for (argument = 0; argument < nargs; argument++)
 668     {
 669       struct cleanup *back_to;
 670       struct type *type = value_type (args[argument]);
 671       int len = TYPE_LENGTH (type);
 672       char *contents = (char *) value_contents (args[argument]);
 673
 674       /* Pad the argument appropriately.  */
 675       int padded_len = align_up (len, wordsize);
 676       gdb_byte *padded = xmalloc (padded_len);
 677       back_to = make_cleanup (xfree, padded);
 678
 679       memset (padded, 0, padded_len);
 680       memcpy (len < wordsize ? padded + padded_len - len : padded,
 681               contents, len);
 682
 683       /* Could the argument fit in the remaining registers?  */
 684       if (padded_len <= (E_ARGLAST_REGNUM - reg + 1) * wordsize)
 685         {
 686           /* Are we going to pass it on the stack anyway, for no good
 687              reason?  */
 688           if (len > wordsize && len % wordsize)
 689             {
 690               /* I feel so unclean.  */
 691               write_memory (sp + stack_offset, padded, padded_len);
 692               stack_offset += padded_len;
 693
 694               /* That's right --- even though we passed the argument
 695                  on the stack, we consume the registers anyway!  Love
 696                  me, love my dog.  */
 697               reg += padded_len / wordsize;
 698             }
 699           else
 700             {
 701               /* Heavens to Betsy --- it's really going in registers!
 702                  Note that on the h8/300s, there are gaps between the
 703                  registers in the register file.  */
 704               int offset;
 705
 706               for (offset = 0; offset < padded_len; offset += wordsize)
 707                 {
 708                   ULONGEST word
 709                     = extract_unsigned_integer (padded + offset,
 710                                                 wordsize, byte_order);
 711                   regcache_cooked_write_unsigned (regcache, reg++, word);
 712                 }
 713             }
 714         }
 715       else
 716         {
 717           /* It doesn't fit in registers!  Onto the stack it goes.  */
 718           write_memory (sp + stack_offset, padded, padded_len);
 719           stack_offset += padded_len;
 720
 721           /* Once one argument has spilled onto the stack, all
 722              subsequent arguments go on the stack.  */
 723           reg = E_ARGLAST_REGNUM + 1;
 724         }
 725
 726       do_cleanups (back_to);
 727     }
 728
 729   /* Store return address.  */
 730   sp -= wordsize;
 731   write_memory_unsigned_integer (sp, wordsize, byte_order, bp_addr);
 732
 733   /* Update stack pointer.  */
 734   regcache_cooked_write_unsigned (regcache, E_SP_REGNUM, sp);
 735
 736   /* Return the new stack pointer minus the return address slot since
 737      that's what DWARF2/GCC uses as the frame's CFA.  */
 738   return sp + wordsize;
 739 }
 740
 741 /* Function: extract_return_value
 742    Figure out where in REGBUF the called function has left its return value.
 743    Copy that into VALBUF.  Be sure to account for CPU type.   */
 744
 745 static void
 746 h8300_extract_return_value (struct type *type, struct regcache *regcache,
 747                             void *valbuf)
 748 {
 749   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 750   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 751   int len = TYPE_LENGTH (type);
 752   ULONGEST c, addr;
 753
 754   switch (TYPE_LENGTH (type))
 755     {
 756     case 1:
 757     case 2:
 758       regcache_cooked_read_unsigned (regcache, E_RET0_REGNUM, &c);
 759       store_unsigned_integer (valbuf, TYPE_LENGTH (type), byte_order, c);
 760       break;
 761     case 4:                     /* Needs two registers on plain H8/300 */
 762       regcache_cooked_read_unsigned (regcache, E_RET0_REGNUM, &c);
 763       store_unsigned_integer (valbuf, 2, byte_order, c);
 764       regcache_cooked_read_unsigned (regcache, E_RET1_REGNUM, &c);
 765       store_unsigned_integer ((void *)((char *) valbuf + 2), 2, byte_order, c);
 766       break;
 767     case 8:                     /* long long is now 8 bytes.  */
 768       if (TYPE_CODE (type) == TYPE_CODE_INT)
 769         {
 770           regcache_cooked_read_unsigned (regcache, E_RET0_REGNUM, &addr);
 771           c = read_memory_unsigned_integer ((CORE_ADDR) addr,
 772                                             TYPE_LENGTH (type), byte_order);
 773           store_unsigned_integer (valbuf, TYPE_LENGTH (type), byte_order, c);
 774         }
 775       else
 776         {
 777           error (_("I don't know how this 8 byte value is returned."));
 778         }
 779       break;
 780     }
 781 }
 782
 783 static void
 784 h8300h_extract_return_value (struct type *type, struct regcache *regcache,
 785                              void *valbuf)
 786 {
 787   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 788   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 789   ULONGEST c;
 790
 791   switch (TYPE_LENGTH (type))
 792     {
 793     case 1:
 794     case 2:
 795     case 4:
 796       regcache_cooked_read_unsigned (regcache, E_RET0_REGNUM, &c);
 797       store_unsigned_integer (valbuf, TYPE_LENGTH (type), byte_order, c);
 798       break;
 799     case 8:                     /* long long is now 8 bytes.  */
 800       if (TYPE_CODE (type) == TYPE_CODE_INT)
 801         {
 802           regcache_cooked_read_unsigned (regcache, E_RET0_REGNUM, &c);
 803           store_unsigned_integer (valbuf, 4, byte_order, c);
 804           regcache_cooked_read_unsigned (regcache, E_RET1_REGNUM, &c);
 805           store_unsigned_integer ((void *) ((char *) valbuf + 4), 4,
 806                                   byte_order, c);
 807         }
 808       else
 809         {
 810           error (_("I don't know how this 8 byte value is returned."));
 811         }
 812       break;
 813     }
 814 }
 815
 816 static int
 817 h8300_use_struct_convention (struct type *value_type)
 818 {
 819   /* Types of 1, 2 or 4 bytes are returned in R0/R1, everything else on the
 820      stack.  */
 821
 822   if (TYPE_CODE (value_type) == TYPE_CODE_STRUCT
 823       || TYPE_CODE (value_type) == TYPE_CODE_UNION)
 824     return 1;
 825   return !(TYPE_LENGTH (value_type) == 1
 826            || TYPE_LENGTH (value_type) == 2
 827            || TYPE_LENGTH (value_type) == 4);
 828 }
 829
 830 static int
 831 h8300h_use_struct_convention (struct type *value_type)
 832 {
 833   /* Types of 1, 2 or 4 bytes are returned in R0, INT types of 8 bytes are
 834      returned in R0/R1, everything else on the stack.  */
 835   if (TYPE_CODE (value_type) == TYPE_CODE_STRUCT
 836       || TYPE_CODE (value_type) == TYPE_CODE_UNION)
 837     return 1;
 838   return !(TYPE_LENGTH (value_type) == 1
 839            || TYPE_LENGTH (value_type) == 2
 840            || TYPE_LENGTH (value_type) == 4
 841            || (TYPE_LENGTH (value_type) == 8
 842                && TYPE_CODE (value_type) == TYPE_CODE_INT));
 843 }
 844
 845 /* Function: store_return_value
 846    Place the appropriate value in the appropriate registers.
 847    Primarily used by the RETURN command.  */
 848
 849 static void
 850 h8300_store_return_value (struct type *type, struct regcache *regcache,
 851                           const void *valbuf)
 852 {
 853   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 854   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 855   ULONGEST val;
 856
 857   switch (TYPE_LENGTH (type))
 858     {
 859     case 1:
 860     case 2:                     /* short...  */
 861       val = extract_unsigned_integer (valbuf, TYPE_LENGTH (type), byte_order);
 862       regcache_cooked_write_unsigned (regcache, E_RET0_REGNUM, val);
 863       break;
 864     case 4:                     /* long, float */
 865       val = extract_unsigned_integer (valbuf, TYPE_LENGTH (type), byte_order);
 866       regcache_cooked_write_unsigned (regcache, E_RET0_REGNUM,
 867                                       (val >> 16) & 0xffff);
 868       regcache_cooked_write_unsigned (regcache, E_RET1_REGNUM, val & 0xffff);
 869       break;
 870     case 8:                     /* long long, double and long double
 871                                    are all defined as 4 byte types so
 872                                    far so this shouldn't happen.  */
 873       error (_("I don't know how to return an 8 byte value."));
 874       break;
 875     }
 876 }
 877
 878 static void
 879 h8300h_store_return_value (struct type *type, struct regcache *regcache,
 880                            const void *valbuf)
 881 {
 882   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 883   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 884   ULONGEST val;
 885
 886   switch (TYPE_LENGTH (type))
 887     {
 888     case 1:
 889     case 2:
 890     case 4:                     /* long, float */
 891       val = extract_unsigned_integer (valbuf, TYPE_LENGTH (type), byte_order);
 892       regcache_cooked_write_unsigned (regcache, E_RET0_REGNUM, val);
 893       break;
 894     case 8:
 895       val = extract_unsigned_integer (valbuf, TYPE_LENGTH (type), byte_order);
 896       regcache_cooked_write_unsigned (regcache, E_RET0_REGNUM,
 897                                       (val >> 32) & 0xffffffff);
 898       regcache_cooked_write_unsigned (regcache, E_RET1_REGNUM,
 899                                       val & 0xffffffff);
 900       break;
 901     }
 902 }
 903
 904 static enum return_value_convention
 905 h8300_return_value (struct gdbarch *gdbarch, struct value *function,
 906                     struct type *type, struct regcache *regcache,
 907                     gdb_byte *readbuf, const gdb_byte *writebuf)
 908 {
 909   if (h8300_use_struct_convention (type))
 910     return RETURN_VALUE_STRUCT_CONVENTION;
 911   if (writebuf)
 912     h8300_store_return_value (type, regcache, writebuf);
 913   else if (readbuf)
 914     h8300_extract_return_value (type, regcache, readbuf);
 915   return RETURN_VALUE_REGISTER_CONVENTION;
 916 }
 917
 918 static enum return_value_convention
 919 h8300h_return_value (struct gdbarch *gdbarch, struct value *function,
 920                      struct type *type, struct regcache *regcache,
 921                      gdb_byte *readbuf, const gdb_byte *writebuf)
 922 {
 923   if (h8300h_use_struct_convention (type))
 924     {
 925       if (readbuf)
 926         {
 927           ULONGEST addr;
 928
 929           regcache_raw_read_unsigned (regcache, E_R0_REGNUM, &addr);
 930           read_memory (addr, readbuf, TYPE_LENGTH (type));
 931         }
 932
 933       return RETURN_VALUE_ABI_RETURNS_ADDRESS;
 934     }
 935   if (writebuf)
 936     h8300h_store_return_value (type, regcache, writebuf);
 937   else if (readbuf)
 938     h8300h_extract_return_value (type, regcache, readbuf);
 939   return RETURN_VALUE_REGISTER_CONVENTION;
 940 }
 941
 942 static struct cmd_list_element *setmachinelist;
 943
 944 static const char *
 945 h8300_register_name (struct gdbarch *gdbarch, int regno)
 946 {
 947   /* The register names change depending on which h8300 processor
 948      type is selected.  */
 949   static char *register_names[] = {
 950     "r0", "r1", "r2", "r3", "r4", "r5", "r6",
 951     "sp", "", "pc", "cycles", "tick", "inst",
 952     "ccr",                      /* pseudo register */
 953   };
 954   if (regno < 0
 955       || regno >= (sizeof (register_names) / sizeof (*register_names)))
 956     internal_error (__FILE__, __LINE__,
 957                     _("h8300_register_name: illegal register number %d"),
 958                     regno);
 959   else
 960     return register_names[regno];
 961 }
 962
 963 static const char *
 964 h8300s_register_name (struct gdbarch *gdbarch, int regno)
 965 {
 966   static char *register_names[] = {
 967     "er0", "er1", "er2", "er3", "er4", "er5", "er6",
 968     "sp", "", "pc", "cycles", "", "tick", "inst",
 969     "mach", "macl",
 970     "ccr", "exr"                /* pseudo registers */
 971   };
 972   if (regno < 0
 973       || regno >= (sizeof (register_names) / sizeof (*register_names)))
 974     internal_error (__FILE__, __LINE__,
 975                     _("h8300s_register_name: illegal register number %d"),
 976                     regno);
 977   else
 978     return register_names[regno];
 979 }
 980
 981 static const char *
 982 h8300sx_register_name (struct gdbarch *gdbarch, int regno)
 983 {
 984   static char *register_names[] = {
 985     "er0", "er1", "er2", "er3", "er4", "er5", "er6",
 986     "sp", "", "pc", "cycles", "", "tick", "inst",
 987     "mach", "macl", "sbr", "vbr",
 988     "ccr", "exr"                /* pseudo registers */
 989   };
 990   if (regno < 0
 991       || regno >= (sizeof (register_names) / sizeof (*register_names)))
 992     internal_error (__FILE__, __LINE__,
 993                     _("h8300sx_register_name: illegal register number %d"),
 994                     regno);
 995   else
 996     return register_names[regno];
 997 }
 998
 999 static void
1000 h8300_print_register (struct gdbarch *gdbarch, struct ui_file *file,
1001                       struct frame_info *frame, int regno)
1002 {
1003   LONGEST rval;
1004   const char *name = gdbarch_register_name (gdbarch, regno);
1005
1006   if (!name || !*name)
1007     return;
1008
1009   rval = get_frame_register_signed (frame, regno);
1010
1011   fprintf_filtered (file, "%-14s ", name);
1012   if ((regno == E_PSEUDO_CCR_REGNUM (gdbarch)) || \
1013       (regno == E_PSEUDO_EXR_REGNUM (gdbarch) && is_h8300smode (gdbarch)))
1014     {
1015       fprintf_filtered (file, "0x%02x        ", (unsigned char) rval);
1016       print_longest (file, 'u', 1, rval);
1017     }
1018   else
1019     {
1020       fprintf_filtered (file, "0x%s  ", phex ((ULONGEST) rval,
1021                         BINWORD (gdbarch)));
1022       print_longest (file, 'd', 1, rval);
1023     }
1024   if (regno == E_PSEUDO_CCR_REGNUM (gdbarch))
1025     {
1026       /* CCR register */
1027       int C, Z, N, V;
1028       unsigned char l = rval & 0xff;
1029       fprintf_filtered (file, "\t");
1030       fprintf_filtered (file, "I-%d ", (l & 0x80) != 0);
1031       fprintf_filtered (file, "UI-%d ", (l & 0x40) != 0);
1032       fprintf_filtered (file, "H-%d ", (l & 0x20) != 0);
1033       fprintf_filtered (file, "U-%d ", (l & 0x10) != 0);
1034       N = (l & 0x8) != 0;
1035       Z = (l & 0x4) != 0;
1036       V = (l & 0x2) != 0;
1037       C = (l & 0x1) != 0;
1038       fprintf_filtered (file, "N-%d ", N);
1039       fprintf_filtered (file, "Z-%d ", Z);
1040       fprintf_filtered (file, "V-%d ", V);
1041       fprintf_filtered (file, "C-%d ", C);
1042       if ((C | Z) == 0)
1043         fprintf_filtered (file, "u> ");
1044       if ((C | Z) == 1)
1045         fprintf_filtered (file, "u<= ");
1046       if ((C == 0))
1047         fprintf_filtered (file, "u>= ");
1048       if (C == 1)
1049         fprintf_filtered (file, "u< ");
1050       if (Z == 0)
1051         fprintf_filtered (file, "!= ");
1052       if (Z == 1)
1053         fprintf_filtered (file, "== ");
1054       if ((N ^ V) == 0)
1055         fprintf_filtered (file, ">= ");
1056       if ((N ^ V) == 1)
1057         fprintf_filtered (file, "< ");
1058       if ((Z | (N ^ V)) == 0)
1059         fprintf_filtered (file, "> ");
1060       if ((Z | (N ^ V)) == 1)
1061         fprintf_filtered (file, "<= ");
1062     }
1063   else if (regno == E_PSEUDO_EXR_REGNUM (gdbarch) && is_h8300smode (gdbarch))
1064     {
1065       /* EXR register */
1066       unsigned char l = rval & 0xff;
1067       fprintf_filtered (file, "\t");
1068       fprintf_filtered (file, "T-%d - - - ", (l & 0x80) != 0);
1069       fprintf_filtered (file, "I2-%d ", (l & 4) != 0);
1070       fprintf_filtered (file, "I1-%d ", (l & 2) != 0);
1071       fprintf_filtered (file, "I0-%d", (l & 1) != 0);
1072     }
1073   fprintf_filtered (file, "\n");
1074 }
1075
1076 static void
1077 h8300_print_registers_info (struct gdbarch *gdbarch, struct ui_file *file,
1078                             struct frame_info *frame, int regno, int cpregs)
1079 {
1080   if (regno < 0)
1081     {
1082       for (regno = E_R0_REGNUM; regno <= E_SP_REGNUM; ++regno)
1083         h8300_print_register (gdbarch, file, frame, regno);
1084       h8300_print_register (gdbarch, file, frame,
1085                             E_PSEUDO_CCR_REGNUM (gdbarch));
1086       h8300_print_register (gdbarch, file, frame, E_PC_REGNUM);
1087       if (is_h8300smode (gdbarch))
1088         {
1089           h8300_print_register (gdbarch, file, frame,
1090                                 E_PSEUDO_EXR_REGNUM (gdbarch));
1091           if (is_h8300sxmode (gdbarch))
1092             {
1093               h8300_print_register (gdbarch, file, frame, E_SBR_REGNUM);
1094               h8300_print_register (gdbarch, file, frame, E_VBR_REGNUM);
1095             }
1096           h8300_print_register (gdbarch, file, frame, E_MACH_REGNUM);
1097           h8300_print_register (gdbarch, file, frame, E_MACL_REGNUM);
1098           h8300_print_register (gdbarch, file, frame, E_CYCLES_REGNUM);
1099           h8300_print_register (gdbarch, file, frame, E_TICKS_REGNUM);
1100           h8300_print_register (gdbarch, file, frame, E_INSTS_REGNUM);
1101         }
1102       else
1103         {
1104           h8300_print_register (gdbarch, file, frame, E_CYCLES_REGNUM);
1105           h8300_print_register (gdbarch, file, frame, E_TICK_REGNUM);
1106           h8300_print_register (gdbarch, file, frame, E_INST_REGNUM);
1107         }
1108     }
1109   else
1110     {
1111       if (regno == E_CCR_REGNUM)
1112         h8300_print_register (gdbarch, file, frame,
1113                               E_PSEUDO_CCR_REGNUM (gdbarch));
1114       else if (regno == E_PSEUDO_EXR_REGNUM (gdbarch)
1115                && is_h8300smode (gdbarch))
1116         h8300_print_register (gdbarch, file, frame,
1117                               E_PSEUDO_EXR_REGNUM (gdbarch));
1118       else
1119         h8300_print_register (gdbarch, file, frame, regno);
1120     }
1121 }
1122
1123 static struct type *
1124 h8300_register_type (struct gdbarch *gdbarch, int regno)
1125 {
1126   if (regno < 0 || regno >= gdbarch_num_regs (gdbarch)
1127                             + gdbarch_num_pseudo_regs (gdbarch))
1128     internal_error (__FILE__, __LINE__,
1129                     _("h8300_register_type: illegal register number %d"),
1130                     regno);
1131   else
1132     {
1133       switch (regno)
1134         {
1135         case E_PC_REGNUM:
1136           return builtin_type (gdbarch)->builtin_func_ptr;
1137         case E_SP_REGNUM:
1138         case E_FP_REGNUM:
1139           return builtin_type (gdbarch)->builtin_data_ptr;
1140         default:
1141           if (regno == E_PSEUDO_CCR_REGNUM (gdbarch))
1142             return builtin_type (gdbarch)->builtin_uint8;
1143           else if (regno == E_PSEUDO_EXR_REGNUM (gdbarch))
1144             return builtin_type (gdbarch)->builtin_uint8;
1145           else if (is_h8300hmode (gdbarch))
1146             return builtin_type (gdbarch)->builtin_int32;
1147           else
1148             return builtin_type (gdbarch)->builtin_int16;
1149         }
1150     }
1151 }
1152
1153 static enum register_status
1154 h8300_pseudo_register_read (struct gdbarch *gdbarch,
1155                             struct regcache *regcache, int regno,
1156                             gdb_byte *buf)
1157 {
1158   if (regno == E_PSEUDO_CCR_REGNUM (gdbarch))
1159     return regcache_raw_read (regcache, E_CCR_REGNUM, buf);
1160   else if (regno == E_PSEUDO_EXR_REGNUM (gdbarch))
1161     return regcache_raw_read (regcache, E_EXR_REGNUM, buf);
1162   else
1163     return regcache_raw_read (regcache, regno, buf);
1164 }
1165
1166 static void
1167 h8300_pseudo_register_write (struct gdbarch *gdbarch,
1168                              struct regcache *regcache, int regno,
1169                              const gdb_byte *buf)
1170 {
1171   if (regno == E_PSEUDO_CCR_REGNUM (gdbarch))
1172     regcache_raw_write (regcache, E_CCR_REGNUM, buf);
1173   else if (regno == E_PSEUDO_EXR_REGNUM (gdbarch))
1174     regcache_raw_write (regcache, E_EXR_REGNUM, buf);
1175   else
1176     regcache_raw_write (regcache, regno, buf);
1177 }
1178
1179 static int
1180 h8300_dbg_reg_to_regnum (struct gdbarch *gdbarch, int regno)
1181 {
1182   if (regno == E_CCR_REGNUM)
1183     return E_PSEUDO_CCR_REGNUM (gdbarch);
1184   return regno;
1185 }
1186
1187 static int
1188 h8300s_dbg_reg_to_regnum (struct gdbarch *gdbarch, int regno)
1189 {
1190   if (regno == E_CCR_REGNUM)
1191     return E_PSEUDO_CCR_REGNUM (gdbarch);
1192   if (regno == E_EXR_REGNUM)
1193     return E_PSEUDO_EXR_REGNUM (gdbarch);
1194   return regno;
1195 }
1196
1197 const static unsigned char *
1198 h8300_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pcptr,
1199                           int *lenptr)
1200 {
1201   /*static unsigned char breakpoint[] = { 0x7A, 0xFF }; *//* ??? */
1202   static unsigned char breakpoint[] = { 0x01, 0x80 };   /* Sleep */
1203
1204   *lenptr = sizeof (breakpoint);
1205   return breakpoint;
1206 }
1207
1208 static void
1209 h8300_print_float_info (struct gdbarch *gdbarch, struct ui_file *file,
1210                         struct frame_info *frame, const char *args)
1211 {
1212   fprintf_filtered (file, "\
1213 No floating-point info available for this processor.\n");
1214 }
1215
1216 static struct gdbarch *
1217 h8300_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
1218 {
1219   struct gdbarch_tdep *tdep = NULL;
1220   struct gdbarch *gdbarch;
1221
1222   arches = gdbarch_list_lookup_by_info (arches, &info);
1223   if (arches != NULL)
1224     return arches->gdbarch;
1225
1226 #if 0
1227   tdep = (struct gdbarch_tdep *) xmalloc (sizeof (struct gdbarch_tdep));
1228 #endif
1229
1230   if (info.bfd_arch_info->arch != bfd_arch_h8300)
1231     return NULL;
1232
1233   gdbarch = gdbarch_alloc (&info, 0);
1234
1235   switch (info.bfd_arch_info->mach)
1236     {
1237     case bfd_mach_h8300:
1238       set_gdbarch_num_regs (gdbarch, 13);
1239       set_gdbarch_num_pseudo_regs (gdbarch, 1);
1240       set_gdbarch_ecoff_reg_to_regnum (gdbarch, h8300_dbg_reg_to_regnum);
1241       set_gdbarch_dwarf2_reg_to_regnum (gdbarch, h8300_dbg_reg_to_regnum);
1242       set_gdbarch_stab_reg_to_regnum (gdbarch, h8300_dbg_reg_to_regnum);
1243       set_gdbarch_register_name (gdbarch, h8300_register_name);
1244       set_gdbarch_ptr_bit (gdbarch, 2 * TARGET_CHAR_BIT);
1245       set_gdbarch_addr_bit (gdbarch, 2 * TARGET_CHAR_BIT);
1246       set_gdbarch_return_value (gdbarch, h8300_return_value);
1247       set_gdbarch_print_insn (gdbarch, print_insn_h8300);
1248       break;
1249     case bfd_mach_h8300h:
1250     case bfd_mach_h8300hn:
1251       set_gdbarch_num_regs (gdbarch, 13);
1252       set_gdbarch_num_pseudo_regs (gdbarch, 1);
1253       set_gdbarch_ecoff_reg_to_regnum (gdbarch, h8300_dbg_reg_to_regnum);
1254       set_gdbarch_dwarf2_reg_to_regnum (gdbarch, h8300_dbg_reg_to_regnum);
1255       set_gdbarch_stab_reg_to_regnum (gdbarch, h8300_dbg_reg_to_regnum);
1256       set_gdbarch_register_name (gdbarch, h8300_register_name);
1257       if (info.bfd_arch_info->mach != bfd_mach_h8300hn)
1258         {
1259           set_gdbarch_ptr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
1260           set_gdbarch_addr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
1261         }
1262       else
1263         {
1264           set_gdbarch_ptr_bit (gdbarch, 2 * TARGET_CHAR_BIT);
1265           set_gdbarch_addr_bit (gdbarch, 2 * TARGET_CHAR_BIT);
1266         }
1267       set_gdbarch_return_value (gdbarch, h8300h_return_value);
1268       set_gdbarch_print_insn (gdbarch, print_insn_h8300h);
1269       break;
1270     case bfd_mach_h8300s:
1271     case bfd_mach_h8300sn:
1272       set_gdbarch_num_regs (gdbarch, 16);
1273       set_gdbarch_num_pseudo_regs (gdbarch, 2);
1274       set_gdbarch_ecoff_reg_to_regnum (gdbarch, h8300s_dbg_reg_to_regnum);
1275       set_gdbarch_dwarf2_reg_to_regnum (gdbarch, h8300s_dbg_reg_to_regnum);
1276       set_gdbarch_stab_reg_to_regnum (gdbarch, h8300s_dbg_reg_to_regnum);
1277       set_gdbarch_register_name (gdbarch, h8300s_register_name);
1278       if (info.bfd_arch_info->mach != bfd_mach_h8300sn)
1279         {
1280           set_gdbarch_ptr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
1281           set_gdbarch_addr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
1282         }
1283       else
1284         {
1285           set_gdbarch_ptr_bit (gdbarch, 2 * TARGET_CHAR_BIT);
1286           set_gdbarch_addr_bit (gdbarch, 2 * TARGET_CHAR_BIT);
1287         }
1288       set_gdbarch_return_value (gdbarch, h8300h_return_value);
1289       set_gdbarch_print_insn (gdbarch, print_insn_h8300s);
1290       break;
1291     case bfd_mach_h8300sx:
1292     case bfd_mach_h8300sxn:
1293       set_gdbarch_num_regs (gdbarch, 18);
1294       set_gdbarch_num_pseudo_regs (gdbarch, 2);
1295       set_gdbarch_ecoff_reg_to_regnum (gdbarch, h8300s_dbg_reg_to_regnum);
1296       set_gdbarch_dwarf2_reg_to_regnum (gdbarch, h8300s_dbg_reg_to_regnum);
1297       set_gdbarch_stab_reg_to_regnum (gdbarch, h8300s_dbg_reg_to_regnum);
1298       set_gdbarch_register_name (gdbarch, h8300sx_register_name);
1299       if (info.bfd_arch_info->mach != bfd_mach_h8300sxn)
1300         {
1301           set_gdbarch_ptr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
1302           set_gdbarch_addr_bit (gdbarch, 4 * TARGET_CHAR_BIT);
1303         }
1304       else
1305         {
1306           set_gdbarch_ptr_bit (gdbarch, 2 * TARGET_CHAR_BIT);
1307           set_gdbarch_addr_bit (gdbarch, 2 * TARGET_CHAR_BIT);
1308         }
1309       set_gdbarch_return_value (gdbarch, h8300h_return_value);
1310       set_gdbarch_print_insn (gdbarch, print_insn_h8300s);
1311       break;
1312     }
1313
1314   set_gdbarch_pseudo_register_read (gdbarch, h8300_pseudo_register_read);
1315   set_gdbarch_pseudo_register_write (gdbarch, h8300_pseudo_register_write);
1316
1317   /*
1318    * Basic register fields and methods.
1319    */
1320
1321   set_gdbarch_sp_regnum (gdbarch, E_SP_REGNUM);
1322   set_gdbarch_pc_regnum (gdbarch, E_PC_REGNUM);
1323   set_gdbarch_register_type (gdbarch, h8300_register_type);
1324   set_gdbarch_print_registers_info (gdbarch, h8300_print_registers_info);
1325   set_gdbarch_print_float_info (gdbarch, h8300_print_float_info);
1326
1327   /*
1328    * Frame Info
1329    */
1330   set_gdbarch_skip_prologue (gdbarch, h8300_skip_prologue);
1331
1332   /* Frame unwinder.  */
1333   set_gdbarch_unwind_pc (gdbarch, h8300_unwind_pc);
1334   set_gdbarch_unwind_sp (gdbarch, h8300_unwind_sp);
1335   set_gdbarch_dummy_id (gdbarch, h8300_dummy_id);
1336   frame_base_set_default (gdbarch, &h8300_frame_base);
1337
1338   /*
1339    * Miscelany
1340    */
1341   /* Stack grows up.  */
1342   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
1343
1344   set_gdbarch_breakpoint_from_pc (gdbarch, h8300_breakpoint_from_pc);
1345   set_gdbarch_push_dummy_call (gdbarch, h8300_push_dummy_call);
1346
1347   set_gdbarch_char_signed (gdbarch, 0);
1348   set_gdbarch_int_bit (gdbarch, 2 * TARGET_CHAR_BIT);
1349   set_gdbarch_long_bit (gdbarch, 4 * TARGET_CHAR_BIT);
1350   set_gdbarch_long_long_bit (gdbarch, 8 * TARGET_CHAR_BIT);
1351   set_gdbarch_double_bit (gdbarch, 4 * TARGET_CHAR_BIT);
1352   set_gdbarch_double_format (gdbarch, floatformats_ieee_single);
1353   set_gdbarch_long_double_bit (gdbarch, 4 * TARGET_CHAR_BIT);
1354   set_gdbarch_long_double_format (gdbarch, floatformats_ieee_single);
1355
1356   set_gdbarch_believe_pcc_promotion (gdbarch, 1);
1357
1358   /* Hook in the DWARF CFI frame unwinder.  */
1359   dwarf2_append_unwinders (gdbarch);
1360   frame_unwind_append_unwinder (gdbarch, &h8300_frame_unwind);
1361
1362   return gdbarch;
1363
1364 }
1365
1366 extern initialize_file_ftype _initialize_h8300_tdep; /* -Wmissing-prototypes */
1367
1368 void
1369 _initialize_h8300_tdep (void)
1370 {
1371   register_gdbarch_init (bfd_arch_h8300, h8300_gdbarch_init);
1372 }
1373
1374 static int
1375 is_h8300hmode (struct gdbarch *gdbarch)
1376 {
1377   return gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_h8300sx
1378     || gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_h8300sxn
1379     || gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_h8300s
1380     || gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_h8300sn
1381     || gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_h8300h
1382     || gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_h8300hn;
1383 }
1384
1385 static int
1386 is_h8300smode (struct gdbarch *gdbarch)
1387 {
1388   return gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_h8300sx
1389     || gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_h8300sxn
1390     || gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_h8300s
1391     || gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_h8300sn;
1392 }
1393
1394 static int
1395 is_h8300sxmode (struct gdbarch *gdbarch)
1396 {
1397   return gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_h8300sx
1398     || gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_h8300sxn;
1399 }
1400
1401 static int
1402 is_h8300_normal_mode (struct gdbarch *gdbarch)
1403 {
1404   return gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_h8300sxn
1405     || gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_h8300sn
1406     || gdbarch_bfd_arch_info (gdbarch)->mach == bfd_mach_h8300hn;
1407 }