1 /* Target-dependent code for Mitsubishi D30V, for GDB.
2 Copyright (C) 1996, 1997, 2000 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
21 /* Contributed by Martin Hunt, hunt@cygnus.com */
30 #include "gdb_string.h"
37 #include "language.h" /* For local_hex_string() */
39 void d30v_frame_find_saved_regs (struct frame_info
*fi
,
40 struct frame_saved_regs
*fsr
);
41 void d30v_frame_find_saved_regs_offsets (struct frame_info
*fi
,
42 struct frame_saved_regs
*fsr
);
43 static void d30v_pop_dummy_frame (struct frame_info
*fi
);
44 static void d30v_print_flags (void);
45 static void print_flags_command (char *, int);
47 /* the following defines assume:
48 fp is r61, lr is r62, sp is r63, and ?? is r22
49 if that changes, they will need to be updated */
51 #define OP_MASK_ALL_BUT_RA 0x0ffc0fff /* throw away Ra, keep the rest */
53 #define OP_STW_SPM 0x054c0fc0 /* stw Ra, @(sp-) */
54 #define OP_STW_SP_R0 0x05400fc0 /* stw Ra, @(sp,r0) */
55 #define OP_STW_SP_IMM0 0x05480fc0 /* st Ra, @(sp, 0x0) */
56 #define OP_STW_R22P_R0 0x05440580 /* stw Ra, @(r22+,r0) */
58 #define OP_ST2W_SPM 0x056c0fc0 /* st2w Ra, @(sp-) */
59 #define OP_ST2W_SP_R0 0x05600fc0 /* st2w Ra, @(sp, r0) */
60 #define OP_ST2W_SP_IMM0 0x05680fc0 /* st2w Ra, @(sp, 0x0) */
61 #define OP_ST2W_R22P_R0 0x05640580 /* st2w Ra, @(r22+, r0) */
63 #define OP_MASK_OPCODE 0x0ffc0000 /* just the opcode, ign operands */
64 #define OP_NOP 0x00f00000 /* nop */
66 #define OP_MASK_ALL_BUT_IMM 0x0fffffc0 /* throw away imm, keep the rest */
67 #define OP_SUB_SP_IMM 0x082bffc0 /* sub sp,sp,imm */
68 #define OP_ADD_SP_IMM 0x080bffc0 /* add sp,sp,imm */
69 #define OP_ADD_R22_SP_IMM 0x08096fc0 /* add r22,sp,imm */
70 #define OP_STW_FP_SP_IMM 0x054bdfc0 /* stw fp,@(sp,imm) */
71 #define OP_OR_SP_R0_IMM 0x03abf000 /* or sp,r0,imm */
74 #define OP_OR_FP_R0_SP 0x03a3d03f /* or fp,r0,sp */
75 #define OP_OR_FP_SP_R0 0x03a3dfc0 /* or fp,sp,r0 */
76 #define OP_OR_FP_IMM0_SP 0x03abd03f /* or fp,0x0,sp */
77 #define OP_STW_FP_R22P_R0 0x0547d580 /* stw fp,@(r22+,r0) */
78 #define OP_STW_LR_R22P_R0 0x0547e580 /* stw lr,@(r22+,r0) */
80 #define OP_MASK_OP_AND_RB 0x0ff80fc0 /* keep op and rb,throw away rest */
81 #define OP_STW_SP_IMM 0x05480fc0 /* stw Ra,@(sp,imm) */
82 #define OP_ST2W_SP_IMM 0x05680fc0 /* st2w Ra,@(sp,imm) */
83 #define OP_STW_FP_IMM 0x05480f40 /* stw Ra,@(fp,imm) */
84 #define OP_STW_FP_R0 0x05400f40 /* stw Ra,@(fp,r0) */
86 #define OP_MASK_FM_BIT 0x80000000
87 #define OP_MASK_CC_BITS 0x70000000
88 #define OP_MASK_SUB_INST 0x0fffffff
90 #define EXTRACT_RA(op) (((op) >> 12) & 0x3f)
91 #define EXTRACT_RB(op) (((op) >> 6) & 0x3f)
92 #define EXTRACT_RC(op) (((op) & 0x3f)
93 #define EXTRACT_UIMM6(op) ((op) & 0x3f)
94 #define EXTRACT_IMM6(op) ((((int)EXTRACT_UIMM6(op)) << 26) >> 26)
95 #define EXTRACT_IMM26(op) ((((op)&0x0ff00000) >> 2) | ((op)&0x0003ffff))
96 #define EXTRACT_IMM32(opl, opr) ((EXTRACT_UIMM6(opl) << 26)|EXTRACT_IMM26(opr))
100 d30v_frame_chain_valid (CORE_ADDR chain
, struct frame_info
*fi
)
103 return ((chain
) != 0 && (fi
) != 0 && (fi
)->return_pc
!= 0);
105 return ((chain
) != 0 && (fi
) != 0 && (fi
)->frame
<= chain
);
109 /* Discard from the stack the innermost frame, restoring all saved
113 d30v_pop_frame (void)
115 struct frame_info
*frame
= get_current_frame ();
118 struct frame_saved_regs fsr
;
121 fp
= FRAME_FP (frame
);
124 d30v_pop_dummy_frame (frame
);
128 /* fill out fsr with the address of where each */
129 /* register was stored in the frame */
130 get_frame_saved_regs (frame
, &fsr
);
132 /* now update the current registers with the old values */
133 for (regnum
= A0_REGNUM
; regnum
< A0_REGNUM
+ 2; regnum
++)
135 if (fsr
.regs
[regnum
])
137 read_memory (fsr
.regs
[regnum
], raw_buffer
, 8);
138 write_register_bytes (REGISTER_BYTE (regnum
), raw_buffer
, 8);
141 for (regnum
= 0; regnum
< SP_REGNUM
; regnum
++)
143 if (fsr
.regs
[regnum
])
145 write_register (regnum
, read_memory_unsigned_integer (fsr
.regs
[regnum
], 4));
148 if (fsr
.regs
[PSW_REGNUM
])
150 write_register (PSW_REGNUM
, read_memory_unsigned_integer (fsr
.regs
[PSW_REGNUM
], 4));
153 write_register (PC_REGNUM
, read_register (LR_REGNUM
));
154 write_register (SP_REGNUM
, fp
+ frame
->size
);
155 target_store_registers (-1);
156 flush_cached_frames ();
160 check_prologue (unsigned long op
)
162 /* add sp,sp,imm -- observed */
163 if ((op
& OP_MASK_ALL_BUT_IMM
) == OP_ADD_SP_IMM
)
166 /* add r22,sp,imm -- observed */
167 if ((op
& OP_MASK_ALL_BUT_IMM
) == OP_ADD_R22_SP_IMM
)
170 /* or fp,r0,sp -- observed */
171 if (op
== OP_OR_FP_R0_SP
)
175 if ((op
& OP_MASK_OPCODE
) == OP_NOP
)
178 /* stw Ra,@(sp,r0) */
179 if ((op
& OP_MASK_ALL_BUT_RA
) == OP_STW_SP_R0
)
182 /* stw Ra,@(sp,0x0) */
183 if ((op
& OP_MASK_ALL_BUT_RA
) == OP_STW_SP_IMM0
)
186 /* st2w Ra,@(sp,r0) */
187 if ((op
& OP_MASK_ALL_BUT_RA
) == OP_ST2W_SP_R0
)
190 /* st2w Ra,@(sp,0x0) */
191 if ((op
& OP_MASK_ALL_BUT_RA
) == OP_ST2W_SP_IMM0
)
194 /* stw fp, @(r22+,r0) -- observed */
195 if (op
== OP_STW_FP_R22P_R0
)
198 /* stw r62, @(r22+,r0) -- observed */
199 if (op
== OP_STW_LR_R22P_R0
)
202 /* stw Ra, @(fp,r0) -- observed */
203 if ((op
& OP_MASK_ALL_BUT_RA
) == OP_STW_FP_R0
)
204 return 1; /* first arg */
206 /* stw Ra, @(fp,imm) -- observed */
207 if ((op
& OP_MASK_OP_AND_RB
) == OP_STW_FP_IMM
)
208 return 1; /* second and subsequent args */
210 /* stw fp,@(sp,imm) -- observed */
211 if ((op
& OP_MASK_ALL_BUT_IMM
) == OP_STW_FP_SP_IMM
)
214 /* st2w Ra,@(r22+,r0) */
215 if ((op
& OP_MASK_ALL_BUT_RA
) == OP_ST2W_R22P_R0
)
219 if ((op
& OP_MASK_ALL_BUT_RA
) == OP_STW_SPM
)
222 /* st2w Ra, @(sp-) */
223 if ((op
& OP_MASK_ALL_BUT_RA
) == OP_ST2W_SPM
)
226 /* sub.? sp,sp,imm */
227 if ((op
& OP_MASK_ALL_BUT_IMM
) == OP_SUB_SP_IMM
)
234 d30v_skip_prologue (CORE_ADDR pc
)
237 unsigned long opl
, opr
; /* left / right sub operations */
238 unsigned long fm0
, fm1
; /* left / right mode bits */
239 unsigned long cc0
, cc1
;
240 unsigned long op1
, op2
;
241 CORE_ADDR func_addr
, func_end
;
242 struct symtab_and_line sal
;
244 /* If we have line debugging information, then the end of the */
245 /* prologue should the first assembly instruction of the first source line */
246 if (find_pc_partial_function (pc
, NULL
, &func_addr
, &func_end
))
248 sal
= find_pc_line (func_addr
, 0);
249 if (sal
.end
&& sal
.end
< func_end
)
253 if (target_read_memory (pc
, (char *) &op
[0], 8))
254 return pc
; /* Can't access it -- assume no prologue. */
258 opl
= (unsigned long) read_memory_integer (pc
, 4);
259 opr
= (unsigned long) read_memory_integer (pc
+ 4, 4);
261 fm0
= (opl
& OP_MASK_FM_BIT
);
262 fm1
= (opr
& OP_MASK_FM_BIT
);
264 cc0
= (opl
& OP_MASK_CC_BITS
);
265 cc1
= (opr
& OP_MASK_CC_BITS
);
267 opl
= (opl
& OP_MASK_SUB_INST
);
268 opr
= (opr
& OP_MASK_SUB_INST
);
272 /* long instruction (opl contains the opcode) */
273 if (((opl
& OP_MASK_ALL_BUT_IMM
) != OP_ADD_SP_IMM
) && /* add sp,sp,imm */
274 ((opl
& OP_MASK_ALL_BUT_IMM
) != OP_ADD_R22_SP_IMM
) && /* add r22,sp,imm */
275 ((opl
& OP_MASK_OP_AND_RB
) != OP_STW_SP_IMM
) && /* stw Ra, @(sp,imm) */
276 ((opl
& OP_MASK_OP_AND_RB
) != OP_ST2W_SP_IMM
)) /* st2w Ra, @(sp,imm) */
281 /* short instructions */
292 if (check_prologue (op1
))
294 if (!check_prologue (op2
))
296 /* if the previous opcode was really part of the prologue */
297 /* and not just a NOP, then we want to break after both instructions */
298 if ((op1
& OP_MASK_OPCODE
) != OP_NOP
)
311 static int end_of_stack
;
313 /* Given a GDB frame, determine the address of the calling function's frame.
314 This will be used to create a new GDB frame struct, and then
315 INIT_EXTRA_FRAME_INFO and INIT_FRAME_PC will be called for the new frame.
319 d30v_frame_chain (struct frame_info
*frame
)
321 struct frame_saved_regs fsr
;
323 d30v_frame_find_saved_regs (frame
, &fsr
);
326 return (CORE_ADDR
) 0;
328 if (frame
->return_pc
== IMEM_START
)
329 return (CORE_ADDR
) 0;
331 if (!fsr
.regs
[FP_REGNUM
])
333 if (!fsr
.regs
[SP_REGNUM
] || fsr
.regs
[SP_REGNUM
] == STACK_START
)
334 return (CORE_ADDR
) 0;
336 return fsr
.regs
[SP_REGNUM
];
339 if (!read_memory_unsigned_integer (fsr
.regs
[FP_REGNUM
], 4))
340 return (CORE_ADDR
) 0;
342 return read_memory_unsigned_integer (fsr
.regs
[FP_REGNUM
], 4);
345 static int next_addr
, uses_frame
;
346 static int frame_size
;
349 prologue_find_regs (unsigned long op
, struct frame_saved_regs
*fsr
,
355 /* add sp,sp,imm -- observed */
356 if ((op
& OP_MASK_ALL_BUT_IMM
) == OP_ADD_SP_IMM
)
358 offset
= EXTRACT_IMM6 (op
);
359 /*next_addr += offset; */
360 frame_size
+= -offset
;
364 /* add r22,sp,imm -- observed */
365 if ((op
& OP_MASK_ALL_BUT_IMM
) == OP_ADD_R22_SP_IMM
)
367 offset
= EXTRACT_IMM6 (op
);
368 next_addr
= (offset
- frame_size
);
372 /* stw Ra, @(fp, offset) -- observed */
373 if ((op
& OP_MASK_OP_AND_RB
) == OP_STW_FP_IMM
)
376 offset
= EXTRACT_IMM6 (op
);
377 fsr
->regs
[n
] = (offset
- frame_size
);
381 /* stw Ra, @(fp, r0) -- observed */
382 if ((op
& OP_MASK_ALL_BUT_RA
) == OP_STW_FP_R0
)
385 fsr
->regs
[n
] = (-frame_size
);
389 /* or fp,0,sp -- observed */
390 if ((op
== OP_OR_FP_R0_SP
) ||
391 (op
== OP_OR_FP_SP_R0
) ||
392 (op
== OP_OR_FP_IMM0_SP
))
399 if ((op
& OP_MASK_OPCODE
) == OP_NOP
)
402 /* stw Ra,@(r22+,r0) -- observed */
403 if ((op
& OP_MASK_ALL_BUT_RA
) == OP_STW_R22P_R0
)
406 fsr
->regs
[n
] = next_addr
;
410 #if 0 /* subsumed in pattern above */
411 /* stw fp,@(r22+,r0) -- observed */
412 if (op
== OP_STW_FP_R22P_R0
)
414 fsr
->regs
[FP_REGNUM
] = next_addr
; /* XXX */
419 /* stw r62,@(r22+,r0) -- observed */
420 if (op
== OP_STW_LR_R22P_R0
)
422 fsr
->regs
[LR_REGNUM
] = next_addr
;
427 /* st2w Ra,@(r22+,r0) -- observed */
428 if ((op
& OP_MASK_ALL_BUT_RA
) == OP_ST2W_R22P_R0
)
431 fsr
->regs
[n
] = next_addr
;
432 fsr
->regs
[n
+ 1] = next_addr
+ 4;
438 if ((op
& OP_MASK_ALL_BUT_RA
) == OP_STW_SPM
)
441 fsr
->regs
[n
] = next_addr
;
446 /* st2w Ra, @(sp-) */
447 else if ((op
& OP_MASK_ALL_BUT_RA
) == OP_ST2W_SPM
)
450 fsr
->regs
[n
] = next_addr
;
451 fsr
->regs
[n
+ 1] = next_addr
+ 4;
457 if ((op
& OP_MASK_ALL_BUT_IMM
) == OP_SUB_SP_IMM
)
459 offset
= EXTRACT_IMM6 (op
);
460 frame_size
+= -offset
;
464 /* st rn, @(sp,0) -- observed */
465 if (((op
& OP_MASK_ALL_BUT_RA
) == OP_STW_SP_R0
) ||
466 ((op
& OP_MASK_ALL_BUT_RA
) == OP_STW_SP_IMM0
))
469 fsr
->regs
[n
] = (-frame_size
);
473 /* st2w rn, @(sp,0) */
474 if (((op
& OP_MASK_ALL_BUT_RA
) == OP_ST2W_SP_R0
) ||
475 ((op
& OP_MASK_ALL_BUT_RA
) == OP_ST2W_SP_IMM0
))
478 fsr
->regs
[n
] = (-frame_size
);
479 fsr
->regs
[n
+ 1] = (-frame_size
) + 4;
483 /* stw fp,@(sp,imm) -- observed */
484 if ((op
& OP_MASK_ALL_BUT_IMM
) == OP_STW_FP_SP_IMM
)
486 offset
= EXTRACT_IMM6 (op
);
487 fsr
->regs
[FP_REGNUM
] = (offset
- frame_size
);
493 /* Put here the code to store, into a struct frame_saved_regs, the
494 addresses of the saved registers of frame described by FRAME_INFO.
495 This includes special registers such as pc and fp saved in special
496 ways in the stack frame. sp is even more special: the address we
497 return for it IS the sp for the next frame. */
499 d30v_frame_find_saved_regs (struct frame_info
*fi
, struct frame_saved_regs
*fsr
)
502 unsigned long opl
, opr
;
503 unsigned long op1
, op2
;
504 unsigned long fm0
, fm1
;
508 memset (fsr
, 0, sizeof (*fsr
));
515 d30v_frame_find_saved_regs_offsets (fi
, fsr
);
517 fi
->size
= frame_size
;
520 fp
= read_register (SP_REGNUM
);
522 for (i
= 0; i
< NUM_REGS
- 1; i
++)
525 fsr
->regs
[i
] = fsr
->regs
[i
] + fp
+ frame_size
;
528 if (fsr
->regs
[LR_REGNUM
])
529 fi
->return_pc
= read_memory_unsigned_integer (fsr
->regs
[LR_REGNUM
], 4);
531 fi
->return_pc
= read_register (LR_REGNUM
);
533 /* the SP is not normally (ever?) saved, but check anyway */
534 if (!fsr
->regs
[SP_REGNUM
])
536 /* if the FP was saved, that means the current FP is valid, */
537 /* otherwise, it isn't being used, so we use the SP instead */
539 fsr
->regs
[SP_REGNUM
] = read_register (FP_REGNUM
) + fi
->size
;
542 fsr
->regs
[SP_REGNUM
] = fp
+ fi
->size
;
544 fsr
->regs
[FP_REGNUM
] = 0;
550 d30v_frame_find_saved_regs_offsets (struct frame_info
*fi
,
551 struct frame_saved_regs
*fsr
)
554 unsigned long opl
, opr
;
555 unsigned long op1
, op2
;
556 unsigned long fm0
, fm1
;
560 memset (fsr
, 0, sizeof (*fsr
));
565 pc
= get_pc_function_start (fi
->pc
);
570 opl
= (unsigned long) read_memory_integer (pc
, 4);
571 opr
= (unsigned long) read_memory_integer (pc
+ 4, 4);
573 fm0
= (opl
& OP_MASK_FM_BIT
);
574 fm1
= (opr
& OP_MASK_FM_BIT
);
576 opl
= (opl
& OP_MASK_SUB_INST
);
577 opr
= (opr
& OP_MASK_SUB_INST
);
581 /* long instruction */
582 if ((opl
& OP_MASK_ALL_BUT_IMM
) == OP_ADD_SP_IMM
)
585 long offset
= EXTRACT_IMM32 (opl
, opr
);
586 frame_size
+= -offset
;
588 else if ((opl
& OP_MASK_ALL_BUT_IMM
) == OP_ADD_R22_SP_IMM
)
590 /* add r22,sp,offset */
591 long offset
= EXTRACT_IMM32 (opl
, opr
);
592 next_addr
= (offset
- frame_size
);
594 else if ((opl
& OP_MASK_OP_AND_RB
) == OP_STW_SP_IMM
)
596 /* st Ra, @(sp,imm) */
597 long offset
= EXTRACT_IMM32 (opl
, opr
);
598 short n
= EXTRACT_RA (opl
);
599 fsr
->regs
[n
] = (offset
- frame_size
);
601 else if ((opl
& OP_MASK_OP_AND_RB
) == OP_ST2W_SP_IMM
)
603 /* st2w Ra, @(sp,offset) */
604 long offset
= EXTRACT_IMM32 (opl
, opr
);
605 short n
= EXTRACT_RA (opl
);
606 fsr
->regs
[n
] = (offset
- frame_size
);
607 fsr
->regs
[n
+ 1] = (offset
- frame_size
) + 4;
609 else if ((opl
& OP_MASK_ALL_BUT_IMM
) == OP_OR_SP_R0_IMM
)
618 /* short instructions */
629 if (!prologue_find_regs (op1
, fsr
, pc
) || !prologue_find_regs (op2
, fsr
, pc
))
636 fi
->size
= frame_size
;
639 fp
= read_register (SP_REGNUM
);
641 for (i
= 0; i
< NUM_REGS
- 1; i
++)
644 fsr
->regs
[i
] = fsr
->regs
[i
] + fp
+ frame_size
;
647 if (fsr
->regs
[LR_REGNUM
])
648 fi
->return_pc
= read_memory_unsigned_integer (fsr
->regs
[LR_REGNUM
], 4);
650 fi
->return_pc
= read_register (LR_REGNUM
);
652 /* the SP is not normally (ever?) saved, but check anyway */
653 if (!fsr
->regs
[SP_REGNUM
])
655 /* if the FP was saved, that means the current FP is valid, */
656 /* otherwise, it isn't being used, so we use the SP instead */
658 fsr
->regs
[SP_REGNUM
] = read_register (FP_REGNUM
) + fi
->size
;
661 fsr
->regs
[SP_REGNUM
] = fp
+ fi
->size
;
663 fsr
->regs
[FP_REGNUM
] = 0;
670 d30v_init_extra_frame_info (int fromleaf
, struct frame_info
*fi
)
672 struct frame_saved_regs dummy
;
674 if (fi
->next
&& (fi
->pc
== 0))
675 fi
->pc
= fi
->next
->return_pc
;
677 d30v_frame_find_saved_regs_offsets (fi
, &dummy
);
684 if ((fi
->next
== 0) && (uses_frame
== 0))
685 /* innermost frame and it's "frameless",
686 so the fi->frame field is wrong, fix it! */
687 fi
->frame
= read_sp ();
689 if (dummy
.regs
[LR_REGNUM
])
691 /* it was saved, grab it! */
692 dummy
.regs
[LR_REGNUM
] += (fi
->frame
+ frame_size
);
693 fi
->return_pc
= read_memory_unsigned_integer (dummy
.regs
[LR_REGNUM
], 4);
696 fi
->return_pc
= read_register (LR_REGNUM
);
700 d30v_init_frame_pc (int fromleaf
, struct frame_info
*prev
)
702 /* default value, put here so we can breakpoint on it and
703 see if the default value is really the right thing to use */
704 prev
->pc
= (fromleaf
? SAVED_PC_AFTER_CALL (prev
->next
) : \
705 prev
->next
? FRAME_SAVED_PC (prev
->next
) : read_pc ());
708 static void d30v_print_register (int regnum
, int tabular
);
711 d30v_print_register (int regnum
, int tabular
)
713 if (regnum
< A0_REGNUM
)
716 printf_filtered ("%08lx", (long) read_register (regnum
));
718 printf_filtered ("0x%lx %ld",
719 (long) read_register (regnum
),
720 (long) read_register (regnum
));
724 char regbuf
[MAX_REGISTER_RAW_SIZE
];
726 read_relative_register_raw_bytes (regnum
, regbuf
);
728 val_print (REGISTER_VIRTUAL_TYPE (regnum
), regbuf
, 0, 0,
729 gdb_stdout
, 'x', 1, 0, Val_pretty_default
);
733 printf_filtered (" ");
734 val_print (REGISTER_VIRTUAL_TYPE (regnum
), regbuf
, 0, 0,
735 gdb_stdout
, 'd', 1, 0, Val_pretty_default
);
741 d30v_print_flags (void)
743 long psw
= read_register (PSW_REGNUM
);
744 printf_filtered ("flags #1");
745 printf_filtered (" (sm) %d", (psw
& PSW_SM
) != 0);
746 printf_filtered (" (ea) %d", (psw
& PSW_EA
) != 0);
747 printf_filtered (" (db) %d", (psw
& PSW_DB
) != 0);
748 printf_filtered (" (ds) %d", (psw
& PSW_DS
) != 0);
749 printf_filtered (" (ie) %d", (psw
& PSW_IE
) != 0);
750 printf_filtered (" (rp) %d", (psw
& PSW_RP
) != 0);
751 printf_filtered (" (md) %d\n", (psw
& PSW_MD
) != 0);
753 printf_filtered ("flags #2");
754 printf_filtered (" (f0) %d", (psw
& PSW_F0
) != 0);
755 printf_filtered (" (f1) %d", (psw
& PSW_F1
) != 0);
756 printf_filtered (" (f2) %d", (psw
& PSW_F2
) != 0);
757 printf_filtered (" (f3) %d", (psw
& PSW_F3
) != 0);
758 printf_filtered (" (s) %d", (psw
& PSW_S
) != 0);
759 printf_filtered (" (v) %d", (psw
& PSW_V
) != 0);
760 printf_filtered (" (va) %d", (psw
& PSW_VA
) != 0);
761 printf_filtered (" (c) %d\n", (psw
& PSW_C
) != 0);
765 print_flags_command (char *args
, int from_tty
)
771 d30v_do_registers_info (int regnum
, int fpregs
)
773 long long num1
, num2
;
778 if (REGISTER_NAME (0) == NULL
|| REGISTER_NAME (0)[0] == '\000')
781 printf_filtered ("%s ", REGISTER_NAME (regnum
));
782 d30v_print_register (regnum
, 0);
784 printf_filtered ("\n");
788 /* Have to print all the registers. Format them nicely. */
790 printf_filtered ("PC=");
791 print_address (read_pc (), gdb_stdout
);
793 printf_filtered (" PSW=");
794 d30v_print_register (PSW_REGNUM
, 1);
796 printf_filtered (" BPC=");
797 print_address (read_register (BPC_REGNUM
), gdb_stdout
);
799 printf_filtered (" BPSW=");
800 d30v_print_register (BPSW_REGNUM
, 1);
801 printf_filtered ("\n");
803 printf_filtered ("DPC=");
804 print_address (read_register (DPC_REGNUM
), gdb_stdout
);
806 printf_filtered (" DPSW=");
807 d30v_print_register (DPSW_REGNUM
, 1);
809 printf_filtered (" IBA=");
810 print_address (read_register (IBA_REGNUM
), gdb_stdout
);
811 printf_filtered ("\n");
813 printf_filtered ("RPT_C=");
814 d30v_print_register (RPT_C_REGNUM
, 1);
816 printf_filtered (" RPT_S=");
817 print_address (read_register (RPT_S_REGNUM
), gdb_stdout
);
819 printf_filtered (" RPT_E=");
820 print_address (read_register (RPT_E_REGNUM
), gdb_stdout
);
821 printf_filtered ("\n");
823 printf_filtered ("MOD_S=");
824 print_address (read_register (MOD_S_REGNUM
), gdb_stdout
);
826 printf_filtered (" MOD_E=");
827 print_address (read_register (MOD_E_REGNUM
), gdb_stdout
);
828 printf_filtered ("\n");
830 printf_filtered ("EIT_VB=");
831 print_address (read_register (EIT_VB_REGNUM
), gdb_stdout
);
833 printf_filtered (" INT_S=");
834 d30v_print_register (INT_S_REGNUM
, 1);
836 printf_filtered (" INT_M=");
837 d30v_print_register (INT_M_REGNUM
, 1);
838 printf_filtered ("\n");
841 for (regnum
= 0; regnum
<= 63;)
845 printf_filtered ("R%d-R%d ", regnum
, regnum
+ 7);
847 printf_filtered (" ");
849 printf_filtered (" ");
851 for (i
= 0; i
< 8; i
++)
853 printf_filtered (" ");
854 d30v_print_register (regnum
++, 1);
857 printf_filtered ("\n");
860 printf_filtered ("A0-A1 ");
862 d30v_print_register (A0_REGNUM
, 1);
863 printf_filtered (" ");
864 d30v_print_register (A1_REGNUM
, 1);
865 printf_filtered ("\n");
869 d30v_fix_call_dummy (char *dummyname
, CORE_ADDR start_sp
, CORE_ADDR fun
,
870 int nargs
, value_ptr
*args
, struct type
*type
, int gcc_p
)
874 char buffer
[MAX_REGISTER_RAW_SIZE
];
875 struct frame_info
*frame
= get_current_frame ();
876 frame
->dummy
= start_sp
;
877 /*start_sp |= DMEM_START; */
880 for (regnum
= 0; regnum
< NUM_REGS
; regnum
++)
882 sp
-= REGISTER_RAW_SIZE (regnum
);
883 store_address (buffer
, REGISTER_RAW_SIZE (regnum
), read_register (regnum
));
884 write_memory (sp
, buffer
, REGISTER_RAW_SIZE (regnum
));
886 write_register (SP_REGNUM
, (LONGEST
) sp
);
887 /* now we need to load LR with the return address */
888 write_register (LR_REGNUM
, (LONGEST
) d30v_call_dummy_address ());
893 d30v_pop_dummy_frame (struct frame_info
*fi
)
895 CORE_ADDR sp
= fi
->dummy
;
898 for (regnum
= 0; regnum
< NUM_REGS
; regnum
++)
900 sp
-= REGISTER_RAW_SIZE (regnum
);
901 write_register (regnum
, read_memory_unsigned_integer (sp
, REGISTER_RAW_SIZE (regnum
)));
903 flush_cached_frames (); /* needed? */
908 d30v_push_arguments (int nargs
, value_ptr
*args
, CORE_ADDR sp
,
909 int struct_return
, CORE_ADDR struct_addr
)
911 int i
, len
, index
= 0, regnum
= 2;
912 char buffer
[4], *contents
;
917 /* Pass 1. Put all large args on stack */
918 for (i
= 0; i
< nargs
; i
++)
920 value_ptr arg
= args
[i
];
921 struct type
*arg_type
= check_typedef (VALUE_TYPE (arg
));
922 len
= TYPE_LENGTH (arg_type
);
923 contents
= VALUE_CONTENTS (arg
);
924 val
= extract_signed_integer (contents
, len
);
927 /* put on stack and pass pointers */
929 write_memory (sp
, contents
, len
);
936 for (i
= 0; i
< nargs
; i
++)
938 value_ptr arg
= args
[i
];
939 struct type
*arg_type
= check_typedef (VALUE_TYPE (arg
));
940 len
= TYPE_LENGTH (arg_type
);
941 contents
= VALUE_CONTENTS (arg
);
944 /* we need multiple registers */
947 for (ndx
= 0; len
> 0; ndx
+= 8, len
-= 8)
950 regnum
++; /* all args > 4 bytes start in even register */
954 val
= extract_signed_integer (&contents
[ndx
], 4);
955 write_register (regnum
++, val
);
958 val
= extract_signed_integer (&contents
[ndx
+ 4], 4);
960 val
= extract_signed_integer (&contents
[ndx
+ 4], len
- 4);
961 write_register (regnum
++, val
);
965 /* no more registers available. put it on the stack */
967 /* all args > 4 bytes are padded to a multiple of 8 bytes
968 and start on an 8 byte boundary */
970 sp
-= (sp
& 7); /* align it */
972 sp
-= ((len
+ 7) & ~7); /* allocate space */
973 write_memory (sp
, &contents
[ndx
], len
);
982 val
= extract_signed_integer (contents
, len
);
983 write_register (regnum
++, val
);
987 /* all args are padded to a multiple of 4 bytes (at least) */
988 sp
-= ((len
+ 3) & ~3);
989 write_memory (sp
, contents
, len
);
994 /* stack pointer is not on an 8 byte boundary -- align it */
1000 /* pick an out-of-the-way place to set the return value */
1001 /* for an inferior function call. The link register is set to this */
1002 /* value and a momentary breakpoint is set there. When the breakpoint */
1003 /* is hit, the dummy frame is popped and the previous environment is */
1007 d30v_call_dummy_address (void)
1010 struct minimal_symbol
*sym
;
1012 entry
= entry_point_address ();
1017 sym
= lookup_minimal_symbol ("_start", NULL
, symfile_objfile
);
1019 if (!sym
|| MSYMBOL_TYPE (sym
) != mst_text
)
1022 return SYMBOL_VALUE_ADDRESS (sym
);
1025 /* Given a return value in `regbuf' with a type `valtype',
1026 extract and copy its value into `valbuf'. */
1029 d30v_extract_return_value (struct type
*valtype
, char regbuf
[REGISTER_BYTES
],
1032 memcpy (valbuf
, regbuf
+ REGISTER_BYTE (2), TYPE_LENGTH (valtype
));
1035 /* The following code implements access to, and display of, the D30V's
1036 instruction trace buffer. The buffer consists of 64K or more
1037 4-byte words of data, of which each words includes an 8-bit count,
1038 an 8-bit segment number, and a 16-bit instruction address.
1040 In theory, the trace buffer is continuously capturing instruction
1041 data that the CPU presents on its "debug bus", but in practice, the
1042 ROMified GDB stub only enables tracing when it continues or steps
1043 the program, and stops tracing when the program stops; so it
1044 actually works for GDB to read the buffer counter out of memory and
1045 then read each trace word. The counter records where the tracing
1046 stops, but there is no record of where it started, so we remember
1047 the PC when we resumed and then search backwards in the trace
1048 buffer for a word that includes that address. This is not perfect,
1049 because you will miss trace data if the resumption PC is the target
1050 of a branch. (The value of the buffer counter is semi-random, any
1051 trace data from a previous program stop is gone.) */
1053 /* The address of the last word recorded in the trace buffer. */
1055 #define DBBC_ADDR (0xd80000)
1057 /* The base of the trace buffer, at least for the "Board_0". */
1059 #define TRACE_BUFFER_BASE (0xf40000)
1061 static void trace_command (char *, int);
1063 static void untrace_command (char *, int);
1065 static void trace_info (char *, int);
1067 static void tdisassemble_command (char *, int);
1069 static void display_trace (int, int);
1071 /* True when instruction traces are being collected. */
1075 /* Remembered PC. */
1077 static CORE_ADDR last_pc
;
1079 /* True when trace output should be displayed whenever program stops. */
1081 static int trace_display
;
1083 /* True when trace listing should include source lines. */
1085 static int default_trace_show_source
= 1;
1096 trace_command (char *args
, int from_tty
)
1098 /* Clear the host-side trace buffer, allocating space if needed. */
1099 trace_data
.size
= 0;
1100 if (trace_data
.counts
== NULL
)
1101 trace_data
.counts
= (short *) xmalloc (65536 * sizeof (short));
1102 if (trace_data
.addrs
== NULL
)
1103 trace_data
.addrs
= (CORE_ADDR
*) xmalloc (65536 * sizeof (CORE_ADDR
));
1107 printf_filtered ("Tracing is now on.\n");
1111 untrace_command (char *args
, int from_tty
)
1115 printf_filtered ("Tracing is now off.\n");
1119 trace_info (char *args
, int from_tty
)
1123 if (trace_data
.size
)
1125 printf_filtered ("%d entries in trace buffer:\n", trace_data
.size
);
1127 for (i
= 0; i
< trace_data
.size
; ++i
)
1129 printf_filtered ("%d: %d instruction%s at 0x%s\n",
1130 i
, trace_data
.counts
[i
],
1131 (trace_data
.counts
[i
] == 1 ? "" : "s"),
1132 paddr_nz (trace_data
.addrs
[i
]));
1136 printf_filtered ("No entries in trace buffer.\n");
1138 printf_filtered ("Tracing is currently %s.\n", (tracing
? "on" : "off"));
1141 /* Print the instruction at address MEMADDR in debugged memory,
1142 on STREAM. Returns length of the instruction, in bytes. */
1145 print_insn (CORE_ADDR memaddr
, struct ui_file
*stream
)
1147 /* If there's no disassembler, something is very wrong. */
1148 if (tm_print_insn
== NULL
)
1149 internal_error ("print_insn: no disassembler");
1151 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
)
1152 tm_print_insn_info
.endian
= BFD_ENDIAN_BIG
;
1154 tm_print_insn_info
.endian
= BFD_ENDIAN_LITTLE
;
1155 return (*tm_print_insn
) (memaddr
, &tm_print_insn_info
);
1159 d30v_eva_prepare_to_trace (void)
1164 last_pc
= read_register (PC_REGNUM
);
1167 /* Collect trace data from the target board and format it into a form
1168 more useful for display. */
1171 d30v_eva_get_trace_data (void)
1173 int count
, i
, j
, oldsize
;
1174 int trace_addr
, trace_seg
, trace_cnt
, next_cnt
;
1175 unsigned int last_trace
, trace_word
, next_word
;
1176 unsigned int *tmpspace
;
1181 tmpspace
= xmalloc (65536 * sizeof (unsigned int));
1183 last_trace
= read_memory_unsigned_integer (DBBC_ADDR
, 2) << 2;
1185 /* Collect buffer contents from the target, stopping when we reach
1186 the word recorded when execution resumed. */
1189 while (last_trace
> 0)
1193 read_memory_unsigned_integer (TRACE_BUFFER_BASE
+ last_trace
, 4);
1194 trace_addr
= trace_word
& 0xffff;
1196 /* Ignore an apparently nonsensical entry. */
1197 if (trace_addr
== 0xffd5)
1199 tmpspace
[count
++] = trace_word
;
1200 if (trace_addr
== last_pc
)
1206 /* Move the data to the host-side trace buffer, adjusting counts to
1207 include the last instruction executed and transforming the address
1208 into something that GDB likes. */
1210 for (i
= 0; i
< count
; ++i
)
1212 trace_word
= tmpspace
[i
];
1213 next_word
= ((i
== 0) ? 0 : tmpspace
[i
- 1]);
1214 trace_addr
= trace_word
& 0xffff;
1215 next_cnt
= (next_word
>> 24) & 0xff;
1216 j
= trace_data
.size
+ count
- i
- 1;
1217 trace_data
.addrs
[j
] = (trace_addr
<< 2) + 0x1000000;
1218 trace_data
.counts
[j
] = next_cnt
+ 1;
1221 oldsize
= trace_data
.size
;
1222 trace_data
.size
+= count
;
1227 display_trace (oldsize
, trace_data
.size
);
1231 tdisassemble_command (char *arg
, int from_tty
)
1234 CORE_ADDR low
, high
;
1240 high
= trace_data
.size
;
1242 else if (!(space_index
= (char *) strchr (arg
, ' ')))
1244 low
= parse_and_eval_address (arg
);
1249 /* Two arguments. */
1250 *space_index
= '\0';
1251 low
= parse_and_eval_address (arg
);
1252 high
= parse_and_eval_address (space_index
+ 1);
1257 printf_filtered ("Dump of trace from %s to %s:\n",
1261 display_trace (low
, high
);
1263 printf_filtered ("End of trace dump.\n");
1264 gdb_flush (gdb_stdout
);
1268 display_trace (int low
, int high
)
1270 int i
, count
, trace_show_source
, first
, suppress
;
1271 CORE_ADDR next_address
;
1273 trace_show_source
= default_trace_show_source
;
1274 if (!have_full_symbols () && !have_partial_symbols ())
1276 trace_show_source
= 0;
1277 printf_filtered ("No symbol table is loaded. Use the \"file\" command.\n");
1278 printf_filtered ("Trace will not display any source.\n");
1283 for (i
= low
; i
< high
; ++i
)
1285 next_address
= trace_data
.addrs
[i
];
1286 count
= trace_data
.counts
[i
];
1290 if (trace_show_source
)
1292 struct symtab_and_line sal
, sal_prev
;
1294 sal_prev
= find_pc_line (next_address
- 4, 0);
1295 sal
= find_pc_line (next_address
, 0);
1299 if (first
|| sal
.line
!= sal_prev
.line
)
1300 print_source_lines (sal
.symtab
, sal
.line
, sal
.line
+ 1, 0);
1306 /* FIXME-32x64--assumes sal.pc fits in long. */
1307 printf_filtered ("No source file for address %s.\n",
1308 local_hex_string ((unsigned long) sal
.pc
));
1313 print_address (next_address
, gdb_stdout
);
1314 printf_filtered (":");
1315 printf_filtered ("\t");
1317 next_address
= next_address
+ print_insn (next_address
, gdb_stdout
);
1318 printf_filtered ("\n");
1319 gdb_flush (gdb_stdout
);
1324 extern void (*target_resume_hook
) (void);
1325 extern void (*target_wait_loop_hook
) (void);
1328 _initialize_d30v_tdep (void)
1330 tm_print_insn
= print_insn_d30v
;
1332 target_resume_hook
= d30v_eva_prepare_to_trace
;
1333 target_wait_loop_hook
= d30v_eva_get_trace_data
;
1335 add_info ("flags", print_flags_command
, "Print d30v flags.");
1337 add_com ("trace", class_support
, trace_command
,
1338 "Enable tracing of instruction execution.");
1340 add_com ("untrace", class_support
, untrace_command
,
1341 "Disable tracing of instruction execution.");
1343 add_com ("tdisassemble", class_vars
, tdisassemble_command
,
1344 "Disassemble the trace buffer.\n\
1345 Two optional arguments specify a range of trace buffer entries\n\
1346 as reported by info trace (NOT addresses!).");
1348 add_info ("trace", trace_info
,
1349 "Display info about the trace data buffer.");
1351 add_show_from_set (add_set_cmd ("tracedisplay", no_class
,
1352 var_integer
, (char *) &trace_display
,
1353 "Set automatic display of trace.\n", &setlist
),
1355 add_show_from_set (add_set_cmd ("tracesource", no_class
,
1356 var_integer
, (char *) &default_trace_show_source
,
1357 "Set display of source code with trace.\n", &setlist
),