gdb/d30v-tdep.c

   1 /* Target-dependent code for Mitsubishi D30V, 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, hunt@cygnus.com */
  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 "regcache.h"
  38
  39 #include "language.h" /* For local_hex_string() */
  40
  41 void d30v_frame_find_saved_regs (struct frame_info *fi,
  42                                  struct frame_saved_regs *fsr);
  43 void d30v_frame_find_saved_regs_offsets (struct frame_info *fi,
  44                                          struct frame_saved_regs *fsr);
  45 static void d30v_pop_dummy_frame (struct frame_info *fi);
  46 static void d30v_print_flags (void);
  47 static void print_flags_command (char *, int);
  48
  49 /* the following defines assume:
  50    fp is r61, lr is r62, sp is r63, and ?? is r22
  51    if that changes, they will need to be updated */
  52
  53 #define OP_MASK_ALL_BUT_RA      0x0ffc0fff      /* throw away Ra, keep the rest */
  54
  55 #define OP_STW_SPM              0x054c0fc0      /* stw Ra, @(sp-) */
  56 #define OP_STW_SP_R0            0x05400fc0      /* stw Ra, @(sp,r0) */
  57 #define OP_STW_SP_IMM0          0x05480fc0      /* st Ra, @(sp, 0x0) */
  58 #define OP_STW_R22P_R0          0x05440580      /* stw Ra, @(r22+,r0) */
  59
  60 #define OP_ST2W_SPM             0x056c0fc0      /* st2w Ra, @(sp-) */
  61 #define OP_ST2W_SP_R0           0x05600fc0      /* st2w Ra, @(sp, r0) */
  62 #define OP_ST2W_SP_IMM0         0x05680fc0      /* st2w Ra, @(sp, 0x0) */
  63 #define OP_ST2W_R22P_R0         0x05640580      /* st2w Ra, @(r22+, r0) */
  64
  65 #define OP_MASK_OPCODE          0x0ffc0000      /* just the opcode, ign operands */
  66 #define OP_NOP                  0x00f00000      /* nop */
  67
  68 #define OP_MASK_ALL_BUT_IMM     0x0fffffc0      /* throw away imm, keep the rest */
  69 #define OP_SUB_SP_IMM           0x082bffc0      /* sub sp,sp,imm */
  70 #define OP_ADD_SP_IMM           0x080bffc0      /* add sp,sp,imm */
  71 #define OP_ADD_R22_SP_IMM       0x08096fc0      /* add r22,sp,imm */
  72 #define OP_STW_FP_SP_IMM        0x054bdfc0      /* stw fp,@(sp,imm) */
  73 #define OP_OR_SP_R0_IMM         0x03abf000      /* or sp,r0,imm */
  74
  75 /* no mask */
  76 #define OP_OR_FP_R0_SP          0x03a3d03f      /* or fp,r0,sp */
  77 #define OP_OR_FP_SP_R0          0x03a3dfc0      /* or fp,sp,r0 */
  78 #define OP_OR_FP_IMM0_SP        0x03abd03f      /* or fp,0x0,sp */
  79 #define OP_STW_FP_R22P_R0       0x0547d580      /* stw fp,@(r22+,r0) */
  80 #define OP_STW_LR_R22P_R0       0x0547e580      /* stw lr,@(r22+,r0) */
  81
  82 #define OP_MASK_OP_AND_RB       0x0ff80fc0      /* keep op and rb,throw away rest */
  83 #define OP_STW_SP_IMM           0x05480fc0      /* stw Ra,@(sp,imm) */
  84 #define OP_ST2W_SP_IMM          0x05680fc0      /* st2w Ra,@(sp,imm) */
  85 #define OP_STW_FP_IMM           0x05480f40      /* stw Ra,@(fp,imm) */
  86 #define OP_STW_FP_R0            0x05400f40      /* stw Ra,@(fp,r0) */
  87
  88 #define OP_MASK_FM_BIT          0x80000000
  89 #define OP_MASK_CC_BITS         0x70000000
  90 #define OP_MASK_SUB_INST        0x0fffffff
  91
  92 #define EXTRACT_RA(op)          (((op) >> 12) & 0x3f)
  93 #define EXTRACT_RB(op)          (((op) >> 6) & 0x3f)
  94 #define EXTRACT_RC(op)          (((op) & 0x3f)
  95 #define EXTRACT_UIMM6(op)       ((op) & 0x3f)
  96 #define EXTRACT_IMM6(op)        ((((int)EXTRACT_UIMM6(op)) << 26) >> 26)
  97 #define EXTRACT_IMM26(op)       ((((op)&0x0ff00000) >> 2) | ((op)&0x0003ffff))
  98 #define EXTRACT_IMM32(opl, opr) ((EXTRACT_UIMM6(opl) << 26)|EXTRACT_IMM26(opr))
  99
 100
 101 int
 102 d30v_frame_chain_valid (CORE_ADDR chain, struct frame_info *fi)
 103 {
 104 #if 0
 105   return ((chain) != 0 && (fi) != 0 && (fi)->return_pc != 0);
 106 #else
 107   return ((chain) != 0 && (fi) != 0 && (fi)->frame <= chain);
 108 #endif
 109 }
 110
 111 /* Discard from the stack the innermost frame, restoring all saved
 112    registers.  */
 113
 114 void
 115 d30v_pop_frame (void)
 116 {
 117   struct frame_info *frame = get_current_frame ();
 118   CORE_ADDR fp;
 119   int regnum;
 120   struct frame_saved_regs fsr;
 121   char raw_buffer[8];
 122
 123   fp = FRAME_FP (frame);
 124   if (frame->dummy)
 125     {
 126       d30v_pop_dummy_frame (frame);
 127       return;
 128     }
 129
 130   /* fill out fsr with the address of where each */
 131   /* register was stored in the frame */
 132   get_frame_saved_regs (frame, &fsr);
 133
 134   /* now update the current registers with the old values */
 135   for (regnum = A0_REGNUM; regnum < A0_REGNUM + 2; regnum++)
 136     {
 137       if (fsr.regs[regnum])
 138         {
 139           read_memory (fsr.regs[regnum], raw_buffer, 8);
 140           write_register_bytes (REGISTER_BYTE (regnum), raw_buffer, 8);
 141         }
 142     }
 143   for (regnum = 0; regnum < SP_REGNUM; regnum++)
 144     {
 145       if (fsr.regs[regnum])
 146         {
 147           write_register (regnum, read_memory_unsigned_integer (fsr.regs[regnum], 4));
 148         }
 149     }
 150   if (fsr.regs[PSW_REGNUM])
 151     {
 152       write_register (PSW_REGNUM, read_memory_unsigned_integer (fsr.regs[PSW_REGNUM], 4));
 153     }
 154
 155   write_register (PC_REGNUM, read_register (LR_REGNUM));
 156   write_register (SP_REGNUM, fp + frame->size);
 157   target_store_registers (-1);
 158   flush_cached_frames ();
 159 }
 160
 161 static int
 162 check_prologue (unsigned long op)
 163 {
 164   /* add sp,sp,imm -- observed */
 165   if ((op & OP_MASK_ALL_BUT_IMM) == OP_ADD_SP_IMM)
 166     return 1;
 167
 168   /* add r22,sp,imm -- observed */
 169   if ((op & OP_MASK_ALL_BUT_IMM) == OP_ADD_R22_SP_IMM)
 170     return 1;
 171
 172   /* or  fp,r0,sp -- observed */
 173   if (op == OP_OR_FP_R0_SP)
 174     return 1;
 175
 176   /* nop */
 177   if ((op & OP_MASK_OPCODE) == OP_NOP)
 178     return 1;
 179
 180   /* stw  Ra,@(sp,r0) */
 181   if ((op & OP_MASK_ALL_BUT_RA) == OP_STW_SP_R0)
 182     return 1;
 183
 184   /* stw  Ra,@(sp,0x0) */
 185   if ((op & OP_MASK_ALL_BUT_RA) == OP_STW_SP_IMM0)
 186     return 1;
 187
 188   /* st2w  Ra,@(sp,r0) */
 189   if ((op & OP_MASK_ALL_BUT_RA) == OP_ST2W_SP_R0)
 190     return 1;
 191
 192   /* st2w  Ra,@(sp,0x0) */
 193   if ((op & OP_MASK_ALL_BUT_RA) == OP_ST2W_SP_IMM0)
 194     return 1;
 195
 196   /* stw fp, @(r22+,r0) -- observed */
 197   if (op == OP_STW_FP_R22P_R0)
 198     return 1;
 199
 200   /* stw r62, @(r22+,r0) -- observed */
 201   if (op == OP_STW_LR_R22P_R0)
 202     return 1;
 203
 204   /* stw Ra, @(fp,r0) -- observed */
 205   if ((op & OP_MASK_ALL_BUT_RA) == OP_STW_FP_R0)
 206     return 1;                   /* first arg */
 207
 208   /* stw Ra, @(fp,imm) -- observed */
 209   if ((op & OP_MASK_OP_AND_RB) == OP_STW_FP_IMM)
 210     return 1;                   /* second and subsequent args */
 211
 212   /* stw fp,@(sp,imm) -- observed */
 213   if ((op & OP_MASK_ALL_BUT_IMM) == OP_STW_FP_SP_IMM)
 214     return 1;
 215
 216   /* st2w Ra,@(r22+,r0) */
 217   if ((op & OP_MASK_ALL_BUT_RA) == OP_ST2W_R22P_R0)
 218     return 1;
 219
 220   /* stw  Ra, @(sp-) */
 221   if ((op & OP_MASK_ALL_BUT_RA) == OP_STW_SPM)
 222     return 1;
 223
 224   /* st2w  Ra, @(sp-) */
 225   if ((op & OP_MASK_ALL_BUT_RA) == OP_ST2W_SPM)
 226     return 1;
 227
 228   /* sub.?  sp,sp,imm */
 229   if ((op & OP_MASK_ALL_BUT_IMM) == OP_SUB_SP_IMM)
 230     return 1;
 231
 232   return 0;
 233 }
 234
 235 CORE_ADDR
 236 d30v_skip_prologue (CORE_ADDR pc)
 237 {
 238   unsigned long op[2];
 239   unsigned long opl, opr;       /* left / right sub operations */
 240   unsigned long fm0, fm1;       /* left / right mode bits */
 241   unsigned long cc0, cc1;
 242   unsigned long op1, op2;
 243   CORE_ADDR func_addr, func_end;
 244   struct symtab_and_line sal;
 245
 246   /* If we have line debugging information, then the end of the */
 247   /* prologue should the first assembly instruction of  the first source line */
 248   if (find_pc_partial_function (pc, NULL, &func_addr, &func_end))
 249     {
 250       sal = find_pc_line (func_addr, 0);
 251       if (sal.end && sal.end < func_end)
 252         return sal.end;
 253     }
 254
 255   if (target_read_memory (pc, (char *) &op[0], 8))
 256     return pc;                  /* Can't access it -- assume no prologue. */
 257
 258   while (1)
 259     {
 260       opl = (unsigned long) read_memory_integer (pc, 4);
 261       opr = (unsigned long) read_memory_integer (pc + 4, 4);
 262
 263       fm0 = (opl & OP_MASK_FM_BIT);
 264       fm1 = (opr & OP_MASK_FM_BIT);
 265
 266       cc0 = (opl & OP_MASK_CC_BITS);
 267       cc1 = (opr & OP_MASK_CC_BITS);
 268
 269       opl = (opl & OP_MASK_SUB_INST);
 270       opr = (opr & OP_MASK_SUB_INST);
 271
 272       if (fm0 && fm1)
 273         {
 274           /* long instruction (opl contains the opcode) */
 275           if (((opl & OP_MASK_ALL_BUT_IMM) != OP_ADD_SP_IMM) &&         /* add sp,sp,imm */
 276               ((opl & OP_MASK_ALL_BUT_IMM) != OP_ADD_R22_SP_IMM) &&     /* add r22,sp,imm */
 277               ((opl & OP_MASK_OP_AND_RB) != OP_STW_SP_IMM) &&   /* stw Ra, @(sp,imm) */
 278               ((opl & OP_MASK_OP_AND_RB) != OP_ST2W_SP_IMM))    /* st2w Ra, @(sp,imm) */
 279             break;
 280         }
 281       else
 282         {
 283           /* short instructions */
 284           if (fm0 && !fm1)
 285             {
 286               op1 = opr;
 287               op2 = opl;
 288             }
 289           else
 290             {
 291               op1 = opl;
 292               op2 = opr;
 293             }
 294           if (check_prologue (op1))
 295             {
 296               if (!check_prologue (op2))
 297                 {
 298                   /* if the previous opcode was really part of the prologue */
 299                   /* and not just a NOP, then we want to break after both instructions */
 300                   if ((op1 & OP_MASK_OPCODE) != OP_NOP)
 301                     pc += 8;
 302                   break;
 303                 }
 304             }
 305           else
 306             break;
 307         }
 308       pc += 8;
 309     }
 310   return pc;
 311 }
 312
 313 static int end_of_stack;
 314
 315 /* Given a GDB frame, determine the address of the calling function's frame.
 316    This will be used to create a new GDB frame struct, and then
 317    INIT_EXTRA_FRAME_INFO and INIT_FRAME_PC will be called for the new frame.
 318  */
 319
 320 CORE_ADDR
 321 d30v_frame_chain (struct frame_info *frame)
 322 {
 323   struct frame_saved_regs fsr;
 324
 325   d30v_frame_find_saved_regs (frame, &fsr);
 326
 327   if (end_of_stack)
 328     return (CORE_ADDR) 0;
 329
 330   if (frame->return_pc == IMEM_START)
 331     return (CORE_ADDR) 0;
 332
 333   if (!fsr.regs[FP_REGNUM])
 334     {
 335       if (!fsr.regs[SP_REGNUM] || fsr.regs[SP_REGNUM] == STACK_START)
 336         return (CORE_ADDR) 0;
 337
 338       return fsr.regs[SP_REGNUM];
 339     }
 340
 341   if (!read_memory_unsigned_integer (fsr.regs[FP_REGNUM], 4))
 342     return (CORE_ADDR) 0;
 343
 344   return read_memory_unsigned_integer (fsr.regs[FP_REGNUM], 4);
 345 }
 346
 347 static int next_addr, uses_frame;
 348 static int frame_size;
 349
 350 static int
 351 prologue_find_regs (unsigned long op, struct frame_saved_regs *fsr,
 352                     CORE_ADDR addr)
 353 {
 354   int n;
 355   int offset;
 356
 357   /* add sp,sp,imm -- observed */
 358   if ((op & OP_MASK_ALL_BUT_IMM) == OP_ADD_SP_IMM)
 359     {
 360       offset = EXTRACT_IMM6 (op);
 361       /*next_addr += offset; */
 362       frame_size += -offset;
 363       return 1;
 364     }
 365
 366   /* add r22,sp,imm -- observed */
 367   if ((op & OP_MASK_ALL_BUT_IMM) == OP_ADD_R22_SP_IMM)
 368     {
 369       offset = EXTRACT_IMM6 (op);
 370       next_addr = (offset - frame_size);
 371       return 1;
 372     }
 373
 374   /* stw Ra, @(fp, offset) -- observed */
 375   if ((op & OP_MASK_OP_AND_RB) == OP_STW_FP_IMM)
 376     {
 377       n = EXTRACT_RA (op);
 378       offset = EXTRACT_IMM6 (op);
 379       fsr->regs[n] = (offset - frame_size);
 380       return 1;
 381     }
 382
 383   /* stw Ra, @(fp, r0) -- observed */
 384   if ((op & OP_MASK_ALL_BUT_RA) == OP_STW_FP_R0)
 385     {
 386       n = EXTRACT_RA (op);
 387       fsr->regs[n] = (-frame_size);
 388       return 1;
 389     }
 390
 391   /* or  fp,0,sp -- observed */
 392   if ((op == OP_OR_FP_R0_SP) ||
 393       (op == OP_OR_FP_SP_R0) ||
 394       (op == OP_OR_FP_IMM0_SP))
 395     {
 396       uses_frame = 1;
 397       return 1;
 398     }
 399
 400   /* nop */
 401   if ((op & OP_MASK_OPCODE) == OP_NOP)
 402     return 1;
 403
 404   /* stw Ra,@(r22+,r0) -- observed */
 405   if ((op & OP_MASK_ALL_BUT_RA) == OP_STW_R22P_R0)
 406     {
 407       n = EXTRACT_RA (op);
 408       fsr->regs[n] = next_addr;
 409       next_addr += 4;
 410       return 1;
 411     }
 412 #if 0                           /* subsumed in pattern above */
 413   /* stw fp,@(r22+,r0) -- observed */
 414   if (op == OP_STW_FP_R22P_R0)
 415     {
 416       fsr->regs[FP_REGNUM] = next_addr;         /* XXX */
 417       next_addr += 4;
 418       return 1;
 419     }
 420
 421   /* stw r62,@(r22+,r0) -- observed */
 422   if (op == OP_STW_LR_R22P_R0)
 423     {
 424       fsr->regs[LR_REGNUM] = next_addr;
 425       next_addr += 4;
 426       return 1;
 427     }
 428 #endif
 429   /* st2w Ra,@(r22+,r0) -- observed */
 430   if ((op & OP_MASK_ALL_BUT_RA) == OP_ST2W_R22P_R0)
 431     {
 432       n = EXTRACT_RA (op);
 433       fsr->regs[n] = next_addr;
 434       fsr->regs[n + 1] = next_addr + 4;
 435       next_addr += 8;
 436       return 1;
 437     }
 438
 439   /* stw  rn, @(sp-) */
 440   if ((op & OP_MASK_ALL_BUT_RA) == OP_STW_SPM)
 441     {
 442       n = EXTRACT_RA (op);
 443       fsr->regs[n] = next_addr;
 444       next_addr -= 4;
 445       return 1;
 446     }
 447
 448   /* st2w  Ra, @(sp-) */
 449   else if ((op & OP_MASK_ALL_BUT_RA) == OP_ST2W_SPM)
 450     {
 451       n = EXTRACT_RA (op);
 452       fsr->regs[n] = next_addr;
 453       fsr->regs[n + 1] = next_addr + 4;
 454       next_addr -= 8;
 455       return 1;
 456     }
 457
 458   /* sub  sp,sp,imm */
 459   if ((op & OP_MASK_ALL_BUT_IMM) == OP_SUB_SP_IMM)
 460     {
 461       offset = EXTRACT_IMM6 (op);
 462       frame_size += -offset;
 463       return 1;
 464     }
 465
 466   /* st  rn, @(sp,0) -- observed */
 467   if (((op & OP_MASK_ALL_BUT_RA) == OP_STW_SP_R0) ||
 468       ((op & OP_MASK_ALL_BUT_RA) == OP_STW_SP_IMM0))
 469     {
 470       n = EXTRACT_RA (op);
 471       fsr->regs[n] = (-frame_size);
 472       return 1;
 473     }
 474
 475   /* st2w  rn, @(sp,0) */
 476   if (((op & OP_MASK_ALL_BUT_RA) == OP_ST2W_SP_R0) ||
 477       ((op & OP_MASK_ALL_BUT_RA) == OP_ST2W_SP_IMM0))
 478     {
 479       n = EXTRACT_RA (op);
 480       fsr->regs[n] = (-frame_size);
 481       fsr->regs[n + 1] = (-frame_size) + 4;
 482       return 1;
 483     }
 484
 485   /* stw fp,@(sp,imm) -- observed */
 486   if ((op & OP_MASK_ALL_BUT_IMM) == OP_STW_FP_SP_IMM)
 487     {
 488       offset = EXTRACT_IMM6 (op);
 489       fsr->regs[FP_REGNUM] = (offset - frame_size);
 490       return 1;
 491     }
 492   return 0;
 493 }
 494
 495 /* Put here the code to store, into a struct frame_saved_regs, the
 496    addresses of the saved registers of frame described by FRAME_INFO.
 497    This includes special registers such as pc and fp saved in special
 498    ways in the stack frame.  sp is even more special: the address we
 499    return for it IS the sp for the next frame. */
 500 void
 501 d30v_frame_find_saved_regs (struct frame_info *fi, struct frame_saved_regs *fsr)
 502 {
 503   CORE_ADDR fp, pc;
 504   unsigned long opl, opr;
 505   unsigned long op1, op2;
 506   unsigned long fm0, fm1;
 507   int i;
 508
 509   fp = fi->frame;
 510   memset (fsr, 0, sizeof (*fsr));
 511   next_addr = 0;
 512   frame_size = 0;
 513   end_of_stack = 0;
 514
 515   uses_frame = 0;
 516
 517   d30v_frame_find_saved_regs_offsets (fi, fsr);
 518
 519   fi->size = frame_size;
 520
 521   if (!fp)
 522     fp = read_register (SP_REGNUM);
 523
 524   for (i = 0; i < NUM_REGS - 1; i++)
 525     if (fsr->regs[i])
 526       {
 527         fsr->regs[i] = fsr->regs[i] + fp + frame_size;
 528       }
 529
 530   if (fsr->regs[LR_REGNUM])
 531     fi->return_pc = read_memory_unsigned_integer (fsr->regs[LR_REGNUM], 4);
 532   else
 533     fi->return_pc = read_register (LR_REGNUM);
 534
 535   /* the SP is not normally (ever?) saved, but check anyway */
 536   if (!fsr->regs[SP_REGNUM])
 537     {
 538       /* if the FP was saved, that means the current FP is valid, */
 539       /* otherwise, it isn't being used, so we use the SP instead */
 540       if (uses_frame)
 541         fsr->regs[SP_REGNUM] = read_register (FP_REGNUM) + fi->size;
 542       else
 543         {
 544           fsr->regs[SP_REGNUM] = fp + fi->size;
 545           fi->frameless = 1;
 546           fsr->regs[FP_REGNUM] = 0;
 547         }
 548     }
 549 }
 550
 551 void
 552 d30v_frame_find_saved_regs_offsets (struct frame_info *fi,
 553                                     struct frame_saved_regs *fsr)
 554 {
 555   CORE_ADDR fp, pc;
 556   unsigned long opl, opr;
 557   unsigned long op1, op2;
 558   unsigned long fm0, fm1;
 559   int i;
 560
 561   fp = fi->frame;
 562   memset (fsr, 0, sizeof (*fsr));
 563   next_addr = 0;
 564   frame_size = 0;
 565   end_of_stack = 0;
 566
 567   pc = get_pc_function_start (fi->pc);
 568
 569   uses_frame = 0;
 570   while (pc < fi->pc)
 571     {
 572       opl = (unsigned long) read_memory_integer (pc, 4);
 573       opr = (unsigned long) read_memory_integer (pc + 4, 4);
 574
 575       fm0 = (opl & OP_MASK_FM_BIT);
 576       fm1 = (opr & OP_MASK_FM_BIT);
 577
 578       opl = (opl & OP_MASK_SUB_INST);
 579       opr = (opr & OP_MASK_SUB_INST);
 580
 581       if (fm0 && fm1)
 582         {
 583           /* long instruction */
 584           if ((opl & OP_MASK_ALL_BUT_IMM) == OP_ADD_SP_IMM)
 585             {
 586               /* add sp,sp,n */
 587               long offset = EXTRACT_IMM32 (opl, opr);
 588               frame_size += -offset;
 589             }
 590           else if ((opl & OP_MASK_ALL_BUT_IMM) == OP_ADD_R22_SP_IMM)
 591             {
 592               /* add r22,sp,offset */
 593               long offset = EXTRACT_IMM32 (opl, opr);
 594               next_addr = (offset - frame_size);
 595             }
 596           else if ((opl & OP_MASK_OP_AND_RB) == OP_STW_SP_IMM)
 597             {
 598               /* st Ra, @(sp,imm) */
 599               long offset = EXTRACT_IMM32 (opl, opr);
 600               short n = EXTRACT_RA (opl);
 601               fsr->regs[n] = (offset - frame_size);
 602             }
 603           else if ((opl & OP_MASK_OP_AND_RB) == OP_ST2W_SP_IMM)
 604             {
 605               /* st2w Ra, @(sp,offset) */
 606               long offset = EXTRACT_IMM32 (opl, opr);
 607               short n = EXTRACT_RA (opl);
 608               fsr->regs[n] = (offset - frame_size);
 609               fsr->regs[n + 1] = (offset - frame_size) + 4;
 610             }
 611           else if ((opl & OP_MASK_ALL_BUT_IMM) == OP_OR_SP_R0_IMM)
 612             {
 613               end_of_stack = 1;
 614             }
 615           else
 616             break;
 617         }
 618       else
 619         {
 620           /* short instructions */
 621           if (fm0 && !fm1)
 622             {
 623               op2 = opl;
 624               op1 = opr;
 625             }
 626           else
 627             {
 628               op1 = opl;
 629               op2 = opr;
 630             }
 631           if (!prologue_find_regs (op1, fsr, pc) || !prologue_find_regs (op2, fsr, pc))
 632             break;
 633         }
 634       pc += 8;
 635     }
 636
 637 #if 0
 638   fi->size = frame_size;
 639
 640   if (!fp)
 641     fp = read_register (SP_REGNUM);
 642
 643   for (i = 0; i < NUM_REGS - 1; i++)
 644     if (fsr->regs[i])
 645       {
 646         fsr->regs[i] = fsr->regs[i] + fp + frame_size;
 647       }
 648
 649   if (fsr->regs[LR_REGNUM])
 650     fi->return_pc = read_memory_unsigned_integer (fsr->regs[LR_REGNUM], 4);
 651   else
 652     fi->return_pc = read_register (LR_REGNUM);
 653
 654   /* the SP is not normally (ever?) saved, but check anyway */
 655   if (!fsr->regs[SP_REGNUM])
 656     {
 657       /* if the FP was saved, that means the current FP is valid, */
 658       /* otherwise, it isn't being used, so we use the SP instead */
 659       if (uses_frame)
 660         fsr->regs[SP_REGNUM] = read_register (FP_REGNUM) + fi->size;
 661       else
 662         {
 663           fsr->regs[SP_REGNUM] = fp + fi->size;
 664           fi->frameless = 1;
 665           fsr->regs[FP_REGNUM] = 0;
 666         }
 667     }
 668 #endif
 669 }
 670
 671 void
 672 d30v_init_extra_frame_info (int fromleaf, struct frame_info *fi)
 673 {
 674   struct frame_saved_regs dummy;
 675
 676   if (fi->next && (fi->pc == 0))
 677     fi->pc = fi->next->return_pc;
 678
 679   d30v_frame_find_saved_regs_offsets (fi, &dummy);
 680
 681   if (uses_frame == 0)
 682     fi->frameless = 1;
 683   else
 684     fi->frameless = 0;
 685
 686   if ((fi->next == 0) && (uses_frame == 0))
 687     /* innermost frame and it's "frameless",
 688        so the fi->frame field is wrong, fix it! */
 689     fi->frame = read_sp ();
 690
 691   if (dummy.regs[LR_REGNUM])
 692     {
 693       /* it was saved, grab it! */
 694       dummy.regs[LR_REGNUM] += (fi->frame + frame_size);
 695       fi->return_pc = read_memory_unsigned_integer (dummy.regs[LR_REGNUM], 4);
 696     }
 697   else
 698     fi->return_pc = read_register (LR_REGNUM);
 699 }
 700
 701 void
 702 d30v_init_frame_pc (int fromleaf, struct frame_info *prev)
 703 {
 704   /* default value, put here so we can breakpoint on it and
 705      see if the default value is really the right thing to use */
 706   prev->pc = (fromleaf ? SAVED_PC_AFTER_CALL (prev->next) : \
 707               prev->next ? FRAME_SAVED_PC (prev->next) : read_pc ());
 708 }
 709
 710 static void d30v_print_register (int regnum, int tabular);
 711
 712 static void
 713 d30v_print_register (int regnum, int tabular)
 714 {
 715   if (regnum < A0_REGNUM)
 716     {
 717       if (tabular)
 718         printf_filtered ("%08lx", (long) read_register (regnum));
 719       else
 720         printf_filtered ("0x%lx %ld",
 721                          (long) read_register (regnum),
 722                          (long) read_register (regnum));
 723     }
 724   else
 725     {
 726       char regbuf[MAX_REGISTER_RAW_SIZE];
 727
 728       read_relative_register_raw_bytes (regnum, regbuf);
 729
 730       val_print (REGISTER_VIRTUAL_TYPE (regnum), regbuf, 0, 0,
 731                  gdb_stdout, 'x', 1, 0, Val_pretty_default);
 732
 733       if (!tabular)
 734         {
 735           printf_filtered ("    ");
 736           val_print (REGISTER_VIRTUAL_TYPE (regnum), regbuf, 0, 0,
 737                      gdb_stdout, 'd', 1, 0, Val_pretty_default);
 738         }
 739     }
 740 }
 741
 742 static void
 743 d30v_print_flags (void)
 744 {
 745   long psw = read_register (PSW_REGNUM);
 746   printf_filtered ("flags #1");
 747   printf_filtered ("   (sm) %d", (psw & PSW_SM) != 0);
 748   printf_filtered ("   (ea) %d", (psw & PSW_EA) != 0);
 749   printf_filtered ("   (db) %d", (psw & PSW_DB) != 0);
 750   printf_filtered ("   (ds) %d", (psw & PSW_DS) != 0);
 751   printf_filtered ("   (ie) %d", (psw & PSW_IE) != 0);
 752   printf_filtered ("   (rp) %d", (psw & PSW_RP) != 0);
 753   printf_filtered ("   (md) %d\n", (psw & PSW_MD) != 0);
 754
 755   printf_filtered ("flags #2");
 756   printf_filtered ("   (f0) %d", (psw & PSW_F0) != 0);
 757   printf_filtered ("   (f1) %d", (psw & PSW_F1) != 0);
 758   printf_filtered ("   (f2) %d", (psw & PSW_F2) != 0);
 759   printf_filtered ("   (f3) %d", (psw & PSW_F3) != 0);
 760   printf_filtered ("    (s) %d", (psw & PSW_S) != 0);
 761   printf_filtered ("    (v) %d", (psw & PSW_V) != 0);
 762   printf_filtered ("   (va) %d", (psw & PSW_VA) != 0);
 763   printf_filtered ("    (c) %d\n", (psw & PSW_C) != 0);
 764 }
 765
 766 static void
 767 print_flags_command (char *args, int from_tty)
 768 {
 769   d30v_print_flags ();
 770 }
 771
 772 void
 773 d30v_do_registers_info (int regnum, int fpregs)
 774 {
 775   long long num1, num2;
 776   long psw;
 777
 778   if (regnum != -1)
 779     {
 780       if (REGISTER_NAME (0) == NULL || REGISTER_NAME (0)[0] == '\000')
 781         return;
 782
 783       printf_filtered ("%s ", REGISTER_NAME (regnum));
 784       d30v_print_register (regnum, 0);
 785
 786       printf_filtered ("\n");
 787       return;
 788     }
 789
 790   /* Have to print all the registers.  Format them nicely.  */
 791
 792   printf_filtered ("PC=");
 793   print_address (read_pc (), gdb_stdout);
 794
 795   printf_filtered (" PSW=");
 796   d30v_print_register (PSW_REGNUM, 1);
 797
 798   printf_filtered (" BPC=");
 799   print_address (read_register (BPC_REGNUM), gdb_stdout);
 800
 801   printf_filtered (" BPSW=");
 802   d30v_print_register (BPSW_REGNUM, 1);
 803   printf_filtered ("\n");
 804
 805   printf_filtered ("DPC=");
 806   print_address (read_register (DPC_REGNUM), gdb_stdout);
 807
 808   printf_filtered (" DPSW=");
 809   d30v_print_register (DPSW_REGNUM, 1);
 810
 811   printf_filtered (" IBA=");
 812   print_address (read_register (IBA_REGNUM), gdb_stdout);
 813   printf_filtered ("\n");
 814
 815   printf_filtered ("RPT_C=");
 816   d30v_print_register (RPT_C_REGNUM, 1);
 817
 818   printf_filtered (" RPT_S=");
 819   print_address (read_register (RPT_S_REGNUM), gdb_stdout);
 820
 821   printf_filtered (" RPT_E=");
 822   print_address (read_register (RPT_E_REGNUM), gdb_stdout);
 823   printf_filtered ("\n");
 824
 825   printf_filtered ("MOD_S=");
 826   print_address (read_register (MOD_S_REGNUM), gdb_stdout);
 827
 828   printf_filtered (" MOD_E=");
 829   print_address (read_register (MOD_E_REGNUM), gdb_stdout);
 830   printf_filtered ("\n");
 831
 832   printf_filtered ("EIT_VB=");
 833   print_address (read_register (EIT_VB_REGNUM), gdb_stdout);
 834
 835   printf_filtered (" INT_S=");
 836   d30v_print_register (INT_S_REGNUM, 1);
 837
 838   printf_filtered (" INT_M=");
 839   d30v_print_register (INT_M_REGNUM, 1);
 840   printf_filtered ("\n");
 841
 842   d30v_print_flags ();
 843   for (regnum = 0; regnum <= 63;)
 844     {
 845       int i;
 846
 847       printf_filtered ("R%d-R%d ", regnum, regnum + 7);
 848       if (regnum < 10)
 849         printf_filtered (" ");
 850       if (regnum + 7 < 10)
 851         printf_filtered (" ");
 852
 853       for (i = 0; i < 8; i++)
 854         {
 855           printf_filtered (" ");
 856           d30v_print_register (regnum++, 1);
 857         }
 858
 859       printf_filtered ("\n");
 860     }
 861
 862   printf_filtered ("A0-A1    ");
 863
 864   d30v_print_register (A0_REGNUM, 1);
 865   printf_filtered ("    ");
 866   d30v_print_register (A1_REGNUM, 1);
 867   printf_filtered ("\n");
 868 }
 869
 870 CORE_ADDR
 871 d30v_fix_call_dummy (char *dummyname, CORE_ADDR start_sp, CORE_ADDR fun,
 872                      int nargs, value_ptr *args, struct type *type, int gcc_p)
 873 {
 874   int regnum;
 875   CORE_ADDR sp;
 876   char buffer[MAX_REGISTER_RAW_SIZE];
 877   struct frame_info *frame = get_current_frame ();
 878   frame->dummy = start_sp;
 879   /*start_sp |= DMEM_START; */
 880
 881   sp = start_sp;
 882   for (regnum = 0; regnum < NUM_REGS; regnum++)
 883     {
 884       sp -= REGISTER_RAW_SIZE (regnum);
 885       store_address (buffer, REGISTER_RAW_SIZE (regnum), read_register (regnum));
 886       write_memory (sp, buffer, REGISTER_RAW_SIZE (regnum));
 887     }
 888   write_register (SP_REGNUM, (LONGEST) sp);
 889   /* now we need to load LR with the return address */
 890   write_register (LR_REGNUM, (LONGEST) d30v_call_dummy_address ());
 891   return sp;
 892 }
 893
 894 static void
 895 d30v_pop_dummy_frame (struct frame_info *fi)
 896 {
 897   CORE_ADDR sp = fi->dummy;
 898   int regnum;
 899
 900   for (regnum = 0; regnum < NUM_REGS; regnum++)
 901     {
 902       sp -= REGISTER_RAW_SIZE (regnum);
 903       write_register (regnum, read_memory_unsigned_integer (sp, REGISTER_RAW_SIZE (regnum)));
 904     }
 905   flush_cached_frames ();       /* needed? */
 906 }
 907
 908
 909 CORE_ADDR
 910 d30v_push_arguments (int nargs, value_ptr *args, CORE_ADDR sp,
 911                      int struct_return, CORE_ADDR struct_addr)
 912 {
 913   int i, len, index = 0, regnum = 2;
 914   char buffer[4], *contents;
 915   LONGEST val;
 916   CORE_ADDR ptrs[10];
 917
 918 #if 0
 919   /* Pass 1. Put all large args on stack */
 920   for (i = 0; i < nargs; i++)
 921     {
 922       value_ptr arg = args[i];
 923       struct type *arg_type = check_typedef (VALUE_TYPE (arg));
 924       len = TYPE_LENGTH (arg_type);
 925       contents = VALUE_CONTENTS (arg);
 926       val = extract_signed_integer (contents, len);
 927       if (len > 4)
 928         {
 929           /* put on stack and pass pointers */
 930           sp -= len;
 931           write_memory (sp, contents, len);
 932           ptrs[index++] = sp;
 933         }
 934     }
 935 #endif
 936   index = 0;
 937
 938   for (i = 0; i < nargs; i++)
 939     {
 940       value_ptr arg = args[i];
 941       struct type *arg_type = check_typedef (VALUE_TYPE (arg));
 942       len = TYPE_LENGTH (arg_type);
 943       contents = VALUE_CONTENTS (arg);
 944       if (len > 4)
 945         {
 946           /* we need multiple registers */
 947           int ndx;
 948
 949           for (ndx = 0; len > 0; ndx += 8, len -= 8)
 950             {
 951               if (regnum & 1)
 952                 regnum++;       /* all args > 4 bytes start in even register */
 953
 954               if (regnum < 18)
 955                 {
 956                   val = extract_signed_integer (&contents[ndx], 4);
 957                   write_register (regnum++, val);
 958
 959                   if (len >= 8)
 960                     val = extract_signed_integer (&contents[ndx + 4], 4);
 961                   else
 962                     val = extract_signed_integer (&contents[ndx + 4], len - 4);
 963                   write_register (regnum++, val);
 964                 }
 965               else
 966                 {
 967                   /* no more registers available.  put it on the stack */
 968
 969                   /* all args > 4 bytes are padded to a multiple of 8 bytes
 970                      and start on an 8 byte boundary */
 971                   if (sp & 7)
 972                     sp -= (sp & 7);     /* align it */
 973
 974                   sp -= ((len + 7) & ~7);       /* allocate space */
 975                   write_memory (sp, &contents[ndx], len);
 976                   break;
 977                 }
 978             }
 979         }
 980       else
 981         {
 982           if (regnum < 18)
 983             {
 984               val = extract_signed_integer (contents, len);
 985               write_register (regnum++, val);
 986             }
 987           else
 988             {
 989               /* all args are padded to a multiple of 4 bytes (at least) */
 990               sp -= ((len + 3) & ~3);
 991               write_memory (sp, contents, len);
 992             }
 993         }
 994     }
 995   if (sp & 7)
 996     /* stack pointer is not on an 8 byte boundary -- align it */
 997     sp -= (sp & 7);
 998   return sp;
 999 }
1000
1001
1002 /* pick an out-of-the-way place to set the return value */
1003 /* for an inferior function call.  The link register is set to this  */
1004 /* value and a momentary breakpoint is set there.  When the breakpoint */
1005 /* is hit, the dummy frame is popped and the previous environment is */
1006 /* restored. */
1007
1008 CORE_ADDR
1009 d30v_call_dummy_address (void)
1010 {
1011   CORE_ADDR entry;
1012   struct minimal_symbol *sym;
1013
1014   entry = entry_point_address ();
1015
1016   if (entry != 0)
1017     return entry;
1018
1019   sym = lookup_minimal_symbol ("_start", NULL, symfile_objfile);
1020
1021   if (!sym || MSYMBOL_TYPE (sym) != mst_text)
1022     return 0;
1023   else
1024     return SYMBOL_VALUE_ADDRESS (sym);
1025 }
1026
1027 /* Given a return value in `regbuf' with a type `valtype',
1028    extract and copy its value into `valbuf'.  */
1029
1030 void
1031 d30v_extract_return_value (struct type *valtype, char regbuf[REGISTER_BYTES],
1032                            char *valbuf)
1033 {
1034   memcpy (valbuf, regbuf + REGISTER_BYTE (2), TYPE_LENGTH (valtype));
1035 }
1036
1037 /* The following code implements access to, and display of, the D30V's
1038    instruction trace buffer.  The buffer consists of 64K or more
1039    4-byte words of data, of which each words includes an 8-bit count,
1040    an 8-bit segment number, and a 16-bit instruction address.
1041
1042    In theory, the trace buffer is continuously capturing instruction
1043    data that the CPU presents on its "debug bus", but in practice, the
1044    ROMified GDB stub only enables tracing when it continues or steps
1045    the program, and stops tracing when the program stops; so it
1046    actually works for GDB to read the buffer counter out of memory and
1047    then read each trace word.  The counter records where the tracing
1048    stops, but there is no record of where it started, so we remember
1049    the PC when we resumed and then search backwards in the trace
1050    buffer for a word that includes that address.  This is not perfect,
1051    because you will miss trace data if the resumption PC is the target
1052    of a branch.  (The value of the buffer counter is semi-random, any
1053    trace data from a previous program stop is gone.)  */
1054
1055 /* The address of the last word recorded in the trace buffer.  */
1056
1057 #define DBBC_ADDR (0xd80000)
1058
1059 /* The base of the trace buffer, at least for the "Board_0".  */
1060
1061 #define TRACE_BUFFER_BASE (0xf40000)
1062
1063 static void trace_command (char *, int);
1064
1065 static void untrace_command (char *, int);
1066
1067 static void trace_info (char *, int);
1068
1069 static void tdisassemble_command (char *, int);
1070
1071 static void display_trace (int, int);
1072
1073 /* True when instruction traces are being collected.  */
1074
1075 static int tracing;
1076
1077 /* Remembered PC.  */
1078
1079 static CORE_ADDR last_pc;
1080
1081 /* True when trace output should be displayed whenever program stops.  */
1082
1083 static int trace_display;
1084
1085 /* True when trace listing should include source lines.  */
1086
1087 static int default_trace_show_source = 1;
1088
1089 struct trace_buffer
1090   {
1091     int size;
1092     short *counts;
1093     CORE_ADDR *addrs;
1094   }
1095 trace_data;
1096
1097 static void
1098 trace_command (char *args, int from_tty)
1099 {
1100   /* Clear the host-side trace buffer, allocating space if needed.  */
1101   trace_data.size = 0;
1102   if (trace_data.counts == NULL)
1103     trace_data.counts = (short *) xmalloc (65536 * sizeof (short));
1104   if (trace_data.addrs == NULL)
1105     trace_data.addrs = (CORE_ADDR *) xmalloc (65536 * sizeof (CORE_ADDR));
1106
1107   tracing = 1;
1108
1109   printf_filtered ("Tracing is now on.\n");
1110 }
1111
1112 static void
1113 untrace_command (char *args, int from_tty)
1114 {
1115   tracing = 0;
1116
1117   printf_filtered ("Tracing is now off.\n");
1118 }
1119
1120 static void
1121 trace_info (char *args, int from_tty)
1122 {
1123   int i;
1124
1125   if (trace_data.size)
1126     {
1127       printf_filtered ("%d entries in trace buffer:\n", trace_data.size);
1128
1129       for (i = 0; i < trace_data.size; ++i)
1130         {
1131           printf_filtered ("%d: %d instruction%s at 0x%s\n",
1132                            i, trace_data.counts[i],
1133                            (trace_data.counts[i] == 1 ? "" : "s"),
1134                            paddr_nz (trace_data.addrs[i]));
1135         }
1136     }
1137   else
1138     printf_filtered ("No entries in trace buffer.\n");
1139
1140   printf_filtered ("Tracing is currently %s.\n", (tracing ? "on" : "off"));
1141 }
1142
1143 /* Print the instruction at address MEMADDR in debugged memory,
1144    on STREAM.  Returns length of the instruction, in bytes.  */
1145
1146 static int
1147 print_insn (CORE_ADDR memaddr, struct ui_file *stream)
1148 {
1149   /* If there's no disassembler, something is very wrong.  */
1150   if (tm_print_insn == NULL)
1151     internal_error (__FILE__, __LINE__,
1152                     "print_insn: no disassembler");
1153
1154   if (TARGET_BYTE_ORDER == BIG_ENDIAN)
1155     tm_print_insn_info.endian = BFD_ENDIAN_BIG;
1156   else
1157     tm_print_insn_info.endian = BFD_ENDIAN_LITTLE;
1158   return (*tm_print_insn) (memaddr, &tm_print_insn_info);
1159 }
1160
1161 void
1162 d30v_eva_prepare_to_trace (void)
1163 {
1164   if (!tracing)
1165     return;
1166
1167   last_pc = read_register (PC_REGNUM);
1168 }
1169
1170 /* Collect trace data from the target board and format it into a form
1171    more useful for display.  */
1172
1173 void
1174 d30v_eva_get_trace_data (void)
1175 {
1176   int count, i, j, oldsize;
1177   int trace_addr, trace_seg, trace_cnt, next_cnt;
1178   unsigned int last_trace, trace_word, next_word;
1179   unsigned int *tmpspace;
1180
1181   if (!tracing)
1182     return;
1183
1184   tmpspace = xmalloc (65536 * sizeof (unsigned int));
1185
1186   last_trace = read_memory_unsigned_integer (DBBC_ADDR, 2) << 2;
1187
1188   /* Collect buffer contents from the target, stopping when we reach
1189      the word recorded when execution resumed.  */
1190
1191   count = 0;
1192   while (last_trace > 0)
1193     {
1194       QUIT;
1195       trace_word =
1196         read_memory_unsigned_integer (TRACE_BUFFER_BASE + last_trace, 4);
1197       trace_addr = trace_word & 0xffff;
1198       last_trace -= 4;
1199       /* Ignore an apparently nonsensical entry.  */
1200       if (trace_addr == 0xffd5)
1201         continue;
1202       tmpspace[count++] = trace_word;
1203       if (trace_addr == last_pc)
1204         break;
1205       if (count > 65535)
1206         break;
1207     }
1208
1209   /* Move the data to the host-side trace buffer, adjusting counts to
1210      include the last instruction executed and transforming the address
1211      into something that GDB likes.  */
1212
1213   for (i = 0; i < count; ++i)
1214     {
1215       trace_word = tmpspace[i];
1216       next_word = ((i == 0) ? 0 : tmpspace[i - 1]);
1217       trace_addr = trace_word & 0xffff;
1218       next_cnt = (next_word >> 24) & 0xff;
1219       j = trace_data.size + count - i - 1;
1220       trace_data.addrs[j] = (trace_addr << 2) + 0x1000000;
1221       trace_data.counts[j] = next_cnt + 1;
1222     }
1223
1224   oldsize = trace_data.size;
1225   trace_data.size += count;
1226
1227   xfree (tmpspace);
1228
1229   if (trace_display)
1230     display_trace (oldsize, trace_data.size);
1231 }
1232
1233 static void
1234 tdisassemble_command (char *arg, int from_tty)
1235 {
1236   int i, count;
1237   CORE_ADDR low, high;
1238   char *space_index;
1239
1240   if (!arg)
1241     {
1242       low = 0;
1243       high = trace_data.size;
1244     }
1245   else if (!(space_index = (char *) strchr (arg, ' ')))
1246     {
1247       low = parse_and_eval_address (arg);
1248       high = low + 5;
1249     }
1250   else
1251     {
1252       /* Two arguments.  */
1253       *space_index = '\0';
1254       low = parse_and_eval_address (arg);
1255       high = parse_and_eval_address (space_index + 1);
1256       if (high < low)
1257         high = low;
1258     }
1259
1260   printf_filtered ("Dump of trace from %s to %s:\n",
1261                    paddr_u (low),
1262                    paddr_u (high));
1263
1264   display_trace (low, high);
1265
1266   printf_filtered ("End of trace dump.\n");
1267   gdb_flush (gdb_stdout);
1268 }
1269
1270 static void
1271 display_trace (int low, int high)
1272 {
1273   int i, count, trace_show_source, first, suppress;
1274   CORE_ADDR next_address;
1275
1276   trace_show_source = default_trace_show_source;
1277   if (!have_full_symbols () && !have_partial_symbols ())
1278     {
1279       trace_show_source = 0;
1280       printf_filtered ("No symbol table is loaded.  Use the \"file\" command.\n");
1281       printf_filtered ("Trace will not display any source.\n");
1282     }
1283
1284   first = 1;
1285   suppress = 0;
1286   for (i = low; i < high; ++i)
1287     {
1288       next_address = trace_data.addrs[i];
1289       count = trace_data.counts[i];
1290       while (count-- > 0)
1291         {
1292           QUIT;
1293           if (trace_show_source)
1294             {
1295               struct symtab_and_line sal, sal_prev;
1296
1297               sal_prev = find_pc_line (next_address - 4, 0);
1298               sal = find_pc_line (next_address, 0);
1299
1300               if (sal.symtab)
1301                 {
1302                   if (first || sal.line != sal_prev.line)
1303                     print_source_lines (sal.symtab, sal.line, sal.line + 1, 0);
1304                   suppress = 0;
1305                 }
1306               else
1307                 {
1308                   if (!suppress)
1309                     /* FIXME-32x64--assumes sal.pc fits in long.  */
1310                     printf_filtered ("No source file for address %s.\n",
1311                                  local_hex_string ((unsigned long) sal.pc));
1312                   suppress = 1;
1313                 }
1314             }
1315           first = 0;
1316           print_address (next_address, gdb_stdout);
1317           printf_filtered (":");
1318           printf_filtered ("\t");
1319           wrap_here ("    ");
1320           next_address = next_address + print_insn (next_address, gdb_stdout);
1321           printf_filtered ("\n");
1322           gdb_flush (gdb_stdout);
1323         }
1324     }
1325 }
1326
1327 extern void (*target_resume_hook) (void);
1328 extern void (*target_wait_loop_hook) (void);
1329
1330 void
1331 _initialize_d30v_tdep (void)
1332 {
1333   tm_print_insn = print_insn_d30v;
1334
1335   target_resume_hook = d30v_eva_prepare_to_trace;
1336   target_wait_loop_hook = d30v_eva_get_trace_data;
1337
1338   add_info ("flags", print_flags_command, "Print d30v flags.");
1339
1340   add_com ("trace", class_support, trace_command,
1341            "Enable tracing of instruction execution.");
1342
1343   add_com ("untrace", class_support, untrace_command,
1344            "Disable tracing of instruction execution.");
1345
1346   add_com ("tdisassemble", class_vars, tdisassemble_command,
1347            "Disassemble the trace buffer.\n\
1348 Two optional arguments specify a range of trace buffer entries\n\
1349 as reported by info trace (NOT addresses!).");
1350
1351   add_info ("trace", trace_info,
1352             "Display info about the trace data buffer.");
1353
1354   add_show_from_set (add_set_cmd ("tracedisplay", no_class,
1355                                   var_integer, (char *) &trace_display,
1356                              "Set automatic display of trace.\n", &setlist),
1357                      &showlist);
1358   add_show_from_set (add_set_cmd ("tracesource", no_class,
1359                            var_integer, (char *) &default_trace_show_source,
1360                       "Set display of source code with trace.\n", &setlist),
1361                      &showlist);
1362
1363 }