/* Machine-dependent code which would otherwise be in inflow.c and core.c,
for GDB, the GNU debugger.
- Copyright (C) 1992 Free Software Foundation, Inc.
+ Copyright (C) 1986, 1987 Free Software Foundation, Inc.
This code is for the i860 cpu.
- Contributed by Peggy Fieland (pfieland@stratus.com)
GDB is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY. No author or distributor accepts responsibility to anyone
#include "symtab.h"
#include "value.h"
-#include "tm-i860.h"
#include "i860-opcode.h"
-#include "break.h"
+#include "breakpoint.h"
+#include "i860-break.h"
#include "command.h"
+#include "target.h"
#ifdef notdef
#include <sys/types.h>
extern int print_insn();
extern void bzero();
extern void bcopy();
-extern int store_inferior_registers(int);
-extern int outside_startup_file();
int btdebug = 0; /* change value to 1 to enable debugging code */
+int ansi_conformant;
#define BTDEBUG if (btdebug) btdebug_message
extern int errno;
extern int attach_flag;
+extern char registers[];
+CORE_ADDR get_saved_basereg();
#define INSTRUCTION_LENGTH 4
#define REGISTER_LENGTH 4
+#define ALIGN_ARG(size,len) ((size + (len-1))&(-len))
+#define NUM_FLOAT_ARG_REGS 8
+#define NUM_INT_ARG_REGS 12
/* routine to print debugging messages */
void btdebug_message(char *format, ...)
va_end ( arglist );
}
+\f
+/* Peggy Fieland. Routine that attempts to find the start of the entry sequence
+ for a routine. */
+/* maximum number of instrutions to search back */
+#define MAX_ROUTINE_SIZE 4096
+CORE_ADDR find_entry_start(pc)
+CORE_ADDR pc;
+{
+ CORE_ADDR instr, top_pc;
+ int i;
+
+ top_pc = pc;
+ for (i = 0; i < MAX_ROUTINE_SIZE; ++i)
+
+ {
+ instr = (unsigned)( adj_read_memory_integer (top_pc));
+ /* Recognize "addu|adds -X,sp,sp" insn. */
+
+ if ((instr & 0xEFFF0000) == 0x84420000)
+ {
+ return (top_pc);
+ }
+ top_pc -= INSTRUCTION_LENGTH;
+ }
+ return (0);
+}
+
+
+\f
+/* Written by Peggy Fieland (Margaret_Fieland@vos.stratus.com) */
+/* get the contents of a base register. Used for dwarf OP_BASEREG */
+/* At present, only OP_BASEREG generated is for R28. NOTE that for stuff based on R28,
+ the value we want is the VALUE AT PROCEDURE INVOKATION, and thus is the frame we
+ use to get the value is the caller's frame. */
+CORE_ADDR get_saved_basereg (frame, basereg)
+FRAME frame;
+int basereg;
+{
+ CORE_ADDR addr;
+ if (basereg == R28) /* Unconditionally ??? */
+ {
+ frame = get_prev_frame (frame);
+ get_saved_register((char *) &addr, (int *) NULL, (CORE_ADDR *) NULL, frame,
+ basereg, (enum lval_type *)NULL);
+
+ }
+ else
+ get_saved_register((char *) &addr, (int *) NULL, (CORE_ADDR *) NULL, frame,
+ basereg, (enum lval_type *)NULL);
+
+ return (addr);
+}
+
\f
/* return nonzero if the routine containing pc has been
*/
static int g_routine(pc)
+
CORE_ADDR pc;
{
CORE_ADDR instr;
CORE_ADDR top_pc;
top_pc = get_pc_function_start(pc);
+ if (top_pc == NULL)
+ top_pc = find_entry_start (pc);
+
if (top_pc != NULL)
{
instr = (unsigned)( adj_read_memory_integer (top_pc));
return(0);
}
+
/* return the stack offset where r1 (return linkage ) register is stored */
-static int find_r1_offset(pc)
-CORE_ADDR pc;
+static CORE_ADDR find_r1(pc,sp,fp)
+CORE_ADDR pc,sp, fp;
{
int r1_off,i;
- CORE_ADDR instr;
+ CORE_ADDR instr, ret_pc;
/* look for the instruction and examine the offset */
- for (i=INSTRUCTION_LENGTH*1; i< INSTRUCTION_LENGTH*4; i+=INSTRUCTION_LENGTH){
- instr = (unsigned)( adj_read_memory_integer(pc+i));
- if ((instr & 0xFFE0F801) == 0x1C400801) { /* st.l r1,X(sp) */
+ for (i=INSTRUCTION_LENGTH*1; i< INSTRUCTION_LENGTH*4; i+=INSTRUCTION_LENGTH)
+ {
+ instr = (unsigned)( adj_read_memory_integer(pc+i));
+ if ((instr & 0xFFE0F801) == 0x1C400801)
+ {
+ /* st.l r1,X(sp) */
- r1_off = SIGN_EXT16(((instr&0x001F0000) >> 5) |
- (instr&0x000007FE));
- return(r1_off);
+ r1_off = SIGN_EXT16(((instr&0x001F0000) >> 5) |
+ (instr&0x000007FE));
+ ret_pc = read_memory_integer(sp+r1_off,sizeof(long));
+ return(ret_pc);
+ }
+ else if ((instr & 0xFFE0F801) == 0x1C600801)
+ {
+ /* st.l r1,X(fp) */
+ r1_off = SIGN_EXT16(((instr&0x001F0000) >> 5) |
+ (instr&0x000007FE));
+ ret_pc = read_memory_integer(fp+r1_off,sizeof(long));
+ return(ret_pc);
+ }
}
- }
- return(-1);
+ return(0);
}
CORE_ADDR skip_prologue(CORE_ADDR);
else
return (1);
}
-
-
-
/* get the pc and frame pointer (or sp )
* for the routine that called us
* when we (this_pc) is not within a -g routine
/* note this is written for Metaware version R2.1d compiler */
/* Modified by Peggy Fieland Margaret_Fieland@vos.stratus.com */
-static int caller_pc(this_pc,this_sp,to_pc,to_fp)
- CORE_ADDR this_pc,this_sp;
+static int caller_pc(this_pc,this_sp,this_fp,to_pc,to_fp, called_from_frame_chain)
+ CORE_ADDR this_pc,this_sp, this_fp;
CORE_ADDR *to_pc, *to_fp;
+ int called_from_frame_chain;
{
CORE_ADDR func_start;
int sp_offset,offset;
func_start = get_pc_function_start(this_pc);
+ if (func_start == NULL)
+ func_start = find_entry_start (this_pc);
+
BTDEBUG("caller_pc func_start %x\n", func_start);
+ if ((func_start == NULL))
+ {
+ /* error in traceback */
+ fprintf(stderr, "error, unable to find start of function\n");
+ return(0);
+
+ }
+
if (func_start!= NULL)
{
if( has_a_frame(func_start) ){
}
else
{
- /* if we get here, procedure doesn't have a frame. If we didn't
+ /* if we get here, procedure doesn't have a frame. If we
do anything weird, the frame pointer and return register have
the values we want. Check them to see if they are valid. */
CORE_ADDR temp_rp, temp_fp;
+ /* temporary warning, since at the moment we don't have support for
+ the shared library */
+
temp_rp = read_register(RP_REGNUM);
temp_fp = read_register(FP_REGNUM);
if (!valid_regs(temp_rp, temp_fp))
{
- printf("error frame_chain\n");
+ fprintf(stderr,
+ "error - unable to find return address, traceback terminating\n");
return(0);
}
BTDEBUG("caller_pc no frame, using r1 %x and fp %x\n",
BTDEBUG("sp_offset = %d %x\n",sp_offset,sp_offset);
- offset = find_r1_offset(func_start);
+ pc = find_r1(func_start, this_sp, this_fp);
- if( offset < 0 ){
- printf("cant find return address for routine at %x\n",
- func_start);
- return(0);
- }
- pc = read_memory_integer(this_sp+offset,sizeof(long));
+ if(pc == NULL)
+ {
+
+ /* r1 wasn't stored between pc and function start */
+ pc = read_register (RP_REGNUM);
+ }
+
sp= this_sp - sp_offset;
BTDEBUG("callers pc = %x sp = %x\n",pc,sp);
BTDEBUG("caller_a_g\n");
if( ! (offset = find_fp_offset(func_start)) ) {
- printf("error fp_offset\n");
+ fprintf(stderr, "error - unable to find caller frame for routine at 0x%x, "
+ "traceback terminating\n", func_start);
return(0);
}
BTDEBUG("offset = %x %d\n",offset,offset);
if (!valid_regs(temp_rp, temp_fp))
{
- printf("error frame_chain\n");
+ fprintf(stderr,
+ "error - unable to find return address, traceback terminating\n");
+
return(0);
}
BTDEBUG("caller_pc no frame, using r1 %x and fp %x\n",
CORE_ADDR nextadr, prevadr;
int val = not_branch;
long offset; /* Must be signed for sign-extend */
- extern char registers[];
prevadr = nextadr = 0;
brk->address1 = 0;
/* bc /bnc */
/* bc.t /bnc.t*/
if ((instr & 0xF8000000) == 0x68000000) /* br or call */
- printf(" Breakpoint adjusted to avoid br/call delay slot and multiple breakpoints\n");
+ BTDEBUG(" Breakpoint adjusted to avoid br/call delay slot and multiple breakpoints\n");
if ((instr & 0xF4000000) == 0x74000000) /* bc.t or bnc.t */
- printf(" Breakpoint adjusted to avoid bc.t/bnc.t delay slot and multiple breakpoints\n");
+ BTDEBUG(" Breakpoint adjusted to avoid bc.t/bnc.t delay slot and"
+ "multiple breakpoints\n");
+
/* it IS really OK to set a break on the instruction AFTER the conditional branch
-- it DOESN't have a delay slot */
if ((instr & 0xF4000000) == 0x70000000) /* bc / bnc */
- /* printf(" Breakpoint adjusted to avoid bc/bnc delay slot and multiple breakpoints\n"); */
adjust = 0;
} else if
((instr & 0xFC00003F) == 0x4C000002 || /* bri/ calli */
(instr & 0xFC000000) == 0x40000000)
{
adjust++;
- printf(" Breakpoint adjusted to avoid calli/bri delay slot and multiple breakpoints\n");
+ BTDEBUG(" Breakpoint adjusted to avoid calli/bri delay slot and"
+ " multiple breakpoints\n");
} else if
((instr & 0xF0000000) == 0x50000000) /* bte - btne */
{
((instr & 0xFC000000) == 0xB4000000)
{
adjust++;
- printf(" Breakpoint adjusted to avoid bla delay slot and multiple breakpoints\n");
+ BTDEBUG(" Breakpoint adjusted to avoid bla delay slot and"
+ " multiple breakpoints\n");
}
if (adjust != 0)
{
{
CORE_ADDR pc;
branch_type place_brk();
-
+ int *shadow0, *shadow1, *shadow2, *shadow3;
+
+ shadow0 = (int *) &brk.shadow_contents[0];
+ shadow1 = (int *) &brk.shadow_contents[4];
+ shadow2 = (int *) &brk.shadow_contents[8];
+ shadow3 = (int *) &brk.shadow_contents[12];
pc = read_register (PC_REGNUM);
if (!one_stepped)
{
brk.address = pc;
place_brk (pc, SINGLE_STEP_MODE, &brk);
- brk.shadow_contents[0] = brk.shadow_contents[1] = 0;
- brk.shadow_contents[2] = brk.shadow_contents[3] = 0;
+ *shadow0 = *shadow1 = *shadow2 = *shadow3 = 0;
if (brk.mode == DIM)
{
}
if (( brk.address1 != NULL))
{
- adj_read_memory (brk.act_addr[2], &brk.shadow_contents[2],
+ adj_read_memory (brk.act_addr[2], shadow2,
INSTRUCTION_LENGTH);
adj_write_memory (brk.act_addr[2], break_insn, INSTRUCTION_LENGTH);
- adj_read_memory (brk.act_addr[3], &brk.shadow_contents[3],
+ adj_read_memory (brk.act_addr[3], shadow3,
INSTRUCTION_LENGTH);
/* adj_write_memory (brk.act_addr[3], float_insn,
INSTRUCTION_LENGTH); */
btdebug_message("\n");
}
- adj_read_memory (brk.act_addr[0], &brk.shadow_contents[0],
+ adj_read_memory (brk.act_addr[0], shadow0,
INSTRUCTION_LENGTH);
adj_write_memory (brk.act_addr[0], break_insn,
INSTRUCTION_LENGTH);
- adj_read_memory (brk.act_addr[1], &brk.shadow_contents[1],
+ adj_read_memory (brk.act_addr[1], shadow1,
INSTRUCTION_LENGTH);
/* adj_write_memory (brk.act_addr[1], float_insn,
INSTRUCTION_LENGTH); */
print_insn( brk.act_addr[2], stderr);
btdebug_message("\n");
}
- adj_read_memory (brk.act_addr[2], &brk.shadow_contents[2],
+ adj_read_memory (brk.act_addr[2], shadow2,
INSTRUCTION_LENGTH);
adj_write_memory (brk.act_addr[2], break_insn, INSTRUCTION_LENGTH);
}
print_insn( brk.act_addr[0], stderr);
btdebug_message("\n");
}
- adj_read_memory (brk.act_addr[0], &brk.shadow_contents[0],
+ adj_read_memory (brk.act_addr[0], shadow0,
INSTRUCTION_LENGTH);
adj_write_memory (brk.act_addr[0], break_insn,INSTRUCTION_LENGTH);
}
/* Remove breakpoints */
if (brk.mode == DIM)
{
- adj_write_memory (brk.act_addr[0], &brk.shadow_contents[0],
+ adj_write_memory (brk.act_addr[0], shadow0,
INSTRUCTION_LENGTH);
- adj_write_memory (brk.act_addr[1], &brk.shadow_contents[1],
+ adj_write_memory (brk.act_addr[1], shadow1,
INSTRUCTION_LENGTH);
} else {
- adj_write_memory (brk.act_addr[0], &brk.shadow_contents[0],
+ adj_write_memory (brk.act_addr[0], shadow0,
INSTRUCTION_LENGTH);
}
{
if (brk.mode == DIM)
{
- adj_write_memory (brk.act_addr[2], &brk.shadow_contents[2],
+ adj_write_memory (brk.act_addr[2], shadow2,
INSTRUCTION_LENGTH);
- adj_write_memory (brk.act_addr[3], &brk.shadow_contents[3],
+ adj_write_memory (brk.act_addr[3], shadow3,
INSTRUCTION_LENGTH);
} else {
- adj_write_memory (brk.act_addr[2], &brk.shadow_contents[2],
+ adj_write_memory (brk.act_addr[2], shadow2,
INSTRUCTION_LENGTH);
}
}
at fp + NUM_REGS*4 */
for (i = 1; i < NUM_REGS; i++) /* skip reg 0 */
- if (i != SP_REGNUM && i != FP0_REGNUM && i != FP0_REGNUM + 1)
- /* the register numbers used in the instruction and the ones used to index
- the regs array are not the same -- compensate */
- frame_saved_regs->regs[i+R0] = frame_info->frame + i*REGISTER_LENGTH;
-
- frame_saved_regs->regs[SP_REGNUM] = frame_info->frame + NUM_REGS*REGISTER_LENGTH;
+ /* the register numbers used in the instruction and the ones used to index
+ the regs array are not the same -- compensate */
+ frame_saved_regs->regs[i+R0] = frame_info->frame + i*REGISTER_LENGTH;
call_dummy_set = 0;
return;
}
pc = get_pc_function_start (frame_info->pc);
+ if (pc == NULL)
+ pc = find_entry_start (frame_info->pc);
+
if (pc != NULL)
{
instr = (unsigned)(adj_read_memory_integer (pc));
CORE_ADDR instr;
int offset;
CORE_ADDR thisfp = thisframe->frame;
-
- /* get the frame pointer actually sp for a non -g
+ struct frame_saved_regs fsr;
+ CORE_ADDR thissp;
+
+ /* get the frame pointer actually sp for a non -g
* for the routine that called us routine
*/
}
if( ! g_routine(thisframe->pc) ){
+ thissp = get_saved_basereg (thisframe, SP_REGNUM);
+
BTDEBUG( "non g at %x\n",thisframe->pc);
- caller_pc(thisframe->pc,thisframe->sp,&pc,&fp);
+ caller_pc(thisframe->pc, thissp, thisfp,&pc,&fp, 1);
BTDEBUG("caller_pc returned %x %x \n",pc,fp);
return(fp);
/* handle the Metaware-type pseudo-frame */
func_start = get_pc_function_start(thisframe->pc);
-
+ if (func_start == NULL)
+ func_start = find_entry_start (thisframe->pc);
+
if (func_start != NULL)
{
CORE_ADDR func_start, prologue_end;
func_start = get_pc_function_start(pc);
+ if (func_start == NULL)
+ func_start = find_entry_start (pc);
+
if (func_start != NULL)
{
prologue_end = func_start;
CORE_ADDR pc1;
CORE_ADDR sp ;
CORE_ADDR fp;
+ struct frame_saved_regs fsr;
frame = frame_struct->frame;
pc = frame_struct->pc;
- sp = frame_struct->sp;
-
+
+
BTDEBUG("frame_saved_pc input: frame %x, pc %x",
frame, pc);
}
else if( ! g_routine(pc) )
{
- caller_pc(pc,sp,&pc,&frame);
+ sp = get_saved_basereg (frame_struct, SP_REGNUM);
+
+ caller_pc(pc,sp,frame_struct->frame, &pc,&frame, 0);
}
else
{
pc = read_memory_integer (frame + 4, sizeof(long));
- if (!outside_startup_file(pc))
+ if (inside_entry_file(pc))
{
- BTDEBUG("pc %x outside startup file \n",pc);
+ BTDEBUG("pc %x outside entry file \n",pc);
pc1 = read_memory_integer (frame, sizeof(long));
- if (outside_startup_file(pc1))
+ if (!inside_entry_file(pc1))
pc = pc1;
else
pc = 0;
}
/* Pass arguments to a function in the inferior process - ABI compliant
- Note that this routine DOES NOT HANDLE memory argument lists, ie
- it gives up if there are too many arguments to pass in registers.*/
+ Modified by Peggy Fieland (Margaret_Fieland@vos.stratus.com) to account
+ for newer ABI conventions. Note that now, unfortunately, we MUST KNOW
+ if we expect a float or a double. For now, we will assume that the
+ caller of this routine has the types of these arguments correct....
+ NOTE THAT THIS ROUTINE DOES NO ARGUMENT COERCION -- it's all in the
+ caller.
+ Modified by Peggy Fieland to handle memory argument lists.
+ */
-void
-pass_function_arguments(args, nargs, struct_return)
+#define IS_EVEN_REG(fl) (((fl - FP0_REGNUM)%2) == 0)
+CORE_ADDR
+pass_function_arguments(args, nargs, struct_return, struct_addr, sp)
value *args;
int nargs;
int struct_return;
+ CORE_ADDR struct_addr;
+ CORE_ADDR sp;
{
- int ireg = (struct_return) ? 17 : 16;
- int freg = FP0_REGNUM + 8;
+ int ireg = (struct_return) ? R17 : R16;
+ int freg = F8;
int i;
struct type *type;
value arg;
- long tmp;
- value value_arg_coerce();
-
+ signed long tmp;
+ unsigned long ul_tmp;
+ signed short s_tmp;
+ unsigned short us_tmp;
+ signed char c_tmp;
+ unsigned char uc_tmp;
+ CORE_ADDR arg_ptr;
+ int len;
+
+ if (struct_return)
+ {
+ write_register(R16, struct_addr);
+ }
+
+ arg_ptr = sp; /* Space was allocated for memory argument list in i860_arg_coerce */
+
+ /* Loop through the arguments, putting the values in a register or memory as appropriate. */
for (i = 0; i < nargs; i++)
{
- arg = value_arg_coerce(args[i]);
+ arg = args[i];
type = VALUE_TYPE(arg);
+ len = TYPE_LENGTH(type);
if (type == builtin_type_double)
{
- write_register_bytes(REGISTER_BYTE(freg), VALUE_CONTENTS(arg), sizeof(double));
- freg += 2;
+ /* see ABI . Note freg MUST BE INCREMENTED even if arg goes into the
+ memory argument list for this code to work correctly for subsequent
+ arguments. */
+ if (!IS_EVEN_REG(freg))
+ freg += 1;
+ /* see if argument can be put in a register, or whether it must go
+ into the memory argument list */
+ if (freg < F8 + NUM_FLOAT_ARG_REGS)
+ {
+ /* It can go in a register */
+ bcopy(VALUE_CONTENTS(arg), &tmp, sizeof(double));
+ write_register_bytes(REGISTER_BYTE(freg), (char *) &tmp, TYPE_LENGTH(type));
+ freg += 2;
+ }
+ else
+ {
+ /* It goes into memory argument list */
+ arg_ptr = ALIGN_ARG( arg_ptr, sizeof(double));
+ write_memory (arg_ptr, VALUE_CONTENTS (arg), len);
+ arg_ptr += len;
+ }
+
+ }
+ else if (type == builtin_type_float)
+ {
+ if (freg < F8 + NUM_FLOAT_ARG_REGS)
+ {
+ /* It can go in a register */
+ bcopy(VALUE_CONTENTS(arg), &tmp, sizeof(long));
+ write_register_bytes (REGISTER_BYTE(freg), (char *) &tmp, TYPE_LENGTH(type));
+ freg++;
+ }
+ else
+ {
+ /* It goes into the memory argument list */
+ arg_ptr = ALIGN_ARG(arg_ptr, sizeof(float));
+ write_memory (arg_ptr, VALUE_CONTENTS (arg), len);
+ arg_ptr += len;
+ }
}
else
{
- bcopy(VALUE_CONTENTS(arg), &tmp, sizeof(long));
- write_register(ireg, tmp);
- ireg++;
+ /* All structs are passed by value, and hence they all go into the memory
+ argument list (see ABI); otherwise, as above, see if we have run
+ out of registers */
+
+ /* Cast value correctly so we can load it into a register or into the
+ memory argument list -- see ABI */
+ if (TYPE_LENGTH(type) < sizeof(long))
+ {
+ if (TYPE_FLAGS(type) & TYPE_FLAG_UNSIGNED)
+ arg = value_cast(builtin_type_unsigned_int, arg);
+ else
+ arg = value_cast (builtin_type_int, arg);
+ type = VALUE_TYPE(arg);
+ len = TYPE_LENGTH(type);
+ }
+
+ if ((TYPE_CODE(type) == TYPE_CODE_STRUCT) || (ireg >= R16 + NUM_INT_ARG_REGS))
+ {
+ /* It goes into the memory argument list. Minimum alignment requirements
+ are on a 4-byte boundary */
+
+ if ((TYPE_CODE(type) == TYPE_CODE_INT) ||
+ (TYPE_CODE(type) == TYPE_CODE_ENUM) ||
+ (TYPE_CODE(type) == TYPE_CODE_CHAR) ||
+ (TYPE_CODE(type) == TYPE_CODE_BOOL))
+ arg_ptr = ALIGN_ARG(arg_ptr, len);
+ else
+ arg_ptr = ALIGN_ARG (arg_ptr, sizeof(long)); /* align on 4-byte boundary */
+ write_memory (arg_ptr, VALUE_CONTENTS (arg), len);
+ arg_ptr += len;
+ }
+ else
+ {
+
+ bcopy(VALUE_CONTENTS(arg), &tmp, sizeof(long));
+ write_register(ireg, tmp);
+ ireg++;
+ }
+
}
}
- if (ireg >= 28 || freg >= FP0_REGNUM + 16)
- error("Too many arguments to function");
+
+
+ return (sp);
+
}
};
#define NREGS 32
-#if 0
-/* This routine is uncalled -- remove this routine sometime */
+
get_reg(regno)
{
char raw_buffer[32];
int addr;
int virtual_buffer;
-
- read_relative_register_raw_bytes (regno, raw_buffer);
+
+ /* NOTE that only integer and floating point registers can be relative to a frame */
+
+ if ((regno >= R0) && (regno <= F31)) /* user register */
+ read_relative_register_raw_bytes (regno, raw_buffer);
+ else
+ bcopy (®isters[regno << 2], raw_buffer, sizeof (long));
+
REGISTER_CONVERT_TO_VIRTUAL (addr, raw_buffer, &virtual_buffer);
return(virtual_buffer);
}
-#endif
#if 0
}
#endif
-extern char registers[];
/* i860-specific routine to print the register set. Note that we ALWAYS print information
- on the floating point registers, so we ignore the parameter fpregs */
+ on the floating point registers, so we ignore the parameter fpregs.
+ NOTE also that only integer and floating point registers can be relative to a frame --
+ see subroutine get_reg (above ) */
+
void i860_do_registers_info(regnum,fpregs)
int regnum;
int fpregs;
if (regnum != -1) /* print one register */
{
- if ((regnum >=F0 ) && (regnum <= F31))
- bcopy (®isters[ADJ_FREG(regnum)<<2], &val, sizeof (long));
- else
- bcopy (®isters[regnum<<2], &val, sizeof (long));
+ val = get_reg(regnum);
printf("%-4s 0x%08x\t", reg_names[regnum], val);
printf("\n\t"); fflush(stdout);
}
printf("\n Control/Status Registers :- \n\t");
for (j=0; j<=DB; j++)
{
- bcopy (®isters[j<<2], &val, sizeof (long));
+ val = get_reg(j);
printf("%-4s 0x%08x\t", reg_names[j], val);
}
printf("\n\t"); fflush(stdout);
/* EPSR */
- bcopy (®isters[EPSR<<2], &val, sizeof (long));
+ val = get_reg(EPSR);
printf("%-4s 0x%08x\t", reg_names[EPSR], val);
/* FSR */
- bcopy (®isters[FSR<<2], &val, sizeof (long));
+ val = get_reg(FSR);
printf("%-4s 0x%08x\t", reg_names[FSR], val);
/* CCR */
- bcopy (®isters[CCR<<2], &val, sizeof (long));
+ val = get_reg(CCR);
printf("%-4s 0x%08x\t", reg_names[CCR], val);
/* BEAR*/
- bcopy (®isters[BEAR<<2], &val, sizeof (long));
+ val = get_reg(BEAR);
printf("%-4s 0x%08x\t", reg_names[BEAR], val);
#ifdef JIM_ADD_PRIV
for (j=P0; j<=P3; j++)
{
- bcopy (®isters[j<<2], &val, sizeof (long));
+ val = get_reg(j);
printf("%-4s 0x%08x\t", reg_names[j], val);
}
#endif
{
printf("\n\t"); fflush(stdout);
}
- bcopy (®isters[j<<2], &val, sizeof (long));
+ val = get_reg(j);
printf("%-4s 0x%08x\t", reg_names[j], val);
}
{
printf("\n\t"); fflush(stdout);
}
- bcopy (®isters[ADJ_FREG(j)<<2], &val, sizeof (long));
+ val = get_reg(j);
printf("%-4s 0x%08x\t", reg_names[j], val);
}
{
printf("\n\t"); fflush(stdout);
}
- bcopy (®isters[j<<2], &val, sizeof (long));
- bcopy (®isters[(j+1)<<2], &valh, sizeof (long));
+ val = get_reg(j);
+ valh = get_reg(j+1);
printf("%-6s 0x%08x %08x\t", reg_names[j], val,valh);
}
{
unsigned int valh;
j = PSV_I1;
- bcopy (®isters[j<<2], &val, sizeof (long));
- bcopy (®isters[(j+1)<<2], &valh, sizeof (long));
+ val = get_reg(j);
+ valh = get_reg(j+1);
printf("\t\t\t%-8s 0x%08x %08x \n", reg_names[j], val,valh);
}
for (j=PSV_L1; j<=PSV_L3; j+=REGISTER_LENGTH)
{
unsigned int valh, val2,val3;
- bcopy (®isters[j<<2], &val, sizeof (long));
- bcopy (®isters[(j+1)<<2], &valh, sizeof (long));
- bcopy (®isters[(j+2)<<2], &val2, sizeof (long));
- bcopy (®isters[(j+3)<<2], &val3, sizeof (long));
+
+ val = get_reg(j);
+ valh = get_reg(j+1);
+ val2 = get_reg(j+2);
+ val3 = get_reg(j+3);
+
printf("\t\t%-8s 0x%08x %08x %08x %08x\n", reg_names[j],
val,valh,val2,val3);
}
for (i=PSV_FSR1,j=PSV_A1,k=PSV_M1; j<=PSV_A3; i++,j+=2,k+=2)
{
unsigned int valh,val2,val3,val4;
- bcopy (®isters[i<<2], &val4, sizeof (long));
- bcopy (®isters[j<<2], &val, sizeof (long));
- bcopy (®isters[(j+1)<<2], &valh, sizeof (long));
- bcopy (®isters[k<<2], &val2, sizeof (long));
- bcopy (®isters[(k+1)<<2], &val3, sizeof (long));
+
+ val4 = get_reg(i);
+ val = get_reg(j);
+ valh = get_reg(j+1);
+ val2 = get_reg(k);
+ val3 = get_reg(k+1);
+
printf(" %-4s 0x%08x %08x\t", reg_names[j], val,valh);
printf("%-4s 0x%08x %08x\t", reg_names[k], val2,val3);
printf("%-4s 0x%08x\n", reg_names[i], val4);
/* set a "read" data breakpoint. */
void
-d_ro_break_command(arg)
-char *arg;
+d_ro_break_command(char *arg, int num)
{
dbrkval = strtoul(arg, NULL, 0);
dbrkmod = 0x01;
/* set a "write" data breakpoint. */
void
-d_wo_break_command(arg)
-char *arg;
+d_wo_break_command(char *arg, int num)
{
dbrkval = strtoul(arg, NULL, 0);
dbrkmod = 0x02;
/* set a "read/write" data breakpoint. */
void
-d_rw_break_command(arg)
-char *arg;
-{
- dbrkval = strtoul(arg, NULL, 0);
- dbrkmod = 0x03;
- BTDEBUG(" rw_dbreak - %x %x\n", dbrkval, dbrkmod);
-}
+d_rw_break_command(char *arg, int num)
+{
+ dbrkval = strtoul(arg, NULL, 0);
+ dbrkmod = 0x03;
+ BTDEBUG(" rw_dbreak - %x %x\n", dbrkval, dbrkmod);
+ }
/* clear data breakpoint. */
-void
-clear_dbreak()
-{
- dbrkval = 0;
- dbrkmod = 0;
-}
-
-/* i860-specific breakpoint initialization. Includes adding the i860-specific
- data breakpoint commands. */
-void
-i860_init_breakpoints()
-{
+ void clear_dbreak(char *arg, int num)
+ {
+ dbrkval = 0;
+ dbrkmod = 0;
+ }
+
+/* i860-specific breakpoint initialization. Includes adding the
+i860-specific data breakpoint commands. */
+void i860_init_breakpoints()
+{
dbrkval = dbrkmod = 0;
add_com ("dbro", class_breakpoint, d_ro_break_command,
"Set a data breakpoint READ ONLY, 32-bit data element.");
struct breakpoint *b;
{
int val;
+ int *shadow0, *shadow1, *shadow2, *shadow3;
+
+ shadow0 = (int *)&b->shadow_contents[0];
+ shadow1 = (int *)&b->shadow_contents[4];
+ shadow2 = (int *)&b->shadow_contents[8];
+ shadow3 = (int *)&b->shadow_contents[12];
place_brk( b->address, BREAK_MODE, b );
+
if (b->mode == DIM)
{
- adj_read_memory (b->act_addr[0], &b->shadow_contents[0], INSTRUCTION_LENGTH);
+ adj_read_memory (b->act_addr[0], shadow0, INSTRUCTION_LENGTH);
val = adj_write_memory (b->act_addr[0], break_insn, INSTRUCTION_LENGTH);
if (val != 0 ) return val;
- adj_read_memory (b->act_addr[1], &b->shadow_contents[1], INSTRUCTION_LENGTH);
+ adj_read_memory (b->act_addr[1], shadow1, INSTRUCTION_LENGTH);
/* val = adj_write_memory (b->act_addr[1], float_insn, INSTRUCTION_LENGTH); */
if (val != 0) return val;
}
else
{
- adj_read_memory (b->act_addr[0], &b->shadow_contents[0], INSTRUCTION_LENGTH);
+ adj_read_memory (b->act_addr[0], shadow0, INSTRUCTION_LENGTH);
val = adj_write_memory (b->act_addr[0], break_insn, INSTRUCTION_LENGTH);
}
if (b->address1 != 0)
if (b->mode == DIM)
{
- adj_read_memory (b->act_addr[2], &b->shadow_contents[2], INSTRUCTION_LENGTH);
+ adj_read_memory (b->act_addr[2], shadow2, INSTRUCTION_LENGTH);
val = adj_write_memory (b->act_addr[2], break_insn, INSTRUCTION_LENGTH);
if (val) return val;
- adj_read_memory (b->act_addr[3], &b->shadow_contents[3], INSTRUCTION_LENGTH);
+ adj_read_memory (b->act_addr[3], shadow3, INSTRUCTION_LENGTH);
/* val = adj_write_memory (b->act_addr[3], float_insn, INSTRUCTION_LENGTH); */
if (val != 0) return val;
}
else
{
- adj_read_memory (b->act_addr[2], &b->shadow_contents[0], INSTRUCTION_LENGTH);
+ adj_read_memory (b->act_addr[2], shadow0, INSTRUCTION_LENGTH);
val = adj_write_memory (b->act_addr[2], break_insn, INSTRUCTION_LENGTH);
}
}
if (val != 0)
return val;
- BTDEBUG("Inserted breakpoint at 0x%x, shadow 0x%x, 0x%x.\n",
- b->address, b->shadow_contents[0], b->shadow_contents[1]);
+
b->inserted = 1;
return 0;
}
struct breakpoint *b;
{
int val;
+ int *shadow0, *shadow1, *shadow2, *shadow3;
+
+ shadow0 = (int *)&b->shadow_contents[0];
+ shadow1 = (int *)&b->shadow_contents[4];
+ shadow2 = (int *)&b->shadow_contents[8];
+ shadow3 = (int *)&b->shadow_contents[12];
+
if (b->inserted)
{
if (b->mode == DIM)
{
- val =adj_write_memory (b->act_addr[0], &(b->shadow_contents[0]),
+ val =adj_write_memory (b->act_addr[0], shadow0,
INSTRUCTION_LENGTH);
- val =adj_write_memory (b->act_addr[1], &(b->shadow_contents[1]),
+ val =adj_write_memory (b->act_addr[1],shadow1,
INSTRUCTION_LENGTH);
if (b->address1 != NULL)
{
- val =adj_write_memory (b->act_addr[2], &(b->shadow_contents[2]),
+ val =adj_write_memory (b->act_addr[2],shadow2,
INSTRUCTION_LENGTH);
- val =adj_write_memory (b->act_addr[3], &(b->shadow_contents[3]),
+ val =adj_write_memory (b->act_addr[3], shadow3,
INSTRUCTION_LENGTH);
}
}
else
{
- val =adj_write_memory (b->act_addr[0], b->shadow_contents,
+ val =adj_write_memory (b->act_addr[0], shadow0,
INSTRUCTION_LENGTH);
if (b->address1 != NULL)
{
- val =adj_write_memory (b->act_addr[2], b->shadow_contents,
+ val =adj_write_memory (b->act_addr[2],shadow0,
INSTRUCTION_LENGTH);
}
}
if (val != 0)
return val;
b->inserted = 0;
- BTDEBUG( "Removed breakpoint at 0x%x, shadow 0x%x, 0x%x.\n",
- b->address, b->shadow_contents[0], b->shadow_contents[1]);
}
return 0;
}
}
#endif
+
+
+/* Push an empty stack frame, to record the current PC, etc. */
+/* We have this frame with fp pointing to a block where all GDB-visible
+ registers are stored in the order GDB knows them, and sp at the next
+ alignment point below fp. Note: fp + NUM_REGS*4 was the old sp
+ */
+extern CORE_ADDR text_end;
+CORE_ADDR dummy_start_addr;
+void i860_push_frame()
+{
+ register CORE_ADDR old_fp = read_register(FP_REGNUM);
+ register CORE_ADDR old_sp = read_register(SP_REGNUM);
+ register CORE_ADDR fp ;
+ extern char registers[];
+
+ fp = old_sp - REGISTER_BYTES;
+ write_memory(fp, registers, REGISTER_BYTES); /* write out old register values */
+ /* reset FP and SP */
+ write_register(FP_REGNUM, fp);
+ write_register(SP_REGNUM, (fp &~ 15)); /* re-align */
+ call_dummy_set = 1;
+}
+/* Discard from the stack the innermost frame,
+ restoring all saved registers. */
+
+void i860_pop_frame()
+{ register FRAME frame = get_current_frame ();
+ register CORE_ADDR fp;
+ struct frame_info *fi;
+ int i;
+
+ fi = get_frame_info (frame);
+ fp = fi->frame;
+
+ if (call_dummy_set && fi -> pc >= call_dummy_start &&
+ fi -> pc <= call_dummy_start + CALL_DUMMY_LENGTH)
+ {
+
+ read_memory(fp, registers, REGISTER_BYTES);
+
+ target_store_registers(-1);
+
+ {
+ /* since we stomped on code that will be executed when we exit the program,
+ restore it. */
+ extern REGISTER_TYPE call_save_code[4];
+
+ write_memory (call_dummy_start, (char *) call_save_code, 16);
+
+ }
+ call_dummy_set = 0;
+ }
+ else
+ {
+ register int regnum;
+ struct frame_saved_regs fsr;
+ char raw_buffer[12];
+
+ get_frame_saved_regs (fi, &fsr);
+ for (regnum = FP0_REGNUM + 31; regnum >= FP0_REGNUM; regnum--)
+ if (fsr.regs[regnum])
+ write_register (regnum, read_memory_integer (fsr.regs[regnum], 4));
+ for (regnum = R31; regnum >= 1; regnum--)
+ if (fsr.regs[regnum])
+ if (regnum != SP_REGNUM)
+ write_register (regnum, read_memory_integer (fsr.regs[regnum], 4));
+ else
+ write_register (SP_REGNUM, fsr.regs[SP_REGNUM]);
+ if (fsr.regs[PS_REGNUM])
+ write_register (PS_REGNUM, read_memory_integer (fsr.regs[PS_REGNUM], 4));
+ if (fsr.regs[FPS_REGNUM])
+ write_register (FPS_REGNUM, read_memory_integer (fsr.regs[FPS_REGNUM],4));
+ if (fsr.regs[PC_REGNUM])
+ write_register (PC_REGNUM,CLEAN_PC( read_memory_integer (fsr.regs[PC_REGNUM], 4)));
+ }
+
+ flush_cached_frames ();
+
+ set_current_frame (create_new_frame (read_register (FP_REGNUM),
+ read_pc ()));
+
+}
+
+CORE_ADDR i860_arg_coerce(nargs, args, struct_return, sp)
+ int nargs;
+ value *args;
+ int struct_return;
+ CORE_ADDR sp;
+{
+
+ register int scalar;
+ register enum type_code code2;
+ register struct type *type;
+ int i;
+ value arg;
+ int num_int_args = 0;
+ int num_float_args = 0;
+ int size = 0;
+ CORE_ADDR arg_ptr;
+
+ /* if we return a structure, it's address is in R16, and thus it uses up one of the integer
+ argument registers. See the ABI. */
+ if (struct_return)
+ num_int_args += 1;
+
+ /* loop to do the right thing with all the arguments and calculate the size of the memory
+ argument list. We keep count of the number of integer and the number of float parameters,
+ as well as the size of the memory argument list. */
+
+ for (i = 0; i < nargs; i++)
+ {
+
+ /* NOTE that this is all hunky dory in spite of the fact that we don't actually
+ have the signature of the called procedure EXCEPT if we are passing in floats!
+ This is true, since registers are 4 bytes, and the minimum alignment in the
+ memory argument list is 4 bytes. See the ABI for more gory details. The switch
+ "ansi-conformant" is an attempt to get around this problem. */
+
+ code2 = TYPE_CODE (VALUE_TYPE(args[i]));
+
+ /* Only coerce if we've got switch "ansi-conformant" off.
+ Actually, it's OK ( and probably helpful) to coerce ALL integer arguments
+ (see comment above), but never mind, we make them the right size in
+ pass_function_arguments. */
+
+ if ((!ansi_conformant) && (code2 != TYPE_CODE_STRUCT))
+ value_arg_coerce(args[i]);
+
+ arg = args[i];
+ type = VALUE_TYPE(args[i]);
+
+ /* All structures are passed by value in the memory argument list. */
+ if (code2 == TYPE_CODE_STRUCT)
+ {
+ size = ALIGN_ARG(size, sizeof(long));
+ size += TYPE_LENGTH(type);
+ }
+ else if (type == builtin_type_float)
+ {
+ num_float_args += 1;
+ if (num_float_args > NUM_FLOAT_ARG_REGS)
+ {
+ size = ALIGN_ARG(size, TYPE_LENGTH(type)) ;
+ size += TYPE_LENGTH(type);
+ }
+ }
+ else if (type == builtin_type_double)
+ {
+ /* floating register alignment -- see ABI */
+ if ((num_float_args%2) != 0)
+ num_float_args += 1;
+
+ num_float_args += 2; /* use up two registers */
+
+ if (num_float_args > NUM_FLOAT_ARG_REGS)
+ {
+ size = ALIGN_ARG(size, TYPE_LENGTH(type)) ;
+ size += TYPE_LENGTH(type);
+ }
+ }
+ else
+ {
+ int len = max (sizeof(long), TYPE_LENGTH(type));
+
+ num_int_args += 1;
+
+ if (num_int_args > NUM_INT_ARG_REGS)
+ {
+ /* see ABI -- in-memory arguments have AT LEAST word alignment */
+ if ((TYPE_CODE(type) == TYPE_CODE_INT) ||
+ (TYPE_CODE(type) == TYPE_CODE_ENUM) ||
+ (TYPE_CODE(type) == TYPE_CODE_CHAR) ||
+ (TYPE_CODE(type) == TYPE_CODE_BOOL))
+ size = ALIGN_ARG(size, len);
+ else
+ size = ALIGN_ARG(size, sizeof(long));
+ size += len;
+ }
+ }
+
+ }
+
+
+ /* recalculate the stack pointer, leaving enough space for the memory argument list and
+ realigning the stack pointer. */
+ if (size != 0)
+ {
+ arg_ptr = sp - size;
+
+ arg_ptr = arg_ptr & (-16); /* realign stack */
+ write_register (R28,arg_ptr);
+ sp = arg_ptr;
+ }
+
+return (sp);
+
+}
+void i860_extract_return_value(type,regbuf,valbuf)
+struct type *type;
+char regbuf[REGISTER_BYTES];
+char *valbuf;
+{
+ register int len = TYPE_LENGTH (type);
+ double tmp_db;
+ float tmp_flt;
+
+ if ((TYPE_CODE(type) == TYPE_CODE_FLT))
+ {
+ if (len == sizeof (float))
+ {
+ /* FIXME
+ NOTE that this assumes that the function declaration was ANSI_CONFORMANT --
+ at the present time I can't think of ANY WAY to disambiguate the two following
+ cases:
+ float really_does_return_a_float(float ff)
+ { ...}
+ and
+ float actually_returns_a_double(ff)
+ float ff;
+ {...}
+ */
+ bcopy ((char *) (regbuf) + REGISTER_BYTE(ADJ_FREG(F8)), (valbuf), TYPE_LENGTH (type)) ;
+ }
+ else
+ bcopy ((char *) (regbuf) + REGISTER_BYTE(F8), (valbuf), TYPE_LENGTH (type)) ;
+ }
+ else
+ bcopy ((char *) (regbuf) + REGISTER_BYTE(R16), (valbuf), TYPE_LENGTH (type));
+
+}
+void i860_store_return_value(type,valbuf)
+struct type *type;
+char *valbuf;
+{
+ register int len = TYPE_LENGTH (type);
+ double tmp_db;
+
+ if ((TYPE_CODE(type) == TYPE_CODE_FLT) )
+ {
+ write_register_bytes (REGISTER_BYTE (F8), valbuf, len);
+ }
+ else
+ write_register_bytes (REGISTER_BYTE (R16), valbuf, TYPE_LENGTH (type));
+
+}
+
projects / deliverable / binutils-gdb.git / blobdiff