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