#include "alpha-tdep.h"
\f
+/* Return the name of the REGNO register.
+
+ An empty name corresponds to a register number that used to
+ be used for a virtual register. That virtual register has
+ been removed, but the index is still reserved to maintain
+ compatibility with existing remote alpha targets. */
+
static const char *
alpha_register_name (int regno)
{
static int
alpha_cannot_fetch_register (int regno)
{
- return regno == ALPHA_ZERO_REGNUM;
+ return (regno == ALPHA_ZERO_REGNUM
+ || strlen (alpha_register_name (regno)) == 0);
}
static int
alpha_cannot_store_register (int regno)
{
- return regno == ALPHA_ZERO_REGNUM;
+ return (regno == ALPHA_ZERO_REGNUM
+ || strlen (alpha_register_name (regno)) == 0);
}
static struct type *
return (regno * 8);
}
-static int
-alpha_register_raw_size (int regno)
-{
- return 8;
-}
-
-static int
-alpha_register_virtual_size (int regno)
-{
- return 8;
-}
-
/* The following represents exactly the conversion performed by
the LDS instruction. This applies to both single-precision
floating point and 32-bit integers. */
memcpy (out, in, 8);
break;
default:
- error ("Cannot retrieve value from floating point register");
+ error (_("Cannot retrieve value from floating point register"));
}
}
memcpy (out, in, 8);
break;
default:
- error ("Cannot store value in floating point register");
+ error (_("Cannot store value in floating point register"));
}
put_frame_register (frame, regnum, out);
}
for (i = 0, m_arg = alpha_args; i < nargs; i++, m_arg++)
{
struct value *arg = args[i];
- struct type *arg_type = check_typedef (VALUE_TYPE (arg));
+ struct type *arg_type = check_typedef (value_type (arg));
/* Cast argument to long if necessary as the compiler does it too. */
switch (TYPE_CODE (arg_type))
break;
default:
- internal_error (__FILE__, __LINE__, "unknown floating point width");
+ internal_error (__FILE__, __LINE__, _("unknown floating point width"));
}
break;
break;
default:
- internal_error (__FILE__, __LINE__, "unknown floating point width");
+ internal_error (__FILE__, __LINE__, _("unknown floating point width"));
}
break;
/* FIXME: 128-bit long doubles are returned like structures:
by writing into indirect storage provided by the caller
as the first argument. */
- error ("Cannot set a 128-bit long double return value.");
+ error (_("Cannot set a 128-bit long double return value."));
default:
- internal_error (__FILE__, __LINE__, "unknown floating point width");
+ internal_error (__FILE__, __LINE__, _("unknown floating point width"));
}
break;
/* FIXME: 128-bit long doubles are returned like structures:
by writing into indirect storage provided by the caller
as the first argument. */
- error ("Cannot set a 128-bit long double return value.");
+ error (_("Cannot set a 128-bit long double return value."));
default:
- internal_error (__FILE__, __LINE__, "unknown floating point width");
+ internal_error (__FILE__, __LINE__, _("unknown floating point width"));
}
break;
static int blurb_printed = 0;
if (fence == tdep->vm_min_address)
- warning ("Hit beginning of text section without finding");
+ warning (_("Hit beginning of text section without finding \
+enclosing function for address 0x%s"), paddr_nz (orig_pc));
else
- warning ("Hit heuristic-fence-post without finding");
- warning ("enclosing function for address 0x%s", paddr_nz (orig_pc));
+ warning (_("Hit heuristic-fence-post without finding \
+enclosing function for address 0x%s"), paddr_nz (orig_pc));
if (!blurb_printed)
{
- printf_filtered ("\
+ printf_filtered (_("\
This warning occurs if you are debugging a function without any symbols\n\
(for example, in a stripped executable). In that case, you may wish to\n\
increase the size of the search with the `set heuristic-fence-post' command.\n\
\n\
Otherwise, you told GDB there was a function where there isn't one, or\n\
-(more likely) you have encountered a bug in GDB.\n");
+(more likely) you have encountered a bug in GDB.\n"));
blurb_printed = 1;
}
}
}
/* Otherwise assume the next frame has the same register value. */
- frame_register (next_frame, regnum, optimizedp, lvalp, addrp,
- realnump, bufferp);
+ frame_register_unwind (next_frame, regnum, optimizedp, lvalp, addrp,
+ realnump, bufferp);
}
static const struct frame_unwind alpha_heuristic_frame_unwind = {
}
\f
-/* ALPHA stack frames are almost impenetrable. When execution stops,
- we basically have to look at symbol information for the function
- that we stopped in, which tells us *which* register (if any) is
- the base of the frame pointer, and what offset from that register
- the frame itself is at.
-
- This presents a problem when trying to examine a stack in memory
- (that isn't executing at the moment), using the "frame" command. We
- don't have a PC, nor do we have any registers except SP.
-
- This routine takes two arguments, SP and PC, and tries to make the
- cached frames look as if these two arguments defined a frame on the
- cache. This allows the rest of info frame to extract the important
- arguments without difficulty. */
-
-struct frame_info *
-alpha_setup_arbitrary_frame (int argc, CORE_ADDR *argv)
-{
- if (argc != 2)
- error ("ALPHA frame specifications require two arguments: sp and pc");
-
- return create_new_frame (argv[0], argv[1]);
-}
-
/* Assuming NEXT_FRAME->prev is a dummy, return the frame ID of that
dummy frame. The frame ID's base needs to match the TOS value
saved by save_dummy_frame_tos(), and the PC match the dummy frame's
set_gdbarch_register_name (gdbarch, alpha_register_name);
set_gdbarch_deprecated_register_byte (gdbarch, alpha_register_byte);
- set_gdbarch_deprecated_register_raw_size (gdbarch, alpha_register_raw_size);
- set_gdbarch_deprecated_register_virtual_size (gdbarch, alpha_register_virtual_size);
set_gdbarch_register_type (gdbarch, alpha_register_type);
set_gdbarch_cannot_fetch_register (gdbarch, alpha_cannot_fetch_register);
/* 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\
-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);
- add_show_from_set (c, &showlist);
+ 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."),
+ _("\
+The distance searched for the start of a function is \"%d\"."),
+ reinit_frame_cache_sfunc, NULL,
+ &setlist, &showlist);
}
projects / deliverable / binutils-gdb.git / blobdiff