gdb/m68hc11-tdep.c

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