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