1 /* Target-dependent code for the TI TMS320C80 (MVP) for GDB, the GNU debugger.
2 Copyright 1996, 1997, 1999, 2000, 2001 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. */
28 #include "gdb_string.h"
33 /* Function: frame_find_saved_regs
34 Return the frame_saved_regs structure for the frame.
35 Doesn't really work for dummy frames, but it does pass back
36 an empty frame_saved_regs, so I guess that's better than total failure */
39 tic80_frame_find_saved_regs (struct frame_info
*fi
,
40 struct frame_saved_regs
*regaddr
)
42 memcpy (regaddr
, &fi
->fsr
, sizeof (struct frame_saved_regs
));
45 /* Function: skip_prologue
46 Find end of function prologue. */
49 tic80_skip_prologue (CORE_ADDR 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 (struct frame_info
*fi
)
84 struct symtab_and_line sal
;
85 CORE_ADDR prologue_start
, prologue_end
, current_pc
;
87 /* Assume there is no frame until proven otherwise. */
88 fi
->framereg
= SP_REGNUM
;
92 /* this code essentially duplicates skip_prologue,
93 but we need the start address below. */
95 if (find_pc_partial_function (fi
->pc
, NULL
, &prologue_start
, &prologue_end
))
97 sal
= find_pc_line (prologue_start
, 0);
99 if (sal
.line
== 0) /* no line info, use current PC */
100 if (prologue_start
!= entry_point_address ())
101 prologue_end
= fi
->pc
;
103 return; /* _start has no frame or prologue */
104 else if (sal
.end
< prologue_end
) /* next line begins after fn end */
105 prologue_end
= sal
.end
; /* (probably means no prologue) */
109 prologue_end
= prologue_start
+ 40; /* We're in the boondocks: allow for */
110 /* 16 pushes, an add, and "mv fp,sp" */
112 prologue_end
= min (prologue_end
, fi
->pc
);
114 /* Now search the prologue looking for instructions that set up the
115 frame pointer, adjust the stack pointer, and save registers. */
117 for (current_pc
= prologue_start
; current_pc
< prologue_end
; current_pc
+= 4)
123 insn
= read_memory_unsigned_integer (current_pc
, 4);
125 if ((insn
& 0x301000) == 0x301000) /* Long immediate? */
126 /* FIXME - set offset for long immediate instructions */
130 offset
= insn
& 0x7fff; /* extract 15-bit offset */
131 if (offset
& 0x4000) /* if negative, sign-extend */
132 offset
= -(0x8000 - offset
);
135 if ((insn
& 0x7fd0000) == 0x590000) /* st.{w,d} reg, xx(r1) */
137 regno
= ((insn
>> 27) & 0x1f);
138 fi
->fsr
.regs
[regno
] = offset
;
139 if (insn
& 0x8000) /* 64-bit store (st.d)? */
140 fi
->fsr
.regs
[regno
+ 1] = offset
+ 4;
142 else if ((insn
& 0xffff8000) == 0x086c8000) /* addu xx, r1, r1 */
143 fi
->framesize
= -offset
;
144 else if ((insn
& 0xffff8000) == 0xf06c8000) /* addu xx, r1, r30 */
146 fi
->framereg
= FP_REGNUM
; /* fp is now valid */
147 fi
->frameoffset
= offset
;
148 break; /* end of stack adjustments */
150 else if (insn
== 0xf03b2001) /* addu r1, r0, r30 */
152 fi
->framereg
= FP_REGNUM
; /* fp is now valid */
154 break; /* end of stack adjustments */
157 /* FIXME - handle long immediate instructions */
158 break; /* anything else isn't prologue */
162 /* Function: init_extra_frame_info
163 This function actually figures out the frame address for a given pc and
164 sp. This is tricky on the c80 because we sometimes don't use an explicit
165 frame pointer, and the previous stack pointer isn't necessarily recorded
166 on the stack. The only reliable way to get this info is to
167 examine the prologue. */
170 tic80_init_extra_frame_info (struct frame_info
*fi
)
175 fi
->pc
= FRAME_SAVED_PC (fi
->next
);
177 /* Because zero is a valid register offset relative to SP, we initialize
178 the offsets to -1 to indicate unused entries. */
179 for (reg
= 0; reg
< NUM_REGS
; reg
++)
180 fi
->fsr
.regs
[reg
] = -1;
182 if (PC_IN_CALL_DUMMY (fi
->pc
, fi
->frame
, fi
->frame
))
184 /* We need to setup fi->frame here because run_stack_dummy gets it wrong
185 by assuming it's always FP. */
186 fi
->frame
= generic_read_register_dummy (fi
->pc
, fi
->frame
, SP_REGNUM
);
193 tic80_scan_prologue (fi
);
195 if (!fi
->next
) /* this is the innermost frame? */
196 fi
->frame
= read_register (fi
->framereg
);
198 /* not the innermost frame */
199 /* If this function uses FP as the frame register, and the function
200 it called saved the FP, get the saved FP. */ if (fi
->framereg
== FP_REGNUM
&&
201 fi
->next
->fsr
.regs
[FP_REGNUM
] != (unsigned) -1)
202 fi
->frame
= read_memory_integer (fi
->next
->fsr
.regs
[FP_REGNUM
], 4);
204 /* Convert SP-relative offsets of saved registers to real addresses. */
205 for (reg
= 0; reg
< NUM_REGS
; reg
++)
206 if (fi
->fsr
.regs
[reg
] == (unsigned) -1)
207 fi
->fsr
.regs
[reg
] = 0; /* unused entry */
209 fi
->fsr
.regs
[reg
] += fi
->frame
- fi
->frameoffset
;
213 /* Function: find_callers_reg
214 Find REGNUM on the stack. Otherwise, it's in an active register. One thing
215 we might want to do here is to check REGNUM against the clobber mask, and
216 somehow flag it as invalid if it isn't saved on the stack somewhere. This
217 would provide a graceful failure mode when trying to get the value of
218 caller-saves registers for an inner frame. */
221 tic80_find_callers_reg (struct frame_info
*fi
, int regnum
)
223 for (; fi
; fi
= fi
->next
)
224 if (PC_IN_CALL_DUMMY (fi
->pc
, fi
->frame
, fi
->frame
))
225 return generic_read_register_dummy (fi
->pc
, fi
->frame
, regnum
);
226 else if (fi
->fsr
.regs
[regnum
] != 0)
227 return read_memory_integer (fi
->fsr
.regs
[regnum
],
228 REGISTER_RAW_SIZE (regnum
));
229 return read_register (regnum
);
232 /* Function: frame_chain
233 Given a GDB frame, determine the address of the calling function's frame.
234 This will be used to create a new GDB frame struct, and then
235 INIT_EXTRA_FRAME_INFO and INIT_FRAME_PC will be called for the new frame.
236 For c80, we save the frame size when we initialize the frame_info. */
239 tic80_frame_chain (struct frame_info
*fi
)
241 CORE_ADDR fn_start
, callers_pc
, fp
;
243 /* is this a dummy frame? */
244 if (PC_IN_CALL_DUMMY (fi
->pc
, fi
->frame
, fi
->frame
))
245 return fi
->frame
; /* dummy frame same as caller's frame */
247 /* is caller-of-this a dummy frame? */
248 callers_pc
= FRAME_SAVED_PC (fi
); /* find out who called us: */
249 fp
= tic80_find_callers_reg (fi
, FP_REGNUM
);
250 if (PC_IN_CALL_DUMMY (callers_pc
, fp
, fp
))
251 return fp
; /* dummy frame's frame may bear no relation to ours */
253 if (find_pc_partial_function (fi
->pc
, 0, &fn_start
, 0))
254 if (fn_start
== entry_point_address ())
255 return 0; /* in _start fn, don't chain further */
257 if (fi
->framereg
== FP_REGNUM
)
258 return tic80_find_callers_reg (fi
, FP_REGNUM
);
260 return fi
->frame
+ fi
->framesize
;
263 /* Function: pop_frame
264 Discard from the stack the innermost frame,
265 restoring all saved registers. */
268 tic80_pop_frame (struct frame_info
*frame
)
272 if (PC_IN_CALL_DUMMY (frame
->pc
, frame
->frame
, frame
->frame
))
273 generic_pop_dummy_frame ();
276 for (regnum
= 0; regnum
< NUM_REGS
; regnum
++)
277 if (frame
->fsr
.regs
[regnum
] != 0)
278 write_register (regnum
,
279 read_memory_integer (frame
->fsr
.regs
[regnum
], 4));
281 write_register (PC_REGNUM
, FRAME_SAVED_PC (frame
));
282 write_register (SP_REGNUM
, read_register (FP_REGNUM
));
284 if (read_register (PSW_REGNUM
) & 0x80)
285 write_register (SPU_REGNUM
, read_register (SP_REGNUM
));
287 write_register (SPI_REGNUM
, read_register (SP_REGNUM
));
290 flush_cached_frames ();
294 /* Function: frame_saved_pc
295 Find the caller of this frame. We do this by seeing if LR_REGNUM is saved
296 in the stack anywhere, otherwise we get it from the registers. */
299 tic80_frame_saved_pc (struct frame_info
*fi
)
301 if (PC_IN_CALL_DUMMY (fi
->pc
, fi
->frame
, fi
->frame
))
302 return generic_read_register_dummy (fi
->pc
, fi
->frame
, PC_REGNUM
);
304 return tic80_find_callers_reg (fi
, LR_REGNUM
);
307 /* Function: tic80_push_return_address (pc, sp)
308 Set up the return address for the inferior function call.
309 Necessary for targets that don't actually execute a JSR/BSR instruction
310 (ie. when using an empty CALL_DUMMY) */
313 tic80_push_return_address (CORE_ADDR pc
, CORE_ADDR sp
)
315 write_register (LR_REGNUM
, CALL_DUMMY_ADDRESS ());
320 /* Function: push_arguments
321 Setup the function arguments for calling a function in the inferior.
323 On the TI C80 architecture, there are six register pairs (R2/R3 to R12/13)
324 which are dedicated for passing function arguments. Up to the first six
325 arguments (depending on size) may go into these registers.
326 The rest go on the stack.
328 Arguments that are smaller than 4 bytes will still take up a whole
329 register or a whole 32-bit word on the stack, and will be
330 right-justified in the register or the stack word. This includes
331 chars, shorts, and small aggregate types.
333 Arguments that are four bytes or less in size are placed in the
334 even-numbered register of a register pair, and the odd-numbered
335 register is not used.
337 Arguments of 8 bytes size (such as floating point doubles) are placed
338 in a register pair. The least significant 32-bit word is placed in
339 the even-numbered register, and the most significant word in the
340 odd-numbered register.
342 Aggregate types with sizes between 4 and 8 bytes are passed
343 entirely on the stack, and are left-justified within the
344 double-word (as opposed to aggregates smaller than 4 bytes
345 which are right-justified).
347 Aggregates of greater than 8 bytes are first copied onto the stack,
348 and then a pointer to the copy is passed in the place of the normal
349 argument (either in a register if available, or on the stack).
351 Functions that must return an aggregate type can return it in the
352 normal return value registers (R2 and R3) if its size is 8 bytes or
353 less. For larger return values, the caller must allocate space for
354 the callee to copy the return value to. A pointer to this space is
355 passed as an implicit first argument, always in R0. */
358 tic80_push_arguments (int nargs
, value_ptr
*args
, CORE_ADDR sp
,
359 unsigned char struct_return
, CORE_ADDR struct_addr
)
361 int stack_offset
, stack_alloc
;
369 int odd_sized_struct
;
372 /* first force sp to a 4-byte alignment */
375 argreg
= ARG0_REGNUM
;
376 /* The "struct return pointer" pseudo-argument goes in R0 */
378 write_register (argreg
++, struct_addr
);
380 /* Now make sure there's space on the stack */
381 for (argnum
= 0, stack_alloc
= 0;
382 argnum
< nargs
; argnum
++)
383 stack_alloc
+= ((TYPE_LENGTH (VALUE_TYPE (args
[argnum
])) + 3) & ~3);
384 sp
-= stack_alloc
; /* make room on stack for args */
387 /* Now load as many as possible of the first arguments into
388 registers, and push the rest onto the stack. There are 16 bytes
389 in four registers available. Loop thru args from first to last. */
391 argreg
= ARG0_REGNUM
;
392 for (argnum
= 0, stack_offset
= 0; argnum
< nargs
; argnum
++)
394 type
= VALUE_TYPE (args
[argnum
]);
395 len
= TYPE_LENGTH (type
);
396 memset (valbuf
, 0, sizeof (valbuf
));
397 val
= (char *) VALUE_CONTENTS (args
[argnum
]);
399 /* FIXME -- tic80 can take doubleword arguments in register pairs */
400 is_struct
= (type
->code
== TYPE_CODE_STRUCT
);
401 odd_sized_struct
= 0;
406 { /* value gets right-justified in the register or stack word */
407 memcpy (valbuf
+ (4 - len
), val
, len
);
410 if (len
> 4 && (len
& 3) != 0)
411 odd_sized_struct
= 1; /* such structs go entirely on stack */
415 /* Structs are always passed by reference. */
416 write_register (argreg
, sp
+ stack_offset
);
422 if (is_struct
|| argreg
> ARGLAST_REGNUM
|| odd_sized_struct
)
423 { /* must go on the stack */
424 write_memory (sp
+ stack_offset
, val
, 4);
427 /* NOTE WELL!!!!! This is not an "else if" clause!!!
428 That's because some things get passed on the stack
429 AND in the registers! */
430 if (!is_struct
&& argreg
<= ARGLAST_REGNUM
)
431 { /* there's room in a register */
432 regval
= extract_address (val
, REGISTER_RAW_SIZE (argreg
));
433 write_register (argreg
, regval
);
434 argreg
+= 2; /* FIXME -- what about doubleword args? */
436 /* Store the value 4 bytes at a time. This means that things
437 larger than 4 bytes may go partly in registers and partly
439 len
-= REGISTER_RAW_SIZE (argreg
);
440 val
+= REGISTER_RAW_SIZE (argreg
);
446 /* Function: tic80_write_sp
447 Because SP is really a read-only register that mirrors either SPU or SPI,
448 we must actually write one of those two as well, depending on PSW. */
451 tic80_write_sp (CORE_ADDR val
)
454 unsigned long psw
= read_register (PSW_REGNUM
);
456 if (psw
& 0x80) /* stack mode: user or interrupt */
457 write_register (SPU_REGNUM
, val
);
459 write_register (SPI_REGNUM
, val
);
461 write_register (SP_REGNUM
, val
);
465 _initialize_tic80_tdep (void)
467 tm_print_insn
= print_insn_tic80
;
This page took 0.049281 seconds and 4 git commands to generate.