gdb/d10v-tdep.c

   1 /* Target-dependent code for Mitsubishi D10V, for GDB.
   2
   3    Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003 Free Software
   4    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 /*  Contributed by Martin Hunt, hunt@cygnus.com */
  24
  25 #include "defs.h"
  26 #include "frame.h"
  27 #include "frame-unwind.h"
  28 #include "frame-base.h"
  29 #include "symtab.h"
  30 #include "gdbtypes.h"
  31 #include "gdbcmd.h"
  32 #include "gdbcore.h"
  33 #include "gdb_string.h"
  34 #include "value.h"
  35 #include "inferior.h"
  36 #include "dis-asm.h"
  37 #include "symfile.h"
  38 #include "objfiles.h"
  39 #include "language.h"
  40 #include "arch-utils.h"
  41 #include "regcache.h"
  42 #include "remote.h"
  43 #include "floatformat.h"
  44 #include "gdb/sim-d10v.h"
  45 #include "sim-regno.h"
  46 #include "disasm.h"
  47 #include "trad-frame.h"
  48
  49 #include "gdb_assert.h"
  50
  51 struct gdbarch_tdep
  52   {
  53     int a0_regnum;
  54     int nr_dmap_regs;
  55     unsigned long (*dmap_register) (void *regcache, int nr);
  56     unsigned long (*imap_register) (void *regcache, int nr);
  57   };
  58
  59 /* These are the addresses the D10V-EVA board maps data and
  60    instruction memory to. */
  61
  62 enum memspace {
  63   DMEM_START  = 0x2000000,
  64   IMEM_START  = 0x1000000,
  65   STACK_START = 0x200bffe
  66 };
  67
  68 /* d10v register names. */
  69
  70 enum
  71   {
  72     R0_REGNUM = 0,
  73     R3_REGNUM = 3,
  74     D10V_FP_REGNUM = 11,
  75     LR_REGNUM = 13,
  76     D10V_SP_REGNUM = 15,
  77     PSW_REGNUM = 16,
  78     D10V_PC_REGNUM = 18,
  79     NR_IMAP_REGS = 2,
  80     NR_A_REGS = 2,
  81     TS2_NUM_REGS = 37,
  82     TS3_NUM_REGS = 42,
  83     /* d10v calling convention. */
  84     ARG1_REGNUM = R0_REGNUM,
  85     ARGN_REGNUM = R3_REGNUM,
  86     RET1_REGNUM = R0_REGNUM,
  87   };
  88
  89 static int
  90 nr_dmap_regs (struct gdbarch *gdbarch)
  91 {
  92   return gdbarch_tdep (gdbarch)->nr_dmap_regs;
  93 }
  94
  95 static int
  96 a0_regnum (struct gdbarch *gdbarch)
  97 {
  98   return gdbarch_tdep (gdbarch)->a0_regnum;
  99 }
 100
 101 /* Local functions */
 102
 103 extern void _initialize_d10v_tdep (void);
 104
 105 static CORE_ADDR d10v_read_sp (void);
 106
 107 static void d10v_eva_prepare_to_trace (void);
 108
 109 static void d10v_eva_get_trace_data (void);
 110
 111 static CORE_ADDR
 112 d10v_frame_align (struct gdbarch *gdbarch, CORE_ADDR sp)
 113 {
 114   /* Align to the size of an instruction (so that they can safely be
 115      pushed onto the stack.  */
 116   return sp & ~3;
 117 }
 118
 119 /* Should we use EXTRACT_STRUCT_VALUE_ADDRESS instead of
 120    EXTRACT_RETURN_VALUE?  GCC_P is true if compiled with gcc
 121    and TYPE is the type (which is known to be struct, union or array).
 122
 123    The d10v returns anything less than 8 bytes in size in
 124    registers. */
 125
 126 static int
 127 d10v_use_struct_convention (int gcc_p, struct type *type)
 128 {
 129   long alignment;
 130   int i;
 131   /* The d10v only passes a struct in a register when that structure
 132      has an alignment that matches the size of a register. */
 133   /* If the structure doesn't fit in 4 registers, put it on the
 134      stack. */
 135   if (TYPE_LENGTH (type) > 8)
 136     return 1;
 137   /* If the struct contains only one field, don't put it on the stack
 138      - gcc can fit it in one or more registers. */
 139   if (TYPE_NFIELDS (type) == 1)
 140     return 0;
 141   alignment = TYPE_LENGTH (TYPE_FIELD_TYPE (type, 0));
 142   for (i = 1; i < TYPE_NFIELDS (type); i++)
 143     {
 144       /* If the alignment changes, just assume it goes on the
 145          stack. */
 146       if (TYPE_LENGTH (TYPE_FIELD_TYPE (type, i)) != alignment)
 147         return 1;
 148     }
 149   /* If the alignment is suitable for the d10v's 16 bit registers,
 150      don't put it on the stack. */
 151   if (alignment == 2 || alignment == 4)
 152     return 0;
 153   return 1;
 154 }
 155
 156
 157 static const unsigned char *
 158 d10v_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr)
 159 {
 160   static unsigned char breakpoint[] =
 161   {0x2f, 0x90, 0x5e, 0x00};
 162   *lenptr = sizeof (breakpoint);
 163   return breakpoint;
 164 }
 165
 166 /* Map the REG_NR onto an ascii name.  Return NULL or an empty string
 167    when the reg_nr isn't valid. */
 168
 169 enum ts2_regnums
 170   {
 171     TS2_IMAP0_REGNUM = 32,
 172     TS2_DMAP_REGNUM = 34,
 173     TS2_NR_DMAP_REGS = 1,
 174     TS2_A0_REGNUM = 35
 175   };
 176
 177 static const char *
 178 d10v_ts2_register_name (int reg_nr)
 179 {
 180   static char *register_names[] =
 181   {
 182     "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
 183     "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
 184     "psw", "bpsw", "pc", "bpc", "cr4", "cr5", "cr6", "rpt_c",
 185     "rpt_s", "rpt_e", "mod_s", "mod_e", "cr12", "cr13", "iba", "cr15",
 186     "imap0", "imap1", "dmap", "a0", "a1"
 187   };
 188   if (reg_nr < 0)
 189     return NULL;
 190   if (reg_nr >= (sizeof (register_names) / sizeof (*register_names)))
 191     return NULL;
 192   return register_names[reg_nr];
 193 }
 194
 195 enum ts3_regnums
 196   {
 197     TS3_IMAP0_REGNUM = 36,
 198     TS3_DMAP0_REGNUM = 38,
 199     TS3_NR_DMAP_REGS = 4,
 200     TS3_A0_REGNUM = 32
 201   };
 202
 203 static const char *
 204 d10v_ts3_register_name (int reg_nr)
 205 {
 206   static char *register_names[] =
 207   {
 208     "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
 209     "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
 210     "psw", "bpsw", "pc", "bpc", "cr4", "cr5", "cr6", "rpt_c",
 211     "rpt_s", "rpt_e", "mod_s", "mod_e", "cr12", "cr13", "iba", "cr15",
 212     "a0", "a1",
 213     "spi", "spu",
 214     "imap0", "imap1",
 215     "dmap0", "dmap1", "dmap2", "dmap3"
 216   };
 217   if (reg_nr < 0)
 218     return NULL;
 219   if (reg_nr >= (sizeof (register_names) / sizeof (*register_names)))
 220     return NULL;
 221   return register_names[reg_nr];
 222 }
 223
 224 /* Access the DMAP/IMAP registers in a target independent way.
 225
 226    Divide the D10V's 64k data space into four 16k segments:
 227    0x0000 -- 0x3fff, 0x4000 -- 0x7fff, 0x8000 -- 0xbfff, and
 228    0xc000 -- 0xffff.
 229
 230    On the TS2, the first two segments (0x0000 -- 0x3fff, 0x4000 --
 231    0x7fff) always map to the on-chip data RAM, and the fourth always
 232    maps to I/O space.  The third (0x8000 - 0xbfff) can be mapped into
 233    unified memory or instruction memory, under the control of the
 234    single DMAP register.
 235
 236    On the TS3, there are four DMAP registers, each of which controls
 237    one of the segments.  */
 238
 239 static unsigned long
 240 d10v_ts2_dmap_register (void *regcache, int reg_nr)
 241 {
 242   switch (reg_nr)
 243     {
 244     case 0:
 245     case 1:
 246       return 0x2000;
 247     case 2:
 248       {
 249         ULONGEST reg;
 250         regcache_cooked_read_unsigned (regcache, TS2_DMAP_REGNUM, &reg);
 251         return reg;
 252       }
 253     default:
 254       return 0;
 255     }
 256 }
 257
 258 static unsigned long
 259 d10v_ts3_dmap_register (void *regcache, int reg_nr)
 260 {
 261   ULONGEST reg;
 262   regcache_cooked_read_unsigned (regcache, TS3_DMAP0_REGNUM + reg_nr, &reg);
 263   return reg;
 264 }
 265
 266 static unsigned long
 267 d10v_ts2_imap_register (void *regcache, int reg_nr)
 268 {
 269   ULONGEST reg;
 270   regcache_cooked_read_unsigned (regcache, TS2_IMAP0_REGNUM + reg_nr, &reg);
 271   return reg;
 272 }
 273
 274 static unsigned long
 275 d10v_ts3_imap_register (void *regcache, int reg_nr)
 276 {
 277   ULONGEST reg;
 278   regcache_cooked_read_unsigned (regcache, TS3_IMAP0_REGNUM + reg_nr, &reg);
 279   return reg;
 280 }
 281
 282 /* MAP GDB's internal register numbering (determined by the layout fo
 283    the REGISTER_BYTE array) onto the simulator's register
 284    numbering. */
 285
 286 static int
 287 d10v_ts2_register_sim_regno (int nr)
 288 {
 289   /* Only makes sense to supply raw registers.  */
 290   gdb_assert (nr >= 0 && nr < NUM_REGS);
 291   if (nr >= TS2_IMAP0_REGNUM
 292       && nr < TS2_IMAP0_REGNUM + NR_IMAP_REGS)
 293     return nr - TS2_IMAP0_REGNUM + SIM_D10V_IMAP0_REGNUM;
 294   if (nr == TS2_DMAP_REGNUM)
 295     return nr - TS2_DMAP_REGNUM + SIM_D10V_TS2_DMAP_REGNUM;
 296   if (nr >= TS2_A0_REGNUM
 297       && nr < TS2_A0_REGNUM + NR_A_REGS)
 298     return nr - TS2_A0_REGNUM + SIM_D10V_A0_REGNUM;
 299   return nr;
 300 }
 301
 302 static int
 303 d10v_ts3_register_sim_regno (int nr)
 304 {
 305   /* Only makes sense to supply raw registers.  */
 306   gdb_assert (nr >= 0 && nr < NUM_REGS);
 307   if (nr >= TS3_IMAP0_REGNUM
 308       && nr < TS3_IMAP0_REGNUM + NR_IMAP_REGS)
 309     return nr - TS3_IMAP0_REGNUM + SIM_D10V_IMAP0_REGNUM;
 310   if (nr >= TS3_DMAP0_REGNUM
 311       && nr < TS3_DMAP0_REGNUM + TS3_NR_DMAP_REGS)
 312     return nr - TS3_DMAP0_REGNUM + SIM_D10V_DMAP0_REGNUM;
 313   if (nr >= TS3_A0_REGNUM
 314       && nr < TS3_A0_REGNUM + NR_A_REGS)
 315     return nr - TS3_A0_REGNUM + SIM_D10V_A0_REGNUM;
 316   return nr;
 317 }
 318
 319 /* Return the GDB type object for the "standard" data type
 320    of data in register N.  */
 321
 322 static struct type *
 323 d10v_register_type (struct gdbarch *gdbarch, int reg_nr)
 324 {
 325   if (reg_nr == D10V_PC_REGNUM)
 326     return builtin_type_void_func_ptr;
 327   if (reg_nr == D10V_SP_REGNUM || reg_nr == D10V_FP_REGNUM)
 328     return builtin_type_void_data_ptr;
 329   else if (reg_nr >= a0_regnum (gdbarch)
 330            && reg_nr < (a0_regnum (gdbarch) + NR_A_REGS))
 331     return builtin_type_int64;
 332   else
 333     return builtin_type_int16;
 334 }
 335
 336 static int
 337 d10v_daddr_p (CORE_ADDR x)
 338 {
 339   return (((x) & 0x3000000) == DMEM_START);
 340 }
 341
 342 static int
 343 d10v_iaddr_p (CORE_ADDR x)
 344 {
 345   return (((x) & 0x3000000) == IMEM_START);
 346 }
 347
 348 static CORE_ADDR
 349 d10v_make_daddr (CORE_ADDR x)
 350 {
 351   return ((x) | DMEM_START);
 352 }
 353
 354 static CORE_ADDR
 355 d10v_make_iaddr (CORE_ADDR x)
 356 {
 357   if (d10v_iaddr_p (x))
 358     return x;   /* Idempotency -- x is already in the IMEM space. */
 359   else
 360     return (((x) << 2) | IMEM_START);
 361 }
 362
 363 static CORE_ADDR
 364 d10v_convert_iaddr_to_raw (CORE_ADDR x)
 365 {
 366   return (((x) >> 2) & 0xffff);
 367 }
 368
 369 static CORE_ADDR
 370 d10v_convert_daddr_to_raw (CORE_ADDR x)
 371 {
 372   return ((x) & 0xffff);
 373 }
 374
 375 static void
 376 d10v_address_to_pointer (struct type *type, void *buf, CORE_ADDR addr)
 377 {
 378   /* Is it a code address?  */
 379   if (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_FUNC
 380       || TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_METHOD)
 381     {
 382       store_unsigned_integer (buf, TYPE_LENGTH (type),
 383                               d10v_convert_iaddr_to_raw (addr));
 384     }
 385   else
 386     {
 387       /* Strip off any upper segment bits.  */
 388       store_unsigned_integer (buf, TYPE_LENGTH (type),
 389                               d10v_convert_daddr_to_raw (addr));
 390     }
 391 }
 392
 393 static CORE_ADDR
 394 d10v_pointer_to_address (struct type *type, const void *buf)
 395 {
 396   CORE_ADDR addr = extract_unsigned_integer (buf, TYPE_LENGTH (type));
 397   /* Is it a code address?  */
 398   if (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_FUNC
 399       || TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_METHOD
 400       || TYPE_CODE_SPACE (TYPE_TARGET_TYPE (type)))
 401     return d10v_make_iaddr (addr);
 402   else
 403     return d10v_make_daddr (addr);
 404 }
 405
 406 /* Don't do anything if we have an integer, this way users can type 'x
 407    <addr>' w/o having gdb outsmart them.  The internal gdb conversions
 408    to the correct space are taken care of in the pointer_to_address
 409    function.  If we don't do this, 'x $fp' wouldn't work.  */
 410 static CORE_ADDR
 411 d10v_integer_to_address (struct type *type, void *buf)
 412 {
 413   LONGEST val;
 414   val = unpack_long (type, buf);
 415   return val;
 416 }
 417
 418 /* Write into appropriate registers a function return value
 419    of type TYPE, given in virtual format.
 420
 421    Things always get returned in RET1_REGNUM, RET2_REGNUM, ... */
 422
 423 static void
 424 d10v_store_return_value (struct type *type, struct regcache *regcache,
 425                          const void *valbuf)
 426 {
 427   /* Only char return values need to be shifted right within the first
 428      regnum.  */
 429   if (TYPE_LENGTH (type) == 1
 430       && TYPE_CODE (type) == TYPE_CODE_INT)
 431     {
 432       bfd_byte tmp[2];
 433       tmp[1] = *(bfd_byte *)valbuf;
 434       regcache_cooked_write (regcache, RET1_REGNUM, tmp);
 435     }
 436   else
 437     {
 438       int reg;
 439       /* A structure is never more than 8 bytes long.  See
 440          use_struct_convention().  */
 441       gdb_assert (TYPE_LENGTH (type) <= 8);
 442       /* Write out most registers, stop loop before trying to write
 443          out any dangling byte at the end of the buffer.  */
 444       for (reg = 0; (reg * 2) + 1 < TYPE_LENGTH (type); reg++)
 445         {
 446           regcache_cooked_write (regcache, RET1_REGNUM + reg,
 447                                  (bfd_byte *) valbuf + reg * 2);
 448         }
 449       /* Write out any dangling byte at the end of the buffer.  */
 450       if ((reg * 2) + 1 == TYPE_LENGTH (type))
 451         regcache_cooked_write_part (regcache, reg, 0, 1,
 452                                     (bfd_byte *) valbuf + reg * 2);
 453     }
 454 }
 455
 456 /* Extract from an array REGBUF containing the (raw) register state
 457    the address in which a function should return its structure value,
 458    as a CORE_ADDR (or an expression that can be used as one).  */
 459
 460 static CORE_ADDR
 461 d10v_extract_struct_value_address (struct regcache *regcache)
 462 {
 463   ULONGEST addr;
 464   regcache_cooked_read_unsigned (regcache, ARG1_REGNUM, &addr);
 465   return (addr | DMEM_START);
 466 }
 467
 468 static int
 469 check_prologue (unsigned short op)
 470 {
 471   /* st  rn, @-sp */
 472   if ((op & 0x7E1F) == 0x6C1F)
 473     return 1;
 474
 475   /* st2w  rn, @-sp */
 476   if ((op & 0x7E3F) == 0x6E1F)
 477     return 1;
 478
 479   /* subi  sp, n */
 480   if ((op & 0x7FE1) == 0x01E1)
 481     return 1;
 482
 483   /* mv  r11, sp */
 484   if (op == 0x417E)
 485     return 1;
 486
 487   /* nop */
 488   if (op == 0x5E00)
 489     return 1;
 490
 491   /* st  rn, @sp */
 492   if ((op & 0x7E1F) == 0x681E)
 493     return 1;
 494
 495   /* st2w  rn, @sp */
 496   if ((op & 0x7E3F) == 0x3A1E)
 497     return 1;
 498
 499   return 0;
 500 }
 501
 502 static CORE_ADDR
 503 d10v_skip_prologue (CORE_ADDR pc)
 504 {
 505   unsigned long op;
 506   unsigned short op1, op2;
 507   CORE_ADDR func_addr, func_end;
 508   struct symtab_and_line sal;
 509
 510   /* If we have line debugging information, then the end of the */
 511   /* prologue should the first assembly instruction of  the first source line */
 512   if (find_pc_partial_function (pc, NULL, &func_addr, &func_end))
 513     {
 514       sal = find_pc_line (func_addr, 0);
 515       if (sal.end && sal.end < func_end)
 516         return sal.end;
 517     }
 518
 519   if (target_read_memory (pc, (char *) &op, 4))
 520     return pc;                  /* Can't access it -- assume no prologue. */
 521
 522   while (1)
 523     {
 524       op = (unsigned long) read_memory_integer (pc, 4);
 525       if ((op & 0xC0000000) == 0xC0000000)
 526         {
 527           /* long instruction */
 528           if (((op & 0x3FFF0000) != 0x01FF0000) &&      /* add3 sp,sp,n */
 529               ((op & 0x3F0F0000) != 0x340F0000) &&      /* st  rn, @(offset,sp) */
 530               ((op & 0x3F1F0000) != 0x350F0000))        /* st2w  rn, @(offset,sp) */
 531             break;
 532         }
 533       else
 534         {
 535           /* short instructions */
 536           if ((op & 0xC0000000) == 0x80000000)
 537             {
 538               op2 = (op & 0x3FFF8000) >> 15;
 539               op1 = op & 0x7FFF;
 540             }
 541           else
 542             {
 543               op1 = (op & 0x3FFF8000) >> 15;
 544               op2 = op & 0x7FFF;
 545             }
 546           if (check_prologue (op1))
 547             {
 548               if (!check_prologue (op2))
 549                 {
 550                   /* if the previous opcode was really part of the prologue */
 551                   /* and not just a NOP, then we want to break after both instructions */
 552                   if (op1 != 0x5E00)
 553                     pc += 4;
 554                   break;
 555                 }
 556             }
 557           else
 558             break;
 559         }
 560       pc += 4;
 561     }
 562   return pc;
 563 }
 564
 565 struct d10v_unwind_cache
 566 {
 567   /* The previous frame's inner most stack address.  Used as this
 568      frame ID's stack_addr.  */
 569   CORE_ADDR prev_sp;
 570   /* The frame's base, optionally used by the high-level debug info.  */
 571   CORE_ADDR base;
 572   int size;
 573   /* How far the SP and r11 (FP) have been offset from the start of
 574      the stack frame (as defined by the previous frame's stack
 575      pointer).  */
 576   LONGEST sp_offset;
 577   LONGEST r11_offset;
 578   int uses_frame;
 579   /* Table indicating the location of each and every register.  */
 580   struct trad_frame_saved_reg *saved_regs;
 581 };
 582
 583 static int
 584 prologue_find_regs (struct d10v_unwind_cache *info, unsigned short op,
 585                     CORE_ADDR addr)
 586 {
 587   int n;
 588
 589   /* st  rn, @-sp */
 590   if ((op & 0x7E1F) == 0x6C1F)
 591     {
 592       n = (op & 0x1E0) >> 5;
 593       info->sp_offset -= 2;
 594       info->saved_regs[n].addr = info->sp_offset;
 595       return 1;
 596     }
 597
 598   /* st2w  rn, @-sp */
 599   else if ((op & 0x7E3F) == 0x6E1F)
 600     {
 601       n = (op & 0x1E0) >> 5;
 602       info->sp_offset -= 4;
 603       info->saved_regs[n + 0].addr = info->sp_offset + 0;
 604       info->saved_regs[n + 1].addr = info->sp_offset + 2;
 605       return 1;
 606     }
 607
 608   /* subi  sp, n */
 609   if ((op & 0x7FE1) == 0x01E1)
 610     {
 611       n = (op & 0x1E) >> 1;
 612       if (n == 0)
 613         n = 16;
 614       info->sp_offset -= n;
 615       return 1;
 616     }
 617
 618   /* mv  r11, sp */
 619   if (op == 0x417E)
 620     {
 621       info->uses_frame = 1;
 622       info->r11_offset = info->sp_offset;
 623       return 1;
 624     }
 625
 626   /* st  rn, @r11 */
 627   if ((op & 0x7E1F) == 0x6816)
 628     {
 629       n = (op & 0x1E0) >> 5;
 630       info->saved_regs[n].addr = info->r11_offset;
 631       return 1;
 632     }
 633
 634   /* nop */
 635   if (op == 0x5E00)
 636     return 1;
 637
 638   /* st  rn, @sp */
 639   if ((op & 0x7E1F) == 0x681E)
 640     {
 641       n = (op & 0x1E0) >> 5;
 642       info->saved_regs[n].addr = info->sp_offset;
 643       return 1;
 644     }
 645
 646   /* st2w  rn, @sp */
 647   if ((op & 0x7E3F) == 0x3A1E)
 648     {
 649       n = (op & 0x1E0) >> 5;
 650       info->saved_regs[n + 0].addr = info->sp_offset + 0;
 651       info->saved_regs[n + 1].addr = info->sp_offset + 2;
 652       return 1;
 653     }
 654
 655   return 0;
 656 }
 657
 658 /* Put here the code to store, into fi->saved_regs, the addresses of
 659    the saved registers of frame described by FRAME_INFO.  This
 660    includes special registers such as pc and fp saved in special ways
 661    in the stack frame.  sp is even more special: the address we return
 662    for it IS the sp for the next frame. */
 663
 664 static struct d10v_unwind_cache *
 665 d10v_frame_unwind_cache (struct frame_info *next_frame,
 666                          void **this_prologue_cache)
 667 {
 668   struct gdbarch *gdbarch = get_frame_arch (next_frame);
 669   CORE_ADDR pc;
 670   ULONGEST prev_sp;
 671   ULONGEST this_base;
 672   unsigned long op;
 673   unsigned short op1, op2;
 674   int i;
 675   struct d10v_unwind_cache *info;
 676
 677   if ((*this_prologue_cache))
 678     return (*this_prologue_cache);
 679
 680   info = FRAME_OBSTACK_ZALLOC (struct d10v_unwind_cache);
 681   (*this_prologue_cache) = info;
 682   info->saved_regs = trad_frame_alloc_saved_regs (next_frame);
 683
 684   info->size = 0;
 685   info->sp_offset = 0;
 686
 687   info->uses_frame = 0;
 688   for (pc = frame_func_unwind (next_frame);
 689        pc > 0 && pc < frame_pc_unwind (next_frame);
 690        pc += 4)
 691     {
 692       op = get_frame_memory_unsigned (next_frame, pc, 4);
 693       if ((op & 0xC0000000) == 0xC0000000)
 694         {
 695           /* long instruction */
 696           if ((op & 0x3FFF0000) == 0x01FF0000)
 697             {
 698               /* add3 sp,sp,n */
 699               short n = op & 0xFFFF;
 700               info->sp_offset += n;
 701             }
 702           else if ((op & 0x3F0F0000) == 0x340F0000)
 703             {
 704               /* st  rn, @(offset,sp) */
 705               short offset = op & 0xFFFF;
 706               short n = (op >> 20) & 0xF;
 707               info->saved_regs[n].addr = info->sp_offset + offset;
 708             }
 709           else if ((op & 0x3F1F0000) == 0x350F0000)
 710             {
 711               /* st2w  rn, @(offset,sp) */
 712               short offset = op & 0xFFFF;
 713               short n = (op >> 20) & 0xF;
 714               info->saved_regs[n + 0].addr = info->sp_offset + offset + 0;
 715               info->saved_regs[n + 1].addr = info->sp_offset + offset + 2;
 716             }
 717           else
 718             break;
 719         }
 720       else
 721         {
 722           /* short instructions */
 723           if ((op & 0xC0000000) == 0x80000000)
 724             {
 725               op2 = (op & 0x3FFF8000) >> 15;
 726               op1 = op & 0x7FFF;
 727             }
 728           else
 729             {
 730               op1 = (op & 0x3FFF8000) >> 15;
 731               op2 = op & 0x7FFF;
 732             }
 733           if (!prologue_find_regs (info, op1, pc)
 734               || !prologue_find_regs (info, op2, pc))
 735             break;
 736         }
 737     }
 738
 739   info->size = -info->sp_offset;
 740
 741   /* Compute the previous frame's stack pointer (which is also the
 742      frame's ID's stack address), and this frame's base pointer.  */
 743   if (info->uses_frame)
 744     {
 745       /* The SP was moved to the FP.  This indicates that a new frame
 746          was created.  Get THIS frame's FP value by unwinding it from
 747          the next frame.  */
 748       frame_unwind_unsigned_register (next_frame, D10V_FP_REGNUM, &this_base);
 749       /* The FP points at the last saved register.  Adjust the FP back
 750          to before the first saved register giving the SP.  */
 751       prev_sp = this_base + info->size;
 752     }
 753   else
 754     {
 755       /* Assume that the FP is this frame's SP but with that pushed
 756          stack space added back.  */
 757       frame_unwind_unsigned_register (next_frame, D10V_SP_REGNUM, &this_base);
 758       prev_sp = this_base + info->size;
 759     }
 760
 761   /* Convert that SP/BASE into real addresses.  */
 762   info->prev_sp =  d10v_make_daddr (prev_sp);
 763   info->base = d10v_make_daddr (this_base);
 764
 765   /* Adjust all the saved registers so that they contain addresses and
 766      not offsets.  */
 767   for (i = 0; i < NUM_REGS - 1; i++)
 768     if (info->saved_regs[i].addr)
 769       {
 770         info->saved_regs[i].addr = (info->prev_sp + info->saved_regs[i].addr);
 771       }
 772
 773   /* The call instruction moves the caller's PC in the callee's LR.
 774      Since this is an unwind, do the reverse.  Copy the location of LR
 775      into PC (the address / regnum) so that a request for PC will be
 776      converted into a request for the LR.  */
 777   info->saved_regs[D10V_PC_REGNUM] = info->saved_regs[LR_REGNUM];
 778
 779   /* The previous frame's SP needed to be computed.  Save the computed
 780      value.  */
 781   trad_frame_register_value (info->saved_regs, D10V_SP_REGNUM,
 782                              d10v_make_daddr (prev_sp));
 783
 784   return info;
 785 }
 786
 787 static void
 788 d10v_print_registers_info (struct gdbarch *gdbarch, struct ui_file *file,
 789                            struct frame_info *frame, int regnum, int all)
 790 {
 791   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
 792   if (regnum >= 0)
 793     {
 794       default_print_registers_info (gdbarch, file, frame, regnum, all);
 795       return;
 796     }
 797
 798   {
 799     ULONGEST pc, psw, rpt_s, rpt_e, rpt_c;
 800     frame_read_unsigned_register (frame, D10V_PC_REGNUM, &pc);
 801     frame_read_unsigned_register (frame, PSW_REGNUM, &psw);
 802     frame_read_unsigned_register (frame, frame_map_name_to_regnum ("rpt_s", -1), &rpt_s);
 803     frame_read_unsigned_register (frame, frame_map_name_to_regnum ("rpt_e", -1), &rpt_e);
 804     frame_read_unsigned_register (frame, frame_map_name_to_regnum ("rpt_c", -1), &rpt_c);
 805     fprintf_filtered (file, "PC=%04lx (0x%lx) PSW=%04lx RPT_S=%04lx RPT_E=%04lx RPT_C=%04lx\n",
 806                      (long) pc, (long) d10v_make_iaddr (pc), (long) psw,
 807                      (long) rpt_s, (long) rpt_e, (long) rpt_c);
 808   }
 809
 810   {
 811     int group;
 812     for (group = 0; group < 16; group += 8)
 813       {
 814         int r;
 815         fprintf_filtered (file, "R%d-R%-2d", group, group + 7);
 816         for (r = group; r < group + 8; r++)
 817           {
 818             ULONGEST tmp;
 819             frame_read_unsigned_register (frame, r, &tmp);
 820             fprintf_filtered (file, " %04lx", (long) tmp);
 821           }
 822         fprintf_filtered (file, "\n");
 823       }
 824   }
 825
 826   /* Note: The IMAP/DMAP registers don't participate in function
 827      calls.  Don't bother trying to unwind them.  */
 828
 829   {
 830     int a;
 831     for (a = 0; a < NR_IMAP_REGS; a++)
 832       {
 833         if (a > 0)
 834           fprintf_filtered (file, "    ");
 835         fprintf_filtered (file, "IMAP%d %04lx", a,
 836                           tdep->imap_register (current_regcache, a));
 837       }
 838     if (nr_dmap_regs (gdbarch) == 1)
 839       /* Registers DMAP0 and DMAP1 are constant.  Just return dmap2.  */
 840       fprintf_filtered (file, "    DMAP %04lx\n",
 841                         tdep->dmap_register (current_regcache, 2));
 842     else
 843       {
 844         for (a = 0; a < nr_dmap_regs (gdbarch); a++)
 845           {
 846             fprintf_filtered (file, "    DMAP%d %04lx", a,
 847                               tdep->dmap_register (current_regcache, a));
 848           }
 849         fprintf_filtered (file, "\n");
 850       }
 851   }
 852
 853   {
 854     char num[MAX_REGISTER_SIZE];
 855     int a;
 856     fprintf_filtered (file, "A0-A%d", NR_A_REGS - 1);
 857     for (a = a0_regnum (gdbarch); a < a0_regnum (gdbarch) + NR_A_REGS; a++)
 858       {
 859         int i;
 860         fprintf_filtered (file, "  ");
 861         frame_read_register (frame, a, num);
 862         for (i = 0; i < register_size (gdbarch, a); i++)
 863           {
 864             fprintf_filtered (file, "%02x", (num[i] & 0xff));
 865           }
 866       }
 867   }
 868   fprintf_filtered (file, "\n");
 869 }
 870
 871 static void
 872 show_regs (char *args, int from_tty)
 873 {
 874   d10v_print_registers_info (current_gdbarch, gdb_stdout,
 875                              get_current_frame (), -1, 1);
 876 }
 877
 878 static CORE_ADDR
 879 d10v_read_pc (ptid_t ptid)
 880 {
 881   ptid_t save_ptid;
 882   CORE_ADDR pc;
 883   CORE_ADDR retval;
 884
 885   save_ptid = inferior_ptid;
 886   inferior_ptid = ptid;
 887   pc = (int) read_register (D10V_PC_REGNUM);
 888   inferior_ptid = save_ptid;
 889   retval = d10v_make_iaddr (pc);
 890   return retval;
 891 }
 892
 893 static void
 894 d10v_write_pc (CORE_ADDR val, ptid_t ptid)
 895 {
 896   ptid_t save_ptid;
 897
 898   save_ptid = inferior_ptid;
 899   inferior_ptid = ptid;
 900   write_register (D10V_PC_REGNUM, d10v_convert_iaddr_to_raw (val));
 901   inferior_ptid = save_ptid;
 902 }
 903
 904 static CORE_ADDR
 905 d10v_read_sp (void)
 906 {
 907   return (d10v_make_daddr (read_register (D10V_SP_REGNUM)));
 908 }
 909
 910 /* When arguments must be pushed onto the stack, they go on in reverse
 911    order.  The below implements a FILO (stack) to do this. */
 912
 913 struct stack_item
 914 {
 915   int len;
 916   struct stack_item *prev;
 917   void *data;
 918 };
 919
 920 static struct stack_item *push_stack_item (struct stack_item *prev,
 921                                            void *contents, int len);
 922 static struct stack_item *
 923 push_stack_item (struct stack_item *prev, void *contents, int len)
 924 {
 925   struct stack_item *si;
 926   si = xmalloc (sizeof (struct stack_item));
 927   si->data = xmalloc (len);
 928   si->len = len;
 929   si->prev = prev;
 930   memcpy (si->data, contents, len);
 931   return si;
 932 }
 933
 934 static struct stack_item *pop_stack_item (struct stack_item *si);
 935 static struct stack_item *
 936 pop_stack_item (struct stack_item *si)
 937 {
 938   struct stack_item *dead = si;
 939   si = si->prev;
 940   xfree (dead->data);
 941   xfree (dead);
 942   return si;
 943 }
 944
 945
 946 static CORE_ADDR
 947 d10v_push_dummy_code (struct gdbarch *gdbarch,
 948                       CORE_ADDR sp, CORE_ADDR funaddr, int using_gcc,
 949                       struct value **args, int nargs,
 950                       struct type *value_type,
 951                       CORE_ADDR *real_pc, CORE_ADDR *bp_addr)
 952 {
 953   /* Allocate space sufficient for a breakpoint.  */
 954   sp = (sp - 4) & ~3;
 955   /* Store the address of that breakpoint taking care to first convert
 956      it into a code (IADDR) address from a stack (DADDR) address.
 957      This of course assumes that the two virtual addresses map onto
 958      the same real address.  */
 959   (*bp_addr) = d10v_make_iaddr (d10v_convert_iaddr_to_raw (sp));
 960   /* d10v always starts the call at the callee's entry point.  */
 961   (*real_pc) = funaddr;
 962   return sp;
 963 }
 964
 965 static CORE_ADDR
 966 d10v_push_dummy_call (struct gdbarch *gdbarch, CORE_ADDR func_addr,
 967                       struct regcache *regcache, CORE_ADDR bp_addr,
 968                       int nargs, struct value **args, CORE_ADDR sp, int struct_return,
 969                       CORE_ADDR struct_addr)
 970 {
 971   int i;
 972   int regnum = ARG1_REGNUM;
 973   struct stack_item *si = NULL;
 974   long val;
 975
 976   /* Set the return address.  For the d10v, the return breakpoint is
 977      always at BP_ADDR.  */
 978   regcache_cooked_write_unsigned (regcache, LR_REGNUM,
 979                                   d10v_convert_iaddr_to_raw (bp_addr));
 980
 981   /* If STRUCT_RETURN is true, then the struct return address (in
 982      STRUCT_ADDR) will consume the first argument-passing register.
 983      Both adjust the register count and store that value.  */
 984   if (struct_return)
 985     {
 986       regcache_cooked_write_unsigned (regcache, regnum, struct_addr);
 987       regnum++;
 988     }
 989
 990   /* Fill in registers and arg lists */
 991   for (i = 0; i < nargs; i++)
 992     {
 993       struct value *arg = args[i];
 994       struct type *type = check_typedef (VALUE_TYPE (arg));
 995       char *contents = VALUE_CONTENTS (arg);
 996       int len = TYPE_LENGTH (type);
 997       int aligned_regnum = (regnum + 1) & ~1;
 998
 999       /* printf ("push: type=%d len=%d\n", TYPE_CODE (type), len); */
1000       if (len <= 2 && regnum <= ARGN_REGNUM)
1001         /* fits in a single register, do not align */
1002         {
1003           val = extract_unsigned_integer (contents, len);
1004           regcache_cooked_write_unsigned (regcache, regnum++, val);
1005         }
1006       else if (len <= (ARGN_REGNUM - aligned_regnum + 1) * 2)
1007         /* value fits in remaining registers, store keeping left
1008            aligned */
1009         {
1010           int b;
1011           regnum = aligned_regnum;
1012           for (b = 0; b < (len & ~1); b += 2)
1013             {
1014               val = extract_unsigned_integer (&contents[b], 2);
1015               regcache_cooked_write_unsigned (regcache, regnum++, val);
1016             }
1017           if (b < len)
1018             {
1019               val = extract_unsigned_integer (&contents[b], 1);
1020               regcache_cooked_write_unsigned (regcache, regnum++, (val << 8));
1021             }
1022         }
1023       else
1024         {
1025           /* arg will go onto stack */
1026           regnum = ARGN_REGNUM + 1;
1027           si = push_stack_item (si, contents, len);
1028         }
1029     }
1030
1031   while (si)
1032     {
1033       sp = (sp - si->len) & ~1;
1034       write_memory (sp, si->data, si->len);
1035       si = pop_stack_item (si);
1036     }
1037
1038   /* Finally, update the SP register.  */
1039   regcache_cooked_write_unsigned (regcache, D10V_SP_REGNUM,
1040                                   d10v_convert_daddr_to_raw (sp));
1041
1042   return sp;
1043 }
1044
1045
1046 /* Given a return value in `regbuf' with a type `valtype',
1047    extract and copy its value into `valbuf'.  */
1048
1049 static void
1050 d10v_extract_return_value (struct type *type, struct regcache *regcache,
1051                            void *valbuf)
1052 {
1053   int len;
1054   if (TYPE_LENGTH (type) == 1)
1055     {
1056       ULONGEST c;
1057       regcache_cooked_read_unsigned (regcache, RET1_REGNUM, &c);
1058       store_unsigned_integer (valbuf, 1, c);
1059     }
1060   else
1061     {
1062       /* For return values of odd size, the first byte is in the
1063          least significant part of the first register.  The
1064          remaining bytes in remaining registers. Interestingly, when
1065          such values are passed in, the last byte is in the most
1066          significant byte of that same register - wierd. */
1067       int reg = RET1_REGNUM;
1068       int off = 0;
1069       if (TYPE_LENGTH (type) & 1)
1070         {
1071           regcache_cooked_read_part (regcache, RET1_REGNUM, 1, 1,
1072                                      (bfd_byte *)valbuf + off);
1073           off++;
1074           reg++;
1075         }
1076       /* Transfer the remaining registers.  */
1077       for (; off < TYPE_LENGTH (type); reg++, off += 2)
1078         {
1079           regcache_cooked_read (regcache, RET1_REGNUM + reg,
1080                                 (bfd_byte *) valbuf + off);
1081         }
1082     }
1083 }
1084
1085 /* Translate a GDB virtual ADDR/LEN into a format the remote target
1086    understands.  Returns number of bytes that can be transfered
1087    starting at TARG_ADDR.  Return ZERO if no bytes can be transfered
1088    (segmentation fault).  Since the simulator knows all about how the
1089    VM system works, we just call that to do the translation. */
1090
1091 static void
1092 remote_d10v_translate_xfer_address (struct gdbarch *gdbarch,
1093                                     struct regcache *regcache,
1094                                     CORE_ADDR memaddr, int nr_bytes,
1095                                     CORE_ADDR *targ_addr, int *targ_len)
1096 {
1097   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
1098   long out_addr;
1099   long out_len;
1100   out_len = sim_d10v_translate_addr (memaddr, nr_bytes, &out_addr, regcache,
1101                                      tdep->dmap_register, tdep->imap_register);
1102   *targ_addr = out_addr;
1103   *targ_len = out_len;
1104 }
1105
1106
1107 /* The following code implements access to, and display of, the D10V's
1108    instruction trace buffer.  The buffer consists of 64K or more
1109    4-byte words of data, of which each words includes an 8-bit count,
1110    an 8-bit segment number, and a 16-bit instruction address.
1111
1112    In theory, the trace buffer is continuously capturing instruction
1113    data that the CPU presents on its "debug bus", but in practice, the
1114    ROMified GDB stub only enables tracing when it continues or steps
1115    the program, and stops tracing when the program stops; so it
1116    actually works for GDB to read the buffer counter out of memory and
1117    then read each trace word.  The counter records where the tracing
1118    stops, but there is no record of where it started, so we remember
1119    the PC when we resumed and then search backwards in the trace
1120    buffer for a word that includes that address.  This is not perfect,
1121    because you will miss trace data if the resumption PC is the target
1122    of a branch.  (The value of the buffer counter is semi-random, any
1123    trace data from a previous program stop is gone.)  */
1124
1125 /* The address of the last word recorded in the trace buffer.  */
1126
1127 #define DBBC_ADDR (0xd80000)
1128
1129 /* The base of the trace buffer, at least for the "Board_0".  */
1130
1131 #define TRACE_BUFFER_BASE (0xf40000)
1132
1133 static void trace_command (char *, int);
1134
1135 static void untrace_command (char *, int);
1136
1137 static void trace_info (char *, int);
1138
1139 static void tdisassemble_command (char *, int);
1140
1141 static void display_trace (int, int);
1142
1143 /* True when instruction traces are being collected.  */
1144
1145 static int tracing;
1146
1147 /* Remembered PC.  */
1148
1149 static CORE_ADDR last_pc;
1150
1151 /* True when trace output should be displayed whenever program stops.  */
1152
1153 static int trace_display;
1154
1155 /* True when trace listing should include source lines.  */
1156
1157 static int default_trace_show_source = 1;
1158
1159 struct trace_buffer
1160   {
1161     int size;
1162     short *counts;
1163     CORE_ADDR *addrs;
1164   }
1165 trace_data;
1166
1167 static void
1168 trace_command (char *args, int from_tty)
1169 {
1170   /* Clear the host-side trace buffer, allocating space if needed.  */
1171   trace_data.size = 0;
1172   if (trace_data.counts == NULL)
1173     trace_data.counts = XCALLOC (65536, short);
1174   if (trace_data.addrs == NULL)
1175     trace_data.addrs = XCALLOC (65536, CORE_ADDR);
1176
1177   tracing = 1;
1178
1179   printf_filtered ("Tracing is now on.\n");
1180 }
1181
1182 static void
1183 untrace_command (char *args, int from_tty)
1184 {
1185   tracing = 0;
1186
1187   printf_filtered ("Tracing is now off.\n");
1188 }
1189
1190 static void
1191 trace_info (char *args, int from_tty)
1192 {
1193   int i;
1194
1195   if (trace_data.size)
1196     {
1197       printf_filtered ("%d entries in trace buffer:\n", trace_data.size);
1198
1199       for (i = 0; i < trace_data.size; ++i)
1200         {
1201           printf_filtered ("%d: %d instruction%s at 0x%s\n",
1202                            i,
1203                            trace_data.counts[i],
1204                            (trace_data.counts[i] == 1 ? "" : "s"),
1205                            paddr_nz (trace_data.addrs[i]));
1206         }
1207     }
1208   else
1209     printf_filtered ("No entries in trace buffer.\n");
1210
1211   printf_filtered ("Tracing is currently %s.\n", (tracing ? "on" : "off"));
1212 }
1213
1214 static void
1215 d10v_eva_prepare_to_trace (void)
1216 {
1217   if (!tracing)
1218     return;
1219
1220   last_pc = read_register (D10V_PC_REGNUM);
1221 }
1222
1223 /* Collect trace data from the target board and format it into a form
1224    more useful for display.  */
1225
1226 static void
1227 d10v_eva_get_trace_data (void)
1228 {
1229   int count, i, j, oldsize;
1230   int trace_addr, trace_seg, trace_cnt, next_cnt;
1231   unsigned int last_trace, trace_word, next_word;
1232   unsigned int *tmpspace;
1233
1234   if (!tracing)
1235     return;
1236
1237   tmpspace = xmalloc (65536 * sizeof (unsigned int));
1238
1239   last_trace = read_memory_unsigned_integer (DBBC_ADDR, 2) << 2;
1240
1241   /* Collect buffer contents from the target, stopping when we reach
1242      the word recorded when execution resumed.  */
1243
1244   count = 0;
1245   while (last_trace > 0)
1246     {
1247       QUIT;
1248       trace_word =
1249         read_memory_unsigned_integer (TRACE_BUFFER_BASE + last_trace, 4);
1250       trace_addr = trace_word & 0xffff;
1251       last_trace -= 4;
1252       /* Ignore an apparently nonsensical entry.  */
1253       if (trace_addr == 0xffd5)
1254         continue;
1255       tmpspace[count++] = trace_word;
1256       if (trace_addr == last_pc)
1257         break;
1258       if (count > 65535)
1259         break;
1260     }
1261
1262   /* Move the data to the host-side trace buffer, adjusting counts to
1263      include the last instruction executed and transforming the address
1264      into something that GDB likes.  */
1265
1266   for (i = 0; i < count; ++i)
1267     {
1268       trace_word = tmpspace[i];
1269       next_word = ((i == 0) ? 0 : tmpspace[i - 1]);
1270       trace_addr = trace_word & 0xffff;
1271       next_cnt = (next_word >> 24) & 0xff;
1272       j = trace_data.size + count - i - 1;
1273       trace_data.addrs[j] = (trace_addr << 2) + 0x1000000;
1274       trace_data.counts[j] = next_cnt + 1;
1275     }
1276
1277   oldsize = trace_data.size;
1278   trace_data.size += count;
1279
1280   xfree (tmpspace);
1281
1282   if (trace_display)
1283     display_trace (oldsize, trace_data.size);
1284 }
1285
1286 static void
1287 tdisassemble_command (char *arg, int from_tty)
1288 {
1289   int i, count;
1290   CORE_ADDR low, high;
1291
1292   if (!arg)
1293     {
1294       low = 0;
1295       high = trace_data.size;
1296     }
1297   else
1298     {
1299       char *space_index = strchr (arg, ' ');
1300       if (space_index == NULL)
1301         {
1302           low = parse_and_eval_address (arg);
1303           high = low + 5;
1304         }
1305       else
1306         {
1307           /* Two arguments.  */
1308           *space_index = '\0';
1309           low = parse_and_eval_address (arg);
1310           high = parse_and_eval_address (space_index + 1);
1311           if (high < low)
1312             high = low;
1313         }
1314     }
1315
1316   printf_filtered ("Dump of trace from %s to %s:\n", paddr_u (low), paddr_u (high));
1317
1318   display_trace (low, high);
1319
1320   printf_filtered ("End of trace dump.\n");
1321   gdb_flush (gdb_stdout);
1322 }
1323
1324 static void
1325 display_trace (int low, int high)
1326 {
1327   int i, count, trace_show_source, first, suppress;
1328   CORE_ADDR next_address;
1329
1330   trace_show_source = default_trace_show_source;
1331   if (!have_full_symbols () && !have_partial_symbols ())
1332     {
1333       trace_show_source = 0;
1334       printf_filtered ("No symbol table is loaded.  Use the \"file\" command.\n");
1335       printf_filtered ("Trace will not display any source.\n");
1336     }
1337
1338   first = 1;
1339   suppress = 0;
1340   for (i = low; i < high; ++i)
1341     {
1342       next_address = trace_data.addrs[i];
1343       count = trace_data.counts[i];
1344       while (count-- > 0)
1345         {
1346           QUIT;
1347           if (trace_show_source)
1348             {
1349               struct symtab_and_line sal, sal_prev;
1350
1351               sal_prev = find_pc_line (next_address - 4, 0);
1352               sal = find_pc_line (next_address, 0);
1353
1354               if (sal.symtab)
1355                 {
1356                   if (first || sal.line != sal_prev.line)
1357                     print_source_lines (sal.symtab, sal.line, sal.line + 1, 0);
1358                   suppress = 0;
1359                 }
1360               else
1361                 {
1362                   if (!suppress)
1363                     /* FIXME-32x64--assumes sal.pc fits in long.  */
1364                     printf_filtered ("No source file for address %s.\n",
1365                                  local_hex_string ((unsigned long) sal.pc));
1366                   suppress = 1;
1367                 }
1368             }
1369           first = 0;
1370           print_address (next_address, gdb_stdout);
1371           printf_filtered (":");
1372           printf_filtered ("\t");
1373           wrap_here ("    ");
1374           next_address += gdb_print_insn (next_address, gdb_stdout);
1375           printf_filtered ("\n");
1376           gdb_flush (gdb_stdout);
1377         }
1378     }
1379 }
1380
1381 static CORE_ADDR
1382 d10v_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
1383 {
1384   ULONGEST pc;
1385   frame_unwind_unsigned_register (next_frame, D10V_PC_REGNUM, &pc);
1386   return d10v_make_iaddr (pc);
1387 }
1388
1389 /* Given a GDB frame, determine the address of the calling function's
1390    frame.  This will be used to create a new GDB frame struct.  */
1391
1392 static void
1393 d10v_frame_this_id (struct frame_info *next_frame,
1394                     void **this_prologue_cache,
1395                     struct frame_id *this_id)
1396 {
1397   struct d10v_unwind_cache *info
1398     = d10v_frame_unwind_cache (next_frame, this_prologue_cache);
1399   CORE_ADDR base;
1400   CORE_ADDR func;
1401   struct frame_id id;
1402
1403   /* The FUNC is easy.  */
1404   func = frame_func_unwind (next_frame);
1405
1406   /* This is meant to halt the backtrace at "_start".  Make sure we
1407      don't halt it at a generic dummy frame. */
1408   if (func <= IMEM_START || inside_entry_file (func))
1409     return;
1410
1411   /* Hopefully the prologue analysis either correctly determined the
1412      frame's base (which is the SP from the previous frame), or set
1413      that base to "NULL".  */
1414   base = info->prev_sp;
1415   if (base == STACK_START || base == 0)
1416     return;
1417
1418   id = frame_id_build (base, func);
1419
1420   /* Check that we're not going round in circles with the same frame
1421      ID (but avoid applying the test to sentinel frames which do go
1422      round in circles).  Can't use frame_id_eq() as that doesn't yet
1423      compare the frame's PC value.  */
1424   if (frame_relative_level (next_frame) >= 0
1425       && get_frame_type (next_frame) != DUMMY_FRAME
1426       && frame_id_eq (get_frame_id (next_frame), id))
1427     return;
1428
1429   (*this_id) = id;
1430 }
1431
1432 static void
1433 d10v_frame_prev_register (struct frame_info *next_frame,
1434                           void **this_prologue_cache,
1435                           int regnum, int *optimizedp,
1436                           enum lval_type *lvalp, CORE_ADDR *addrp,
1437                           int *realnump, void *bufferp)
1438 {
1439   struct d10v_unwind_cache *info
1440     = d10v_frame_unwind_cache (next_frame, this_prologue_cache);
1441   trad_frame_prev_register (next_frame, info->saved_regs, regnum,
1442                             optimizedp, lvalp, addrp, realnump, bufferp);
1443 }
1444
1445 static const struct frame_unwind d10v_frame_unwind = {
1446   NORMAL_FRAME,
1447   d10v_frame_this_id,
1448   d10v_frame_prev_register
1449 };
1450
1451 static const struct frame_unwind *
1452 d10v_frame_p (CORE_ADDR pc)
1453 {
1454   return &d10v_frame_unwind;
1455 }
1456
1457 static CORE_ADDR
1458 d10v_frame_base_address (struct frame_info *next_frame, void **this_cache)
1459 {
1460   struct d10v_unwind_cache *info
1461     = d10v_frame_unwind_cache (next_frame, this_cache);
1462   return info->base;
1463 }
1464
1465 static const struct frame_base d10v_frame_base = {
1466   &d10v_frame_unwind,
1467   d10v_frame_base_address,
1468   d10v_frame_base_address,
1469   d10v_frame_base_address
1470 };
1471
1472 /* Assuming NEXT_FRAME->prev is a dummy, return the frame ID of that
1473    dummy frame.  The frame ID's base needs to match the TOS value
1474    saved by save_dummy_frame_tos(), and the PC match the dummy frame's
1475    breakpoint.  */
1476
1477 static struct frame_id
1478 d10v_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *next_frame)
1479 {
1480   ULONGEST base;
1481   frame_unwind_unsigned_register (next_frame, D10V_SP_REGNUM, &base);
1482   return frame_id_build (d10v_make_daddr (base), frame_pc_unwind (next_frame));
1483 }
1484
1485 static gdbarch_init_ftype d10v_gdbarch_init;
1486
1487 static struct gdbarch *
1488 d10v_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
1489 {
1490   struct gdbarch *gdbarch;
1491   int d10v_num_regs;
1492   struct gdbarch_tdep *tdep;
1493   gdbarch_register_name_ftype *d10v_register_name;
1494   gdbarch_register_sim_regno_ftype *d10v_register_sim_regno;
1495
1496   /* Find a candidate among the list of pre-declared architectures. */
1497   arches = gdbarch_list_lookup_by_info (arches, &info);
1498   if (arches != NULL)
1499     return arches->gdbarch;
1500
1501   /* None found, create a new architecture from the information
1502      provided. */
1503   tdep = XMALLOC (struct gdbarch_tdep);
1504   gdbarch = gdbarch_alloc (&info, tdep);
1505
1506   switch (info.bfd_arch_info->mach)
1507     {
1508     case bfd_mach_d10v_ts2:
1509       d10v_num_regs = 37;
1510       d10v_register_name = d10v_ts2_register_name;
1511       d10v_register_sim_regno = d10v_ts2_register_sim_regno;
1512       tdep->a0_regnum = TS2_A0_REGNUM;
1513       tdep->nr_dmap_regs = TS2_NR_DMAP_REGS;
1514       tdep->dmap_register = d10v_ts2_dmap_register;
1515       tdep->imap_register = d10v_ts2_imap_register;
1516       break;
1517     default:
1518     case bfd_mach_d10v_ts3:
1519       d10v_num_regs = 42;
1520       d10v_register_name = d10v_ts3_register_name;
1521       d10v_register_sim_regno = d10v_ts3_register_sim_regno;
1522       tdep->a0_regnum = TS3_A0_REGNUM;
1523       tdep->nr_dmap_regs = TS3_NR_DMAP_REGS;
1524       tdep->dmap_register = d10v_ts3_dmap_register;
1525       tdep->imap_register = d10v_ts3_imap_register;
1526       break;
1527     }
1528
1529   set_gdbarch_read_pc (gdbarch, d10v_read_pc);
1530   set_gdbarch_write_pc (gdbarch, d10v_write_pc);
1531   set_gdbarch_read_sp (gdbarch, d10v_read_sp);
1532
1533   set_gdbarch_num_regs (gdbarch, d10v_num_regs);
1534   set_gdbarch_sp_regnum (gdbarch, D10V_SP_REGNUM);
1535   set_gdbarch_register_name (gdbarch, d10v_register_name);
1536   set_gdbarch_register_type (gdbarch, d10v_register_type);
1537
1538   set_gdbarch_ptr_bit (gdbarch, 2 * TARGET_CHAR_BIT);
1539   set_gdbarch_addr_bit (gdbarch, 32);
1540   set_gdbarch_address_to_pointer (gdbarch, d10v_address_to_pointer);
1541   set_gdbarch_pointer_to_address (gdbarch, d10v_pointer_to_address);
1542   set_gdbarch_integer_to_address (gdbarch, d10v_integer_to_address);
1543   set_gdbarch_short_bit (gdbarch, 2 * TARGET_CHAR_BIT);
1544   set_gdbarch_int_bit (gdbarch, 2 * TARGET_CHAR_BIT);
1545   set_gdbarch_long_bit (gdbarch, 4 * TARGET_CHAR_BIT);
1546   set_gdbarch_long_long_bit (gdbarch, 8 * TARGET_CHAR_BIT);
1547   /* NOTE: The d10v as a 32 bit ``float'' and ``double''. ``long
1548      double'' is 64 bits. */
1549   set_gdbarch_float_bit (gdbarch, 4 * TARGET_CHAR_BIT);
1550   set_gdbarch_double_bit (gdbarch, 4 * TARGET_CHAR_BIT);
1551   set_gdbarch_long_double_bit (gdbarch, 8 * TARGET_CHAR_BIT);
1552   switch (info.byte_order)
1553     {
1554     case BFD_ENDIAN_BIG:
1555       set_gdbarch_float_format (gdbarch, &floatformat_ieee_single_big);
1556       set_gdbarch_double_format (gdbarch, &floatformat_ieee_single_big);
1557       set_gdbarch_long_double_format (gdbarch, &floatformat_ieee_double_big);
1558       break;
1559     case BFD_ENDIAN_LITTLE:
1560       set_gdbarch_float_format (gdbarch, &floatformat_ieee_single_little);
1561       set_gdbarch_double_format (gdbarch, &floatformat_ieee_single_little);
1562       set_gdbarch_long_double_format (gdbarch, &floatformat_ieee_double_little);
1563       break;
1564     default:
1565       internal_error (__FILE__, __LINE__,
1566                       "d10v_gdbarch_init: bad byte order for float format");
1567     }
1568
1569   set_gdbarch_extract_return_value (gdbarch, d10v_extract_return_value);
1570   set_gdbarch_push_dummy_code (gdbarch, d10v_push_dummy_code);
1571   set_gdbarch_push_dummy_call (gdbarch, d10v_push_dummy_call);
1572   set_gdbarch_store_return_value (gdbarch, d10v_store_return_value);
1573   set_gdbarch_extract_struct_value_address (gdbarch, d10v_extract_struct_value_address);
1574   set_gdbarch_use_struct_convention (gdbarch, d10v_use_struct_convention);
1575
1576   set_gdbarch_skip_prologue (gdbarch, d10v_skip_prologue);
1577   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
1578   set_gdbarch_decr_pc_after_break (gdbarch, 4);
1579   set_gdbarch_function_start_offset (gdbarch, 0);
1580   set_gdbarch_breakpoint_from_pc (gdbarch, d10v_breakpoint_from_pc);
1581
1582   set_gdbarch_remote_translate_xfer_address (gdbarch, remote_d10v_translate_xfer_address);
1583
1584   set_gdbarch_frame_args_skip (gdbarch, 0);
1585   set_gdbarch_frameless_function_invocation (gdbarch, frameless_look_for_prologue);
1586
1587   set_gdbarch_frame_num_args (gdbarch, frame_num_args_unknown);
1588   set_gdbarch_frame_align (gdbarch, d10v_frame_align);
1589
1590   set_gdbarch_register_sim_regno (gdbarch, d10v_register_sim_regno);
1591
1592   set_gdbarch_print_registers_info (gdbarch, d10v_print_registers_info);
1593
1594   frame_unwind_append_predicate (gdbarch, d10v_frame_p);
1595   frame_base_set_default (gdbarch, &d10v_frame_base);
1596
1597   /* Methods for saving / extracting a dummy frame's ID.  */
1598   set_gdbarch_unwind_dummy_id (gdbarch, d10v_unwind_dummy_id);
1599   set_gdbarch_save_dummy_frame_tos (gdbarch, generic_save_dummy_frame_tos);
1600
1601   /* Return the unwound PC value.  */
1602   set_gdbarch_unwind_pc (gdbarch, d10v_unwind_pc);
1603
1604   set_gdbarch_print_insn (gdbarch, print_insn_d10v);
1605
1606   return gdbarch;
1607 }
1608
1609 void
1610 _initialize_d10v_tdep (void)
1611 {
1612   register_gdbarch_init (bfd_arch_d10v, d10v_gdbarch_init);
1613
1614   target_resume_hook = d10v_eva_prepare_to_trace;
1615   target_wait_loop_hook = d10v_eva_get_trace_data;
1616
1617   deprecate_cmd (add_com ("regs", class_vars, show_regs, "Print all registers"),
1618                  "info registers");
1619
1620   add_com ("itrace", class_support, trace_command,
1621            "Enable tracing of instruction execution.");
1622
1623   add_com ("iuntrace", class_support, untrace_command,
1624            "Disable tracing of instruction execution.");
1625
1626   add_com ("itdisassemble", class_vars, tdisassemble_command,
1627            "Disassemble the trace buffer.\n\
1628 Two optional arguments specify a range of trace buffer entries\n\
1629 as reported by info trace (NOT addresses!).");
1630
1631   add_info ("itrace", trace_info,
1632             "Display info about the trace data buffer.");
1633
1634   add_setshow_boolean_cmd ("itracedisplay", no_class, &trace_display,
1635                            "Set automatic display of trace.\n",
1636                            "Show automatic display of trace.\n",
1637                            NULL, NULL, &setlist, &showlist);
1638   add_setshow_boolean_cmd ("itracesource", no_class,
1639                            &default_trace_show_source,
1640                            "Set display of source code with trace.\n",
1641                            "Show display of source code with trace.\n",
1642                            NULL, NULL, &setlist, &showlist);
1643 }