projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Fix typo.
[deliverable/binutils-gdb.git] / gdb / d30v-tdep.c
CommitLineData
c906108c 1/* Target-dependent code for Mitsubishi D30V, for GDB.
b6ba6518
KB		 2 Copyright 1996, 1997, 1998, 1999, 2000, 2001
3 Free Software Foundation, Inc.
c906108c 4
c5aa993b 5 This file is part of GDB.
c906108c 6
c5aa993b
JM		 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.
c906108c 11
c5aa993b
JM		 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.
c906108c 16
c5aa993b
JM		 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. */
c906108c
SS		 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"
c5aa993b 34#include "dis-asm.h"
c906108c
SS		 35#include "symfile.h"
36#include "objfiles.h"
4e052eda 37#include "regcache.h"
c906108c 38
d4f3574e
SS		 39#include "language.h" /* For local_hex_string() */
40
a14ed312
KB		 41void d30v_frame_find_saved_regs (struct frame_info *fi,
42 struct frame_saved_regs *fsr);
43void d30v_frame_find_saved_regs_offsets (struct frame_info *fi,
44 struct frame_saved_regs *fsr);
45static void d30v_pop_dummy_frame (struct frame_info *fi);
46static void d30v_print_flags (void);
47static void print_flags_command (char *, int);
c906108c
SS		 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
c5aa993b 53#define OP_MASK_ALL_BUT_RA 0x0ffc0fff /* throw away Ra, keep the rest */
c906108c 54
c5aa993b
JM		 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) */
c906108c 59
c5aa993b
JM		 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) */
c906108c 64
c5aa993b
JM		 65#define OP_MASK_OPCODE 0x0ffc0000 /* just the opcode, ign operands */
66#define OP_NOP 0x00f00000 /* nop */
c906108c 67
c5aa993b
JM		 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 */
c906108c
SS		 74
75/* no mask */
c5aa993b
JM		 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) */
c906108c
SS		 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
101int
72623009 102d30v_frame_chain_valid (CORE_ADDR chain, struct frame_info *fi)
c906108c
SS		 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
114void
fba45db2 115d30v_pop_frame (void)
c906108c
SS		 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 {
c5aa993b 126 d30v_pop_dummy_frame (frame);
c906108c
SS		 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);
c5aa993b 133
c906108c 134 /* now update the current registers with the old values */
c5aa993b 135 for (regnum = A0_REGNUM; regnum < A0_REGNUM + 2; regnum++)
c906108c
SS		 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
c5aa993b 155 write_register (PC_REGNUM, read_register (LR_REGNUM));
c906108c
SS		 156 write_register (SP_REGNUM, fp + frame->size);
157 target_store_registers (-1);
158 flush_cached_frames ();
159}
160
c5aa993b 161static int
fba45db2 162check_prologue (unsigned long op)
c906108c
SS		 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) */
c5aa993b
JM		 189 if ((op & OP_MASK_ALL_BUT_RA) == OP_ST2W_SP_R0)
190 return 1;
c906108c
SS		 191
192 /* st2w Ra,@(sp,0x0) */
c5aa993b
JM		 193 if ((op & OP_MASK_ALL_BUT_RA) == OP_ST2W_SP_IMM0)
194 return 1;
c906108c 195
c5aa993b
JM		 196 /* stw fp, @(r22+,r0) -- observed */
197 if (op == OP_STW_FP_R22P_R0)
198 return 1;
c906108c 199
c5aa993b
JM		 200 /* stw r62, @(r22+,r0) -- observed */
201 if (op == OP_STW_LR_R22P_R0)
202 return 1;
c906108c 203
c5aa993b
JM		 204 /* stw Ra, @(fp,r0) -- observed */
205 if ((op & OP_MASK_ALL_BUT_RA) == OP_STW_FP_R0)
206 return 1; /* first arg */
c906108c 207
c5aa993b
JM		 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 */
c906108c 211
c5aa993b
JM		 212 /* stw fp,@(sp,imm) -- observed */
213 if ((op & OP_MASK_ALL_BUT_IMM) == OP_STW_FP_SP_IMM)
214 return 1;
c906108c 215
c5aa993b
JM		 216 /* st2w Ra,@(r22+,r0) */
217 if ((op & OP_MASK_ALL_BUT_RA) == OP_ST2W_R22P_R0)
218 return 1;
c906108c
SS		 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
235CORE_ADDR
fba45db2 236d30v_skip_prologue (CORE_ADDR pc)
c906108c
SS		 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);
c5aa993b 251 if (sal.end && sal.end < func_end)
c906108c
SS		 252 return sal.end;
253 }
c5aa993b
JM		 254
255 if (target_read_memory (pc, (char *) &op[0], 8))
c906108c
SS		 256 return pc; /* Can't access it -- assume no prologue. */
257
258 while (1)
259 {
c5aa993b
JM		 260 opl = (unsigned long) read_memory_integer (pc, 4);
261 opr = (unsigned long) read_memory_integer (pc + 4, 4);
c906108c
SS		 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) */
c5aa993b
JM		 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) */
c906108c
SS		 279 break;
280 }
281 else
282 {
283 /* short instructions */
284 if (fm0 && !fm1)
285 {
286 op1 = opr;
287 op2 = opl;
c5aa993b
JM		 288 }
289 else
c906108c
SS		 290 {
291 op1 = opl;
292 op2 = opr;
293 }
c5aa993b 294 if (check_prologue (op1))
c906108c 295 {
c5aa993b 296 if (!check_prologue (op2))
c906108c
SS		 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
313static 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.
c5aa993b 318 */
c906108c
SS		 319
320CORE_ADDR
fba45db2 321d30v_frame_chain (struct frame_info *frame)
c906108c
SS		 322{
323 struct frame_saved_regs fsr;
324
325 d30v_frame_find_saved_regs (frame, &fsr);
326
327 if (end_of_stack)
c5aa993b 328 return (CORE_ADDR) 0;
c906108c
SS		 329
330 if (frame->return_pc == IMEM_START)
c5aa993b 331 return (CORE_ADDR) 0;
c906108c
SS		 332
333 if (!fsr.regs[FP_REGNUM])
334 {
335 if (!fsr.regs[SP_REGNUM] || fsr.regs[SP_REGNUM] == STACK_START)
c5aa993b
JM		 336 return (CORE_ADDR) 0;
337
c906108c
SS		 338 return fsr.regs[SP_REGNUM];
339 }
340
c5aa993b
JM		 341 if (!read_memory_unsigned_integer (fsr.regs[FP_REGNUM], 4))
342 return (CORE_ADDR) 0;
c906108c 343
c5aa993b
JM		 344 return read_memory_unsigned_integer (fsr.regs[FP_REGNUM], 4);
345}
c906108c
SS		 346
347static int next_addr, uses_frame;
348static int frame_size;
349
c5aa993b 350static int
fba45db2
KB		 351prologue_find_regs (unsigned long op, struct frame_saved_regs *fsr,
352 CORE_ADDR addr)
c906108c
SS		 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 {
c5aa993b
JM		 360 offset = EXTRACT_IMM6 (op);
361 /*next_addr += offset; */
c906108c
SS		 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 {
c5aa993b 369 offset = EXTRACT_IMM6 (op);
c906108c
SS		 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 {
c5aa993b
JM		 377 n = EXTRACT_RA (op);
378 offset = EXTRACT_IMM6 (op);
c906108c
SS		 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 {
c5aa993b
JM		 386 n = EXTRACT_RA (op);
387 fsr->regs[n] = (-frame_size);
c906108c
SS		 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 {
c5aa993b 407 n = EXTRACT_RA (op);
c906108c
SS		 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 {
c5aa993b 416 fsr->regs[FP_REGNUM] = next_addr; /* XXX */
c906108c
SS		 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 {
c5aa993b 432 n = EXTRACT_RA (op);
c906108c 433 fsr->regs[n] = next_addr;
c5aa993b 434 fsr->regs[n + 1] = next_addr + 4;
c906108c
SS		 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 {
c5aa993b 442 n = EXTRACT_RA (op);
c906108c
SS		 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 {
c5aa993b 451 n = EXTRACT_RA (op);
c906108c 452 fsr->regs[n] = next_addr;
c5aa993b 453 fsr->regs[n + 1] = next_addr + 4;
c906108c
SS		 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 {
c5aa993b 461 offset = EXTRACT_IMM6 (op);
c906108c
SS		 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 {
c5aa993b
JM		 470 n = EXTRACT_RA (op);
471 fsr->regs[n] = (-frame_size);
c906108c
SS		 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 {
c5aa993b
JM		 479 n = EXTRACT_RA (op);
480 fsr->regs[n] = (-frame_size);
481 fsr->regs[n + 1] = (-frame_size) + 4;
c906108c
SS		 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 {
c5aa993b 488 offset = EXTRACT_IMM6 (op);
c906108c
SS		 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. */
500void
fba45db2 501d30v_frame_find_saved_regs (struct frame_info *fi, struct frame_saved_regs *fsr)
c906108c
SS		 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);
c5aa993b 518
c906108c
SS		 519 fi->size = frame_size;
520
521 if (!fp)
c5aa993b 522 fp = read_register (SP_REGNUM);
c906108c 523
c5aa993b 524 for (i = 0; i < NUM_REGS - 1; i++)
c906108c
SS		 525 if (fsr->regs[i])
526 {
527 fsr->regs[i] = fsr->regs[i] + fp + frame_size;
528 }
529
530 if (fsr->regs[LR_REGNUM])
c5aa993b 531 fi->return_pc = read_memory_unsigned_integer (fsr->regs[LR_REGNUM], 4);
c906108c 532 else
c5aa993b
JM		 533 fi->return_pc = read_register (LR_REGNUM);
534
c906108c
SS		 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)
c5aa993b 541 fsr->regs[SP_REGNUM] = read_register (FP_REGNUM) + fi->size;
c906108c
SS		 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
551void
fba45db2
KB		 552d30v_frame_find_saved_regs_offsets (struct frame_info *fi,
553 struct frame_saved_regs *fsr)
c906108c
SS		 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 {
c5aa993b
JM		 572 opl = (unsigned long) read_memory_integer (pc, 4);
573 opr = (unsigned long) read_memory_integer (pc + 4, 4);
c906108c
SS		 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 */
c5aa993b 587 long offset = EXTRACT_IMM32 (opl, opr);
c906108c
SS		 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 */
c5aa993b 593 long offset = EXTRACT_IMM32 (opl, opr);
c906108c
SS		 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) */
c5aa993b
JM		 599 long offset = EXTRACT_IMM32 (opl, opr);
600 short n = EXTRACT_RA (opl);
c906108c
SS		 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) */
c5aa993b
JM		 606 long offset = EXTRACT_IMM32 (opl, opr);
607 short n = EXTRACT_RA (opl);
c906108c 608 fsr->regs[n] = (offset - frame_size);
c5aa993b 609 fsr->regs[n + 1] = (offset - frame_size) + 4;
c906108c
SS		 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;
c5aa993b
JM		 625 }
626 else
c906108c
SS		 627 {
628 op1 = opl;
629 op2 = opr;
630 }
c5aa993b 631 if (!prologue_find_regs (op1, fsr, pc) || !prologue_find_regs (op2, fsr, pc))
c906108c
SS		 632 break;
633 }
634 pc += 8;
635 }
c5aa993b 636
c906108c
SS		 637#if 0
638 fi->size = frame_size;
639
640 if (!fp)
c5aa993b 641 fp = read_register (SP_REGNUM);
c906108c 642
c5aa993b 643 for (i = 0; i < NUM_REGS - 1; i++)
c906108c
SS		 644 if (fsr->regs[i])
645 {
646 fsr->regs[i] = fsr->regs[i] + fp + frame_size;
647 }
648
649 if (fsr->regs[LR_REGNUM])
c5aa993b 650 fi->return_pc = read_memory_unsigned_integer (fsr->regs[LR_REGNUM], 4);
c906108c 651 else
c5aa993b
JM		 652 fi->return_pc = read_register (LR_REGNUM);
653
c906108c
SS		 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)
c5aa993b 660 fsr->regs[SP_REGNUM] = read_register (FP_REGNUM) + fi->size;
c906108c
SS		 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
671void
fba45db2 672d30v_init_extra_frame_info (int fromleaf, struct frame_info *fi)
c906108c
SS		 673{
674 struct frame_saved_regs dummy;
675
676 if (fi->next && (fi->pc == 0))
c5aa993b 677 fi->pc = fi->next->return_pc;
c906108c
SS		 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);
c5aa993b 695 fi->return_pc = read_memory_unsigned_integer (dummy.regs[LR_REGNUM], 4);
c906108c
SS		 696 }
697 else
c5aa993b 698 fi->return_pc = read_register (LR_REGNUM);
c906108c
SS		 699}
700
701void
fba45db2 702d30v_init_frame_pc (int fromleaf, struct frame_info *prev)
c906108c
SS		 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
a14ed312 710static void d30v_print_register (int regnum, int tabular);
c906108c
SS		 711
712static void
fba45db2 713d30v_print_register (int regnum, int tabular)
c906108c
SS		 714{
715 if (regnum < A0_REGNUM)
716 {
717 if (tabular)
d4f3574e 718 printf_filtered ("%08lx", (long) read_register (regnum));
c906108c 719 else
d4f3574e
SS		 720 printf_filtered ("0x%lx %ld",
721 (long) read_register (regnum),
722 (long) read_register (regnum));
c906108c
SS		 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,
c5aa993b 737 gdb_stdout, 'd', 1, 0, Val_pretty_default);
c906108c
SS		 738 }
739 }
740}
741
742static void
fba45db2 743d30v_print_flags (void)
c906108c
SS		 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
766static void
fba45db2 767print_flags_command (char *args, int from_tty)
c906108c
SS		 768{
769 d30v_print_flags ();
770}
771
772void
fba45db2 773d30v_do_registers_info (int regnum, int fpregs)
c906108c
SS		 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
870CORE_ADDR
fba45db2 871d30v_fix_call_dummy (char *dummyname, CORE_ADDR start_sp, CORE_ADDR fun,
ea7c478f
AC		 872 int nargs, struct value **args,
873 struct type *type, int gcc_p)
c906108c
SS		 874{
875 int regnum;
876 CORE_ADDR sp;
877 char buffer[MAX_REGISTER_RAW_SIZE];
878 struct frame_info *frame = get_current_frame ();
879 frame->dummy = start_sp;
c5aa993b 880 /*start_sp |= DMEM_START; */
c906108c
SS		 881
882 sp = start_sp;
883 for (regnum = 0; regnum < NUM_REGS; regnum++)
884 {
c5aa993b
JM		 885 sp -= REGISTER_RAW_SIZE (regnum);
886 store_address (buffer, REGISTER_RAW_SIZE (regnum), read_register (regnum));
887 write_memory (sp, buffer, REGISTER_RAW_SIZE (regnum));
c906108c 888 }
c5aa993b 889 write_register (SP_REGNUM, (LONGEST) sp);
c906108c 890 /* now we need to load LR with the return address */
c5aa993b 891 write_register (LR_REGNUM, (LONGEST) d30v_call_dummy_address ());
c906108c
SS		 892 return sp;
893}
894
895static void
fba45db2 896d30v_pop_dummy_frame (struct frame_info *fi)
c906108c
SS		 897{
898 CORE_ADDR sp = fi->dummy;
899 int regnum;
900
901 for (regnum = 0; regnum < NUM_REGS; regnum++)
902 {
c5aa993b
JM		 903 sp -= REGISTER_RAW_SIZE (regnum);
904 write_register (regnum, read_memory_unsigned_integer (sp, REGISTER_RAW_SIZE (regnum)));
c906108c 905 }
c5aa993b 906 flush_cached_frames (); /* needed? */
c906108c
SS		 907}
908
909
910CORE_ADDR
ea7c478f 911d30v_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
fba45db2 912 int struct_return, CORE_ADDR struct_addr)
c906108c 913{
c5aa993b 914 int i, len, index = 0, regnum = 2;
c906108c
SS		 915 char buffer[4], *contents;
916 LONGEST val;
917 CORE_ADDR ptrs[10];
918
919#if 0
920 /* Pass 1. Put all large args on stack */
921 for (i = 0; i < nargs; i++)
922 {
ea7c478f 923 struct value *arg = args[i];
c906108c
SS		 924 struct type *arg_type = check_typedef (VALUE_TYPE (arg));
925 len = TYPE_LENGTH (arg_type);
c5aa993b 926 contents = VALUE_CONTENTS (arg);
c906108c
SS		 927 val = extract_signed_integer (contents, len);
928 if (len > 4)
929 {
930 /* put on stack and pass pointers */
931 sp -= len;
932 write_memory (sp, contents, len);
933 ptrs[index++] = sp;
934 }
935 }
936#endif
937 index = 0;
938
939 for (i = 0; i < nargs; i++)
940 {
ea7c478f 941 struct value *arg = args[i];
c906108c
SS		 942 struct type *arg_type = check_typedef (VALUE_TYPE (arg));
943 len = TYPE_LENGTH (arg_type);
c5aa993b 944 contents = VALUE_CONTENTS (arg);
c906108c
SS		 945 if (len > 4)
946 {
947 /* we need multiple registers */
948 int ndx;
949
950 for (ndx = 0; len > 0; ndx += 8, len -= 8)
951 {
952 if (regnum & 1)
953 regnum++; /* all args > 4 bytes start in even register */
954
955 if (regnum < 18)
956 {
957 val = extract_signed_integer (&contents[ndx], 4);
958 write_register (regnum++, val);
959
960 if (len >= 8)
c5aa993b 961 val = extract_signed_integer (&contents[ndx + 4], 4);
c906108c 962 else
c5aa993b 963 val = extract_signed_integer (&contents[ndx + 4], len - 4);
c906108c
SS		 964 write_register (regnum++, val);
965 }
966 else
967 {
968 /* no more registers available. put it on the stack */
969
970 /* all args > 4 bytes are padded to a multiple of 8 bytes
c5aa993b 971 and start on an 8 byte boundary */
c906108c 972 if (sp & 7)
c5aa993b 973 sp -= (sp & 7); /* align it */
c906108c 974
c5aa993b 975 sp -= ((len + 7) & ~7); /* allocate space */
c906108c
SS		 976 write_memory (sp, &contents[ndx], len);
977 break;
978 }
979 }
980 }
981 else
982 {
c5aa993b 983 if (regnum < 18)
c906108c
SS		 984 {
985 val = extract_signed_integer (contents, len);
986 write_register (regnum++, val);
987 }
988 else
989 {
990 /* all args are padded to a multiple of 4 bytes (at least) */
991 sp -= ((len + 3) & ~3);
992 write_memory (sp, contents, len);
993 }
994 }
995 }
996 if (sp & 7)
997 /* stack pointer is not on an 8 byte boundary -- align it */
998 sp -= (sp & 7);
999 return sp;
1000}
1001
1002
1003/* pick an out-of-the-way place to set the return value */
1004/* for an inferior function call. The link register is set to this */
1005/* value and a momentary breakpoint is set there. When the breakpoint */
1006/* is hit, the dummy frame is popped and the previous environment is */
1007/* restored. */
1008
1009CORE_ADDR
fba45db2 1010d30v_call_dummy_address (void)
c906108c
SS		 1011{
1012 CORE_ADDR entry;
1013 struct minimal_symbol *sym;
1014
1015 entry = entry_point_address ();
1016
1017 if (entry != 0)
1018 return entry;
1019
1020 sym = lookup_minimal_symbol ("_start", NULL, symfile_objfile);
1021
1022 if (!sym || MSYMBOL_TYPE (sym) != mst_text)
1023 return 0;
1024 else
1025 return SYMBOL_VALUE_ADDRESS (sym);
1026}
1027
1028/* Given a return value in `regbuf' with a type `valtype',
1029 extract and copy its value into `valbuf'. */
1030
1031void
72623009
KB		 1032d30v_extract_return_value (struct type *valtype, char regbuf[REGISTER_BYTES],
1033 char *valbuf)
c906108c
SS		 1034{
1035 memcpy (valbuf, regbuf + REGISTER_BYTE (2), TYPE_LENGTH (valtype));
1036}
1037
1038/* The following code implements access to, and display of, the D30V's
1039 instruction trace buffer. The buffer consists of 64K or more
1040 4-byte words of data, of which each words includes an 8-bit count,
1041 an 8-bit segment number, and a 16-bit instruction address.
1042
1043 In theory, the trace buffer is continuously capturing instruction
1044 data that the CPU presents on its "debug bus", but in practice, the
1045 ROMified GDB stub only enables tracing when it continues or steps
1046 the program, and stops tracing when the program stops; so it
1047 actually works for GDB to read the buffer counter out of memory and
1048 then read each trace word. The counter records where the tracing
1049 stops, but there is no record of where it started, so we remember
1050 the PC when we resumed and then search backwards in the trace
1051 buffer for a word that includes that address. This is not perfect,
1052 because you will miss trace data if the resumption PC is the target
1053 of a branch. (The value of the buffer counter is semi-random, any
1054 trace data from a previous program stop is gone.) */
1055
1056/* The address of the last word recorded in the trace buffer. */
1057
1058#define DBBC_ADDR (0xd80000)
1059
1060/* The base of the trace buffer, at least for the "Board_0". */
1061
1062#define TRACE_BUFFER_BASE (0xf40000)
1063
a14ed312 1064static void trace_command (char *, int);
c906108c 1065
a14ed312 1066static void untrace_command (char *, int);
c906108c 1067
a14ed312 1068static void trace_info (char *, int);
c906108c 1069
a14ed312 1070static void tdisassemble_command (char *, int);
c906108c 1071
a14ed312 1072static void display_trace (int, int);
c906108c
SS		 1073
1074/* True when instruction traces are being collected. */
1075
1076static int tracing;
1077
1078/* Remembered PC. */
1079
1080static CORE_ADDR last_pc;
1081
1082/* True when trace output should be displayed whenever program stops. */
1083
1084static int trace_display;
1085
1086/* True when trace listing should include source lines. */
1087
1088static int default_trace_show_source = 1;
1089
c5aa993b
JM		 1090struct trace_buffer
1091 {
1092 int size;
1093 short *counts;
1094 CORE_ADDR *addrs;
1095 }
1096trace_data;
c906108c
SS		 1097
1098static void
fba45db2 1099trace_command (char *args, int from_tty)
c906108c
SS		 1100{
1101 /* Clear the host-side trace buffer, allocating space if needed. */
1102 trace_data.size = 0;
1103 if (trace_data.counts == NULL)
c5aa993b 1104 trace_data.counts = (short *) xmalloc (65536 * sizeof (short));
c906108c 1105 if (trace_data.addrs == NULL)
c5aa993b 1106 trace_data.addrs = (CORE_ADDR *) xmalloc (65536 * sizeof (CORE_ADDR));
c906108c
SS		 1107
1108 tracing = 1;
1109
1110 printf_filtered ("Tracing is now on.\n");
1111}
1112
1113static void
fba45db2 1114untrace_command (char *args, int from_tty)
c906108c
SS		 1115{
1116 tracing = 0;
1117
1118 printf_filtered ("Tracing is now off.\n");
1119}
1120
1121static void
fba45db2 1122trace_info (char *args, int from_tty)
c906108c
SS		 1123{
1124 int i;
1125
1126 if (trace_data.size)
1127 {
1128 printf_filtered ("%d entries in trace buffer:\n", trace_data.size);
1129
1130 for (i = 0; i < trace_data.size; ++i)
1131 {
d4f3574e 1132 printf_filtered ("%d: %d instruction%s at 0x%s\n",
c906108c
SS		 1133 i, trace_data.counts[i],
1134 (trace_data.counts[i] == 1 ? "" : "s"),
d4f3574e 1135 paddr_nz (trace_data.addrs[i]));
c906108c
SS		 1136 }
1137 }
1138 else
1139 printf_filtered ("No entries in trace buffer.\n");
1140
1141 printf_filtered ("Tracing is currently %s.\n", (tracing ? "on" : "off"));
1142}
1143
1144/* Print the instruction at address MEMADDR in debugged memory,
1145 on STREAM. Returns length of the instruction, in bytes. */
1146
1147static int
fba45db2 1148print_insn (CORE_ADDR memaddr, struct ui_file *stream)
c906108c
SS		 1149{
1150 /* If there's no disassembler, something is very wrong. */
1151 if (tm_print_insn == NULL)
8e65ff28
AC		 1152 internal_error (__FILE__, __LINE__,
1153 "print_insn: no disassembler");
c906108c
SS		 1154
1155 if (TARGET_BYTE_ORDER == BIG_ENDIAN)
1156 tm_print_insn_info.endian = BFD_ENDIAN_BIG;
1157 else
1158 tm_print_insn_info.endian = BFD_ENDIAN_LITTLE;
1159 return (*tm_print_insn) (memaddr, &tm_print_insn_info);
1160}
1161
1162void
fba45db2 1163d30v_eva_prepare_to_trace (void)
c906108c
SS		 1164{
1165 if (!tracing)
1166 return;
1167
1168 last_pc = read_register (PC_REGNUM);
1169}
1170
1171/* Collect trace data from the target board and format it into a form
1172 more useful for display. */
1173
1174void
fba45db2 1175d30v_eva_get_trace_data (void)
c906108c
SS		 1176{
1177 int count, i, j, oldsize;
1178 int trace_addr, trace_seg, trace_cnt, next_cnt;
1179 unsigned int last_trace, trace_word, next_word;
1180 unsigned int *tmpspace;
1181
1182 if (!tracing)
1183 return;
1184
c5aa993b 1185 tmpspace = xmalloc (65536 * sizeof (unsigned int));
c906108c
SS		 1186
1187 last_trace = read_memory_unsigned_integer (DBBC_ADDR, 2) << 2;
1188
1189 /* Collect buffer contents from the target, stopping when we reach
1190 the word recorded when execution resumed. */
1191
1192 count = 0;
1193 while (last_trace > 0)
1194 {
1195 QUIT;
1196 trace_word =
1197 read_memory_unsigned_integer (TRACE_BUFFER_BASE + last_trace, 4);
1198 trace_addr = trace_word & 0xffff;
1199 last_trace -= 4;
1200 /* Ignore an apparently nonsensical entry. */
1201 if (trace_addr == 0xffd5)
1202 continue;
1203 tmpspace[count++] = trace_word;
1204 if (trace_addr == last_pc)
1205 break;
1206 if (count > 65535)
1207 break;
1208 }
1209
1210 /* Move the data to the host-side trace buffer, adjusting counts to
1211 include the last instruction executed and transforming the address
1212 into something that GDB likes. */
1213
1214 for (i = 0; i < count; ++i)
1215 {
1216 trace_word = tmpspace[i];
1217 next_word = ((i == 0) ? 0 : tmpspace[i - 1]);
1218 trace_addr = trace_word & 0xffff;
1219 next_cnt = (next_word >> 24) & 0xff;
1220 j = trace_data.size + count - i - 1;
1221 trace_data.addrs[j] = (trace_addr << 2) + 0x1000000;
1222 trace_data.counts[j] = next_cnt + 1;
1223 }
1224
1225 oldsize = trace_data.size;
1226 trace_data.size += count;
1227
b8c9b27d 1228 xfree (tmpspace);
c906108c
SS		 1229
1230 if (trace_display)
1231 display_trace (oldsize, trace_data.size);
1232}
1233
1234static void
fba45db2 1235tdisassemble_command (char *arg, int from_tty)
c906108c
SS		 1236{
1237 int i, count;
1238 CORE_ADDR low, high;
1239 char *space_index;
1240
1241 if (!arg)
1242 {
1243 low = 0;
1244 high = trace_data.size;
1245 }
1246 else if (!(space_index = (char *) strchr (arg, ' ')))
1247 {
1248 low = parse_and_eval_address (arg);
1249 high = low + 5;
1250 }
1251 else
1252 {
1253 /* Two arguments. */
1254 *space_index = '\0';
1255 low = parse_and_eval_address (arg);
1256 high = parse_and_eval_address (space_index + 1);
1257 if (high < low)
1258 high = low;
1259 }
1260
d4f3574e
SS		 1261 printf_filtered ("Dump of trace from %s to %s:\n",
1262 paddr_u (low),
1263 paddr_u (high));
c906108c
SS		 1264
1265 display_trace (low, high);
1266
1267 printf_filtered ("End of trace dump.\n");
1268 gdb_flush (gdb_stdout);
1269}
1270
1271static void
fba45db2 1272display_trace (int low, int high)
c906108c
SS		 1273{
1274 int i, count, trace_show_source, first, suppress;
1275 CORE_ADDR next_address;
1276
1277 trace_show_source = default_trace_show_source;
c5aa993b 1278 if (!have_full_symbols () && !have_partial_symbols ())
c906108c
SS		 1279 {
1280 trace_show_source = 0;
1281 printf_filtered ("No symbol table is loaded. Use the \"file\" command.\n");
1282 printf_filtered ("Trace will not display any source.\n");
1283 }
1284
1285 first = 1;
1286 suppress = 0;
1287 for (i = low; i < high; ++i)
1288 {
1289 next_address = trace_data.addrs[i];
c5aa993b 1290 count = trace_data.counts[i];
c906108c
SS		 1291 while (count-- > 0)
1292 {
1293 QUIT;
1294 if (trace_show_source)
1295 {
1296 struct symtab_and_line sal, sal_prev;
1297
1298 sal_prev = find_pc_line (next_address - 4, 0);
1299 sal = find_pc_line (next_address, 0);
1300
1301 if (sal.symtab)
1302 {
1303 if (first || sal.line != sal_prev.line)
1304 print_source_lines (sal.symtab, sal.line, sal.line + 1, 0);
1305 suppress = 0;
1306 }
1307 else
1308 {
1309 if (!suppress)
1310 /* FIXME-32x64--assumes sal.pc fits in long. */
1311 printf_filtered ("No source file for address %s.\n",
c5aa993b 1312 local_hex_string ((unsigned long) sal.pc));
c906108c
SS		 1313 suppress = 1;
1314 }
1315 }
1316 first = 0;
1317 print_address (next_address, gdb_stdout);
1318 printf_filtered (":");
1319 printf_filtered ("\t");
1320 wrap_here (" ");
1321 next_address = next_address + print_insn (next_address, gdb_stdout);
1322 printf_filtered ("\n");
1323 gdb_flush (gdb_stdout);
1324 }
1325 }
1326}
1327
507f3c78
KB		 1328extern void (*target_resume_hook) (void);
1329extern void (*target_wait_loop_hook) (void);
c906108c
SS		 1330
1331void
fba45db2 1332_initialize_d30v_tdep (void)
c906108c
SS		 1333{
1334 tm_print_insn = print_insn_d30v;
1335
1336 target_resume_hook = d30v_eva_prepare_to_trace;
1337 target_wait_loop_hook = d30v_eva_get_trace_data;
1338
1339 add_info ("flags", print_flags_command, "Print d30v flags.");
1340
1341 add_com ("trace", class_support, trace_command,
1342 "Enable tracing of instruction execution.");
1343
1344 add_com ("untrace", class_support, untrace_command,
c5aa993b 1345 "Disable tracing of instruction execution.");
c906108c
SS		 1346
1347 add_com ("tdisassemble", class_vars, tdisassemble_command,
1348 "Disassemble the trace buffer.\n\
1349Two optional arguments specify a range of trace buffer entries\n\
1350as reported by info trace (NOT addresses!).");
1351
1352 add_info ("trace", trace_info,
1353 "Display info about the trace data buffer.");
1354
1355 add_show_from_set (add_set_cmd ("tracedisplay", no_class,
c5aa993b
JM		 1356 var_integer, (char *) &trace_display,
1357 "Set automatic display of trace.\n", &setlist),
c906108c
SS		 1358 &showlist);
1359 add_show_from_set (add_set_cmd ("tracesource", no_class,
c5aa993b
JM		 1360 var_integer, (char *) &default_trace_show_source,
1361 "Set display of source code with trace.\n", &setlist),
c906108c
SS		 1362 &showlist);
1363
c5aa993b 1364}
GDB Binutils - Deliverables
This page took 0.170461 seconds and 4 git commands to generate.