gdb/mn10300-tdep.c

   1 /* Target-dependent code for the Matsushita MN10300 for GDB, the GNU debugger.
   2
   3    Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free
   4    Software Foundation, Inc.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 59 Temple Place - Suite 330,
  21    Boston, MA 02111-1307, USA.  */
  22
  23 /* MVS Notes:
  24
  25    To get from 1.1 to 1.2, add:
  26    use_struct_convention
  27    store_return_value
  28    extract_return_value
  29    extract_struct_value_address
  30
  31    Make sure to use regcache.  */
  32
  33 /* MVS Notes:
  34
  35    Apparently cannot run without a stub placeholder for unwind_dummy_id.
  36 */
  37
  38 /* MVS Notes:
  39
  40    To get from 1.2 to 1.3, add:
  41    read_pc, write_pc
  42    frame_unwind_init
  43    struct mn10300_unwind_cache
  44    unwind_pc
  45    unwind_dummy_id
  46    frame_this_id
  47    frame_prev_register
  48    frame_sniffer (struct mn10300_frame_unwind)
  49 */
  50
  51 #include "defs.h"
  52 #include "arch-utils.h"
  53 #include "dis-asm.h"
  54 #include "gdbtypes.h"
  55 #include "regcache.h"
  56 #include "gdb_string.h"
  57 #include "gdb_assert.h"
  58 #include "frame.h"
  59 #include "frame-unwind.h"
  60 #include "frame-base.h"
  61 #include "trad-frame.h"
  62 #include "symtab.h"
  63 #include "dwarf2-frame.h"
  64 #include "regcache.h"
  65
  66 enum {
  67   E_D0_REGNUM = 0,
  68   E_D1_REGNUM = 1,
  69   E_D2_REGNUM = 2,
  70   E_D3_REGNUM = 3,
  71   E_A0_REGNUM = 4,
  72   E_A1_REGNUM = 5,
  73   E_A2_REGNUM = 6,
  74   E_A3_REGNUM = 7,
  75   E_SP_REGNUM = 8,
  76   E_PC_REGNUM = 9,
  77   E_MDR_REGNUM = 10,
  78   E_PSW_REGNUM = 11,
  79   E_LIR_REGNUM = 12,
  80   E_LAR_REGNUM = 13,
  81   E_MDRQ_REGNUM = 14,
  82   E_E0_REGNUM = 15,
  83   E_MCRH_REGNUM = 26,
  84   E_MCRL_REGNUM = 27,
  85   E_MCVF_REGNUM = 28,
  86   E_NUM_REGS = 32
  87 };
  88
  89
  90 /* Compute the alignment required by a type.  */
  91
  92 static int
  93 mn10300_type_align (struct type *type)
  94 {
  95   int i, align = 1;
  96
  97   switch (TYPE_CODE (type))
  98     {
  99     case TYPE_CODE_INT:
 100     case TYPE_CODE_ENUM:
 101     case TYPE_CODE_SET:
 102     case TYPE_CODE_RANGE:
 103     case TYPE_CODE_CHAR:
 104     case TYPE_CODE_BOOL:
 105     case TYPE_CODE_FLT:
 106     case TYPE_CODE_PTR:
 107     case TYPE_CODE_REF:
 108       return TYPE_LENGTH (type);
 109
 110     case TYPE_CODE_COMPLEX:
 111       return TYPE_LENGTH (type) / 2;
 112
 113     case TYPE_CODE_STRUCT:
 114     case TYPE_CODE_UNION:
 115       for (i = 0; i < TYPE_NFIELDS (type); i++)
 116         {
 117           int falign = mn10300_type_align (TYPE_FIELD_TYPE (type, i));
 118           while (align < falign)
 119             align <<= 1;
 120         }
 121       return align;
 122
 123     case TYPE_CODE_ARRAY:
 124       /* HACK!  Structures containing arrays, even small ones, are not
 125          elligible for returning in registers.  */
 126       return 256;
 127
 128     case TYPE_CODE_TYPEDEF:
 129       return mn10300_type_align (check_typedef (type));
 130
 131     default:
 132       internal_error (__FILE__, __LINE__, "bad switch");
 133     }
 134 }
 135
 136 /* MVS note this is deprecated.  */
 137 /* Should call_function allocate stack space for a struct return?  */
 138 /* gcc_p unused */
 139 static int
 140 mn10300_use_struct_convention (int gcc_p, struct type *type)
 141 {
 142   /* Structures bigger than a pair of words can't be returned in
 143      registers.  */
 144   if (TYPE_LENGTH (type) > 8)
 145     return 1;
 146
 147   switch (TYPE_CODE (type))
 148     {
 149     case TYPE_CODE_STRUCT:
 150     case TYPE_CODE_UNION:
 151       /* Structures with a single field are handled as the field
 152          itself.  */
 153       if (TYPE_NFIELDS (type) == 1)
 154         return mn10300_use_struct_convention (gcc_p,
 155                                               TYPE_FIELD_TYPE (type, 0));
 156
 157       /* Structures with word or double-word size are passed in memory, as
 158          long as they require at least word alignment.  */
 159       if (mn10300_type_align (type) >= 4)
 160         return 0;
 161
 162       return 1;
 163
 164       /* Arrays are addressable, so they're never returned in
 165          registers.  This condition can only hold when the array is
 166          the only field of a struct or union.  */
 167     case TYPE_CODE_ARRAY:
 168       return 1;
 169
 170     case TYPE_CODE_TYPEDEF:
 171       return mn10300_use_struct_convention (gcc_p, check_typedef (type));
 172
 173     default:
 174       return 0;
 175     }
 176 }
 177
 178 /* MVS note this is deprecated.  */
 179 static void
 180 mn10300_store_return_value (struct type *type,
 181                             struct regcache *regcache, const void *valbuf)
 182 {
 183   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 184   int len = TYPE_LENGTH (type);
 185   int reg, regsz;
 186
 187   if (TYPE_CODE (type) == TYPE_CODE_PTR)
 188     reg = 4;
 189   else
 190     reg = 0;
 191
 192   regsz = register_size (gdbarch, reg);
 193
 194   if (len <= regsz)
 195     regcache_raw_write_part (regcache, reg, 0, len, valbuf);
 196   else if (len <= 2 * regsz)
 197     {
 198       regcache_raw_write (regcache, reg, valbuf);
 199       gdb_assert (regsz == register_size (gdbarch, reg + 1));
 200       regcache_raw_write_part (regcache, reg+1, 0,
 201                                len - regsz, (char *) valbuf + regsz);
 202     }
 203   else
 204     internal_error (__FILE__, __LINE__,
 205                     "Cannot store return value %d bytes long.", len);
 206 }
 207
 208 /* MVS note deprecated.  */
 209 static void
 210 mn10300_extract_return_value (struct type *type,
 211                               struct regcache *regcache, void *valbuf)
 212 {
 213   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 214   char buf[MAX_REGISTER_SIZE];
 215   int len = TYPE_LENGTH (type);
 216   int reg, regsz;
 217
 218   if (TYPE_CODE (type) == TYPE_CODE_PTR)
 219     reg = 4;
 220   else
 221     reg = 0;
 222
 223   regsz = register_size (gdbarch, reg);
 224   if (len <= regsz)
 225     {
 226       regcache_raw_read (regcache, reg, buf);
 227       memcpy (valbuf, buf, len);
 228     }
 229   else if (len <= 2 * regsz)
 230     {
 231       regcache_raw_read (regcache, reg, buf);
 232       memcpy (valbuf, buf, regsz);
 233       gdb_assert (regsz == register_size (gdbarch, reg + 1));
 234       regcache_raw_read (regcache, reg + 1, buf);
 235       memcpy ((char *) valbuf + regsz, buf, len - regsz);
 236     }
 237   else
 238     internal_error (__FILE__, __LINE__,
 239                     "Cannot extract return value %d bytes long.", len);
 240 }
 241
 242 static char *
 243 register_name (int reg, char **regs, long sizeof_regs)
 244 {
 245   if (reg < 0 || reg >= sizeof_regs / sizeof (regs[0]))
 246     return NULL;
 247   else
 248     return regs[reg];
 249 }
 250
 251 static const char *
 252 mn10300_generic_register_name (int reg)
 253 {
 254   static char *regs[] =
 255   { "d0", "d1", "d2", "d3", "a0", "a1", "a2", "a3",
 256     "sp", "pc", "mdr", "psw", "lir", "lar", "", "",
 257     "", "", "", "", "", "", "", "",
 258     "", "", "", "", "", "", "", "fp"
 259   };
 260   return register_name (reg, regs, sizeof regs);
 261 }
 262
 263
 264 static const char *
 265 am33_register_name (int reg)
 266 {
 267   static char *regs[] =
 268   { "d0", "d1", "d2", "d3", "a0", "a1", "a2", "a3",
 269     "sp", "pc", "mdr", "psw", "lir", "lar", "",
 270     "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
 271     "ssp", "msp", "usp", "mcrh", "mcrl", "mcvf", "", "", ""
 272   };
 273   return register_name (reg, regs, sizeof regs);
 274 }
 275
 276
 277 static struct type *
 278 mn10300_register_type (struct gdbarch *gdbarch, int reg)
 279 {
 280   return builtin_type_int;
 281 }
 282
 283 static CORE_ADDR
 284 mn10300_read_pc (ptid_t ptid)
 285 {
 286   return read_register_pid (E_PC_REGNUM, ptid);
 287 }
 288
 289 static void
 290 mn10300_write_pc (CORE_ADDR val, ptid_t ptid)
 291 {
 292   return write_register_pid (E_PC_REGNUM, val, ptid);
 293 }
 294
 295 /* The breakpoint instruction must be the same size as the smallest
 296    instruction in the instruction set.
 297
 298    The Matsushita mn10x00 processors have single byte instructions
 299    so we need a single byte breakpoint.  Matsushita hasn't defined
 300    one, so we defined it ourselves.  */
 301
 302 const static unsigned char *
 303 mn10300_breakpoint_from_pc (CORE_ADDR *bp_addr, int *bp_size)
 304 {
 305   static char breakpoint[] = {0xff};
 306   *bp_size = 1;
 307   return breakpoint;
 308 }
 309
 310 /* Function: skip_prologue
 311    Return the address of the first inst past the prologue of the function.  */
 312
 313 static CORE_ADDR
 314 mn10300_skip_prologue (CORE_ADDR pc)
 315 {
 316   /* FIXME: not implemented.  */
 317   /* First approximation, try simply using scan_prologue_using_sal.  */
 318   return skip_prologue_using_sal (pc);
 319 }
 320
 321 /* Simple frame_unwind_cache.
 322    This finds the "extra info" for the frame.  */
 323 static struct trad_frame_cache *
 324 mn10300_frame_unwind_cache (struct frame_info *next_frame,
 325                             void **this_prologue_cache)
 326 {
 327   struct trad_frame_cache *cache;
 328
 329   if (*this_prologue_cache)
 330     return (*this_prologue_cache);
 331
 332   cache = trad_frame_cache_zalloc (next_frame);
 333   trad_frame_set_id (cache,
 334                      frame_id_build (gdbarch_unwind_sp (current_gdbarch,
 335                                                         next_frame),
 336                                      gdbarch_unwind_pc (current_gdbarch,
 337                                                         next_frame)));
 338
 339   /* FIXME: The SP isn't the frame base, so this is 0th approximation.  */
 340   /* FIXME: The A3 reg isn't always the frame register either, so this
 341      is 1st approximation.  */
 342   trad_frame_set_this_base (cache,
 343                             frame_unwind_register_signed (next_frame,
 344                                                           E_A3_REGNUM));
 345   (*this_prologue_cache) = cache;
 346   return cache;
 347 }
 348
 349 /* Here is a dummy implementation.  */
 350 static struct frame_id
 351 mn10300_dummy_unwind_dummy_id (struct gdbarch *gdbarch,
 352                                struct frame_info *next_frame)
 353 {
 354   return frame_id_build (0, 0);
 355 }
 356
 357 /* Trad frame implementation.  */
 358 static void
 359 mn10300_frame_this_id (struct frame_info *next_frame,
 360                        void **this_prologue_cache,
 361                        struct frame_id *this_id)
 362 {
 363   struct trad_frame_cache *cache =
 364     mn10300_frame_unwind_cache (next_frame, this_prologue_cache);
 365
 366   trad_frame_get_id (cache, this_id);
 367 }
 368
 369 static void
 370 mn10300_frame_prev_register (struct frame_info *next_frame,
 371                              void **this_prologue_cache,
 372                              int regnum, int *optimizedp,
 373                              enum lval_type *lvalp, CORE_ADDR *addrp,
 374                              int *realnump, void *bufferp)
 375 {
 376   struct trad_frame_cache *cache =
 377     mn10300_frame_unwind_cache (next_frame, this_prologue_cache);
 378
 379   trad_frame_get_register (cache, next_frame, regnum, optimizedp,
 380                            lvalp, addrp, realnump, bufferp);
 381   /* Or...
 382   trad_frame_get_prev_register (next_frame, cache->prev_regs, regnum,
 383                            optimizedp, lvalp, addrp, realnump, bufferp);
 384   */
 385 }
 386
 387 static const struct frame_unwind mn10300_frame_unwind = {
 388   NORMAL_FRAME,
 389   mn10300_frame_this_id,
 390   mn10300_frame_prev_register
 391 };
 392
 393 static CORE_ADDR
 394 mn10300_frame_base_address (struct frame_info *next_frame,
 395                             void **this_prologue_cache)
 396 {
 397   struct trad_frame_cache *cache =
 398     mn10300_frame_unwind_cache (next_frame, this_prologue_cache);
 399
 400   return trad_frame_get_this_base (cache);
 401 }
 402
 403 static const struct frame_unwind *
 404 mn10300_frame_sniffer (struct frame_info *next_frame)
 405 {
 406   return &mn10300_frame_unwind;
 407 }
 408
 409 static const struct frame_base mn10300_frame_base = {
 410   &mn10300_frame_unwind,
 411   mn10300_frame_base_address,
 412   mn10300_frame_base_address,
 413   mn10300_frame_base_address
 414 };
 415
 416 static CORE_ADDR
 417 mn10300_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
 418 {
 419   ULONGEST pc;
 420
 421   frame_unwind_unsigned_register (next_frame, E_PC_REGNUM, &pc);
 422   return pc;
 423 }
 424
 425 static CORE_ADDR
 426 mn10300_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
 427 {
 428   ULONGEST sp;
 429
 430   frame_unwind_unsigned_register (next_frame, E_SP_REGNUM, &sp);
 431   return sp;
 432 }
 433
 434 static void
 435 mn10300_frame_unwind_init (struct gdbarch *gdbarch)
 436 {
 437   frame_unwind_append_sniffer (gdbarch, dwarf2_frame_sniffer);
 438   frame_unwind_append_sniffer (gdbarch, mn10300_frame_sniffer);
 439   frame_base_set_default (gdbarch, &mn10300_frame_base);
 440   set_gdbarch_unwind_dummy_id (gdbarch, mn10300_dummy_unwind_dummy_id);
 441   set_gdbarch_unwind_pc (gdbarch, mn10300_unwind_pc);
 442   set_gdbarch_unwind_sp (gdbarch, mn10300_unwind_sp);
 443 }
 444
 445 static struct gdbarch *
 446 mn10300_gdbarch_init (struct gdbarch_info info,
 447                       struct gdbarch_list *arches)
 448 {
 449   struct gdbarch *gdbarch;
 450
 451   arches = gdbarch_list_lookup_by_info (arches, &info);
 452   if (arches != NULL)
 453     return arches->gdbarch;
 454   gdbarch = gdbarch_alloc (&info, NULL);
 455
 456   switch (info.bfd_arch_info->mach)
 457     {
 458     case 0:
 459     case bfd_mach_mn10300:
 460       set_gdbarch_register_name (gdbarch, mn10300_generic_register_name);
 461       break;
 462     case bfd_mach_am33:
 463       set_gdbarch_register_name (gdbarch, am33_register_name);
 464       break;
 465     default:
 466       internal_error (__FILE__, __LINE__,
 467                       "mn10300_gdbarch_init: Unknown mn10300 variant");
 468       break;
 469     }
 470
 471   /* Registers.  */
 472   set_gdbarch_num_regs (gdbarch, E_NUM_REGS);
 473   set_gdbarch_register_type (gdbarch, mn10300_register_type);
 474   set_gdbarch_skip_prologue (gdbarch, mn10300_skip_prologue);
 475   set_gdbarch_read_pc (gdbarch, mn10300_read_pc);
 476   set_gdbarch_write_pc (gdbarch, mn10300_write_pc);
 477   set_gdbarch_pc_regnum (gdbarch, E_PC_REGNUM);
 478   set_gdbarch_sp_regnum (gdbarch, E_SP_REGNUM);
 479
 480   /* Stack unwinding.  */
 481   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
 482   /* Breakpoints.  */
 483   set_gdbarch_breakpoint_from_pc (gdbarch, mn10300_breakpoint_from_pc);
 484   /* decr_pc_after_break? */
 485   /* Disassembly.  */
 486   set_gdbarch_print_insn (gdbarch, print_insn_mn10300);
 487
 488   /* Stage 2 */
 489   /* MVS Note: at least the first one is deprecated!  */
 490   set_gdbarch_deprecated_use_struct_convention (gdbarch,
 491                                                 mn10300_use_struct_convention);
 492   set_gdbarch_store_return_value (gdbarch, mn10300_store_return_value);
 493   set_gdbarch_extract_return_value (gdbarch, mn10300_extract_return_value);
 494
 495   mn10300_frame_unwind_init (gdbarch);
 496
 497   return gdbarch;
 498 }
 499
 500 void
 501 _initialize_mn10300_tdep (void)
 502 {
 503   register_gdbarch_init (bfd_arch_mn10300, mn10300_gdbarch_init);
 504 }
 505