/* Target-dependent code for the TI TMS320C80 (MVP) for GDB, the GNU debugger.
Copyright 1996, Free Software Foundation, Inc.
-This file is part of GDB.
+ This file is part of GDB.
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-GNU General Public License for more details.
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
-You should have received a copy of the GNU General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330,
+ Boston, MA 02111-1307, USA. */
#include "defs.h"
#include "value.h"
Doesn't really work for dummy frames, but it does pass back
an empty frame_saved_regs, so I guess that's better than total failure */
-void
+void
tic80_frame_find_saved_regs (fi, regaddr)
struct frame_info *fi;
struct frame_saved_regs *regaddr;
/* Function: tic80_scan_prologue
This function decodes the target function prologue to determine:
- 1) the size of the stack frame
- 2) which registers are saved on it
- 3) the offsets of saved regs
- 4) the frame size
+ 1) the size of the stack frame
+ 2) which registers are saved on it
+ 3) the offsets of saved regs
+ 4) the frame size
This information is stored in the "extra" fields of the frame_info. */
static void
{
sal = find_pc_line (prologue_start, 0);
- if (sal.line == 0) /* no line info, use current PC */
+ if (sal.line == 0) /* no line info, use current PC */
if (prologue_start != entry_point_address ())
prologue_end = fi->pc;
else
- return; /* _start has no frame or prologue */
+ return; /* _start has no frame or prologue */
else if (sal.end < prologue_end) /* next line begins after fn end */
- prologue_end = sal.end; /* (probably means no prologue) */
+ prologue_end = sal.end; /* (probably means no prologue) */
}
else
/* FIXME */
- prologue_end = prologue_start + 40; /* We're in the boondocks: allow for */
- /* 16 pushes, an add, and "mv fp,sp" */
+ prologue_end = prologue_start + 40; /* We're in the boondocks: allow for */
+ /* 16 pushes, an add, and "mv fp,sp" */
prologue_end = min (prologue_end, fi->pc);
current_pc += 4;
else
{
- offset = insn & 0x7fff; /* extract 15-bit offset */
- if (offset & 0x4000) /* if negative, sign-extend */
+ offset = insn & 0x7fff; /* extract 15-bit offset */
+ if (offset & 0x4000) /* if negative, sign-extend */
offset = -(0x8000 - offset);
}
{
regno = ((insn >> 27) & 0x1f);
fi->fsr.regs[regno] = offset;
- if (insn & 0x8000) /* 64-bit store (st.d)? */
- fi->fsr.regs[regno+1] = offset+4;
+ if (insn & 0x8000) /* 64-bit store (st.d)? */
+ fi->fsr.regs[regno + 1] = offset + 4;
}
- else if ((insn & 0xffff8000) == 0x086c8000) /* addu xx, r1, r1 */
+ else if ((insn & 0xffff8000) == 0x086c8000) /* addu xx, r1, r1 */
fi->framesize = -offset;
- else if ((insn & 0xffff8000) == 0xf06c8000) /* addu xx, r1, r30 */
+ else if ((insn & 0xffff8000) == 0xf06c8000) /* addu xx, r1, r30 */
{
- fi->framereg = FP_REGNUM; /* fp is now valid */
+ fi->framereg = FP_REGNUM; /* fp is now valid */
fi->frameoffset = offset;
- break; /* end of stack adjustments */
+ break; /* end of stack adjustments */
}
- else if (insn == 0xf03b2001) /* addu r1, r0, r30 */
+ else if (insn == 0xf03b2001) /* addu r1, r0, r30 */
{
- fi->framereg = FP_REGNUM; /* fp is now valid */
+ fi->framereg = FP_REGNUM; /* fp is now valid */
fi->frameoffset = 0;
- break; /* end of stack adjustments */
+ break; /* end of stack adjustments */
}
else
/* FIXME - handle long immediate instructions */
- break; /* anything else isn't prologue */
+ break; /* anything else isn't prologue */
}
}
if (PC_IN_CALL_DUMMY (fi->pc, fi->frame, fi->frame))
{
/* We need to setup fi->frame here because run_stack_dummy gets it wrong
- by assuming it's always FP. */
+ by assuming it's always FP. */
fi->frame = generic_read_register_dummy (fi->pc, fi->frame, SP_REGNUM);
fi->framesize = 0;
fi->frameoffset = 0;
return;
}
- else
+ else
{
tic80_scan_prologue (fi);
- if (!fi->next) /* this is the innermost frame? */
+ if (!fi->next) /* this is the innermost frame? */
fi->frame = read_register (fi->framereg);
- else /* not the innermost frame */
+ else
+ /* not the innermost frame */
/* If this function uses FP as the frame register, and the function
- it called saved the FP, get the saved FP. */
- if (fi->framereg == FP_REGNUM &&
- fi->next->fsr.regs[FP_REGNUM] != (unsigned) -1)
- fi->frame = read_memory_integer (fi->next->fsr.regs[FP_REGNUM], 4);
+ it called saved the FP, get the saved FP. */ if (fi->framereg == FP_REGNUM &&
+ fi->next->fsr.regs[FP_REGNUM] != (unsigned) -1)
+ fi->frame = read_memory_integer (fi->next->fsr.regs[FP_REGNUM], 4);
/* Convert SP-relative offsets of saved registers to real addresses. */
for (reg = 0; reg < NUM_REGS; reg++)
if (fi->fsr.regs[reg] == (unsigned) -1)
- fi->fsr.regs[reg] = 0; /* unused entry */
- else
- fi->fsr.regs[reg] += fi->frame - fi->frameoffset;
+ fi->fsr.regs[reg] = 0; /* unused entry */
+ else
+ fi->fsr.regs[reg] += fi->frame - fi->frameoffset;
}
}
if (PC_IN_CALL_DUMMY (fi->pc, fi->frame, fi->frame))
return generic_read_register_dummy (fi->pc, fi->frame, regnum);
else if (fi->fsr.regs[regnum] != 0)
- return read_memory_integer (fi->fsr.regs[regnum],
- REGISTER_RAW_SIZE(regnum));
+ return read_memory_integer (fi->fsr.regs[regnum],
+ REGISTER_RAW_SIZE (regnum));
return read_register (regnum);
}
CORE_ADDR fn_start, callers_pc, fp;
/* is this a dummy frame? */
- if (PC_IN_CALL_DUMMY(fi->pc, fi->frame, fi->frame))
- return fi->frame; /* dummy frame same as caller's frame */
+ if (PC_IN_CALL_DUMMY (fi->pc, fi->frame, fi->frame))
+ return fi->frame; /* dummy frame same as caller's frame */
/* is caller-of-this a dummy frame? */
- callers_pc = FRAME_SAVED_PC(fi); /* find out who called us: */
+ callers_pc = FRAME_SAVED_PC (fi); /* find out who called us: */
fp = tic80_find_callers_reg (fi, FP_REGNUM);
- if (PC_IN_CALL_DUMMY(callers_pc, fp, fp))
- return fp; /* dummy frame's frame may bear no relation to ours */
+ if (PC_IN_CALL_DUMMY (callers_pc, fp, fp))
+ return fp; /* dummy frame's frame may bear no relation to ours */
if (find_pc_partial_function (fi->pc, 0, &fn_start, 0))
if (fn_start == entry_point_address ())
- return 0; /* in _start fn, don't chain further */
+ return 0; /* in _start fn, don't chain further */
if (fi->framereg == FP_REGNUM)
return tic80_find_callers_reg (fi, FP_REGNUM);
{
for (regnum = 0; regnum < NUM_REGS; regnum++)
if (frame->fsr.regs[regnum] != 0)
- write_register (regnum,
+ write_register (regnum,
read_memory_integer (frame->fsr.regs[regnum], 4));
write_register (PC_REGNUM, FRAME_SAVED_PC (frame));
tic80_frame_saved_pc (fi)
struct frame_info *fi;
{
- if (PC_IN_CALL_DUMMY(fi->pc, fi->frame, fi->frame))
+ if (PC_IN_CALL_DUMMY (fi->pc, fi->frame, fi->frame))
return generic_read_register_dummy (fi->pc, fi->frame, PC_REGNUM);
else
return tic80_find_callers_reg (fi, LR_REGNUM);
register or a whole 32-bit word on the stack, and will be
right-justified in the register or the stack word. This includes
chars, shorts, and small aggregate types.
-
+
Arguments that are four bytes or less in size are placed in the
even-numbered register of a register pair, and the odd-numbered
register is not used.
/* first force sp to a 4-byte alignment */
sp = sp & ~3;
- argreg = ARG0_REGNUM;
+ argreg = ARG0_REGNUM;
/* The "struct return pointer" pseudo-argument goes in R0 */
if (struct_return)
- write_register (argreg++, struct_addr);
-
+ write_register (argreg++, struct_addr);
+
/* Now make sure there's space on the stack */
for (argnum = 0, stack_alloc = 0;
argnum < nargs; argnum++)
- stack_alloc += ((TYPE_LENGTH(VALUE_TYPE(args[argnum])) + 3) & ~3);
- sp -= stack_alloc; /* make room on stack for args */
-
-
+ stack_alloc += ((TYPE_LENGTH (VALUE_TYPE (args[argnum])) + 3) & ~3);
+ sp -= stack_alloc; /* make room on stack for args */
+
+
/* Now load as many as possible of the first arguments into
registers, and push the rest onto the stack. There are 16 bytes
in four registers available. Loop thru args from first to last. */
-
+
argreg = ARG0_REGNUM;
for (argnum = 0, stack_offset = 0; argnum < nargs; argnum++)
{
type = VALUE_TYPE (args[argnum]);
- len = TYPE_LENGTH (type);
+ len = TYPE_LENGTH (type);
memset (valbuf, 0, sizeof (valbuf));
val = (char *) VALUE_CONTENTS (args[argnum]);
-
+
/* FIXME -- tic80 can take doubleword arguments in register pairs */
is_struct = (type->code == TYPE_CODE_STRUCT);
odd_sized_struct = 0;
- if (! is_struct)
+ if (!is_struct)
{
if (len < 4)
- { /* value gets right-justified in the register or stack word */
+ { /* value gets right-justified in the register or stack word */
memcpy (valbuf + (4 - len), val, len);
val = valbuf;
}
if (len > 4 && (len & 3) != 0)
- odd_sized_struct = 1; /* such structs go entirely on stack */
+ odd_sized_struct = 1; /* such structs go entirely on stack */
}
else
{
/* Structs are always passed by reference. */
write_register (argreg, sp + stack_offset);
- argreg ++;
+ argreg++;
}
while (len > 0)
- {
- if (is_struct || argreg > ARGLAST_REGNUM || odd_sized_struct)
- { /* must go on the stack */
- write_memory (sp + stack_offset, val, 4);
- stack_offset += 4;
- }
- /* NOTE WELL!!!!! This is not an "else if" clause!!!
- That's because some things get passed on the stack
- AND in the registers! */
- if (!is_struct && argreg <= ARGLAST_REGNUM)
- { /* there's room in a register */
- regval = extract_address (val, REGISTER_RAW_SIZE(argreg));
- write_register (argreg, regval);
+ {
+ if (is_struct || argreg > ARGLAST_REGNUM || odd_sized_struct)
+ { /* must go on the stack */
+ write_memory (sp + stack_offset, val, 4);
+ stack_offset += 4;
+ }
+ /* NOTE WELL!!!!! This is not an "else if" clause!!!
+ That's because some things get passed on the stack
+ AND in the registers! */
+ if (!is_struct && argreg <= ARGLAST_REGNUM)
+ { /* there's room in a register */
+ regval = extract_address (val, REGISTER_RAW_SIZE (argreg));
+ write_register (argreg, regval);
argreg += 2; /* FIXME -- what about doubleword args? */
- }
- /* Store the value 4 bytes at a time. This means that things
- larger than 4 bytes may go partly in registers and partly
- on the stack. */
- len -= REGISTER_RAW_SIZE(argreg);
- val += REGISTER_RAW_SIZE(argreg);
- }
+ }
+ /* Store the value 4 bytes at a time. This means that things
+ larger than 4 bytes may go partly in registers and partly
+ on the stack. */
+ len -= REGISTER_RAW_SIZE (argreg);
+ val += REGISTER_RAW_SIZE (argreg);
+ }
}
return sp;
}
-/* Function: get_saved_register
- Just call the generic_get_saved_register function. */
-
-void
-get_saved_register (raw_buffer, optimized, addrp, frame, regnum, lval)
- char *raw_buffer;
- int *optimized;
- CORE_ADDR *addrp;
- struct frame_info *frame;
- int regnum;
- enum lval_type *lval;
-{
- generic_get_saved_register (raw_buffer, optimized, addrp,
- frame, regnum, lval);
-}
-
/* Function: tic80_write_sp
Because SP is really a read-only register that mirrors either SPU or SPI,
we must actually write one of those two as well, depending on PSW. */
#if 0
unsigned long psw = read_register (PSW_REGNUM);
- if (psw & 0x80) /* stack mode: user or interrupt */
+ if (psw & 0x80) /* stack mode: user or interrupt */
write_register (SPU_REGNUM, val);
else
write_register (SPI_REGNUM, val);
{
tm_print_insn = print_insn_tic80;
}
-
projects / deliverable / binutils-gdb.git / blobdiff