gdb/m68hc11-tdep.c

   1 /* Target-dependent code for Motorola 68HC11 & 68HC12
   2
   3    Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005 Free Software
   4    Foundation, Inc.
   5
   6    Contributed by Stephane Carrez, stcarrez@nerim.fr
   7
   8 This file is part of GDB.
   9
  10 This program is free software; you can redistribute it and/or modify
  11 it under the terms of the GNU General Public License as published by
  12 the Free Software Foundation; either version 2 of the License, or
  13 (at your option) any later version.
  14
  15 This program is distributed in the hope that it will be useful,
  16 but WITHOUT ANY WARRANTY; without even the implied warranty of
  17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18 GNU General Public License for more details.
  19
  20 You should have received a copy of the GNU General Public License
  21 along with this program; if not, write to the Free Software
  22 Foundation, Inc., 51 Franklin Street, Fifth Floor,
  23 Boston, MA 02110-1301, USA.  */
  24
  25
  26 #include "defs.h"
  27 #include "frame.h"
  28 #include "frame-unwind.h"
  29 #include "frame-base.h"
  30 #include "dwarf2-frame.h"
  31 #include "trad-frame.h"
  32 #include "symtab.h"
  33 #include "gdbtypes.h"
  34 #include "gdbcmd.h"
  35 #include "gdbcore.h"
  36 #include "gdb_string.h"
  37 #include "value.h"
  38 #include "inferior.h"
  39 #include "dis-asm.h"
  40 #include "symfile.h"
  41 #include "objfiles.h"
  42 #include "arch-utils.h"
  43 #include "regcache.h"
  44 #include "reggroups.h"
  45
  46 #include "target.h"
  47 #include "opcode/m68hc11.h"
  48 #include "elf/m68hc11.h"
  49 #include "elf-bfd.h"
  50
  51 /* Macros for setting and testing a bit in a minimal symbol.
  52    For 68HC11/68HC12 we have two flags that tell which return
  53    type the function is using.  This is used for prologue and frame
  54    analysis to compute correct stack frame layout.
  55
  56    The MSB of the minimal symbol's "info" field is used for this purpose.
  57
  58    MSYMBOL_SET_RTC      Actually sets the "RTC" bit.
  59    MSYMBOL_SET_RTI      Actually sets the "RTI" bit.
  60    MSYMBOL_IS_RTC       Tests the "RTC" bit in a minimal symbol.
  61    MSYMBOL_IS_RTI       Tests the "RTC" bit in a minimal symbol.  */
  62
  63 #define MSYMBOL_SET_RTC(msym)                                           \
  64         MSYMBOL_INFO (msym) = (char *) (((long) MSYMBOL_INFO (msym))    \
  65                                         | 0x80000000)
  66
  67 #define MSYMBOL_SET_RTI(msym)                                           \
  68         MSYMBOL_INFO (msym) = (char *) (((long) MSYMBOL_INFO (msym))    \
  69                                         | 0x40000000)
  70
  71 #define MSYMBOL_IS_RTC(msym)                            \
  72         (((long) MSYMBOL_INFO (msym) & 0x80000000) != 0)
  73
  74 #define MSYMBOL_IS_RTI(msym)                            \
  75         (((long) MSYMBOL_INFO (msym) & 0x40000000) != 0)
  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 m68hc11_unwind_cache
 161 {
 162   /* The previous frame's inner most stack address.  Used as this
 163      frame ID's stack_addr.  */
 164   CORE_ADDR prev_sp;
 165   /* The frame's base, optionally used by the high-level debug info.  */
 166   CORE_ADDR base;
 167   CORE_ADDR pc;
 168   int size;
 169   int prologue_type;
 170   CORE_ADDR return_pc;
 171   CORE_ADDR sp_offset;
 172   int frameless;
 173   enum insn_return_kind return_kind;
 174
 175   /* Table indicating the location of each and every register.  */
 176   struct trad_frame_saved_reg *saved_regs;
 177 };
 178
 179 /* Table of registers for 68HC11.  This includes the hard registers
 180    and the soft registers used by GCC.  */
 181 static char *
 182 m68hc11_register_names[] =
 183 {
 184   "x",    "d",    "y",    "sp",   "pc",   "a",    "b",
 185   "ccr",  "page", "frame","tmp",  "zs",   "xy",   0,
 186   "d1",   "d2",   "d3",   "d4",   "d5",   "d6",   "d7",
 187   "d8",   "d9",   "d10",  "d11",  "d12",  "d13",  "d14",
 188   "d15",  "d16",  "d17",  "d18",  "d19",  "d20",  "d21",
 189   "d22",  "d23",  "d24",  "d25",  "d26",  "d27",  "d28",
 190   "d29",  "d30",  "d31",  "d32"
 191 };
 192
 193 struct m68hc11_soft_reg
 194 {
 195   const char *name;
 196   CORE_ADDR   addr;
 197 };
 198
 199 static struct m68hc11_soft_reg soft_regs[M68HC11_ALL_REGS];
 200
 201 #define M68HC11_FP_ADDR soft_regs[SOFT_FP_REGNUM].addr
 202
 203 static int soft_min_addr;
 204 static int soft_max_addr;
 205 static int soft_reg_initialized = 0;
 206
 207 /* Look in the symbol table for the address of a pseudo register
 208    in memory.  If we don't find it, pretend the register is not used
 209    and not available.  */
 210 static void
 211 m68hc11_get_register_info (struct m68hc11_soft_reg *reg, const char *name)
 212 {
 213   struct minimal_symbol *msymbol;
 214
 215   msymbol = lookup_minimal_symbol (name, NULL, NULL);
 216   if (msymbol)
 217     {
 218       reg->addr = SYMBOL_VALUE_ADDRESS (msymbol);
 219       reg->name = xstrdup (name);
 220
 221       /* Keep track of the address range for soft registers.  */
 222       if (reg->addr < (CORE_ADDR) soft_min_addr)
 223         soft_min_addr = reg->addr;
 224       if (reg->addr > (CORE_ADDR) soft_max_addr)
 225         soft_max_addr = reg->addr;
 226     }
 227   else
 228     {
 229       reg->name = 0;
 230       reg->addr = 0;
 231     }
 232 }
 233
 234 /* Initialize the table of soft register addresses according
 235    to the symbol table.  */
 236   static void
 237 m68hc11_initialize_register_info (void)
 238 {
 239   int i;
 240
 241   if (soft_reg_initialized)
 242     return;
 243
 244   soft_min_addr = INT_MAX;
 245   soft_max_addr = 0;
 246   for (i = 0; i < M68HC11_ALL_REGS; i++)
 247     {
 248       soft_regs[i].name = 0;
 249     }
 250
 251   m68hc11_get_register_info (&soft_regs[SOFT_FP_REGNUM], "_.frame");
 252   m68hc11_get_register_info (&soft_regs[SOFT_TMP_REGNUM], "_.tmp");
 253   m68hc11_get_register_info (&soft_regs[SOFT_ZS_REGNUM], "_.z");
 254   soft_regs[SOFT_Z_REGNUM] = soft_regs[SOFT_ZS_REGNUM];
 255   m68hc11_get_register_info (&soft_regs[SOFT_XY_REGNUM], "_.xy");
 256
 257   for (i = SOFT_D1_REGNUM; i < M68HC11_MAX_SOFT_REGS; i++)
 258     {
 259       char buf[10];
 260
 261       sprintf (buf, "_.d%d", i - SOFT_D1_REGNUM + 1);
 262       m68hc11_get_register_info (&soft_regs[i], buf);
 263     }
 264
 265   if (soft_regs[SOFT_FP_REGNUM].name == 0)
 266     warning (_("No frame soft register found in the symbol table.\n"
 267                "Stack backtrace will not work."));
 268   soft_reg_initialized = 1;
 269 }
 270
 271 /* Given an address in memory, return the soft register number if
 272    that address corresponds to a soft register.  Returns -1 if not.  */
 273 static int
 274 m68hc11_which_soft_register (CORE_ADDR addr)
 275 {
 276   int i;
 277
 278   if (addr < soft_min_addr || addr > soft_max_addr)
 279     return -1;
 280
 281   for (i = SOFT_FP_REGNUM; i < M68HC11_ALL_REGS; i++)
 282     {
 283       if (soft_regs[i].name && soft_regs[i].addr == addr)
 284         return i;
 285     }
 286   return -1;
 287 }
 288
 289 /* Fetch a pseudo register.  The 68hc11 soft registers are treated like
 290    pseudo registers.  They are located in memory.  Translate the register
 291    fetch into a memory read.  */
 292 static void
 293 m68hc11_pseudo_register_read (struct gdbarch *gdbarch,
 294                               struct regcache *regcache,
 295                               int regno, gdb_byte *buf)
 296 {
 297   /* The PC is a pseudo reg only for 68HC12 with the memory bank
 298      addressing mode.  */
 299   if (regno == M68HC12_HARD_PC_REGNUM)
 300     {
 301       ULONGEST pc;
 302       const int regsize = TYPE_LENGTH (builtin_type_uint32);
 303
 304       regcache_cooked_read_unsigned (regcache, HARD_PC_REGNUM, &pc);
 305       if (pc >= 0x8000 && pc < 0xc000)
 306         {
 307           ULONGEST page;
 308
 309           regcache_cooked_read_unsigned (regcache, HARD_PAGE_REGNUM, &page);
 310           pc -= 0x8000;
 311           pc += (page << 14);
 312           pc += 0x1000000;
 313         }
 314       store_unsigned_integer (buf, regsize, pc);
 315       return;
 316     }
 317
 318   m68hc11_initialize_register_info ();
 319
 320   /* Fetch a soft register: translate into a memory read.  */
 321   if (soft_regs[regno].name)
 322     {
 323       target_read_memory (soft_regs[regno].addr, buf, 2);
 324     }
 325   else
 326     {
 327       memset (buf, 0, 2);
 328     }
 329 }
 330
 331 /* Store a pseudo register.  Translate the register store
 332    into a memory write.  */
 333 static void
 334 m68hc11_pseudo_register_write (struct gdbarch *gdbarch,
 335                                struct regcache *regcache,
 336                                int regno, const gdb_byte *buf)
 337 {
 338   /* The PC is a pseudo reg only for 68HC12 with the memory bank
 339      addressing mode.  */
 340   if (regno == M68HC12_HARD_PC_REGNUM)
 341     {
 342       const int regsize = TYPE_LENGTH (builtin_type_uint32);
 343       char *tmp = alloca (regsize);
 344       CORE_ADDR pc;
 345
 346       memcpy (tmp, buf, regsize);
 347       pc = extract_unsigned_integer (tmp, regsize);
 348       if (pc >= 0x1000000)
 349         {
 350           pc -= 0x1000000;
 351           regcache_cooked_write_unsigned (regcache, HARD_PAGE_REGNUM,
 352                                           (pc >> 14) & 0x0ff);
 353           pc &= 0x03fff;
 354           regcache_cooked_write_unsigned (regcache, HARD_PC_REGNUM,
 355                                           pc + 0x8000);
 356         }
 357       else
 358         regcache_cooked_write_unsigned (regcache, HARD_PC_REGNUM, pc);
 359       return;
 360     }
 361
 362   m68hc11_initialize_register_info ();
 363
 364   /* Store a soft register: translate into a memory write.  */
 365   if (soft_regs[regno].name)
 366     {
 367       const int regsize = 2;
 368       char *tmp = alloca (regsize);
 369       memcpy (tmp, buf, regsize);
 370       target_write_memory (soft_regs[regno].addr, tmp, regsize);
 371     }
 372 }
 373
 374 static const char *
 375 m68hc11_register_name (int reg_nr)
 376 {
 377   if (reg_nr == M68HC12_HARD_PC_REGNUM && USE_PAGE_REGISTER)
 378     return "pc";
 379   if (reg_nr == HARD_PC_REGNUM && USE_PAGE_REGISTER)
 380     return "ppc";
 381
 382   if (reg_nr < 0)
 383     return NULL;
 384   if (reg_nr >= M68HC11_ALL_REGS)
 385     return NULL;
 386
 387   m68hc11_initialize_register_info ();
 388
 389   /* If we don't know the address of a soft register, pretend it
 390      does not exist.  */
 391   if (reg_nr > M68HC11_LAST_HARD_REG && soft_regs[reg_nr].name == 0)
 392     return NULL;
 393   return m68hc11_register_names[reg_nr];
 394 }
 395
 396 static const unsigned char *
 397 m68hc11_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr)
 398 {
 399   static unsigned char breakpoint[] = {0x0};
 400
 401   *lenptr = sizeof (breakpoint);
 402   return breakpoint;
 403 }
 404
 405 \f
 406 /* 68HC11 & 68HC12 prologue analysis.
 407
 408  */
 409 #define MAX_CODES 12
 410
 411 /* 68HC11 opcodes.  */
 412 #undef M6811_OP_PAGE2
 413 #define M6811_OP_PAGE2   (0x18)
 414 #define M6811_OP_LDX     (0xde)
 415 #define M6811_OP_LDX_EXT (0xfe)
 416 #define M6811_OP_PSHX    (0x3c)
 417 #define M6811_OP_STS     (0x9f)
 418 #define M6811_OP_STS_EXT (0xbf)
 419 #define M6811_OP_TSX     (0x30)
 420 #define M6811_OP_XGDX    (0x8f)
 421 #define M6811_OP_ADDD    (0xc3)
 422 #define M6811_OP_TXS     (0x35)
 423 #define M6811_OP_DES     (0x34)
 424
 425 /* 68HC12 opcodes.  */
 426 #define M6812_OP_PAGE2   (0x18)
 427 #define M6812_OP_MOVW    (0x01)
 428 #define M6812_PB_PSHW    (0xae)
 429 #define M6812_OP_STS     (0x5f)
 430 #define M6812_OP_STS_EXT (0x7f)
 431 #define M6812_OP_LEAS    (0x1b)
 432 #define M6812_OP_PSHX    (0x34)
 433 #define M6812_OP_PSHY    (0x35)
 434
 435 /* Operand extraction.  */
 436 #define OP_DIRECT      (0x100) /* 8-byte direct addressing.  */
 437 #define OP_IMM_LOW     (0x200) /* Low part of 16-bit constant/address.  */
 438 #define OP_IMM_HIGH    (0x300) /* High part of 16-bit constant/address.  */
 439 #define OP_PBYTE       (0x400) /* 68HC12 indexed operand.  */
 440
 441 /* Identification of the sequence.  */
 442 enum m6811_seq_type
 443 {
 444   P_LAST = 0,
 445   P_SAVE_REG,  /* Save a register on the stack.  */
 446   P_SET_FRAME, /* Setup the frame pointer.  */
 447   P_LOCAL_1,   /* Allocate 1 byte for locals.  */
 448   P_LOCAL_2,   /* Allocate 2 bytes for locals.  */
 449   P_LOCAL_N    /* Allocate N bytes for locals.  */
 450 };
 451
 452 struct insn_sequence {
 453   enum m6811_seq_type type;
 454   unsigned length;
 455   unsigned short code[MAX_CODES];
 456 };
 457
 458 /* Sequence of instructions in the 68HC11 function prologue.  */
 459 static struct insn_sequence m6811_prologue[] = {
 460   /* Sequences to save a soft-register.  */
 461   { P_SAVE_REG, 3, { M6811_OP_LDX, OP_DIRECT,
 462                      M6811_OP_PSHX } },
 463   { P_SAVE_REG, 5, { M6811_OP_PAGE2, M6811_OP_LDX, OP_DIRECT,
 464                      M6811_OP_PAGE2, M6811_OP_PSHX } },
 465   { P_SAVE_REG, 4, { M6811_OP_LDX_EXT, OP_IMM_HIGH, OP_IMM_LOW,
 466                      M6811_OP_PSHX } },
 467   { P_SAVE_REG, 6, { M6811_OP_PAGE2, M6811_OP_LDX_EXT, OP_IMM_HIGH, OP_IMM_LOW,
 468                      M6811_OP_PAGE2, M6811_OP_PSHX } },
 469
 470   /* Sequences to allocate local variables.  */
 471   { P_LOCAL_N,  7, { M6811_OP_TSX,
 472                      M6811_OP_XGDX,
 473                      M6811_OP_ADDD, OP_IMM_HIGH, OP_IMM_LOW,
 474                      M6811_OP_XGDX,
 475                      M6811_OP_TXS } },
 476   { P_LOCAL_N, 11, { M6811_OP_PAGE2, M6811_OP_TSX,
 477                      M6811_OP_PAGE2, M6811_OP_XGDX,
 478                      M6811_OP_ADDD, OP_IMM_HIGH, OP_IMM_LOW,
 479                      M6811_OP_PAGE2, M6811_OP_XGDX,
 480                      M6811_OP_PAGE2, M6811_OP_TXS } },
 481   { P_LOCAL_1,  1, { M6811_OP_DES } },
 482   { P_LOCAL_2,  1, { M6811_OP_PSHX } },
 483   { P_LOCAL_2,  2, { M6811_OP_PAGE2, M6811_OP_PSHX } },
 484
 485   /* Initialize the frame pointer.  */
 486   { P_SET_FRAME, 2, { M6811_OP_STS, OP_DIRECT } },
 487   { P_SET_FRAME, 3, { M6811_OP_STS_EXT, OP_IMM_HIGH, OP_IMM_LOW } },
 488   { P_LAST, 0, { 0 } }
 489 };
 490
 491
 492 /* Sequence of instructions in the 68HC12 function prologue.  */
 493 static struct insn_sequence m6812_prologue[] = {
 494   { P_SAVE_REG,  5, { M6812_OP_PAGE2, M6812_OP_MOVW, M6812_PB_PSHW,
 495                       OP_IMM_HIGH, OP_IMM_LOW } },
 496   { P_SET_FRAME, 2, { M6812_OP_STS, OP_DIRECT } },
 497   { P_SET_FRAME, 3, { M6812_OP_STS_EXT, OP_IMM_HIGH, OP_IMM_LOW } },
 498   { P_LOCAL_N,   2, { M6812_OP_LEAS, OP_PBYTE } },
 499   { P_LOCAL_2,   1, { M6812_OP_PSHX } },
 500   { P_LOCAL_2,   1, { M6812_OP_PSHY } },
 501   { P_LAST, 0 }
 502 };
 503
 504
 505 /* Analyze the sequence of instructions starting at the given address.
 506    Returns a pointer to the sequence when it is recognized and
 507    the optional value (constant/address) associated with it.  */
 508 static struct insn_sequence *
 509 m68hc11_analyze_instruction (struct insn_sequence *seq, CORE_ADDR pc,
 510                              CORE_ADDR *val)
 511 {
 512   unsigned char buffer[MAX_CODES];
 513   unsigned bufsize;
 514   unsigned j;
 515   CORE_ADDR cur_val;
 516   short v = 0;
 517
 518   bufsize = 0;
 519   for (; seq->type != P_LAST; seq++)
 520     {
 521       cur_val = 0;
 522       for (j = 0; j < seq->length; j++)
 523         {
 524           if (bufsize < j + 1)
 525             {
 526               buffer[bufsize] = read_memory_unsigned_integer (pc + bufsize,
 527                                                               1);
 528               bufsize++;
 529             }
 530           /* Continue while we match the opcode.  */
 531           if (seq->code[j] == buffer[j])
 532             continue;
 533
 534           if ((seq->code[j] & 0xf00) == 0)
 535             break;
 536
 537           /* Extract a sequence parameter (address or constant).  */
 538           switch (seq->code[j])
 539             {
 540             case OP_DIRECT:
 541               cur_val = (CORE_ADDR) buffer[j];
 542               break;
 543
 544             case OP_IMM_HIGH:
 545               cur_val = cur_val & 0x0ff;
 546               cur_val |= (buffer[j] << 8);
 547               break;
 548
 549             case OP_IMM_LOW:
 550               cur_val &= 0x0ff00;
 551               cur_val |= buffer[j];
 552               break;
 553
 554             case OP_PBYTE:
 555               if ((buffer[j] & 0xE0) == 0x80)
 556                 {
 557                   v = buffer[j] & 0x1f;
 558                   if (v & 0x10)
 559                     v |= 0xfff0;
 560                 }
 561               else if ((buffer[j] & 0xfe) == 0xf0)
 562                 {
 563                   v = read_memory_unsigned_integer (pc + j + 1, 1);
 564                   if (buffer[j] & 1)
 565                     v |= 0xff00;
 566                 }
 567               else if (buffer[j] == 0xf2)
 568                 {
 569                   v = read_memory_unsigned_integer (pc + j + 1, 2);
 570                 }
 571               cur_val = v;
 572               break;
 573             }
 574         }
 575
 576       /* We have a full match.  */
 577       if (j == seq->length)
 578         {
 579           *val = cur_val;
 580           return seq;
 581         }
 582     }
 583   return 0;
 584 }
 585
 586 /* Return the instruction that the function at the PC is using.  */
 587 static enum insn_return_kind
 588 m68hc11_get_return_insn (CORE_ADDR pc)
 589 {
 590   struct minimal_symbol *sym;
 591
 592   /* A flag indicating that this is a STO_M68HC12_FAR or STO_M68HC12_INTERRUPT
 593      function is stored by elfread.c in the high bit of the info field.
 594      Use this to decide which instruction the function uses to return.  */
 595   sym = lookup_minimal_symbol_by_pc (pc);
 596   if (sym == 0)
 597     return RETURN_RTS;
 598
 599   if (MSYMBOL_IS_RTC (sym))
 600     return RETURN_RTC;
 601   else if (MSYMBOL_IS_RTI (sym))
 602     return RETURN_RTI;
 603   else
 604     return RETURN_RTS;
 605 }
 606
 607 /* Analyze the function prologue to find some information
 608    about the function:
 609     - the PC of the first line (for m68hc11_skip_prologue)
 610     - the offset of the previous frame saved address (from current frame)
 611     - the soft registers which are pushed.  */
 612 static CORE_ADDR
 613 m68hc11_scan_prologue (CORE_ADDR pc, CORE_ADDR current_pc,
 614                        struct m68hc11_unwind_cache *info)
 615 {
 616   LONGEST save_addr;
 617   CORE_ADDR func_end;
 618   int size;
 619   int found_frame_point;
 620   int saved_reg;
 621   int done = 0;
 622   struct insn_sequence *seq_table;
 623
 624   info->size = 0;
 625   info->sp_offset = 0;
 626   if (pc >= current_pc)
 627     return current_pc;
 628
 629   size = 0;
 630
 631   m68hc11_initialize_register_info ();
 632   if (pc == 0)
 633     {
 634       info->size = 0;
 635       return pc;
 636     }
 637
 638   seq_table = gdbarch_tdep (current_gdbarch)->prologue;
 639
 640   /* The 68hc11 stack is as follows:
 641
 642
 643      |           |
 644      +-----------+
 645      |           |
 646      | args      |
 647      |           |
 648      +-----------+
 649      | PC-return |
 650      +-----------+
 651      | Old frame |
 652      +-----------+
 653      |           |
 654      | Locals    |
 655      |           |
 656      +-----------+ <--- current frame
 657      |           |
 658
 659      With most processors (like 68K) the previous frame can be computed
 660      easily because it is always at a fixed offset (see link/unlink).
 661      That is, locals are accessed with negative offsets, arguments are
 662      accessed with positive ones.  Since 68hc11 only supports offsets
 663      in the range [0..255], the frame is defined at the bottom of
 664      locals (see picture).
 665
 666      The purpose of the analysis made here is to find out the size
 667      of locals in this function.  An alternative to this is to use
 668      DWARF2 info.  This would be better but I don't know how to
 669      access dwarf2 debug from this function.
 670
 671      Walk from the function entry point to the point where we save
 672      the frame.  While walking instructions, compute the size of bytes
 673      which are pushed.  This gives us the index to access the previous
 674      frame.
 675
 676      We limit the search to 128 bytes so that the algorithm is bounded
 677      in case of random and wrong code.  We also stop and abort if
 678      we find an instruction which is not supposed to appear in the
 679      prologue (as generated by gcc 2.95, 2.96).
 680   */
 681   func_end = pc + 128;
 682   found_frame_point = 0;
 683   info->size = 0;
 684   save_addr = 0;
 685   while (!done && pc + 2 < func_end)
 686     {
 687       struct insn_sequence *seq;
 688       CORE_ADDR val;
 689
 690       seq = m68hc11_analyze_instruction (seq_table, pc, &val);
 691       if (seq == 0)
 692         break;
 693
 694       /* If we are within the instruction group, we can't advance the
 695          pc nor the stack offset.  Otherwise the caller's stack computed
 696          from the current stack can be wrong.  */
 697       if (pc + seq->length > current_pc)
 698         break;
 699
 700       pc = pc + seq->length;
 701       if (seq->type == P_SAVE_REG)
 702         {
 703           if (found_frame_point)
 704             {
 705               saved_reg = m68hc11_which_soft_register (val);
 706               if (saved_reg < 0)
 707                 break;
 708
 709               save_addr -= 2;
 710               if (info->saved_regs)
 711                 info->saved_regs[saved_reg].addr = save_addr;
 712             }
 713           else
 714             {
 715               size += 2;
 716             }
 717         }
 718       else if (seq->type == P_SET_FRAME)
 719         {
 720           found_frame_point = 1;
 721           info->size = size;
 722         }
 723       else if (seq->type == P_LOCAL_1)
 724         {
 725           size += 1;
 726         }
 727       else if (seq->type == P_LOCAL_2)
 728         {
 729           size += 2;
 730         }
 731       else if (seq->type == P_LOCAL_N)
 732         {
 733           /* Stack pointer is decremented for the allocation.  */
 734           if (val & 0x8000)
 735             size -= (int) (val) | 0xffff0000;
 736           else
 737             size -= val;
 738         }
 739     }
 740   if (found_frame_point == 0)
 741     info->sp_offset = size;
 742   else
 743     info->sp_offset = -1;
 744   return pc;
 745 }
 746
 747 static CORE_ADDR
 748 m68hc11_skip_prologue (CORE_ADDR pc)
 749 {
 750   CORE_ADDR func_addr, func_end;
 751   struct symtab_and_line sal;
 752   struct m68hc11_unwind_cache tmp_cache = { 0 };
 753
 754   /* If we have line debugging information, then the end of the
 755      prologue should be the first assembly instruction of the
 756      first source line.  */
 757   if (find_pc_partial_function (pc, NULL, &func_addr, &func_end))
 758     {
 759       sal = find_pc_line (func_addr, 0);
 760       if (sal.end && sal.end < func_end)
 761         return sal.end;
 762     }
 763
 764   pc = m68hc11_scan_prologue (pc, (CORE_ADDR) -1, &tmp_cache);
 765   return pc;
 766 }
 767
 768 static CORE_ADDR
 769 m68hc11_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
 770 {
 771   ULONGEST pc;
 772
 773   frame_unwind_unsigned_register (next_frame, gdbarch_pc_regnum (gdbarch),
 774                                   &pc);
 775   return pc;
 776 }
 777
 778 /* Put here the code to store, into fi->saved_regs, the addresses of
 779    the saved registers of frame described by FRAME_INFO.  This
 780    includes special registers such as pc and fp saved in special ways
 781    in the stack frame.  sp is even more special: the address we return
 782    for it IS the sp for the next frame. */
 783
 784 struct m68hc11_unwind_cache *
 785 m68hc11_frame_unwind_cache (struct frame_info *next_frame,
 786                             void **this_prologue_cache)
 787 {
 788   ULONGEST prev_sp;
 789   ULONGEST this_base;
 790   struct m68hc11_unwind_cache *info;
 791   CORE_ADDR current_pc;
 792   int i;
 793
 794   if ((*this_prologue_cache))
 795     return (*this_prologue_cache);
 796
 797   info = FRAME_OBSTACK_ZALLOC (struct m68hc11_unwind_cache);
 798   (*this_prologue_cache) = info;
 799   info->saved_regs = trad_frame_alloc_saved_regs (next_frame);
 800
 801   info->pc = frame_func_unwind (next_frame);
 802
 803   info->size = 0;
 804   info->return_kind = m68hc11_get_return_insn (info->pc);
 805
 806   /* The SP was moved to the FP.  This indicates that a new frame
 807      was created.  Get THIS frame's FP value by unwinding it from
 808      the next frame.  */
 809   frame_unwind_unsigned_register (next_frame, SOFT_FP_REGNUM, &this_base);
 810   if (this_base == 0)
 811     {
 812       info->base = 0;
 813       return info;
 814     }
 815
 816   current_pc = frame_pc_unwind (next_frame);
 817   if (info->pc != 0)
 818     m68hc11_scan_prologue (info->pc, current_pc, info);
 819
 820   info->saved_regs[HARD_PC_REGNUM].addr = info->size;
 821
 822   if (info->sp_offset != (CORE_ADDR) -1)
 823     {
 824       info->saved_regs[HARD_PC_REGNUM].addr = info->sp_offset;
 825       frame_unwind_unsigned_register (next_frame, HARD_SP_REGNUM, &this_base);
 826       prev_sp = this_base + info->sp_offset + 2;
 827       this_base += STACK_CORRECTION;
 828     }
 829   else
 830     {
 831       /* The FP points at the last saved register.  Adjust the FP back
 832          to before the first saved register giving the SP.  */
 833       prev_sp = this_base + info->size + 2;
 834
 835       this_base += STACK_CORRECTION;
 836       if (soft_regs[SOFT_FP_REGNUM].name)
 837         info->saved_regs[SOFT_FP_REGNUM].addr = info->size - 2;
 838    }
 839
 840   if (info->return_kind == RETURN_RTC)
 841     {
 842       prev_sp += 1;
 843       info->saved_regs[HARD_PAGE_REGNUM].addr = info->size;
 844       info->saved_regs[HARD_PC_REGNUM].addr = info->size + 1;
 845     }
 846   else if (info->return_kind == RETURN_RTI)
 847     {
 848       prev_sp += 7;
 849       info->saved_regs[HARD_CCR_REGNUM].addr = info->size;
 850       info->saved_regs[HARD_D_REGNUM].addr = info->size + 1;
 851       info->saved_regs[HARD_X_REGNUM].addr = info->size + 3;
 852       info->saved_regs[HARD_Y_REGNUM].addr = info->size + 5;
 853       info->saved_regs[HARD_PC_REGNUM].addr = info->size + 7;
 854     }
 855
 856   /* Add 1 here to adjust for the post-decrement nature of the push
 857      instruction.*/
 858   info->prev_sp = prev_sp;
 859
 860   info->base = this_base;
 861
 862   /* Adjust all the saved registers so that they contain addresses and not
 863      offsets.  */
 864   for (i = 0; i < NUM_REGS + NUM_PSEUDO_REGS - 1; i++)
 865     if (trad_frame_addr_p (info->saved_regs, i))
 866       {
 867         info->saved_regs[i].addr += this_base;
 868       }
 869
 870   /* The previous frame's SP needed to be computed.  Save the computed
 871      value.  */
 872   trad_frame_set_value (info->saved_regs, HARD_SP_REGNUM, info->prev_sp);
 873
 874   return info;
 875 }
 876
 877 /* Given a GDB frame, determine the address of the calling function's
 878    frame.  This will be used to create a new GDB frame struct.  */
 879
 880 static void
 881 m68hc11_frame_this_id (struct frame_info *next_frame,
 882                        void **this_prologue_cache,
 883                        struct frame_id *this_id)
 884 {
 885   struct m68hc11_unwind_cache *info
 886     = m68hc11_frame_unwind_cache (next_frame, this_prologue_cache);
 887   CORE_ADDR base;
 888   CORE_ADDR func;
 889   struct frame_id id;
 890
 891   /* The FUNC is easy.  */
 892   func = frame_func_unwind (next_frame);
 893
 894   /* Hopefully the prologue analysis either correctly determined the
 895      frame's base (which is the SP from the previous frame), or set
 896      that base to "NULL".  */
 897   base = info->prev_sp;
 898   if (base == 0)
 899     return;
 900
 901   id = frame_id_build (base, func);
 902   (*this_id) = id;
 903 }
 904
 905 static void
 906 m68hc11_frame_prev_register (struct frame_info *next_frame,
 907                              void **this_prologue_cache,
 908                              int regnum, int *optimizedp,
 909                              enum lval_type *lvalp, CORE_ADDR *addrp,
 910                              int *realnump, gdb_byte *bufferp)
 911 {
 912   struct m68hc11_unwind_cache *info
 913     = m68hc11_frame_unwind_cache (next_frame, this_prologue_cache);
 914
 915   trad_frame_get_prev_register (next_frame, info->saved_regs, regnum,
 916                                 optimizedp, lvalp, addrp, realnump, bufferp);
 917
 918   if (regnum == HARD_PC_REGNUM)
 919     {
 920       /* Take into account the 68HC12 specific call (PC + page).  */
 921       if (info->return_kind == RETURN_RTC
 922           && *addrp >= 0x08000 && *addrp < 0x0c000
 923           && USE_PAGE_REGISTER)
 924         {
 925           int page_optimized;
 926
 927           CORE_ADDR page;
 928
 929           trad_frame_get_prev_register (next_frame, info->saved_regs,
 930                                         HARD_PAGE_REGNUM, &page_optimized,
 931                                         0, &page, 0, 0);
 932           *addrp -= 0x08000;
 933           *addrp += ((page & 0x0ff) << 14);
 934           *addrp += 0x1000000;
 935         }
 936     }
 937 }
 938
 939 static const struct frame_unwind m68hc11_frame_unwind = {
 940   NORMAL_FRAME,
 941   m68hc11_frame_this_id,
 942   m68hc11_frame_prev_register
 943 };
 944
 945 const struct frame_unwind *
 946 m68hc11_frame_sniffer (struct frame_info *next_frame)
 947 {
 948   return &m68hc11_frame_unwind;
 949 }
 950
 951 static CORE_ADDR
 952 m68hc11_frame_base_address (struct frame_info *next_frame, void **this_cache)
 953 {
 954   struct m68hc11_unwind_cache *info
 955     = m68hc11_frame_unwind_cache (next_frame, this_cache);
 956
 957   return info->base;
 958 }
 959
 960 static CORE_ADDR
 961 m68hc11_frame_args_address (struct frame_info *next_frame, void **this_cache)
 962 {
 963   CORE_ADDR addr;
 964   struct m68hc11_unwind_cache *info
 965     = m68hc11_frame_unwind_cache (next_frame, this_cache);
 966
 967   addr = info->base + info->size;
 968   if (info->return_kind == RETURN_RTC)
 969     addr += 1;
 970   else if (info->return_kind == RETURN_RTI)
 971     addr += 7;
 972
 973   return addr;
 974 }
 975
 976 static const struct frame_base m68hc11_frame_base = {
 977   &m68hc11_frame_unwind,
 978   m68hc11_frame_base_address,
 979   m68hc11_frame_base_address,
 980   m68hc11_frame_args_address
 981 };
 982
 983 static CORE_ADDR
 984 m68hc11_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
 985 {
 986   ULONGEST sp;
 987   frame_unwind_unsigned_register (next_frame, HARD_SP_REGNUM, &sp);
 988   return sp;
 989 }
 990
 991 /* Assuming NEXT_FRAME->prev is a dummy, return the frame ID of that
 992    dummy frame.  The frame ID's base needs to match the TOS value
 993    saved by save_dummy_frame_tos(), and the PC match the dummy frame's
 994    breakpoint.  */
 995
 996 static struct frame_id
 997 m68hc11_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *next_frame)
 998 {
 999   ULONGEST tos;
1000   CORE_ADDR pc = frame_pc_unwind (next_frame);
1001
1002   frame_unwind_unsigned_register (next_frame, SOFT_FP_REGNUM, &tos);
1003   tos += 2;
1004   return frame_id_build (tos, pc);
1005 }
1006
1007 \f
1008 /* Get and print the register from the given frame.  */
1009 static void
1010 m68hc11_print_register (struct gdbarch *gdbarch, struct ui_file *file,
1011                         struct frame_info *frame, int regno)
1012 {
1013   LONGEST rval;
1014
1015   if (regno == HARD_PC_REGNUM || regno == HARD_SP_REGNUM
1016       || regno == SOFT_FP_REGNUM || regno == M68HC12_HARD_PC_REGNUM)
1017     rval = get_frame_register_unsigned (frame, regno);
1018   else
1019     rval = get_frame_register_signed (frame, regno);
1020
1021   if (regno == HARD_A_REGNUM || regno == HARD_B_REGNUM
1022       || regno == HARD_CCR_REGNUM || regno == HARD_PAGE_REGNUM)
1023     {
1024       fprintf_filtered (file, "0x%02x   ", (unsigned char) rval);
1025       if (regno != HARD_CCR_REGNUM)
1026         print_longest (file, 'd', 1, rval);
1027     }
1028   else
1029     {
1030       if (regno == HARD_PC_REGNUM && gdbarch_tdep (gdbarch)->use_page_register)
1031         {
1032           ULONGEST page;
1033
1034           page = get_frame_register_unsigned (frame, HARD_PAGE_REGNUM);
1035           fprintf_filtered (file, "0x%02x:%04x ", (unsigned) page,
1036                             (unsigned) rval);
1037         }
1038       else
1039         {
1040           fprintf_filtered (file, "0x%04x ", (unsigned) rval);
1041           if (regno != HARD_PC_REGNUM && regno != HARD_SP_REGNUM
1042               && regno != SOFT_FP_REGNUM && regno != M68HC12_HARD_PC_REGNUM)
1043             print_longest (file, 'd', 1, rval);
1044         }
1045     }
1046
1047   if (regno == HARD_CCR_REGNUM)
1048     {
1049       /* CCR register */
1050       int C, Z, N, V;
1051       unsigned char l = rval & 0xff;
1052
1053       fprintf_filtered (file, "%c%c%c%c%c%c%c%c   ",
1054                         l & M6811_S_BIT ? 'S' : '-',
1055                         l & M6811_X_BIT ? 'X' : '-',
1056                         l & M6811_H_BIT ? 'H' : '-',
1057                         l & M6811_I_BIT ? 'I' : '-',
1058                         l & M6811_N_BIT ? 'N' : '-',
1059                         l & M6811_Z_BIT ? 'Z' : '-',
1060                         l & M6811_V_BIT ? 'V' : '-',
1061                         l & M6811_C_BIT ? 'C' : '-');
1062       N = (l & M6811_N_BIT) != 0;
1063       Z = (l & M6811_Z_BIT) != 0;
1064       V = (l & M6811_V_BIT) != 0;
1065       C = (l & M6811_C_BIT) != 0;
1066
1067       /* Print flags following the h8300  */
1068       if ((C | Z) == 0)
1069         fprintf_filtered (file, "u> ");
1070       else if ((C | Z) == 1)
1071         fprintf_filtered (file, "u<= ");
1072       else if (C == 0)
1073         fprintf_filtered (file, "u< ");
1074
1075       if (Z == 0)
1076         fprintf_filtered (file, "!= ");
1077       else
1078         fprintf_filtered (file, "== ");
1079
1080       if ((N ^ V) == 0)
1081         fprintf_filtered (file, ">= ");
1082       else
1083         fprintf_filtered (file, "< ");
1084
1085       if ((Z | (N ^ V)) == 0)
1086         fprintf_filtered (file, "> ");
1087       else
1088         fprintf_filtered (file, "<= ");
1089     }
1090 }
1091
1092 /* Same as 'info reg' but prints the registers in a different way.  */
1093 static void
1094 m68hc11_print_registers_info (struct gdbarch *gdbarch, struct ui_file *file,
1095                               struct frame_info *frame, int regno, int cpregs)
1096 {
1097   if (regno >= 0)
1098     {
1099       const char *name = gdbarch_register_name (gdbarch, regno);
1100
1101       if (!name || !*name)
1102         return;
1103
1104       fprintf_filtered (file, "%-10s ", name);
1105       m68hc11_print_register (gdbarch, file, frame, regno);
1106       fprintf_filtered (file, "\n");
1107     }
1108   else
1109     {
1110       int i, nr;
1111
1112       fprintf_filtered (file, "PC=");
1113       m68hc11_print_register (gdbarch, file, frame, HARD_PC_REGNUM);
1114
1115       fprintf_filtered (file, " SP=");
1116       m68hc11_print_register (gdbarch, file, frame, HARD_SP_REGNUM);
1117
1118       fprintf_filtered (file, " FP=");
1119       m68hc11_print_register (gdbarch, file, frame, SOFT_FP_REGNUM);
1120
1121       fprintf_filtered (file, "\nCCR=");
1122       m68hc11_print_register (gdbarch, file, frame, HARD_CCR_REGNUM);
1123
1124       fprintf_filtered (file, "\nD=");
1125       m68hc11_print_register (gdbarch, file, frame, HARD_D_REGNUM);
1126
1127       fprintf_filtered (file, " X=");
1128       m68hc11_print_register (gdbarch, file, frame, HARD_X_REGNUM);
1129
1130       fprintf_filtered (file, " Y=");
1131       m68hc11_print_register (gdbarch, file, frame, HARD_Y_REGNUM);
1132
1133       if (gdbarch_tdep (gdbarch)->use_page_register)
1134         {
1135           fprintf_filtered (file, "\nPage=");
1136           m68hc11_print_register (gdbarch, file, frame, HARD_PAGE_REGNUM);
1137         }
1138       fprintf_filtered (file, "\n");
1139
1140       nr = 0;
1141       for (i = SOFT_D1_REGNUM; i < M68HC11_ALL_REGS; i++)
1142         {
1143           /* Skip registers which are not defined in the symbol table.  */
1144           if (soft_regs[i].name == 0)
1145             continue;
1146
1147           fprintf_filtered (file, "D%d=", i - SOFT_D1_REGNUM + 1);
1148           m68hc11_print_register (gdbarch, file, frame, i);
1149           nr++;
1150           if ((nr % 8) == 7)
1151             fprintf_filtered (file, "\n");
1152           else
1153             fprintf_filtered (file, " ");
1154         }
1155       if (nr && (nr % 8) != 7)
1156         fprintf_filtered (file, "\n");
1157     }
1158 }
1159
1160 static CORE_ADDR
1161 m68hc11_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
1162                          struct regcache *regcache, CORE_ADDR bp_addr,
1163                          int nargs, struct value **args, CORE_ADDR sp,
1164                          int struct_return, CORE_ADDR struct_addr)
1165 {
1166   int argnum;
1167   int first_stack_argnum;
1168   struct type *type;
1169   char *val;
1170   int len;
1171   char buf[2];
1172
1173   first_stack_argnum = 0;
1174   if (struct_return)
1175     {
1176       regcache_cooked_write_unsigned (regcache, HARD_D_REGNUM, struct_addr);
1177     }
1178   else if (nargs > 0)
1179     {
1180       type = value_type (args[0]);
1181       len = TYPE_LENGTH (type);
1182
1183       /* First argument is passed in D and X registers.  */
1184       if (len <= 4)
1185         {
1186           ULONGEST v;
1187
1188           v = extract_unsigned_integer (value_contents (args[0]), len);
1189           first_stack_argnum = 1;
1190
1191           regcache_cooked_write_unsigned (regcache, HARD_D_REGNUM, v);
1192           if (len > 2)
1193             {
1194               v >>= 16;
1195               regcache_cooked_write_unsigned (regcache, HARD_X_REGNUM, v);
1196             }
1197         }
1198     }
1199
1200   for (argnum = nargs - 1; argnum >= first_stack_argnum; argnum--)
1201     {
1202       type = value_type (args[argnum]);
1203       len = TYPE_LENGTH (type);
1204
1205       if (len & 1)
1206         {
1207           static char zero = 0;
1208
1209           sp--;
1210           write_memory (sp, &zero, 1);
1211         }
1212       val = (char*) value_contents (args[argnum]);
1213       sp -= len;
1214       write_memory (sp, val, len);
1215     }
1216
1217   /* Store return address.  */
1218   sp -= 2;
1219   store_unsigned_integer (buf, 2, bp_addr);
1220   write_memory (sp, buf, 2);
1221
1222   /* Finally, update the stack pointer...  */
1223   sp -= STACK_CORRECTION;
1224   regcache_cooked_write_unsigned (regcache, HARD_SP_REGNUM, sp);
1225
1226   /* ...and fake a frame pointer.  */
1227   regcache_cooked_write_unsigned (regcache, SOFT_FP_REGNUM, sp);
1228
1229   /* DWARF2/GCC uses the stack address *before* the function call as a
1230      frame's CFA.  */
1231   return sp + 2;
1232 }
1233
1234
1235 /* Return the GDB type object for the "standard" data type
1236    of data in register N.  */
1237
1238 static struct type *
1239 m68hc11_register_type (struct gdbarch *gdbarch, int reg_nr)
1240 {
1241   switch (reg_nr)
1242     {
1243     case HARD_PAGE_REGNUM:
1244     case HARD_A_REGNUM:
1245     case HARD_B_REGNUM:
1246     case HARD_CCR_REGNUM:
1247       return builtin_type_uint8;
1248
1249     case M68HC12_HARD_PC_REGNUM:
1250       return builtin_type_uint32;
1251
1252     default:
1253       return builtin_type_uint16;
1254     }
1255 }
1256
1257 static void
1258 m68hc11_store_return_value (struct type *type, struct regcache *regcache,
1259                             const void *valbuf)
1260 {
1261   int len;
1262
1263   len = TYPE_LENGTH (type);
1264
1265   /* First argument is passed in D and X registers.  */
1266   if (len <= 2)
1267     regcache_raw_write_part (regcache, HARD_D_REGNUM, 2 - len, len, valbuf);
1268   else if (len <= 4)
1269     {
1270       regcache_raw_write_part (regcache, HARD_X_REGNUM, 4 - len,
1271                                len - 2, valbuf);
1272       regcache_raw_write (regcache, HARD_D_REGNUM, (char*) valbuf + (len - 2));
1273     }
1274   else
1275     error (_("return of value > 4 is not supported."));
1276 }
1277
1278
1279 /* Given a return value in `regcache' with a type `type',
1280    extract and copy its value into `valbuf'.  */
1281
1282 static void
1283 m68hc11_extract_return_value (struct type *type, struct regcache *regcache,
1284                               void *valbuf)
1285 {
1286   int len = TYPE_LENGTH (type);
1287   char buf[M68HC11_REG_SIZE];
1288
1289   regcache_raw_read (regcache, HARD_D_REGNUM, buf);
1290   switch (len)
1291     {
1292     case 1:
1293       memcpy (valbuf, buf + 1, 1);
1294       break;
1295
1296     case 2:
1297       memcpy (valbuf, buf, 2);
1298       break;
1299
1300     case 3:
1301       memcpy ((char*) valbuf + 1, buf, 2);
1302       regcache_raw_read (regcache, HARD_X_REGNUM, buf);
1303       memcpy (valbuf, buf + 1, 1);
1304       break;
1305
1306     case 4:
1307       memcpy ((char*) valbuf + 2, buf, 2);
1308       regcache_raw_read (regcache, HARD_X_REGNUM, buf);
1309       memcpy (valbuf, buf, 2);
1310       break;
1311
1312     default:
1313       error (_("bad size for return value"));
1314     }
1315 }
1316
1317 enum return_value_convention
1318 m68hc11_return_value (struct gdbarch *gdbarch, struct type *valtype,
1319                       struct regcache *regcache, gdb_byte *readbuf,
1320                       const gdb_byte *writebuf)
1321 {
1322   if (TYPE_CODE (valtype) == TYPE_CODE_STRUCT
1323       || TYPE_CODE (valtype) == TYPE_CODE_UNION
1324       || TYPE_CODE (valtype) == TYPE_CODE_ARRAY
1325       || TYPE_LENGTH (valtype) > 4)
1326     return RETURN_VALUE_STRUCT_CONVENTION;
1327   else
1328     {
1329       if (readbuf != NULL)
1330         m68hc11_extract_return_value (valtype, regcache, readbuf);
1331       if (writebuf != NULL)
1332         m68hc11_store_return_value (valtype, regcache, writebuf);
1333       return RETURN_VALUE_REGISTER_CONVENTION;
1334     }
1335 }
1336
1337 /* Test whether the ELF symbol corresponds to a function using rtc or
1338    rti to return.  */
1339
1340 static void
1341 m68hc11_elf_make_msymbol_special (asymbol *sym, struct minimal_symbol *msym)
1342 {
1343   unsigned char flags;
1344
1345   flags = ((elf_symbol_type *)sym)->internal_elf_sym.st_other;
1346   if (flags & STO_M68HC12_FAR)
1347     MSYMBOL_SET_RTC (msym);
1348   if (flags & STO_M68HC12_INTERRUPT)
1349     MSYMBOL_SET_RTI (msym);
1350 }
1351
1352 static int
1353 gdb_print_insn_m68hc11 (bfd_vma memaddr, disassemble_info *info)
1354 {
1355   if (TARGET_ARCHITECTURE->arch == bfd_arch_m68hc11)
1356     return print_insn_m68hc11 (memaddr, info);
1357   else
1358     return print_insn_m68hc12 (memaddr, info);
1359 }
1360
1361 \f
1362
1363 /* 68HC11/68HC12 register groups.
1364    Identify real hard registers and soft registers used by gcc.  */
1365
1366 static struct reggroup *m68hc11_soft_reggroup;
1367 static struct reggroup *m68hc11_hard_reggroup;
1368
1369 static void
1370 m68hc11_init_reggroups (void)
1371 {
1372   m68hc11_hard_reggroup = reggroup_new ("hard", USER_REGGROUP);
1373   m68hc11_soft_reggroup = reggroup_new ("soft", USER_REGGROUP);
1374 }
1375
1376 static void
1377 m68hc11_add_reggroups (struct gdbarch *gdbarch)
1378 {
1379   reggroup_add (gdbarch, m68hc11_hard_reggroup);
1380   reggroup_add (gdbarch, m68hc11_soft_reggroup);
1381   reggroup_add (gdbarch, general_reggroup);
1382   reggroup_add (gdbarch, float_reggroup);
1383   reggroup_add (gdbarch, all_reggroup);
1384   reggroup_add (gdbarch, save_reggroup);
1385   reggroup_add (gdbarch, restore_reggroup);
1386   reggroup_add (gdbarch, vector_reggroup);
1387   reggroup_add (gdbarch, system_reggroup);
1388 }
1389
1390 static int
1391 m68hc11_register_reggroup_p (struct gdbarch *gdbarch, int regnum,
1392                              struct reggroup *group)
1393 {
1394   /* We must save the real hard register as well as gcc
1395      soft registers including the frame pointer.  */
1396   if (group == save_reggroup || group == restore_reggroup)
1397     {
1398       return (regnum <= gdbarch_num_regs (gdbarch)
1399               || ((regnum == SOFT_FP_REGNUM
1400                    || regnum == SOFT_TMP_REGNUM
1401                    || regnum == SOFT_ZS_REGNUM
1402                    || regnum == SOFT_XY_REGNUM)
1403                   && m68hc11_register_name (regnum)));
1404     }
1405
1406   /* Group to identify gcc soft registers (d1..dN).  */
1407   if (group == m68hc11_soft_reggroup)
1408     {
1409       return regnum >= SOFT_D1_REGNUM && m68hc11_register_name (regnum);
1410     }
1411
1412   if (group == m68hc11_hard_reggroup)
1413     {
1414       return regnum == HARD_PC_REGNUM || regnum == HARD_SP_REGNUM
1415         || regnum == HARD_X_REGNUM || regnum == HARD_D_REGNUM
1416         || regnum == HARD_Y_REGNUM || regnum == HARD_CCR_REGNUM;
1417     }
1418   return default_register_reggroup_p (gdbarch, regnum, group);
1419 }
1420
1421 static struct gdbarch *
1422 m68hc11_gdbarch_init (struct gdbarch_info info,
1423                       struct gdbarch_list *arches)
1424 {
1425   struct gdbarch *gdbarch;
1426   struct gdbarch_tdep *tdep;
1427   int elf_flags;
1428
1429   soft_reg_initialized = 0;
1430
1431   /* Extract the elf_flags if available.  */
1432   if (info.abfd != NULL
1433       && bfd_get_flavour (info.abfd) == bfd_target_elf_flavour)
1434     elf_flags = elf_elfheader (info.abfd)->e_flags;
1435   else
1436     elf_flags = 0;
1437
1438   /* try to find a pre-existing architecture */
1439   for (arches = gdbarch_list_lookup_by_info (arches, &info);
1440        arches != NULL;
1441        arches = gdbarch_list_lookup_by_info (arches->next, &info))
1442     {
1443       if (gdbarch_tdep (arches->gdbarch)->elf_flags != elf_flags)
1444         continue;
1445
1446       return arches->gdbarch;
1447     }
1448
1449   /* Need a new architecture. Fill in a target specific vector.  */
1450   tdep = (struct gdbarch_tdep *) xmalloc (sizeof (struct gdbarch_tdep));
1451   gdbarch = gdbarch_alloc (&info, tdep);
1452   tdep->elf_flags = elf_flags;
1453
1454   switch (info.bfd_arch_info->arch)
1455     {
1456     case bfd_arch_m68hc11:
1457       tdep->stack_correction = 1;
1458       tdep->use_page_register = 0;
1459       tdep->prologue = m6811_prologue;
1460       set_gdbarch_addr_bit (gdbarch, 16);
1461       set_gdbarch_num_pseudo_regs (gdbarch, M68HC11_NUM_PSEUDO_REGS);
1462       set_gdbarch_pc_regnum (gdbarch, HARD_PC_REGNUM);
1463       set_gdbarch_num_regs (gdbarch, M68HC11_NUM_REGS);
1464       break;
1465
1466     case bfd_arch_m68hc12:
1467       tdep->stack_correction = 0;
1468       tdep->use_page_register = elf_flags & E_M68HC12_BANKS;
1469       tdep->prologue = m6812_prologue;
1470       set_gdbarch_addr_bit (gdbarch, elf_flags & E_M68HC12_BANKS ? 32 : 16);
1471       set_gdbarch_num_pseudo_regs (gdbarch,
1472                                    elf_flags & E_M68HC12_BANKS
1473                                    ? M68HC12_NUM_PSEUDO_REGS
1474                                    : M68HC11_NUM_PSEUDO_REGS);
1475       set_gdbarch_pc_regnum (gdbarch, elf_flags & E_M68HC12_BANKS
1476                              ? M68HC12_HARD_PC_REGNUM : HARD_PC_REGNUM);
1477       set_gdbarch_num_regs (gdbarch, elf_flags & E_M68HC12_BANKS
1478                             ? M68HC12_NUM_REGS : M68HC11_NUM_REGS);
1479       break;
1480
1481     default:
1482       break;
1483     }
1484
1485   /* Initially set everything according to the ABI.
1486      Use 16-bit integers since it will be the case for most
1487      programs.  The size of these types should normally be set
1488      according to the dwarf2 debug information.  */
1489   set_gdbarch_short_bit (gdbarch, 16);
1490   set_gdbarch_int_bit (gdbarch, elf_flags & E_M68HC11_I32 ? 32 : 16);
1491   set_gdbarch_float_bit (gdbarch, 32);
1492   set_gdbarch_double_bit (gdbarch, elf_flags & E_M68HC11_F64 ? 64 : 32);
1493   set_gdbarch_long_double_bit (gdbarch, 64);
1494   set_gdbarch_long_bit (gdbarch, 32);
1495   set_gdbarch_ptr_bit (gdbarch, 16);
1496   set_gdbarch_long_long_bit (gdbarch, 64);
1497
1498   /* Characters are unsigned.  */
1499   set_gdbarch_char_signed (gdbarch, 0);
1500
1501   set_gdbarch_unwind_pc (gdbarch, m68hc11_unwind_pc);
1502   set_gdbarch_unwind_sp (gdbarch, m68hc11_unwind_sp);
1503
1504   /* Set register info.  */
1505   set_gdbarch_fp0_regnum (gdbarch, -1);
1506
1507   set_gdbarch_write_pc (gdbarch, generic_target_write_pc);
1508
1509   set_gdbarch_sp_regnum (gdbarch, HARD_SP_REGNUM);
1510   set_gdbarch_register_name (gdbarch, m68hc11_register_name);
1511   set_gdbarch_register_type (gdbarch, m68hc11_register_type);
1512   set_gdbarch_pseudo_register_read (gdbarch, m68hc11_pseudo_register_read);
1513   set_gdbarch_pseudo_register_write (gdbarch, m68hc11_pseudo_register_write);
1514
1515   set_gdbarch_push_dummy_call (gdbarch, m68hc11_push_dummy_call);
1516
1517   set_gdbarch_return_value (gdbarch, m68hc11_return_value);
1518   set_gdbarch_skip_prologue (gdbarch, m68hc11_skip_prologue);
1519   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
1520   set_gdbarch_breakpoint_from_pc (gdbarch, m68hc11_breakpoint_from_pc);
1521   set_gdbarch_print_insn (gdbarch, gdb_print_insn_m68hc11);
1522
1523   m68hc11_add_reggroups (gdbarch);
1524   set_gdbarch_register_reggroup_p (gdbarch, m68hc11_register_reggroup_p);
1525   set_gdbarch_print_registers_info (gdbarch, m68hc11_print_registers_info);
1526
1527   /* Hook in the DWARF CFI frame unwinder.  */
1528   frame_unwind_append_sniffer (gdbarch, dwarf2_frame_sniffer);
1529
1530   frame_unwind_append_sniffer (gdbarch, m68hc11_frame_sniffer);
1531   frame_base_set_default (gdbarch, &m68hc11_frame_base);
1532
1533   /* Methods for saving / extracting a dummy frame's ID.  The ID's
1534      stack address must match the SP value returned by
1535      PUSH_DUMMY_CALL, and saved by generic_save_dummy_frame_tos.  */
1536   set_gdbarch_unwind_dummy_id (gdbarch, m68hc11_unwind_dummy_id);
1537
1538   /* Return the unwound PC value.  */
1539   set_gdbarch_unwind_pc (gdbarch, m68hc11_unwind_pc);
1540
1541   /* Minsymbol frobbing.  */
1542   set_gdbarch_elf_make_msymbol_special (gdbarch,
1543                                         m68hc11_elf_make_msymbol_special);
1544
1545   set_gdbarch_believe_pcc_promotion (gdbarch, 1);
1546
1547   return gdbarch;
1548 }
1549
1550 extern initialize_file_ftype _initialize_m68hc11_tdep; /* -Wmissing-prototypes */
1551
1552 void
1553 _initialize_m68hc11_tdep (void)
1554 {
1555   register_gdbarch_init (bfd_arch_m68hc11, m68hc11_gdbarch_init);
1556   register_gdbarch_init (bfd_arch_m68hc12, m68hc11_gdbarch_init);
1557   m68hc11_init_reggroups ();
1558 }
1559