gdb/h8300-tdep.c

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