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