gdb/m68hc11-tdep.c

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