1 /* Target-dependent code for the TI TMS320C80 (MVP) for GDB, the GNU debugger.
2 Copyright 1996, 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, Boston, MA 02111-1307, USA. */
27 #include "gdb_string.h"
31 /* Function: frame_find_saved_regs
32 Return the frame_saved_regs structure for the frame.
33 Doesn't really work for dummy frames, but it does pass back
34 an empty frame_saved_regs, so I guess that's better than total failure */
37 tic80_frame_find_saved_regs (fi
, regaddr
)
38 struct frame_info
*fi
;
39 struct frame_saved_regs
*regaddr
;
41 memcpy (regaddr
, &fi
->fsr
, sizeof (struct frame_saved_regs
));
44 /* Function: skip_prologue
45 Find end of function prologue. */
48 tic80_skip_prologue (pc
)
51 CORE_ADDR func_addr
, func_end
;
52 struct symtab_and_line sal
;
54 /* See what the symbol table says */
56 if (find_pc_partial_function (pc
, NULL
, &func_addr
, &func_end
))
58 sal
= find_pc_line (func_addr
, 0);
60 if (sal
.line
!= 0 && sal
.end
< func_end
)
63 /* Either there's no line info, or the line after the prologue is after
64 the end of the function. In this case, there probably isn't a
69 /* We can't find the start of this function, so there's nothing we can do. */
73 /* Function: tic80_scan_prologue
74 This function decodes the target function prologue to determine:
75 1) the size of the stack frame
76 2) which registers are saved on it
77 3) the offsets of saved regs
79 This information is stored in the "extra" fields of the frame_info. */
82 tic80_scan_prologue (fi
)
83 struct frame_info
*fi
;
85 struct symtab_and_line sal
;
86 CORE_ADDR prologue_start
, prologue_end
, current_pc
;
88 /* Assume there is no frame until proven otherwise. */
89 fi
->framereg
= SP_REGNUM
;
93 /* this code essentially duplicates skip_prologue,
94 but we need the start address below. */
96 if (find_pc_partial_function (fi
->pc
, NULL
, &prologue_start
, &prologue_end
))
98 sal
= find_pc_line (prologue_start
, 0);
100 if (sal
.line
== 0) /* no line info, use current PC */
101 if (prologue_start
!= entry_point_address ())
102 prologue_end
= fi
->pc
;
104 return; /* _start has no frame or prologue */
105 else if (sal
.end
< prologue_end
) /* next line begins after fn end */
106 prologue_end
= sal
.end
; /* (probably means no prologue) */
110 prologue_end
= prologue_start
+ 40; /* We're in the boondocks: allow for */
111 /* 16 pushes, an add, and "mv fp,sp" */
113 prologue_end
= min (prologue_end
, fi
->pc
);
115 /* Now search the prologue looking for instructions that set up the
116 frame pointer, adjust the stack pointer, and save registers. */
118 for (current_pc
= prologue_start
; current_pc
< prologue_end
; current_pc
+= 4)
124 insn
= read_memory_unsigned_integer (current_pc
, 4);
126 if ((insn
& 0x301000) == 0x301000) /* Long immediate? */
127 /* FIXME - set offset for long immediate instructions */
131 offset
= insn
& 0x7fff; /* extract 15-bit offset */
132 if (offset
& 0x4000) /* if negative, sign-extend */
133 offset
= -(0x8000 - offset
);
136 if ((insn
& 0x7fd0000) == 0x590000) /* st.{w,d} reg, xx(r1) */
138 regno
= ((insn
>> 27) & 0x1f);
139 fi
->fsr
.regs
[regno
] = offset
;
140 if (insn
& 0x8000) /* 64-bit store (st.d)? */
141 fi
->fsr
.regs
[regno
+1] = offset
+4;
143 else if ((insn
& 0xffff8000) == 0x086c8000) /* addu xx, r1, r1 */
144 fi
->framesize
= -offset
;
145 else if ((insn
& 0xffff8000) == 0xf06c8000) /* addu xx, r1, r30 */
147 fi
->framereg
= FP_REGNUM
; /* fp is now valid */
148 fi
->frameoffset
= offset
;
149 break; /* end of stack adjustments */
151 else if (insn
== 0xf03b2001) /* addu r1, r0, r30 */
153 fi
->framereg
= FP_REGNUM
; /* fp is now valid */
155 break; /* end of stack adjustments */
158 /* FIXME - handle long immediate instructions */
159 break; /* anything else isn't prologue */
163 /* Function: init_extra_frame_info
164 This function actually figures out the frame address for a given pc and
165 sp. This is tricky on the c80 because we sometimes don't use an explicit
166 frame pointer, and the previous stack pointer isn't necessarily recorded
167 on the stack. The only reliable way to get this info is to
168 examine the prologue. */
171 tic80_init_extra_frame_info (fi
)
172 struct frame_info
*fi
;
177 fi
->pc
= FRAME_SAVED_PC (fi
->next
);
179 /* Because zero is a valid register offset relative to SP, we initialize
180 the offsets to -1 to indicate unused entries. */
181 for (reg
= 0; reg
< NUM_REGS
; reg
++)
182 fi
->fsr
.regs
[reg
] = -1;
184 if (PC_IN_CALL_DUMMY (fi
->pc
, fi
->frame
, fi
->frame
))
186 /* We need to setup fi->frame here because run_stack_dummy gets it wrong
187 by assuming it's always FP. */
188 fi
->frame
= generic_read_register_dummy (fi
->pc
, fi
->frame
, SP_REGNUM
);
195 tic80_scan_prologue (fi
);
197 if (!fi
->next
) /* this is the innermost frame? */
198 fi
->frame
= read_register (fi
->framereg
);
199 else /* not the innermost frame */
200 /* If this function uses FP as the frame register, and the function
201 it called saved the FP, get the saved FP. */
202 if (fi
->framereg
== FP_REGNUM
&&
203 fi
->next
->fsr
.regs
[FP_REGNUM
] != (unsigned) -1)
204 fi
->frame
= read_memory_integer (fi
->next
->fsr
.regs
[FP_REGNUM
], 4);
206 /* Convert SP-relative offsets of saved registers to real addresses. */
207 for (reg
= 0; reg
< NUM_REGS
; reg
++)
208 if (fi
->fsr
.regs
[reg
] == (unsigned) -1)
209 fi
->fsr
.regs
[reg
] = 0; /* unused entry */
211 fi
->fsr
.regs
[reg
] += fi
->frame
- fi
->frameoffset
;
215 /* Function: find_callers_reg
216 Find REGNUM on the stack. Otherwise, it's in an active register. One thing
217 we might want to do here is to check REGNUM against the clobber mask, and
218 somehow flag it as invalid if it isn't saved on the stack somewhere. This
219 would provide a graceful failure mode when trying to get the value of
220 caller-saves registers for an inner frame. */
223 tic80_find_callers_reg (fi
, regnum
)
224 struct frame_info
*fi
;
227 for (; fi
; fi
= fi
->next
)
228 if (PC_IN_CALL_DUMMY (fi
->pc
, fi
->frame
, fi
->frame
))
229 return generic_read_register_dummy (fi
->pc
, fi
->frame
, regnum
);
230 else if (fi
->fsr
.regs
[regnum
] != 0)
231 return read_memory_integer (fi
->fsr
.regs
[regnum
],
232 REGISTER_RAW_SIZE(regnum
));
233 return read_register (regnum
);
236 /* Function: frame_chain
237 Given a GDB frame, determine the address of the calling function's frame.
238 This will be used to create a new GDB frame struct, and then
239 INIT_EXTRA_FRAME_INFO and INIT_FRAME_PC will be called for the new frame.
240 For c80, we save the frame size when we initialize the frame_info. */
243 tic80_frame_chain (fi
)
244 struct frame_info
*fi
;
246 CORE_ADDR fn_start
, callers_pc
, fp
;
248 /* is this a dummy frame? */
249 if (PC_IN_CALL_DUMMY(fi
->pc
, fi
->frame
, fi
->frame
))
250 return fi
->frame
; /* dummy frame same as caller's frame */
252 /* is caller-of-this a dummy frame? */
253 callers_pc
= FRAME_SAVED_PC(fi
); /* find out who called us: */
254 fp
= tic80_find_callers_reg (fi
, FP_REGNUM
);
255 if (PC_IN_CALL_DUMMY(callers_pc
, fp
, fp
))
256 return fp
; /* dummy frame's frame may bear no relation to ours */
258 if (find_pc_partial_function (fi
->pc
, 0, &fn_start
, 0))
259 if (fn_start
== entry_point_address ())
260 return 0; /* in _start fn, don't chain further */
262 if (fi
->framereg
== FP_REGNUM
)
263 return tic80_find_callers_reg (fi
, FP_REGNUM
);
265 return fi
->frame
+ fi
->framesize
;
268 /* Function: pop_frame
269 Discard from the stack the innermost frame,
270 restoring all saved registers. */
273 tic80_pop_frame (frame
)
274 struct frame_info
*frame
;
278 if (PC_IN_CALL_DUMMY (frame
->pc
, frame
->frame
, frame
->frame
))
279 generic_pop_dummy_frame ();
282 for (regnum
= 0; regnum
< NUM_REGS
; regnum
++)
283 if (frame
->fsr
.regs
[regnum
] != 0)
284 write_register (regnum
,
285 read_memory_integer (frame
->fsr
.regs
[regnum
], 4));
287 write_register (PC_REGNUM
, FRAME_SAVED_PC (frame
));
288 write_register (SP_REGNUM
, read_register (FP_REGNUM
));
290 if (read_register (PSW_REGNUM
) & 0x80)
291 write_register (SPU_REGNUM
, read_register (SP_REGNUM
));
293 write_register (SPI_REGNUM
, read_register (SP_REGNUM
));
296 flush_cached_frames ();
300 /* Function: frame_saved_pc
301 Find the caller of this frame. We do this by seeing if LR_REGNUM is saved
302 in the stack anywhere, otherwise we get it from the registers. */
305 tic80_frame_saved_pc (fi
)
306 struct frame_info
*fi
;
308 if (PC_IN_CALL_DUMMY(fi
->pc
, fi
->frame
, fi
->frame
))
309 return generic_read_register_dummy (fi
->pc
, fi
->frame
, PC_REGNUM
);
311 return tic80_find_callers_reg (fi
, LR_REGNUM
);
314 /* Function: tic80_push_return_address (pc, sp)
315 Set up the return address for the inferior function call.
316 Necessary for targets that don't actually execute a JSR/BSR instruction
317 (ie. when using an empty CALL_DUMMY) */
320 tic80_push_return_address (pc
, sp
)
324 write_register (LR_REGNUM
, CALL_DUMMY_ADDRESS ());
329 /* Function: push_arguments
330 Setup the function arguments for calling a function in the inferior.
332 On the TI C80 architecture, there are six register pairs (R2/R3 to R12/13)
333 which are dedicated for passing function arguments. Up to the first six
334 arguments (depending on size) may go into these registers.
335 The rest go on the stack.
337 Arguments that are smaller than 4 bytes will still take up a whole
338 register or a whole 32-bit word on the stack, and will be
339 right-justified in the register or the stack word. This includes
340 chars, shorts, and small aggregate types.
342 Arguments that are four bytes or less in size are placed in the
343 even-numbered register of a register pair, and the odd-numbered
344 register is not used.
346 Arguments of 8 bytes size (such as floating point doubles) are placed
347 in a register pair. The least significant 32-bit word is placed in
348 the even-numbered register, and the most significant word in the
349 odd-numbered register.
351 Aggregate types with sizes between 4 and 8 bytes are passed
352 entirely on the stack, and are left-justified within the
353 double-word (as opposed to aggregates smaller than 4 bytes
354 which are right-justified).
356 Aggregates of greater than 8 bytes are first copied onto the stack,
357 and then a pointer to the copy is passed in the place of the normal
358 argument (either in a register if available, or on the stack).
360 Functions that must return an aggregate type can return it in the
361 normal return value registers (R2 and R3) if its size is 8 bytes or
362 less. For larger return values, the caller must allocate space for
363 the callee to copy the return value to. A pointer to this space is
364 passed as an implicit first argument, always in R0. */
367 tic80_push_arguments (nargs
, args
, sp
, struct_return
, struct_addr
)
371 unsigned char struct_return
;
372 CORE_ADDR struct_addr
;
374 int stack_offset
, stack_alloc
;
382 int odd_sized_struct
;
385 /* first force sp to a 4-byte alignment */
388 argreg
= ARG0_REGNUM
;
389 /* The "struct return pointer" pseudo-argument goes in R0 */
391 write_register (argreg
++, struct_addr
);
393 /* Now make sure there's space on the stack */
394 for (argnum
= 0, stack_alloc
= 0;
395 argnum
< nargs
; argnum
++)
396 stack_alloc
+= ((TYPE_LENGTH(VALUE_TYPE(args
[argnum
])) + 3) & ~3);
397 sp
-= stack_alloc
; /* make room on stack for args */
400 /* Now load as many as possible of the first arguments into
401 registers, and push the rest onto the stack. There are 16 bytes
402 in four registers available. Loop thru args from first to last. */
404 argreg
= ARG0_REGNUM
;
405 for (argnum
= 0, stack_offset
= 0; argnum
< nargs
; argnum
++)
407 type
= VALUE_TYPE (args
[argnum
]);
408 len
= TYPE_LENGTH (type
);
409 memset (valbuf
, 0, sizeof (valbuf
));
410 val
= (char *) VALUE_CONTENTS (args
[argnum
]);
412 /* FIXME -- tic80 can take doubleword arguments in register pairs */
413 is_struct
= (type
->code
== TYPE_CODE_STRUCT
);
414 odd_sized_struct
= 0;
419 { /* value gets right-justified in the register or stack word */
420 memcpy (valbuf
+ (4 - len
), val
, len
);
423 if (len
> 4 && (len
& 3) != 0)
424 odd_sized_struct
= 1; /* such structs go entirely on stack */
428 /* Structs are always passed by reference. */
429 write_register (argreg
, sp
+ stack_offset
);
435 if (is_struct
|| argreg
> ARGLAST_REGNUM
|| odd_sized_struct
)
436 { /* must go on the stack */
437 write_memory (sp
+ stack_offset
, val
, 4);
440 /* NOTE WELL!!!!! This is not an "else if" clause!!!
441 That's because some things get passed on the stack
442 AND in the registers! */
443 if (!is_struct
&& argreg
<= ARGLAST_REGNUM
)
444 { /* there's room in a register */
445 regval
= extract_address (val
, REGISTER_RAW_SIZE(argreg
));
446 write_register (argreg
, regval
);
447 argreg
+= 2; /* FIXME -- what about doubleword args? */
449 /* Store the value 4 bytes at a time. This means that things
450 larger than 4 bytes may go partly in registers and partly
452 len
-= REGISTER_RAW_SIZE(argreg
);
453 val
+= REGISTER_RAW_SIZE(argreg
);
459 /* Function: get_saved_register
460 Just call the generic_get_saved_register function. */
463 get_saved_register (raw_buffer
, optimized
, addrp
, frame
, regnum
, lval
)
467 struct frame_info
*frame
;
469 enum lval_type
*lval
;
471 generic_get_saved_register (raw_buffer
, optimized
, addrp
,
472 frame
, regnum
, lval
);
475 /* Function: tic80_write_sp
476 Because SP is really a read-only register that mirrors either SPU or SPI,
477 we must actually write one of those two as well, depending on PSW. */
484 unsigned long psw
= read_register (PSW_REGNUM
);
486 if (psw
& 0x80) /* stack mode: user or interrupt */
487 write_register (SPU_REGNUM
, val
);
489 write_register (SPI_REGNUM
, val
);
491 write_register (SP_REGNUM
, val
);
495 _initialize_tic80_tdep ()
497 tm_print_insn
= print_insn_tic80
;
This page took 0.038759 seconds and 4 git commands to generate.