gdb/m68hc11-tdep.c

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