/* Target-dependent code for the ALPHA architecture, for GDB, the GNU Debugger.
- Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
- Free Software Foundation, Inc.
+
+ Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
+ 2002, 2003, 2005 Free Software Foundation, Inc.
This file is part of GDB.
static void
alpha_register_to_value (struct frame_info *frame, int regnum,
- struct type *valtype, void *out)
+ struct type *valtype, gdb_byte *out)
{
char in[MAX_REGISTER_SIZE];
frame_register_read (frame, regnum, in);
static void
alpha_value_to_register (struct frame_info *frame, int regnum,
- struct type *valtype, const void *in)
+ struct type *valtype, const gdb_byte *in)
{
char out[MAX_REGISTER_SIZE];
switch (TYPE_LENGTH (valtype))
sp = (sp & -16) - 16;
/* Write the real data into the stack. */
- write_memory (sp, VALUE_CONTENTS (arg), 16);
+ write_memory (sp, value_contents (arg), 16);
/* Construct the indirection. */
arg_type = lookup_pointer_type (arg_type);
sp = (sp & -16) - 16;
/* Write the real data into the stack. */
- write_memory (sp, VALUE_CONTENTS (arg), 32);
+ write_memory (sp, value_contents (arg), 32);
/* Construct the indirection. */
arg_type = lookup_pointer_type (arg_type);
m_arg->len = TYPE_LENGTH (arg_type);
m_arg->offset = accumulate_size;
accumulate_size = (accumulate_size + m_arg->len + 7) & ~7;
- m_arg->contents = VALUE_CONTENTS (arg);
+ m_arg->contents = value_contents_writeable (arg);
}
/* Determine required argument register loads, loading an argument register
static void
alpha_extract_return_value (struct type *valtype, struct regcache *regcache,
- void *valbuf)
+ gdb_byte *valbuf)
{
int length = TYPE_LENGTH (valtype);
char raw_buffer[ALPHA_REGISTER_SIZE];
static void
alpha_store_return_value (struct type *valtype, struct regcache *regcache,
- const void *valbuf)
+ const gdb_byte *valbuf)
{
int length = TYPE_LENGTH (valtype);
char raw_buffer[ALPHA_REGISTER_SIZE];
void **this_prologue_cache,
int regnum, int *optimizedp,
enum lval_type *lvalp, CORE_ADDR *addrp,
- int *realnump, void *bufferp)
+ int *realnump, gdb_byte *bufferp)
{
struct alpha_sigtramp_unwind_cache *info
= alpha_sigtramp_frame_unwind_cache (next_frame, this_prologue_cache);
void **this_prologue_cache,
int regnum, int *optimizedp,
enum lval_type *lvalp, CORE_ADDR *addrp,
- int *realnump, void *bufferp)
+ int *realnump, gdb_byte *bufferp)
{
struct alpha_heuristic_unwind_cache *info
= alpha_heuristic_frame_unwind_cache (next_frame, this_prologue_cache, 0);
}
\f
+
+/* Return nonzero if the G_floating register value in REG is equal to
+ zero for FP control instructions. */
+
+static int
+fp_register_zero_p (LONGEST reg)
+{
+ /* Check that all bits except the sign bit are zero. */
+ const LONGEST zero_mask = ((LONGEST) 1 << 63) ^ -1;
+
+ return ((reg & zero_mask) == 0);
+}
+
+/* Return the value of the sign bit for the G_floating register
+ value held in REG. */
+
+static int
+fp_register_sign_bit (LONGEST reg)
+{
+ const LONGEST sign_mask = (LONGEST) 1 << 63;
+
+ return ((reg & sign_mask) != 0);
+}
+
/* alpha_software_single_step() is called just before we want to resume
the inferior, if we want to single-step it but there is no hardware
or kernel single-step support (NetBSD on Alpha, for example). We find
{
unsigned int insn;
unsigned int op;
+ int regno;
int offset;
LONGEST rav;
+ char reg[8];
insn = alpha_read_insn (pc);
}
/* Need to determine if branch is taken; read RA. */
- rav = (LONGEST) read_register ((insn >> 21) & 0x1f);
+ regno = (insn >> 21) & 0x1f;
+ switch (op)
+ {
+ case 0x31: /* FBEQ */
+ case 0x36: /* FBGE */
+ case 0x37: /* FBGT */
+ case 0x33: /* FBLE */
+ case 0x32: /* FBLT */
+ case 0x35: /* FBNE */
+ regno += FP0_REGNUM;
+ }
+
+ regcache_cooked_read (current_regcache, regno, reg);
+ rav = extract_signed_integer (reg, 8);
+
switch (op)
{
case 0x38: /* BLBC */
goto branch_taken;
break;
- /* ??? Missing floating-point branches. */
+ /* Floating point branches. */
+
+ case 0x31: /* FBEQ */
+ if (fp_register_zero_p (rav))
+ goto branch_taken;
+ break;
+ case 0x36: /* FBGE */
+ if (fp_register_sign_bit (rav) == 0 || fp_register_zero_p (rav))
+ goto branch_taken;
+ break;
+ case 0x37: /* FBGT */
+ if (fp_register_sign_bit (rav) == 0 && ! fp_register_zero_p (rav))
+ goto branch_taken;
+ break;
+ case 0x33: /* FBLE */
+ if (fp_register_sign_bit (rav) == 1 || fp_register_zero_p (rav))
+ goto branch_taken;
+ break;
+ case 0x32: /* FBLT */
+ if (fp_register_sign_bit (rav) == 1 && ! fp_register_zero_p (rav))
+ goto branch_taken;
+ break;
+ case 0x35: /* FBNE */
+ if (! fp_register_zero_p (rav))
+ goto branch_taken;
+ break;
}
}
/* We really would like to have both "0" and "unlimited" work, but
command.c doesn't deal with that. So make it a var_zinteger
because the user can always use "999999" or some such for unlimited. */
- c = add_set_cmd ("heuristic-fence-post", class_support, var_zinteger,
- (char *) &heuristic_fence_post,
- _("\
-Set the distance searched for the start of a function.\n\
+ /* We need to throw away the frame cache when we set this, since it
+ might change our ability to get backtraces. */
+ add_setshow_zinteger_cmd ("heuristic-fence-post", class_support,
+ &heuristic_fence_post, _("\
+Set the distance searched for the start of a function."), _("\
+Show the distance searched for the start of a function."), _("\
If you are debugging a stripped executable, GDB needs to search through the\n\
program for the start of a function. This command sets the distance of the\n\
search. The only need to set it is when debugging a stripped executable."),
- &setlist);
- /* We need to throw away the frame cache when we set this, since it
- might change our ability to get backtraces. */
- set_cmd_sfunc (c, reinit_frame_cache_sfunc);
- deprecated_add_show_from_set (c, &showlist);
+ reinit_frame_cache_sfunc,
+ NULL, /* FIXME: i18n: The distance searched for the start of a function is \"%d\". */
+ &setlist, &showlist);
}