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 "gdbcore.h"    /* for write_memory_unsigned_integer */
  59 #include "value.h"
  60 #include "gdbtypes.h"
  61 #include "frame.h"
  62 #include "frame-unwind.h"
  63 #include "frame-base.h"
  64 #include "trad-frame.h"
  65 #include "symtab.h"
  66 #include "dwarf2-frame.h"
  67 #include "regcache.h"
  68
  69 #include "mn10300-tdep.h"
  70
  71
  72 /* Compute the alignment required by a type.  */
  73
  74 static int
  75 mn10300_type_align (struct type *type)
  76 {
  77   int i, align = 1;
  78
  79   switch (TYPE_CODE (type))
  80     {
  81     case TYPE_CODE_INT:
  82     case TYPE_CODE_ENUM:
  83     case TYPE_CODE_SET:
  84     case TYPE_CODE_RANGE:
  85     case TYPE_CODE_CHAR:
  86     case TYPE_CODE_BOOL:
  87     case TYPE_CODE_FLT:
  88     case TYPE_CODE_PTR:
  89     case TYPE_CODE_REF:
  90       return TYPE_LENGTH (type);
  91
  92     case TYPE_CODE_COMPLEX:
  93       return TYPE_LENGTH (type) / 2;
  94
  95     case TYPE_CODE_STRUCT:
  96     case TYPE_CODE_UNION:
  97       for (i = 0; i < TYPE_NFIELDS (type); i++)
  98         {
  99           int falign = mn10300_type_align (TYPE_FIELD_TYPE (type, i));
 100           while (align < falign)
 101             align <<= 1;
 102         }
 103       return align;
 104
 105     case TYPE_CODE_ARRAY:
 106       /* HACK!  Structures containing arrays, even small ones, are not
 107          elligible for returning in registers.  */
 108       return 256;
 109
 110     case TYPE_CODE_TYPEDEF:
 111       return mn10300_type_align (check_typedef (type));
 112
 113     default:
 114       internal_error (__FILE__, __LINE__, _("bad switch"));
 115     }
 116 }
 117
 118 /* MVS note this is deprecated.  */
 119 /* Should call_function allocate stack space for a struct return?  */
 120 /* gcc_p unused */
 121 static int
 122 mn10300_use_struct_convention (int gcc_p, struct type *type)
 123 {
 124   /* Structures bigger than a pair of words can't be returned in
 125      registers.  */
 126   if (TYPE_LENGTH (type) > 8)
 127     return 1;
 128
 129   switch (TYPE_CODE (type))
 130     {
 131     case TYPE_CODE_STRUCT:
 132     case TYPE_CODE_UNION:
 133       /* Structures with a single field are handled as the field
 134          itself.  */
 135       if (TYPE_NFIELDS (type) == 1)
 136         return mn10300_use_struct_convention (gcc_p,
 137                                               TYPE_FIELD_TYPE (type, 0));
 138
 139       /* Structures with word or double-word size are passed in memory, as
 140          long as they require at least word alignment.  */
 141       if (mn10300_type_align (type) >= 4)
 142         return 0;
 143
 144       return 1;
 145
 146       /* Arrays are addressable, so they're never returned in
 147          registers.  This condition can only hold when the array is
 148          the only field of a struct or union.  */
 149     case TYPE_CODE_ARRAY:
 150       return 1;
 151
 152     case TYPE_CODE_TYPEDEF:
 153       return mn10300_use_struct_convention (gcc_p, check_typedef (type));
 154
 155     default:
 156       return 0;
 157     }
 158 }
 159
 160 /* MVS note this is deprecated.  */
 161 static void
 162 mn10300_store_return_value (struct type *type,
 163                             struct regcache *regcache, const void *valbuf)
 164 {
 165   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 166   int len = TYPE_LENGTH (type);
 167   int reg, regsz;
 168
 169   if (TYPE_CODE (type) == TYPE_CODE_PTR)
 170     reg = 4;
 171   else
 172     reg = 0;
 173
 174   regsz = register_size (gdbarch, reg);
 175
 176   if (len <= regsz)
 177     regcache_raw_write_part (regcache, reg, 0, len, valbuf);
 178   else if (len <= 2 * regsz)
 179     {
 180       regcache_raw_write (regcache, reg, valbuf);
 181       gdb_assert (regsz == register_size (gdbarch, reg + 1));
 182       regcache_raw_write_part (regcache, reg+1, 0,
 183                                len - regsz, (char *) valbuf + regsz);
 184     }
 185   else
 186     internal_error (__FILE__, __LINE__,
 187                     _("Cannot store return value %d bytes long."), len);
 188 }
 189
 190 /* MVS note deprecated.  */
 191 static void
 192 mn10300_extract_return_value (struct type *type,
 193                               struct regcache *regcache, void *valbuf)
 194 {
 195   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 196   char buf[MAX_REGISTER_SIZE];
 197   int len = TYPE_LENGTH (type);
 198   int reg, regsz;
 199
 200   if (TYPE_CODE (type) == TYPE_CODE_PTR)
 201     reg = 4;
 202   else
 203     reg = 0;
 204
 205   regsz = register_size (gdbarch, reg);
 206   if (len <= regsz)
 207     {
 208       regcache_raw_read (regcache, reg, buf);
 209       memcpy (valbuf, buf, len);
 210     }
 211   else if (len <= 2 * regsz)
 212     {
 213       regcache_raw_read (regcache, reg, buf);
 214       memcpy (valbuf, buf, regsz);
 215       gdb_assert (regsz == register_size (gdbarch, reg + 1));
 216       regcache_raw_read (regcache, reg + 1, buf);
 217       memcpy ((char *) valbuf + regsz, buf, len - regsz);
 218     }
 219   else
 220     internal_error (__FILE__, __LINE__,
 221                     _("Cannot extract return value %d bytes long."), len);
 222 }
 223
 224 static char *
 225 register_name (int reg, char **regs, long sizeof_regs)
 226 {
 227   if (reg < 0 || reg >= sizeof_regs / sizeof (regs[0]))
 228     return NULL;
 229   else
 230     return regs[reg];
 231 }
 232
 233 static const char *
 234 mn10300_generic_register_name (int reg)
 235 {
 236   static char *regs[] =
 237   { "d0", "d1", "d2", "d3", "a0", "a1", "a2", "a3",
 238     "sp", "pc", "mdr", "psw", "lir", "lar", "", "",
 239     "", "", "", "", "", "", "", "",
 240     "", "", "", "", "", "", "", "fp"
 241   };
 242   return register_name (reg, regs, sizeof regs);
 243 }
 244
 245
 246 static const char *
 247 am33_register_name (int reg)
 248 {
 249   static char *regs[] =
 250   { "d0", "d1", "d2", "d3", "a0", "a1", "a2", "a3",
 251     "sp", "pc", "mdr", "psw", "lir", "lar", "",
 252     "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
 253     "ssp", "msp", "usp", "mcrh", "mcrl", "mcvf", "", "", ""
 254   };
 255   return register_name (reg, regs, sizeof regs);
 256 }
 257
 258
 259 static struct type *
 260 mn10300_register_type (struct gdbarch *gdbarch, int reg)
 261 {
 262   return builtin_type_int;
 263 }
 264
 265 static CORE_ADDR
 266 mn10300_read_pc (ptid_t ptid)
 267 {
 268   return read_register_pid (E_PC_REGNUM, ptid);
 269 }
 270
 271 static void
 272 mn10300_write_pc (CORE_ADDR val, ptid_t ptid)
 273 {
 274   return write_register_pid (E_PC_REGNUM, val, ptid);
 275 }
 276
 277 /* The breakpoint instruction must be the same size as the smallest
 278    instruction in the instruction set.
 279
 280    The Matsushita mn10x00 processors have single byte instructions
 281    so we need a single byte breakpoint.  Matsushita hasn't defined
 282    one, so we defined it ourselves.  */
 283
 284 const static unsigned char *
 285 mn10300_breakpoint_from_pc (CORE_ADDR *bp_addr, int *bp_size)
 286 {
 287   static char breakpoint[] = {0xff};
 288   *bp_size = 1;
 289   return breakpoint;
 290 }
 291
 292 /* Function: skip_prologue
 293    Return the address of the first inst past the prologue of the function.  */
 294
 295 static CORE_ADDR
 296 mn10300_skip_prologue (CORE_ADDR pc)
 297 {
 298 #if 0
 299   CORE_ADDR ret;
 300   /* FIXME: not implemented.  */
 301   /* First approximation, try simply using skip_prologue_using_sal.  */
 302   ret = skip_prologue_using_sal (pc);
 303   return ret ? ret : pc;
 304 #else
 305   return mn10300_analyze_prologue (NULL, NULL, pc);
 306 #endif
 307 }
 308
 309 /* Simple frame_unwind_cache.
 310    This finds the "extra info" for the frame.  */
 311 struct trad_frame_cache *
 312 mn10300_frame_unwind_cache (struct frame_info *next_frame,
 313                             void **this_prologue_cache)
 314 {
 315   struct trad_frame_cache *cache;
 316   CORE_ADDR pc;
 317
 318   if (*this_prologue_cache)
 319     return (*this_prologue_cache);
 320
 321   cache = trad_frame_cache_zalloc (next_frame);
 322   pc = gdbarch_unwind_pc (current_gdbarch, next_frame);
 323   mn10300_analyze_prologue (next_frame, (void **) &cache, pc);
 324
 325   trad_frame_set_id (cache,
 326                      frame_id_build (trad_frame_get_this_base (cache),
 327                                      frame_func_unwind (next_frame)));
 328
 329   (*this_prologue_cache) = cache;
 330   return cache;
 331 }
 332
 333 /* Here is a dummy implementation.  */
 334 static struct frame_id
 335 mn10300_unwind_dummy_id (struct gdbarch *gdbarch,
 336                          struct frame_info *next_frame)
 337 {
 338   return frame_id_build (frame_sp_unwind (next_frame),
 339                          frame_pc_unwind (next_frame));
 340 }
 341
 342 /* Trad frame implementation.  */
 343 static void
 344 mn10300_frame_this_id (struct frame_info *next_frame,
 345                        void **this_prologue_cache,
 346                        struct frame_id *this_id)
 347 {
 348   struct trad_frame_cache *cache =
 349     mn10300_frame_unwind_cache (next_frame, this_prologue_cache);
 350
 351   trad_frame_get_id (cache, this_id);
 352 }
 353
 354 static void
 355 mn10300_frame_prev_register (struct frame_info *next_frame,
 356                              void **this_prologue_cache,
 357                              int regnum, int *optimizedp,
 358                              enum lval_type *lvalp, CORE_ADDR *addrp,
 359                              int *realnump, void *bufferp)
 360 {
 361   struct trad_frame_cache *cache =
 362     mn10300_frame_unwind_cache (next_frame, this_prologue_cache);
 363
 364   trad_frame_get_register (cache, next_frame, regnum, optimizedp,
 365                            lvalp, addrp, realnump, bufferp);
 366   /* Or...
 367   trad_frame_get_prev_register (next_frame, cache->prev_regs, regnum,
 368                            optimizedp, lvalp, addrp, realnump, bufferp);
 369   */
 370 }
 371
 372 static const struct frame_unwind mn10300_frame_unwind = {
 373   NORMAL_FRAME,
 374   mn10300_frame_this_id,
 375   mn10300_frame_prev_register
 376 };
 377
 378 static CORE_ADDR
 379 mn10300_frame_base_address (struct frame_info *next_frame,
 380                             void **this_prologue_cache)
 381 {
 382   struct trad_frame_cache *cache =
 383     mn10300_frame_unwind_cache (next_frame, this_prologue_cache);
 384
 385   return trad_frame_get_this_base (cache);
 386 }
 387
 388 static const struct frame_unwind *
 389 mn10300_frame_sniffer (struct frame_info *next_frame)
 390 {
 391   return &mn10300_frame_unwind;
 392 }
 393
 394 static const struct frame_base mn10300_frame_base = {
 395   &mn10300_frame_unwind,
 396   mn10300_frame_base_address,
 397   mn10300_frame_base_address,
 398   mn10300_frame_base_address
 399 };
 400
 401 static CORE_ADDR
 402 mn10300_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
 403 {
 404   ULONGEST pc;
 405
 406   frame_unwind_unsigned_register (next_frame, E_PC_REGNUM, &pc);
 407   return pc;
 408 }
 409
 410 static CORE_ADDR
 411 mn10300_unwind_sp (struct gdbarch *gdbarch, struct frame_info *next_frame)
 412 {
 413   ULONGEST sp;
 414
 415   frame_unwind_unsigned_register (next_frame, E_SP_REGNUM, &sp);
 416   return sp;
 417 }
 418
 419 static void
 420 mn10300_frame_unwind_init (struct gdbarch *gdbarch)
 421 {
 422   frame_unwind_append_sniffer (gdbarch, dwarf2_frame_sniffer);
 423   frame_unwind_append_sniffer (gdbarch, mn10300_frame_sniffer);
 424   frame_base_set_default (gdbarch, &mn10300_frame_base);
 425   set_gdbarch_unwind_dummy_id (gdbarch, mn10300_unwind_dummy_id);
 426   set_gdbarch_unwind_pc (gdbarch, mn10300_unwind_pc);
 427   set_gdbarch_unwind_sp (gdbarch, mn10300_unwind_sp);
 428 }
 429
 430 /* Function: push_dummy_call
 431  *
 432  * Set up machine state for a target call, including
 433  * function arguments, stack, return address, etc.
 434  *
 435  */
 436
 437 static CORE_ADDR
 438 mn10300_push_dummy_call (struct gdbarch *gdbarch,
 439                          struct value *target_func,
 440                          struct regcache *regcache,
 441                          CORE_ADDR bp_addr,
 442                          int nargs, struct value **args,
 443                          CORE_ADDR sp,
 444                          int struct_return,
 445                          CORE_ADDR struct_addr)
 446 {
 447   const int push_size = register_size (gdbarch, E_PC_REGNUM);
 448   int regs_used = struct_return ? 1 : 0;
 449   int len, arg_len;
 450   int stack_offset = 0;
 451   int argnum;
 452   char *val;
 453
 454   /* FIXME temp, don't handle struct args at all.  */
 455   if (struct_return)
 456     error ("Target doesn't handle struct return");
 457
 458   /* This should be a nop, but align the stack just in case something
 459      went wrong.  Stacks are four byte aligned on the mn10300.  */
 460   sp &= ~3;
 461
 462   /* Now make space on the stack for the args.
 463
 464      XXX This doesn't appear to handle pass-by-invisible reference
 465      arguments.  */
 466   for (len = 0, argnum = 0; argnum < nargs; argnum++)
 467     {
 468       arg_len = (TYPE_LENGTH (value_type (args[argnum])) + 3) & ~3;
 469       if (TYPE_CODE (value_type (args[argnum])) == TYPE_CODE_STRUCT)
 470         error ("Target does not handle struct args");
 471       while (regs_used < 2 && arg_len > 0)
 472         {
 473           regs_used++;
 474           arg_len -= push_size;
 475         }
 476       len += arg_len;
 477     }
 478
 479   /* Allocate stack space.  */
 480   sp -= len;
 481
 482   regs_used = struct_return ? 1 : 0;
 483   /* Push all arguments onto the stack. */
 484   for (argnum = 0; argnum < nargs; argnum++)
 485     {
 486       /* FIXME what about structs?  */
 487       arg_len = TYPE_LENGTH (value_type (*args));
 488       val = (char *) value_contents (*args);
 489
 490       while (regs_used < 2 && arg_len > 0)
 491         {
 492           write_register (regs_used, extract_unsigned_integer (val,
 493                                                                push_size));
 494           val += push_size;
 495           arg_len -= push_size;
 496           regs_used++;
 497         }
 498
 499       while (arg_len > 0)
 500         {
 501           write_memory (sp + stack_offset, val, push_size);
 502           arg_len -= push_size;
 503           val += push_size;
 504           stack_offset += push_size;
 505         }
 506
 507       args++;
 508     }
 509
 510   /* Make space for the flushback area.  */
 511   sp -= 8;
 512
 513   /* Push the return address that contains the magic breakpoint.  */
 514   sp -= 4;
 515   write_memory_unsigned_integer (sp, push_size, bp_addr);
 516   /* Update $sp.  */
 517   regcache_cooked_write_unsigned (regcache, E_SP_REGNUM, sp);
 518   return sp;
 519 }
 520
 521
 522 static struct gdbarch *
 523 mn10300_gdbarch_init (struct gdbarch_info info,
 524                       struct gdbarch_list *arches)
 525 {
 526   struct gdbarch *gdbarch;
 527   struct gdbarch_tdep *tdep;
 528
 529   arches = gdbarch_list_lookup_by_info (arches, &info);
 530   if (arches != NULL)
 531     return arches->gdbarch;
 532
 533   tdep = xmalloc (sizeof (struct gdbarch_tdep));
 534   gdbarch = gdbarch_alloc (&info, tdep);
 535
 536   switch (info.bfd_arch_info->mach)
 537     {
 538     case 0:
 539     case bfd_mach_mn10300:
 540       set_gdbarch_register_name (gdbarch, mn10300_generic_register_name);
 541       tdep->am33_mode = 0;
 542       break;
 543     case bfd_mach_am33:
 544       set_gdbarch_register_name (gdbarch, am33_register_name);
 545       tdep->am33_mode = 1;
 546       break;
 547     default:
 548       internal_error (__FILE__, __LINE__,
 549                       _("mn10300_gdbarch_init: Unknown mn10300 variant"));
 550       break;
 551     }
 552
 553   /* Registers.  */
 554   set_gdbarch_num_regs (gdbarch, E_NUM_REGS);
 555   set_gdbarch_register_type (gdbarch, mn10300_register_type);
 556   set_gdbarch_skip_prologue (gdbarch, mn10300_skip_prologue);
 557   set_gdbarch_read_pc (gdbarch, mn10300_read_pc);
 558   set_gdbarch_write_pc (gdbarch, mn10300_write_pc);
 559   set_gdbarch_pc_regnum (gdbarch, E_PC_REGNUM);
 560   set_gdbarch_sp_regnum (gdbarch, E_SP_REGNUM);
 561
 562   /* Stack unwinding.  */
 563   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
 564   /* Breakpoints.  */
 565   set_gdbarch_breakpoint_from_pc (gdbarch, mn10300_breakpoint_from_pc);
 566   /* decr_pc_after_break? */
 567   /* Disassembly.  */
 568   set_gdbarch_print_insn (gdbarch, print_insn_mn10300);
 569
 570   /* Stage 2 */
 571   /* MVS Note: at least the first one is deprecated!  */
 572   set_gdbarch_deprecated_use_struct_convention (gdbarch,
 573                                                 mn10300_use_struct_convention);
 574   set_gdbarch_store_return_value (gdbarch, mn10300_store_return_value);
 575   set_gdbarch_extract_return_value (gdbarch, mn10300_extract_return_value);
 576
 577   /* Stage 3 -- get target calls working.  */
 578   set_gdbarch_push_dummy_call (gdbarch, mn10300_push_dummy_call);
 579   /* set_gdbarch_return_value (store, extract) */
 580
 581
 582   mn10300_frame_unwind_init (gdbarch);
 583
 584   return gdbarch;
 585 }
 586
 587 /* Dump out the mn10300 specific architecture information. */
 588
 589 static void
 590 mn10300_dump_tdep (struct gdbarch *current_gdbarch, struct ui_file *file)
 591 {
 592   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
 593   fprintf_unfiltered (file, "mn10300_dump_tdep: am33_mode = %d\n",
 594                       tdep->am33_mode);
 595 }
 596
 597 void
 598 _initialize_mn10300_tdep (void)
 599 {
 600   gdbarch_register (bfd_arch_mn10300, mn10300_gdbarch_init, mn10300_dump_tdep);
 601 }
 602