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