gdb/d10v-tdep.c

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