gdb/m68hc11-tdep.c

   1 /* Target-dependent code for Motorola 68HC11 & 68HC12
   2    Copyright 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
   3    Contributed by Stephane Carrez, stcarrez@nerim.fr
   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 2 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, write to the Free Software
  19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  20
  21
  22 #include "defs.h"
  23 #include "frame.h"
  24 #include "symtab.h"
  25 #include "gdbtypes.h"
  26 #include "gdbcmd.h"
  27 #include "gdbcore.h"
  28 #include "gdb_string.h"
  29 #include "value.h"
  30 #include "inferior.h"
  31 #include "dis-asm.h"
  32 #include "symfile.h"
  33 #include "objfiles.h"
  34 #include "arch-utils.h"
  35 #include "regcache.h"
  36 #include "reggroups.h"
  37
  38 #include "target.h"
  39 #include "opcode/m68hc11.h"
  40 #include "elf/m68hc11.h"
  41 #include "elf-bfd.h"
  42
  43 /* Macros for setting and testing a bit in a minimal symbol.
  44    For 68HC11/68HC12 we have two flags that tell which return
  45    type the function is using.  This is used for prologue and frame
  46    analysis to compute correct stack frame layout.
  47
  48    The MSB of the minimal symbol's "info" field is used for this purpose.
  49    This field is already being used to store the symbol size, so the
  50    assumption is that the symbol size cannot exceed 2^30.
  51
  52    MSYMBOL_SET_RTC      Actually sets the "RTC" bit.
  53    MSYMBOL_SET_RTI      Actually sets the "RTI" bit.
  54    MSYMBOL_IS_RTC       Tests the "RTC" bit in a minimal symbol.
  55    MSYMBOL_IS_RTI       Tests the "RTC" bit in a minimal symbol.
  56    MSYMBOL_SIZE         Returns the size of the minimal symbol,
  57                         i.e. the "info" field with the "special" bit
  58                         masked out.  */
  59
  60 #define MSYMBOL_SET_RTC(msym)                                           \
  61         MSYMBOL_INFO (msym) = (char *) (((long) MSYMBOL_INFO (msym))    \
  62                                         | 0x80000000)
  63
  64 #define MSYMBOL_SET_RTI(msym)                                           \
  65         MSYMBOL_INFO (msym) = (char *) (((long) MSYMBOL_INFO (msym))    \
  66                                         | 0x40000000)
  67
  68 #define MSYMBOL_IS_RTC(msym)                            \
  69         (((long) MSYMBOL_INFO (msym) & 0x80000000) != 0)
  70
  71 #define MSYMBOL_IS_RTI(msym)                            \
  72         (((long) MSYMBOL_INFO (msym) & 0x40000000) != 0)
  73
  74 #define MSYMBOL_SIZE(msym)                              \
  75         ((long) MSYMBOL_INFO (msym) & 0x3fffffff)
  76
  77 enum insn_return_kind {
  78   RETURN_RTS,
  79   RETURN_RTC,
  80   RETURN_RTI
  81 };
  82
  83
  84 /* Register numbers of various important registers.
  85    Note that some of these values are "real" register numbers,
  86    and correspond to the general registers of the machine,
  87    and some are "phony" register numbers which are too large
  88    to be actual register numbers as far as the user is concerned
  89    but do serve to get the desired values when passed to read_register.  */
  90
  91 #define HARD_X_REGNUM   0
  92 #define HARD_D_REGNUM   1
  93 #define HARD_Y_REGNUM   2
  94 #define HARD_SP_REGNUM  3
  95 #define HARD_PC_REGNUM  4
  96
  97 #define HARD_A_REGNUM   5
  98 #define HARD_B_REGNUM   6
  99 #define HARD_CCR_REGNUM 7
 100
 101 /* 68HC12 page number register.
 102    Note: to keep a compatibility with gcc register naming, we must
 103    not have to rename FP and other soft registers.  The page register
 104    is a real hard register and must therefore be counted by NUM_REGS.
 105    For this it has the same number as Z register (which is not used).  */
 106 #define HARD_PAGE_REGNUM 8
 107 #define M68HC11_LAST_HARD_REG (HARD_PAGE_REGNUM)
 108
 109 /* Z is replaced by X or Y by gcc during machine reorg.
 110    ??? There is no way to get it and even know whether
 111    it's in X or Y or in ZS.  */
 112 #define SOFT_Z_REGNUM        8
 113
 114 /* Soft registers.  These registers are special.  There are treated
 115    like normal hard registers by gcc and gdb (ie, within dwarf2 info).
 116    They are physically located in memory.  */
 117 #define SOFT_FP_REGNUM       9
 118 #define SOFT_TMP_REGNUM     10
 119 #define SOFT_ZS_REGNUM      11
 120 #define SOFT_XY_REGNUM      12
 121 #define SOFT_UNUSED_REGNUM  13
 122 #define SOFT_D1_REGNUM      14
 123 #define SOFT_D32_REGNUM     (SOFT_D1_REGNUM+31)
 124 #define M68HC11_MAX_SOFT_REGS 32
 125
 126 #define M68HC11_NUM_REGS        (8)
 127 #define M68HC11_NUM_PSEUDO_REGS (M68HC11_MAX_SOFT_REGS+5)
 128 #define M68HC11_ALL_REGS        (M68HC11_NUM_REGS+M68HC11_NUM_PSEUDO_REGS)
 129
 130 #define M68HC11_REG_SIZE    (2)
 131
 132 #define M68HC12_NUM_REGS        (9)
 133 #define M68HC12_NUM_PSEUDO_REGS ((M68HC11_MAX_SOFT_REGS+5)+1-1)
 134 #define M68HC12_HARD_PC_REGNUM  (SOFT_D32_REGNUM+1)
 135
 136 struct insn_sequence;
 137 struct gdbarch_tdep
 138   {
 139     /* Stack pointer correction value.  For 68hc11, the stack pointer points
 140        to the next push location.  An offset of 1 must be applied to obtain
 141        the address where the last value is saved.  For 68hc12, the stack
 142        pointer points to the last value pushed.  No offset is necessary.  */
 143     int stack_correction;
 144
 145     /* Description of instructions in the prologue.  */
 146     struct insn_sequence *prologue;
 147
 148     /* True if the page memory bank register is available
 149        and must be used.  */
 150     int use_page_register;
 151
 152     /* ELF flags for ABI.  */
 153     int elf_flags;
 154   };
 155
 156 #define M6811_TDEP gdbarch_tdep (current_gdbarch)
 157 #define STACK_CORRECTION (M6811_TDEP->stack_correction)
 158 #define USE_PAGE_REGISTER (M6811_TDEP->use_page_register)
 159
 160 struct frame_extra_info
 161 {
 162   CORE_ADDR return_pc;
 163   int frameless;
 164   int size;
 165   enum insn_return_kind return_kind;
 166 };
 167
 168 /* Table of registers for 68HC11.  This includes the hard registers
 169    and the soft registers used by GCC.  */
 170 static char *
 171 m68hc11_register_names[] =
 172 {
 173   "x",    "d",    "y",    "sp",   "pc",   "a",    "b",
 174   "ccr",  "page", "frame","tmp",  "zs",   "xy",   0,
 175   "d1",   "d2",   "d3",   "d4",   "d5",   "d6",   "d7",
 176   "d8",   "d9",   "d10",  "d11",  "d12",  "d13",  "d14",
 177   "d15",  "d16",  "d17",  "d18",  "d19",  "d20",  "d21",
 178   "d22",  "d23",  "d24",  "d25",  "d26",  "d27",  "d28",
 179   "d29",  "d30",  "d31",  "d32"
 180 };
 181
 182 struct m68hc11_soft_reg
 183 {
 184   const char *name;
 185   CORE_ADDR   addr;
 186 };
 187
 188 static struct m68hc11_soft_reg soft_regs[M68HC11_ALL_REGS];
 189
 190 #define M68HC11_FP_ADDR soft_regs[SOFT_FP_REGNUM].addr
 191
 192 static int soft_min_addr;
 193 static int soft_max_addr;
 194 static int soft_reg_initialized = 0;
 195
 196 /* Look in the symbol table for the address of a pseudo register
 197    in memory.  If we don't find it, pretend the register is not used
 198    and not available.  */
 199 static void
 200 m68hc11_get_register_info (struct m68hc11_soft_reg *reg, const char *name)
 201 {
 202   struct minimal_symbol *msymbol;
 203
 204   msymbol = lookup_minimal_symbol (name, NULL, NULL);
 205   if (msymbol)
 206     {
 207       reg->addr = SYMBOL_VALUE_ADDRESS (msymbol);
 208       reg->name = xstrdup (name);
 209
 210       /* Keep track of the address range for soft registers.  */
 211       if (reg->addr < (CORE_ADDR) soft_min_addr)
 212         soft_min_addr = reg->addr;
 213       if (reg->addr > (CORE_ADDR) soft_max_addr)
 214         soft_max_addr = reg->addr;
 215     }
 216   else
 217     {
 218       reg->name = 0;
 219       reg->addr = 0;
 220     }
 221 }
 222
 223 /* Initialize the table of soft register addresses according
 224    to the symbol table.  */
 225   static void
 226 m68hc11_initialize_register_info (void)
 227 {
 228   int i;
 229
 230   if (soft_reg_initialized)
 231     return;
 232
 233   soft_min_addr = INT_MAX;
 234   soft_max_addr = 0;
 235   for (i = 0; i < M68HC11_ALL_REGS; i++)
 236     {
 237       soft_regs[i].name = 0;
 238     }
 239
 240   m68hc11_get_register_info (&soft_regs[SOFT_FP_REGNUM], "_.frame");
 241   m68hc11_get_register_info (&soft_regs[SOFT_TMP_REGNUM], "_.tmp");
 242   m68hc11_get_register_info (&soft_regs[SOFT_ZS_REGNUM], "_.z");
 243   soft_regs[SOFT_Z_REGNUM] = soft_regs[SOFT_ZS_REGNUM];
 244   m68hc11_get_register_info (&soft_regs[SOFT_XY_REGNUM], "_.xy");
 245
 246   for (i = SOFT_D1_REGNUM; i < M68HC11_MAX_SOFT_REGS; i++)
 247     {
 248       char buf[10];
 249
 250       sprintf (buf, "_.d%d", i - SOFT_D1_REGNUM + 1);
 251       m68hc11_get_register_info (&soft_regs[i], buf);
 252     }
 253
 254   if (soft_regs[SOFT_FP_REGNUM].name == 0)
 255     {
 256       warning ("No frame soft register found in the symbol table.\n");
 257       warning ("Stack backtrace will not work.\n");
 258     }
 259   soft_reg_initialized = 1;
 260 }
 261
 262 /* Given an address in memory, return the soft register number if
 263    that address corresponds to a soft register.  Returns -1 if not.  */
 264 static int
 265 m68hc11_which_soft_register (CORE_ADDR addr)
 266 {
 267   int i;
 268
 269   if (addr < soft_min_addr || addr > soft_max_addr)
 270     return -1;
 271
 272   for (i = SOFT_FP_REGNUM; i < M68HC11_ALL_REGS; i++)
 273     {
 274       if (soft_regs[i].name && soft_regs[i].addr == addr)
 275         return i;
 276     }
 277   return -1;
 278 }
 279
 280 /* Fetch a pseudo register.  The 68hc11 soft registers are treated like
 281    pseudo registers.  They are located in memory.  Translate the register
 282    fetch into a memory read.  */
 283 static void
 284 m68hc11_pseudo_register_read (struct gdbarch *gdbarch,
 285                               struct regcache *regcache,
 286                               int regno, void *buf)
 287 {
 288   /* The PC is a pseudo reg only for 68HC12 with the memory bank
 289      addressing mode.  */
 290   if (regno == M68HC12_HARD_PC_REGNUM)
 291     {
 292       const int regsize = TYPE_LENGTH (builtin_type_uint32);
 293       CORE_ADDR pc = read_register (HARD_PC_REGNUM);
 294       int page = read_register (HARD_PAGE_REGNUM);
 295
 296       if (pc >= 0x8000 && pc < 0xc000)
 297         {
 298           pc -= 0x8000;
 299           pc += (page << 14);
 300           pc += 0x1000000;
 301         }
 302       store_unsigned_integer (buf, regsize, pc);
 303       return;
 304     }
 305
 306   m68hc11_initialize_register_info ();
 307
 308   /* Fetch a soft register: translate into a memory read.  */
 309   if (soft_regs[regno].name)
 310     {
 311       target_read_memory (soft_regs[regno].addr, buf, 2);
 312     }
 313   else
 314     {
 315       memset (buf, 0, 2);
 316     }
 317 }
 318
 319 /* Store a pseudo register.  Translate the register store
 320    into a memory write.  */
 321 static void
 322 m68hc11_pseudo_register_write (struct gdbarch *gdbarch,
 323                                struct regcache *regcache,
 324                                int regno, const void *buf)
 325 {
 326   /* The PC is a pseudo reg only for 68HC12 with the memory bank
 327      addressing mode.  */
 328   if (regno == M68HC12_HARD_PC_REGNUM)
 329     {
 330       const int regsize = TYPE_LENGTH (builtin_type_uint32);
 331       char *tmp = alloca (regsize);
 332       CORE_ADDR pc;
 333
 334       memcpy (tmp, buf, regsize);
 335       pc = extract_unsigned_integer (tmp, regsize);
 336       if (pc >= 0x1000000)
 337         {
 338           pc -= 0x1000000;
 339           write_register (HARD_PAGE_REGNUM, (pc >> 14) & 0x0ff);
 340           pc &= 0x03fff;
 341           write_register (HARD_PC_REGNUM, pc + 0x8000);
 342         }
 343       else
 344         write_register (HARD_PC_REGNUM, pc);
 345       return;
 346     }
 347
 348   m68hc11_initialize_register_info ();
 349
 350   /* Store a soft register: translate into a memory write.  */
 351   if (soft_regs[regno].name)
 352     {
 353       const int regsize = 2;
 354       char *tmp = alloca (regsize);
 355       memcpy (tmp, buf, regsize);
 356       target_write_memory (soft_regs[regno].addr, tmp, regsize);
 357     }
 358 }
 359
 360 static const char *
 361 m68hc11_register_name (int reg_nr)
 362 {
 363   if (reg_nr == M68HC12_HARD_PC_REGNUM && USE_PAGE_REGISTER)
 364     return "pc";
 365   if (reg_nr == HARD_PC_REGNUM && USE_PAGE_REGISTER)
 366     return "ppc";
 367
 368   if (reg_nr < 0)
 369     return NULL;
 370   if (reg_nr >= M68HC11_ALL_REGS)
 371     return NULL;
 372
 373   /* If we don't know the address of a soft register, pretend it
 374      does not exist.  */
 375   if (reg_nr > M68HC11_LAST_HARD_REG && soft_regs[reg_nr].name == 0)
 376     return NULL;
 377   return m68hc11_register_names[reg_nr];
 378 }
 379
 380 static const unsigned char *
 381 m68hc11_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr)
 382 {
 383   static unsigned char breakpoint[] = {0x0};
 384
 385   *lenptr = sizeof (breakpoint);
 386   return breakpoint;
 387 }
 388
 389 /* Immediately after a function call, return the saved pc before the frame
 390    is setup.  */
 391
 392 static CORE_ADDR
 393 m68hc11_saved_pc_after_call (struct frame_info *frame)
 394 {
 395   CORE_ADDR addr;
 396
 397   addr = read_register (HARD_SP_REGNUM) + STACK_CORRECTION;
 398   addr &= 0x0ffff;
 399   return read_memory_integer (addr, 2) & 0x0FFFF;
 400 }
 401
 402 static CORE_ADDR
 403 m68hc11_frame_saved_pc (struct frame_info *frame)
 404 {
 405   return get_frame_extra_info (frame)->return_pc;
 406 }
 407
 408 static CORE_ADDR
 409 m68hc11_frame_args_address (struct frame_info *frame)
 410 {
 411   CORE_ADDR addr;
 412
 413   addr = get_frame_base (frame) + get_frame_extra_info (frame)->size + STACK_CORRECTION + 2;
 414   if (get_frame_extra_info (frame)->return_kind == RETURN_RTC)
 415     addr += 1;
 416   else if (get_frame_extra_info (frame)->return_kind == RETURN_RTI)
 417     addr += 7;
 418
 419   return addr;
 420 }
 421
 422 /* Discard from the stack the innermost frame, restoring all saved
 423    registers.  */
 424
 425 static void
 426 m68hc11_pop_frame (void)
 427 {
 428   register struct frame_info *frame = get_current_frame ();
 429   register CORE_ADDR fp, sp;
 430   register int regnum;
 431
 432   if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (frame),
 433                                    get_frame_base (frame),
 434                                    get_frame_base (frame)))
 435     generic_pop_dummy_frame ();
 436   else
 437     {
 438       fp = get_frame_base (frame);
 439       DEPRECATED_FRAME_INIT_SAVED_REGS (frame);
 440
 441       /* Copy regs from where they were saved in the frame.  */
 442       for (regnum = 0; regnum < M68HC11_ALL_REGS; regnum++)
 443         if (get_frame_saved_regs (frame)[regnum])
 444           write_register (regnum,
 445                           read_memory_integer (get_frame_saved_regs (frame)[regnum], 2));
 446
 447       write_register (HARD_PC_REGNUM, get_frame_extra_info (frame)->return_pc);
 448       sp = (fp + get_frame_extra_info (frame)->size + 2) & 0x0ffff;
 449       write_register (HARD_SP_REGNUM, sp);
 450     }
 451   flush_cached_frames ();
 452 }
 453
 454 \f
 455 /* 68HC11 & 68HC12 prologue analysis.
 456
 457  */
 458 #define MAX_CODES 12
 459
 460 /* 68HC11 opcodes.  */
 461 #undef M6811_OP_PAGE2
 462 #define M6811_OP_PAGE2   (0x18)
 463 #define M6811_OP_LDX     (0xde)
 464 #define M6811_OP_LDX_EXT (0xfe)
 465 #define M6811_OP_PSHX    (0x3c)
 466 #define M6811_OP_STS     (0x9f)
 467 #define M6811_OP_STS_EXT (0xbf)
 468 #define M6811_OP_TSX     (0x30)
 469 #define M6811_OP_XGDX    (0x8f)
 470 #define M6811_OP_ADDD    (0xc3)
 471 #define M6811_OP_TXS     (0x35)
 472 #define M6811_OP_DES     (0x34)
 473
 474 /* 68HC12 opcodes.  */
 475 #define M6812_OP_PAGE2   (0x18)
 476 #define M6812_OP_MOVW    (0x01)
 477 #define M6812_PB_PSHW    (0xae)
 478 #define M6812_OP_STS     (0x5f)
 479 #define M6812_OP_STS_EXT (0x7f)
 480 #define M6812_OP_LEAS    (0x1b)
 481 #define M6812_OP_PSHX    (0x34)
 482 #define M6812_OP_PSHY    (0x35)
 483
 484 /* Operand extraction.  */
 485 #define OP_DIRECT      (0x100) /* 8-byte direct addressing.  */
 486 #define OP_IMM_LOW     (0x200) /* Low part of 16-bit constant/address.  */
 487 #define OP_IMM_HIGH    (0x300) /* High part of 16-bit constant/address.  */
 488 #define OP_PBYTE       (0x400) /* 68HC12 indexed operand.  */
 489
 490 /* Identification of the sequence.  */
 491 enum m6811_seq_type
 492 {
 493   P_LAST = 0,
 494   P_SAVE_REG,  /* Save a register on the stack.  */
 495   P_SET_FRAME, /* Setup the frame pointer.  */
 496   P_LOCAL_1,   /* Allocate 1 byte for locals.  */
 497   P_LOCAL_2,   /* Allocate 2 bytes for locals.  */
 498   P_LOCAL_N    /* Allocate N bytes for locals.  */
 499 };
 500
 501 struct insn_sequence {
 502   enum m6811_seq_type type;
 503   unsigned length;
 504   unsigned short code[MAX_CODES];
 505 };
 506
 507 /* Sequence of instructions in the 68HC11 function prologue.  */
 508 static struct insn_sequence m6811_prologue[] = {
 509   /* Sequences to save a soft-register.  */
 510   { P_SAVE_REG, 3, { M6811_OP_LDX, OP_DIRECT,
 511                      M6811_OP_PSHX } },
 512   { P_SAVE_REG, 5, { M6811_OP_PAGE2, M6811_OP_LDX, OP_DIRECT,
 513                      M6811_OP_PAGE2, M6811_OP_PSHX } },
 514   { P_SAVE_REG, 4, { M6811_OP_LDX_EXT, OP_IMM_HIGH, OP_IMM_LOW,
 515                      M6811_OP_PSHX } },
 516   { P_SAVE_REG, 6, { M6811_OP_PAGE2, M6811_OP_LDX_EXT, OP_IMM_HIGH, OP_IMM_LOW,
 517                      M6811_OP_PAGE2, M6811_OP_PSHX } },
 518
 519   /* Sequences to allocate local variables.  */
 520   { P_LOCAL_N,  7, { M6811_OP_TSX,
 521                      M6811_OP_XGDX,
 522                      M6811_OP_ADDD, OP_IMM_HIGH, OP_IMM_LOW,
 523                      M6811_OP_XGDX,
 524                      M6811_OP_TXS } },
 525   { P_LOCAL_N, 11, { M6811_OP_PAGE2, M6811_OP_TSX,
 526                      M6811_OP_PAGE2, M6811_OP_XGDX,
 527                      M6811_OP_ADDD, OP_IMM_HIGH, OP_IMM_LOW,
 528                      M6811_OP_PAGE2, M6811_OP_XGDX,
 529                      M6811_OP_PAGE2, M6811_OP_TXS } },
 530   { P_LOCAL_1,  1, { M6811_OP_DES } },
 531   { P_LOCAL_2,  1, { M6811_OP_PSHX } },
 532   { P_LOCAL_2,  2, { M6811_OP_PAGE2, M6811_OP_PSHX } },
 533
 534   /* Initialize the frame pointer.  */
 535   { P_SET_FRAME, 2, { M6811_OP_STS, OP_DIRECT } },
 536   { P_SET_FRAME, 3, { M6811_OP_STS_EXT, OP_IMM_HIGH, OP_IMM_LOW } },
 537   { P_LAST, 0, { 0 } }
 538 };
 539
 540
 541 /* Sequence of instructions in the 68HC12 function prologue.  */
 542 static struct insn_sequence m6812_prologue[] = {
 543   { P_SAVE_REG,  5, { M6812_OP_PAGE2, M6812_OP_MOVW, M6812_PB_PSHW,
 544                       OP_IMM_HIGH, OP_IMM_LOW } },
 545   { P_SET_FRAME, 2, { M6812_OP_STS, OP_DIRECT } },
 546   { P_SET_FRAME, 3, { M6812_OP_STS_EXT, OP_IMM_HIGH, OP_IMM_LOW } },
 547   { P_LOCAL_N,   2, { M6812_OP_LEAS, OP_PBYTE } },
 548   { P_LOCAL_2,   1, { M6812_OP_PSHX } },
 549   { P_LOCAL_2,   1, { M6812_OP_PSHY } },
 550   { P_LAST, 0 }
 551 };
 552
 553
 554 /* Analyze the sequence of instructions starting at the given address.
 555    Returns a pointer to the sequence when it is recognized and
 556    the optional value (constant/address) associated with it.
 557    Advance the pc for the next sequence.  */
 558 static struct insn_sequence *
 559 m68hc11_analyze_instruction (struct insn_sequence *seq, CORE_ADDR *pc,
 560                              CORE_ADDR *val)
 561 {
 562   unsigned char buffer[MAX_CODES];
 563   unsigned bufsize;
 564   unsigned j;
 565   CORE_ADDR cur_val;
 566   short v = 0;
 567
 568   bufsize = 0;
 569   for (; seq->type != P_LAST; seq++)
 570     {
 571       cur_val = 0;
 572       for (j = 0; j < seq->length; j++)
 573         {
 574           if (bufsize < j + 1)
 575             {
 576               buffer[bufsize] = read_memory_unsigned_integer (*pc + bufsize,
 577                                                               1);
 578               bufsize++;
 579             }
 580           /* Continue while we match the opcode.  */
 581           if (seq->code[j] == buffer[j])
 582             continue;
 583
 584           if ((seq->code[j] & 0xf00) == 0)
 585             break;
 586
 587           /* Extract a sequence parameter (address or constant).  */
 588           switch (seq->code[j])
 589             {
 590             case OP_DIRECT:
 591               cur_val = (CORE_ADDR) buffer[j];
 592               break;
 593
 594             case OP_IMM_HIGH:
 595               cur_val = cur_val & 0x0ff;
 596               cur_val |= (buffer[j] << 8);
 597               break;
 598
 599             case OP_IMM_LOW:
 600               cur_val &= 0x0ff00;
 601               cur_val |= buffer[j];
 602               break;
 603
 604             case OP_PBYTE:
 605               if ((buffer[j] & 0xE0) == 0x80)
 606                 {
 607                   v = buffer[j] & 0x1f;
 608                   if (v & 0x10)
 609                     v |= 0xfff0;
 610                 }
 611               else if ((buffer[j] & 0xfe) == 0xf0)
 612                 {
 613                   v = read_memory_unsigned_integer (*pc + j + 1, 1);
 614                   if (buffer[j] & 1)
 615                     v |= 0xff00;
 616                   *pc = *pc + 1;
 617                 }
 618               else if (buffer[j] == 0xf2)
 619                 {
 620                   v = read_memory_unsigned_integer (*pc + j + 1, 2);
 621                   *pc = *pc + 2;
 622                 }
 623               cur_val = v;
 624               break;
 625             }
 626         }
 627
 628       /* We have a full match.  */
 629       if (j == seq->length)
 630         {
 631           *val = cur_val;
 632           *pc = *pc + j;
 633           return seq;
 634         }
 635     }
 636   return 0;
 637 }
 638
 639 /* Return the instruction that the function at the PC is using.  */
 640 static enum insn_return_kind
 641 m68hc11_get_return_insn (CORE_ADDR pc)
 642 {
 643   struct minimal_symbol *sym;
 644
 645   /* A flag indicating that this is a STO_M68HC12_FAR or STO_M68HC12_INTERRUPT
 646      function is stored by elfread.c in the high bit of the info field.
 647      Use this to decide which instruction the function uses to return.  */
 648   sym = lookup_minimal_symbol_by_pc (pc);
 649   if (sym == 0)
 650     return RETURN_RTS;
 651
 652   if (MSYMBOL_IS_RTC (sym))
 653     return RETURN_RTC;
 654   else if (MSYMBOL_IS_RTI (sym))
 655     return RETURN_RTI;
 656   else
 657     return RETURN_RTS;
 658 }
 659
 660
 661 /* Analyze the function prologue to find some information
 662    about the function:
 663     - the PC of the first line (for m68hc11_skip_prologue)
 664     - the offset of the previous frame saved address (from current frame)
 665     - the soft registers which are pushed.  */
 666 static void
 667 m68hc11_guess_from_prologue (CORE_ADDR pc, CORE_ADDR fp,
 668                              CORE_ADDR *first_line,
 669                              int *frame_offset, CORE_ADDR *pushed_regs)
 670 {
 671   CORE_ADDR save_addr;
 672   CORE_ADDR func_end;
 673   int size;
 674   int found_frame_point;
 675   int saved_reg;
 676   CORE_ADDR first_pc;
 677   int done = 0;
 678   struct insn_sequence *seq_table;
 679
 680   first_pc = get_pc_function_start (pc);
 681   size = 0;
 682
 683   m68hc11_initialize_register_info ();
 684   if (first_pc == 0)
 685     {
 686       *frame_offset = 0;
 687       *first_line   = pc;
 688       return;
 689     }
 690
 691   seq_table = gdbarch_tdep (current_gdbarch)->prologue;
 692
 693   /* The 68hc11 stack is as follows:
 694
 695
 696      |           |
 697      +-----------+
 698      |           |
 699      | args      |
 700      |           |
 701      +-----------+
 702      | PC-return |
 703      +-----------+
 704      | Old frame |
 705      +-----------+
 706      |           |
 707      | Locals    |
 708      |           |
 709      +-----------+ <--- current frame
 710      |           |
 711
 712      With most processors (like 68K) the previous frame can be computed
 713      easily because it is always at a fixed offset (see link/unlink).
 714      That is, locals are accessed with negative offsets, arguments are
 715      accessed with positive ones.  Since 68hc11 only supports offsets
 716      in the range [0..255], the frame is defined at the bottom of
 717      locals (see picture).
 718
 719      The purpose of the analysis made here is to find out the size
 720      of locals in this function.  An alternative to this is to use
 721      DWARF2 info.  This would be better but I don't know how to
 722      access dwarf2 debug from this function.
 723
 724      Walk from the function entry point to the point where we save
 725      the frame.  While walking instructions, compute the size of bytes
 726      which are pushed.  This gives us the index to access the previous
 727      frame.
 728
 729      We limit the search to 128 bytes so that the algorithm is bounded
 730      in case of random and wrong code.  We also stop and abort if
 731      we find an instruction which is not supposed to appear in the
 732      prologue (as generated by gcc 2.95, 2.96).
 733   */
 734   pc = first_pc;
 735   func_end = pc + 128;
 736   found_frame_point = 0;
 737   *frame_offset = 0;
 738   save_addr = fp + STACK_CORRECTION;
 739   while (!done && pc + 2 < func_end)
 740     {
 741       struct insn_sequence *seq;
 742       CORE_ADDR val;
 743
 744       seq = m68hc11_analyze_instruction (seq_table, &pc, &val);
 745       if (seq == 0)
 746         break;
 747
 748       if (seq->type == P_SAVE_REG)
 749         {
 750           if (found_frame_point)
 751             {
 752               saved_reg = m68hc11_which_soft_register (val);
 753               if (saved_reg < 0)
 754                 break;
 755
 756               save_addr -= 2;
 757               if (pushed_regs)
 758                 pushed_regs[saved_reg] = save_addr;
 759             }
 760           else
 761             {
 762               size += 2;
 763             }
 764         }
 765       else if (seq->type == P_SET_FRAME)
 766         {
 767           found_frame_point = 1;
 768           *frame_offset = size;
 769         }
 770       else if (seq->type == P_LOCAL_1)
 771         {
 772           size += 1;
 773         }
 774       else if (seq->type == P_LOCAL_2)
 775         {
 776           size += 2;
 777         }
 778       else if (seq->type == P_LOCAL_N)
 779         {
 780           /* Stack pointer is decremented for the allocation.  */
 781           if (val & 0x8000)
 782             size -= (int) (val) | 0xffff0000;
 783           else
 784             size -= val;
 785         }
 786     }
 787   *first_line  = pc;
 788 }
 789
 790 static CORE_ADDR
 791 m68hc11_skip_prologue (CORE_ADDR pc)
 792 {
 793   CORE_ADDR func_addr, func_end;
 794   struct symtab_and_line sal;
 795   int frame_offset;
 796
 797   /* If we have line debugging information, then the end of the
 798      prologue should be the first assembly instruction of the
 799      first source line.  */
 800   if (find_pc_partial_function (pc, NULL, &func_addr, &func_end))
 801     {
 802       sal = find_pc_line (func_addr, 0);
 803       if (sal.end && sal.end < func_end)
 804         return sal.end;
 805     }
 806
 807   m68hc11_guess_from_prologue (pc, 0, &pc, &frame_offset, 0);
 808   return pc;
 809 }
 810
 811 /* Given a GDB frame, determine the address of the calling function's
 812    frame.  This will be used to create a new GDB frame struct, and
 813    then DEPRECATED_INIT_EXTRA_FRAME_INFO and DEPRECATED_INIT_FRAME_PC
 814    will be called for the new frame.  */
 815
 816 static CORE_ADDR
 817 m68hc11_frame_chain (struct frame_info *frame)
 818 {
 819   CORE_ADDR addr;
 820
 821   if (DEPRECATED_PC_IN_CALL_DUMMY (get_frame_pc (frame),
 822                                    get_frame_base (frame),
 823                                    get_frame_base (frame)))
 824     return get_frame_base (frame);      /* dummy frame same as caller's frame */
 825
 826   if (get_frame_extra_info (frame)->return_pc == 0
 827       || inside_entry_file (get_frame_extra_info (frame)->return_pc))
 828     return (CORE_ADDR) 0;
 829
 830   if (get_frame_base (frame) == 0)
 831     {
 832       return (CORE_ADDR) 0;
 833     }
 834
 835   addr = get_frame_base (frame) + get_frame_extra_info (frame)->size + STACK_CORRECTION - 2;
 836   addr = read_memory_unsigned_integer (addr, 2) & 0x0FFFF;
 837   return addr;
 838 }
 839
 840 /* Put here the code to store, into a struct frame_saved_regs, the
 841    addresses of the saved registers of frame described by FRAME_INFO.
 842    This includes special registers such as pc and fp saved in special
 843    ways in the stack frame.   sp is even more special: the address we
 844    return for it IS the sp for the next frame.  */
 845 static void
 846 m68hc11_frame_init_saved_regs (struct frame_info *fi)
 847 {
 848   CORE_ADDR pc;
 849   CORE_ADDR addr;
 850
 851   if (get_frame_saved_regs (fi) == NULL)
 852     frame_saved_regs_zalloc (fi);
 853   else
 854     memset (get_frame_saved_regs (fi), 0, SIZEOF_FRAME_SAVED_REGS);
 855
 856   pc = get_frame_pc (fi);
 857   get_frame_extra_info (fi)->return_kind = m68hc11_get_return_insn (pc);
 858   m68hc11_guess_from_prologue (pc, get_frame_base (fi), &pc,
 859                                &get_frame_extra_info (fi)->size,
 860                                get_frame_saved_regs (fi));
 861
 862   addr = get_frame_base (fi) + get_frame_extra_info (fi)->size + STACK_CORRECTION;
 863   if (soft_regs[SOFT_FP_REGNUM].name)
 864     get_frame_saved_regs (fi)[SOFT_FP_REGNUM] = addr - 2;
 865
 866   /* Take into account how the function was called/returns.  */
 867   if (get_frame_extra_info (fi)->return_kind == RETURN_RTC)
 868     {
 869       get_frame_saved_regs (fi)[HARD_PAGE_REGNUM] = addr;
 870       addr++;
 871     }
 872   else if (get_frame_extra_info (fi)->return_kind == RETURN_RTI)
 873     {
 874       get_frame_saved_regs (fi)[HARD_CCR_REGNUM] = addr;
 875       get_frame_saved_regs (fi)[HARD_D_REGNUM] = addr + 1;
 876       get_frame_saved_regs (fi)[HARD_X_REGNUM] = addr + 3;
 877       get_frame_saved_regs (fi)[HARD_Y_REGNUM] = addr + 5;
 878       addr += 7;
 879     }
 880   get_frame_saved_regs (fi)[HARD_SP_REGNUM] = addr;
 881   get_frame_saved_regs (fi)[HARD_PC_REGNUM] = get_frame_saved_regs (fi)[HARD_SP_REGNUM];
 882 }
 883
 884 static void
 885 m68hc11_init_extra_frame_info (int fromleaf, struct frame_info *fi)
 886 {
 887   CORE_ADDR addr;
 888
 889   frame_extra_info_zalloc (fi, sizeof (struct frame_extra_info));
 890
 891   if (get_next_frame (fi))
 892     deprecated_update_frame_pc_hack (fi, DEPRECATED_FRAME_SAVED_PC (get_next_frame (fi)));
 893
 894   m68hc11_frame_init_saved_regs (fi);
 895
 896   if (fromleaf)
 897     {
 898       get_frame_extra_info (fi)->return_kind = m68hc11_get_return_insn (get_frame_pc (fi));
 899       get_frame_extra_info (fi)->return_pc = m68hc11_saved_pc_after_call (fi);
 900     }
 901   else
 902     {
 903       addr = get_frame_saved_regs (fi)[HARD_PC_REGNUM];
 904       addr = read_memory_unsigned_integer (addr, 2) & 0x0ffff;
 905
 906       /* Take into account the 68HC12 specific call (PC + page).  */
 907       if (get_frame_extra_info (fi)->return_kind == RETURN_RTC
 908           && addr >= 0x08000 && addr < 0x0c000
 909           && USE_PAGE_REGISTER)
 910         {
 911           CORE_ADDR page_addr = get_frame_saved_regs (fi)[HARD_PAGE_REGNUM];
 912
 913           unsigned page = read_memory_unsigned_integer (page_addr, 1);
 914           addr -= 0x08000;
 915           addr += ((page & 0x0ff) << 14);
 916           addr += 0x1000000;
 917         }
 918       get_frame_extra_info (fi)->return_pc = addr;
 919     }
 920 }
 921
 922 /* Same as 'info reg' but prints the registers in a different way.  */
 923 static void
 924 show_regs (char *args, int from_tty)
 925 {
 926   int ccr = read_register (HARD_CCR_REGNUM);
 927   int i;
 928   int nr;
 929
 930   printf_filtered ("PC=%04x SP=%04x FP=%04x CCR=%02x %c%c%c%c%c%c%c%c\n",
 931                    (int) read_register (HARD_PC_REGNUM),
 932                    (int) read_register (HARD_SP_REGNUM),
 933                    (int) read_register (SOFT_FP_REGNUM),
 934                    ccr,
 935                    ccr & M6811_S_BIT ? 'S' : '-',
 936                    ccr & M6811_X_BIT ? 'X' : '-',
 937                    ccr & M6811_H_BIT ? 'H' : '-',
 938                    ccr & M6811_I_BIT ? 'I' : '-',
 939                    ccr & M6811_N_BIT ? 'N' : '-',
 940                    ccr & M6811_Z_BIT ? 'Z' : '-',
 941                    ccr & M6811_V_BIT ? 'V' : '-',
 942                    ccr & M6811_C_BIT ? 'C' : '-');
 943
 944   printf_filtered ("D=%04x IX=%04x IY=%04x",
 945                    (int) read_register (HARD_D_REGNUM),
 946                    (int) read_register (HARD_X_REGNUM),
 947                    (int) read_register (HARD_Y_REGNUM));
 948
 949   if (USE_PAGE_REGISTER)
 950     {
 951       printf_filtered (" Page=%02x",
 952                        (int) read_register (HARD_PAGE_REGNUM));
 953     }
 954   printf_filtered ("\n");
 955
 956   nr = 0;
 957   for (i = SOFT_D1_REGNUM; i < M68HC11_ALL_REGS; i++)
 958     {
 959       /* Skip registers which are not defined in the symbol table.  */
 960       if (soft_regs[i].name == 0)
 961         continue;
 962
 963       printf_filtered ("D%d=%04x",
 964                        i - SOFT_D1_REGNUM + 1,
 965                        (int) read_register (i));
 966       nr++;
 967       if ((nr % 8) == 7)
 968         printf_filtered ("\n");
 969       else
 970         printf_filtered (" ");
 971     }
 972   if (nr && (nr % 8) != 7)
 973     printf_filtered ("\n");
 974 }
 975
 976 static CORE_ADDR
 977 m68hc11_stack_align (CORE_ADDR addr)
 978 {
 979   return ((addr + 1) & -2);
 980 }
 981
 982 static CORE_ADDR
 983 m68hc11_push_arguments (int nargs,
 984                         struct value **args,
 985                         CORE_ADDR sp,
 986                         int struct_return,
 987                         CORE_ADDR struct_addr)
 988 {
 989   int stack_alloc;
 990   int argnum;
 991   int first_stack_argnum;
 992   int stack_offset;
 993   struct type *type;
 994   char *val;
 995   int len;
 996
 997   stack_alloc = 0;
 998   first_stack_argnum = 0;
 999   if (struct_return)
1000     {
1001       /* The struct is allocated on the stack and gdb used the stack
1002          pointer for the address of that struct.  We must apply the
1003          stack offset on the address.  */
1004       write_register (HARD_D_REGNUM, struct_addr + STACK_CORRECTION);
1005     }
1006   else if (nargs > 0)
1007     {
1008       type = VALUE_TYPE (args[0]);
1009       len = TYPE_LENGTH (type);
1010
1011       /* First argument is passed in D and X registers.  */
1012       if (len <= 4)
1013         {
1014           LONGEST v = extract_unsigned_integer (VALUE_CONTENTS (args[0]), len);
1015           first_stack_argnum = 1;
1016           write_register (HARD_D_REGNUM, v);
1017           if (len > 2)
1018             {
1019               v >>= 16;
1020               write_register (HARD_X_REGNUM, v);
1021             }
1022         }
1023     }
1024   for (argnum = first_stack_argnum; argnum < nargs; argnum++)
1025     {
1026       type = VALUE_TYPE (args[argnum]);
1027       stack_alloc += (TYPE_LENGTH (type) + 1) & -2;
1028     }
1029   sp -= stack_alloc;
1030
1031   stack_offset = STACK_CORRECTION;
1032   for (argnum = first_stack_argnum; argnum < nargs; argnum++)
1033     {
1034       type = VALUE_TYPE (args[argnum]);
1035       len = TYPE_LENGTH (type);
1036
1037       val = (char*) VALUE_CONTENTS (args[argnum]);
1038       write_memory (sp + stack_offset, val, len);
1039       stack_offset += len;
1040       if (len & 1)
1041         {
1042           static char zero = 0;
1043
1044           write_memory (sp + stack_offset, &zero, 1);
1045           stack_offset++;
1046         }
1047     }
1048   return sp;
1049 }
1050
1051
1052 /* Return a location where we can set a breakpoint that will be hit
1053    when an inferior function call returns.  */
1054 static CORE_ADDR
1055 m68hc11_call_dummy_address (void)
1056 {
1057   return entry_point_address ();
1058 }
1059
1060 static struct type *
1061 m68hc11_register_virtual_type (int reg_nr)
1062 {
1063   switch (reg_nr)
1064     {
1065     case HARD_PAGE_REGNUM:
1066     case HARD_A_REGNUM:
1067     case HARD_B_REGNUM:
1068     case HARD_CCR_REGNUM:
1069       return builtin_type_uint8;
1070
1071     case M68HC12_HARD_PC_REGNUM:
1072       return builtin_type_uint32;
1073
1074     default:
1075       return builtin_type_uint16;
1076     }
1077 }
1078
1079 static void
1080 m68hc11_store_struct_return (CORE_ADDR addr, CORE_ADDR sp)
1081 {
1082   /* The struct address computed by gdb is on the stack.
1083      It uses the stack pointer so we must apply the stack
1084      correction offset.  */
1085   write_register (HARD_D_REGNUM, addr + STACK_CORRECTION);
1086 }
1087
1088 static void
1089 m68hc11_store_return_value (struct type *type, char *valbuf)
1090 {
1091   int len;
1092
1093   len = TYPE_LENGTH (type);
1094
1095   /* First argument is passed in D and X registers.  */
1096   if (len <= 4)
1097     {
1098       LONGEST v = extract_unsigned_integer (valbuf, len);
1099
1100       write_register (HARD_D_REGNUM, v);
1101       if (len > 2)
1102         {
1103           v >>= 16;
1104           write_register (HARD_X_REGNUM, v);
1105         }
1106     }
1107   else
1108     error ("return of value > 4 is not supported.");
1109 }
1110
1111
1112 /* Given a return value in `regbuf' with a type `type',
1113    extract and copy its value into `valbuf'.  */
1114
1115 static void
1116 m68hc11_extract_return_value (struct type *type,
1117                               char *regbuf,
1118                               char *valbuf)
1119 {
1120   int len = TYPE_LENGTH (type);
1121
1122   switch (len)
1123     {
1124     case 1:
1125       memcpy (valbuf, &regbuf[HARD_D_REGNUM * 2 + 1], len);
1126       break;
1127
1128     case 2:
1129       memcpy (valbuf, &regbuf[HARD_D_REGNUM * 2], len);
1130       break;
1131
1132     case 3:
1133       memcpy (&valbuf[0], &regbuf[HARD_X_REGNUM * 2 + 1], 1);
1134       memcpy (&valbuf[1], &regbuf[HARD_D_REGNUM * 2], 2);
1135       break;
1136
1137     case 4:
1138       memcpy (&valbuf[0], &regbuf[HARD_X_REGNUM * 2], 2);
1139       memcpy (&valbuf[2], &regbuf[HARD_D_REGNUM * 2], 2);
1140       break;
1141
1142     default:
1143       error ("bad size for return value");
1144     }
1145 }
1146
1147 /* Should call_function allocate stack space for a struct return?  */
1148 static int
1149 m68hc11_use_struct_convention (int gcc_p, struct type *type)
1150 {
1151   return (TYPE_CODE (type) == TYPE_CODE_STRUCT
1152           || TYPE_CODE (type) == TYPE_CODE_UNION
1153           || TYPE_LENGTH (type) > 4);
1154 }
1155
1156 static int
1157 m68hc11_return_value_on_stack (struct type *type)
1158 {
1159   return TYPE_LENGTH (type) > 4;
1160 }
1161
1162 /* Extract from an array REGBUF containing the (raw) register state
1163    the address in which a function should return its structure value,
1164    as a CORE_ADDR (or an expression that can be used as one).  */
1165 static CORE_ADDR
1166 m68hc11_extract_struct_value_address (char *regbuf)
1167 {
1168   return extract_unsigned_integer (&regbuf[HARD_D_REGNUM * 2],
1169                                    REGISTER_RAW_SIZE (HARD_D_REGNUM));
1170 }
1171
1172 /* Function: push_return_address (pc)
1173    Set up the return address for the inferior function call.
1174    Needed for targets where we don't actually execute a JSR/BSR instruction */
1175
1176 static CORE_ADDR
1177 m68hc11_push_return_address (CORE_ADDR pc, CORE_ADDR sp)
1178 {
1179   char valbuf[2];
1180
1181   pc = CALL_DUMMY_ADDRESS ();
1182   sp -= 2;
1183   store_unsigned_integer (valbuf, 2, pc);
1184   write_memory (sp + STACK_CORRECTION, valbuf, 2);
1185   return sp;
1186 }
1187
1188 /* Test whether the ELF symbol corresponds to a function using rtc or
1189    rti to return.  */
1190
1191 static void
1192 m68hc11_elf_make_msymbol_special (asymbol *sym, struct minimal_symbol *msym)
1193 {
1194   unsigned char flags;
1195
1196   flags = ((elf_symbol_type *)sym)->internal_elf_sym.st_other;
1197   if (flags & STO_M68HC12_FAR)
1198     MSYMBOL_SET_RTC (msym);
1199   if (flags & STO_M68HC12_INTERRUPT)
1200     MSYMBOL_SET_RTI (msym);
1201 }
1202
1203 static int
1204 gdb_print_insn_m68hc11 (bfd_vma memaddr, disassemble_info *info)
1205 {
1206   if (TARGET_ARCHITECTURE->arch == bfd_arch_m68hc11)
1207     return print_insn_m68hc11 (memaddr, info);
1208   else
1209     return print_insn_m68hc12 (memaddr, info);
1210 }
1211
1212 \f
1213
1214 /* 68HC11/68HC12 register groups.
1215    Identify real hard registers and soft registers used by gcc.  */
1216
1217 static struct reggroup *m68hc11_soft_reggroup;
1218 static struct reggroup *m68hc11_hard_reggroup;
1219
1220 static void
1221 m68hc11_init_reggroups (void)
1222 {
1223   m68hc11_hard_reggroup = reggroup_new ("hard", USER_REGGROUP);
1224   m68hc11_soft_reggroup = reggroup_new ("soft", USER_REGGROUP);
1225 }
1226
1227 static void
1228 m68hc11_add_reggroups (struct gdbarch *gdbarch)
1229 {
1230   reggroup_add (gdbarch, m68hc11_hard_reggroup);
1231   reggroup_add (gdbarch, m68hc11_soft_reggroup);
1232   reggroup_add (gdbarch, general_reggroup);
1233   reggroup_add (gdbarch, float_reggroup);
1234   reggroup_add (gdbarch, all_reggroup);
1235   reggroup_add (gdbarch, save_reggroup);
1236   reggroup_add (gdbarch, restore_reggroup);
1237   reggroup_add (gdbarch, vector_reggroup);
1238   reggroup_add (gdbarch, system_reggroup);
1239 }
1240
1241 static int
1242 m68hc11_register_reggroup_p (struct gdbarch *gdbarch, int regnum,
1243                              struct reggroup *group)
1244 {
1245   /* We must save the real hard register as well as gcc
1246      soft registers including the frame pointer.  */
1247   if (group == save_reggroup || group == restore_reggroup)
1248     {
1249       return (regnum <= gdbarch_num_regs (gdbarch)
1250               || ((regnum == SOFT_FP_REGNUM
1251                    || regnum == SOFT_TMP_REGNUM
1252                    || regnum == SOFT_ZS_REGNUM
1253                    || regnum == SOFT_XY_REGNUM)
1254                   && m68hc11_register_name (regnum)));
1255     }
1256
1257   /* Group to identify gcc soft registers (d1..dN).  */
1258   if (group == m68hc11_soft_reggroup)
1259     {
1260       return regnum >= SOFT_D1_REGNUM && m68hc11_register_name (regnum);
1261     }
1262
1263   if (group == m68hc11_hard_reggroup)
1264     {
1265       return regnum == HARD_PC_REGNUM || regnum == HARD_SP_REGNUM
1266         || regnum == HARD_X_REGNUM || regnum == HARD_D_REGNUM
1267         || regnum == HARD_Y_REGNUM || regnum == HARD_CCR_REGNUM;
1268     }
1269   return default_register_reggroup_p (gdbarch, regnum, group);
1270 }
1271
1272 static struct gdbarch *
1273 m68hc11_gdbarch_init (struct gdbarch_info info,
1274                       struct gdbarch_list *arches)
1275 {
1276   static LONGEST m68hc11_call_dummy_words[] =
1277   {0};
1278   struct gdbarch *gdbarch;
1279   struct gdbarch_tdep *tdep;
1280   int elf_flags;
1281
1282   soft_reg_initialized = 0;
1283
1284   /* Extract the elf_flags if available.  */
1285   if (info.abfd != NULL
1286       && bfd_get_flavour (info.abfd) == bfd_target_elf_flavour)
1287     elf_flags = elf_elfheader (info.abfd)->e_flags;
1288   else
1289     elf_flags = 0;
1290
1291   /* try to find a pre-existing architecture */
1292   for (arches = gdbarch_list_lookup_by_info (arches, &info);
1293        arches != NULL;
1294        arches = gdbarch_list_lookup_by_info (arches->next, &info))
1295     {
1296       if (gdbarch_tdep (arches->gdbarch)->elf_flags != elf_flags)
1297         continue;
1298
1299       return arches->gdbarch;
1300     }
1301
1302   /* Need a new architecture. Fill in a target specific vector.  */
1303   tdep = (struct gdbarch_tdep *) xmalloc (sizeof (struct gdbarch_tdep));
1304   gdbarch = gdbarch_alloc (&info, tdep);
1305   tdep->elf_flags = elf_flags;
1306
1307   /* NOTE: cagney/2002-12-06: This can be deleted when this arch is
1308      ready to unwind the PC first (see frame.c:get_prev_frame()).  */
1309   set_gdbarch_deprecated_init_frame_pc (gdbarch, init_frame_pc_default);
1310
1311   switch (info.bfd_arch_info->arch)
1312     {
1313     case bfd_arch_m68hc11:
1314       tdep->stack_correction = 1;
1315       tdep->use_page_register = 0;
1316       tdep->prologue = m6811_prologue;
1317       set_gdbarch_addr_bit (gdbarch, 16);
1318       set_gdbarch_num_pseudo_regs (gdbarch, M68HC11_NUM_PSEUDO_REGS);
1319       set_gdbarch_pc_regnum (gdbarch, HARD_PC_REGNUM);
1320       set_gdbarch_num_regs (gdbarch, M68HC11_NUM_REGS);
1321       break;
1322
1323     case bfd_arch_m68hc12:
1324       tdep->stack_correction = 0;
1325       tdep->use_page_register = elf_flags & E_M68HC12_BANKS;
1326       tdep->prologue = m6812_prologue;
1327       set_gdbarch_addr_bit (gdbarch, elf_flags & E_M68HC12_BANKS ? 32 : 16);
1328       set_gdbarch_num_pseudo_regs (gdbarch,
1329                                    elf_flags & E_M68HC12_BANKS
1330                                    ? M68HC12_NUM_PSEUDO_REGS
1331                                    : M68HC11_NUM_PSEUDO_REGS);
1332       set_gdbarch_pc_regnum (gdbarch, elf_flags & E_M68HC12_BANKS
1333                              ? M68HC12_HARD_PC_REGNUM : HARD_PC_REGNUM);
1334       set_gdbarch_num_regs (gdbarch, elf_flags & E_M68HC12_BANKS
1335                             ? M68HC12_NUM_REGS : M68HC11_NUM_REGS);
1336       break;
1337
1338     default:
1339       break;
1340     }
1341
1342   /* Initially set everything according to the ABI.
1343      Use 16-bit integers since it will be the case for most
1344      programs.  The size of these types should normally be set
1345      according to the dwarf2 debug information.  */
1346   set_gdbarch_short_bit (gdbarch, 16);
1347   set_gdbarch_int_bit (gdbarch, elf_flags & E_M68HC11_I32 ? 32 : 16);
1348   set_gdbarch_float_bit (gdbarch, 32);
1349   set_gdbarch_double_bit (gdbarch, elf_flags & E_M68HC11_F64 ? 64 : 32);
1350   set_gdbarch_long_double_bit (gdbarch, 64);
1351   set_gdbarch_long_bit (gdbarch, 32);
1352   set_gdbarch_ptr_bit (gdbarch, 16);
1353   set_gdbarch_long_long_bit (gdbarch, 64);
1354
1355   /* Set register info.  */
1356   set_gdbarch_fp0_regnum (gdbarch, -1);
1357   set_gdbarch_deprecated_max_register_raw_size (gdbarch, 2);
1358   set_gdbarch_deprecated_max_register_virtual_size (gdbarch, 2);
1359   set_gdbarch_deprecated_frame_init_saved_regs (gdbarch, m68hc11_frame_init_saved_regs);
1360   set_gdbarch_frame_args_skip (gdbarch, 0);
1361
1362   set_gdbarch_write_pc (gdbarch, generic_target_write_pc);
1363   set_gdbarch_deprecated_dummy_write_sp (gdbarch, deprecated_write_sp);
1364
1365   set_gdbarch_sp_regnum (gdbarch, HARD_SP_REGNUM);
1366   set_gdbarch_deprecated_fp_regnum (gdbarch, SOFT_FP_REGNUM);
1367   set_gdbarch_register_name (gdbarch, m68hc11_register_name);
1368   set_gdbarch_deprecated_register_size (gdbarch, 2);
1369   set_gdbarch_deprecated_register_bytes (gdbarch, M68HC11_ALL_REGS * 2);
1370   set_gdbarch_register_virtual_type (gdbarch, m68hc11_register_virtual_type);
1371   set_gdbarch_pseudo_register_read (gdbarch, m68hc11_pseudo_register_read);
1372   set_gdbarch_pseudo_register_write (gdbarch, m68hc11_pseudo_register_write);
1373
1374   set_gdbarch_call_dummy_address (gdbarch, m68hc11_call_dummy_address);
1375   set_gdbarch_deprecated_call_dummy_words (gdbarch, m68hc11_call_dummy_words);
1376   set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, sizeof (m68hc11_call_dummy_words));
1377   set_gdbarch_deprecated_get_saved_register (gdbarch, deprecated_generic_get_saved_register);
1378   set_gdbarch_deprecated_extract_return_value (gdbarch, m68hc11_extract_return_value);
1379   set_gdbarch_deprecated_push_arguments (gdbarch, m68hc11_push_arguments);
1380   set_gdbarch_deprecated_push_return_address (gdbarch, m68hc11_push_return_address);
1381   set_gdbarch_return_value_on_stack (gdbarch, m68hc11_return_value_on_stack);
1382
1383   set_gdbarch_deprecated_store_struct_return (gdbarch, m68hc11_store_struct_return);
1384   set_gdbarch_deprecated_store_return_value (gdbarch, m68hc11_store_return_value);
1385   set_gdbarch_deprecated_extract_struct_value_address (gdbarch, m68hc11_extract_struct_value_address);
1386
1387   set_gdbarch_deprecated_frame_chain (gdbarch, m68hc11_frame_chain);
1388   set_gdbarch_deprecated_frame_saved_pc (gdbarch, m68hc11_frame_saved_pc);
1389   set_gdbarch_frame_args_address (gdbarch, m68hc11_frame_args_address);
1390   set_gdbarch_deprecated_saved_pc_after_call (gdbarch, m68hc11_saved_pc_after_call);
1391
1392   set_gdbarch_deprecated_get_saved_register (gdbarch, deprecated_generic_get_saved_register);
1393
1394   set_gdbarch_deprecated_store_struct_return (gdbarch, m68hc11_store_struct_return);
1395   set_gdbarch_deprecated_store_return_value (gdbarch, m68hc11_store_return_value);
1396   set_gdbarch_deprecated_extract_struct_value_address
1397     (gdbarch, m68hc11_extract_struct_value_address);
1398   set_gdbarch_use_struct_convention (gdbarch, m68hc11_use_struct_convention);
1399   set_gdbarch_deprecated_init_extra_frame_info (gdbarch, m68hc11_init_extra_frame_info);
1400   set_gdbarch_deprecated_pop_frame (gdbarch, m68hc11_pop_frame);
1401   set_gdbarch_skip_prologue (gdbarch, m68hc11_skip_prologue);
1402   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
1403   set_gdbarch_decr_pc_after_break (gdbarch, 0);
1404   set_gdbarch_function_start_offset (gdbarch, 0);
1405   set_gdbarch_breakpoint_from_pc (gdbarch, m68hc11_breakpoint_from_pc);
1406   set_gdbarch_stack_align (gdbarch, m68hc11_stack_align);
1407   set_gdbarch_deprecated_extra_stack_alignment_needed (gdbarch, 1);
1408   set_gdbarch_print_insn (gdbarch, gdb_print_insn_m68hc11);
1409
1410   m68hc11_add_reggroups (gdbarch);
1411   set_gdbarch_register_reggroup_p (gdbarch, m68hc11_register_reggroup_p);
1412
1413   /* Minsymbol frobbing.  */
1414   set_gdbarch_elf_make_msymbol_special (gdbarch,
1415                                         m68hc11_elf_make_msymbol_special);
1416
1417   set_gdbarch_believe_pcc_promotion (gdbarch, 1);
1418
1419   return gdbarch;
1420 }
1421
1422 extern initialize_file_ftype _initialize_m68hc11_tdep; /* -Wmissing-prototypes */
1423
1424 void
1425 _initialize_m68hc11_tdep (void)
1426 {
1427   register_gdbarch_init (bfd_arch_m68hc11, m68hc11_gdbarch_init);
1428   register_gdbarch_init (bfd_arch_m68hc12, m68hc11_gdbarch_init);
1429   m68hc11_init_reggroups ();
1430
1431   add_com ("regs", class_vars, show_regs, "Print all registers");
1432 }
1433