#include "completer.h"
#include "language.h"
#include "osabi.h"
-
+#include "gdb_assert.h"
+#include "infttrace.h"
/* For argument passing to the inferior */
#include "symtab.h"
CORE_ADDR hppa_frame_args_address (struct frame_info *fi);
CORE_ADDR hppa_frame_locals_address (struct frame_info *fi);
int hppa_frame_num_args (struct frame_info *frame);
-void hppa_push_dummy_frame (struct inferior_status *inf_status);
+void hppa_push_dummy_frame (void);
void hppa_pop_frame (void);
CORE_ADDR hppa_fix_call_dummy (char *dummy, CORE_ADDR pc, CORE_ADDR fun,
int nargs, struct value **args,
}
args_for_find_stub;
-static int cover_find_stub_with_shl_get (PTR);
+static int cover_find_stub_with_shl_get (void *);
static int is_pa_2 = 0; /* False */
if (TARGET_PTR_BIT == 64 && text_offset == 0)
{
bfd_map_over_sections (objfile->obfd,
- record_text_segment_lowaddr, (PTR) NULL);
+ record_text_segment_lowaddr, NULL);
/* ?!? Mask off some low bits. Should this instead subtract
out the lowest section's filepos or something like that?
obj_private->so_info = NULL;
obj_private->dp = 0;
- objfile->obj_private = (PTR) obj_private;
+ objfile->obj_private = obj_private;
}
obj_private = (obj_private_data_t *) objfile->obj_private;
obj_private->unwind_info = ui;
msym_us = lookup_minimal_symbol_by_pc (pc);
return (u->HP_UX_interrupt_marker
- && !PC_IN_SIGTRAMP (pc, SYMBOL_NAME (msym_us)));
+ && !PC_IN_SIGTRAMP (pc, DEPRECATED_SYMBOL_NAME (msym_us)));
}
/* Called when no unwind descriptor was found for PC. Returns 1 if it
if (u->Save_SP
&& !pc_in_interrupt_handler (pc)
&& msym_us
- && !PC_IN_SIGTRAMP (pc, SYMBOL_NAME (msym_us)))
+ && !PC_IN_SIGTRAMP (pc, DEPRECATED_SYMBOL_NAME (msym_us)))
return -1;
return u->Total_frame_size << 3;
the stub will return to out of the stack. */
u = find_unwind_entry (pc);
if (u && u->stub_unwind.stub_type != 0)
- return FRAME_SAVED_PC (frame);
+ return DEPRECATED_FRAME_SAVED_PC (frame);
else
return pc;
}
{
CORE_ADDR pc = get_frame_pc (frame);
struct unwind_table_entry *u;
- CORE_ADDR old_pc;
+ CORE_ADDR old_pc = 0;
int spun_around_loop = 0;
int rp_offset = 0;
if (frame->next && !fromleaf)
return;
- /* If the next frame represents a frameless function invocation
- then we have to do some adjustments that are normally done by
- FRAME_CHAIN. (FRAME_CHAIN is not called in this case.) */
+ /* If the next frame represents a frameless function invocation then
+ we have to do some adjustments that are normally done by
+ DEPRECATED_FRAME_CHAIN. (DEPRECATED_FRAME_CHAIN is not called in
+ this case.) */
if (fromleaf)
{
/* Find the framesize of *this* frame without peeking at the PC
in the current frame structure (it isn't set yet). */
- framesize = find_proc_framesize (FRAME_SAVED_PC (get_next_frame (frame)));
+ framesize = find_proc_framesize (DEPRECATED_FRAME_SAVED_PC (get_next_frame (frame)));
/* Now adjust our base frame accordingly. If we have a frame pointer
use it, else subtract the size of this frame from the current
\f
/* Given a GDB frame, determine the address of the calling function's
frame. This will be used to create a new GDB frame struct, and
- then INIT_EXTRA_FRAME_INFO and DEPRECATED_INIT_FRAME_PC will be
- called for the new frame.
+ then DEPRECATED_INIT_EXTRA_FRAME_INFO and DEPRECATED_INIT_FRAME_PC
+ will be called for the new frame.
This may involve searching through prologues for several functions
at boundaries where GCC calls HP C code, or where code which has
pthread library itself, you'd get errors.
So for today, we don't make that check. */
- frame_symbol_name = SYMBOL_NAME (min_frame_symbol);
+ frame_symbol_name = DEPRECATED_SYMBOL_NAME (min_frame_symbol);
if (frame_symbol_name != 0)
{
if (0 == strncmp (frame_symbol_name,
/* Get frame sizes for the current frame and the frame of the
caller. */
my_framesize = find_proc_framesize (frame->pc);
- caller_pc = FRAME_SAVED_PC (frame);
+ caller_pc = DEPRECATED_FRAME_SAVED_PC (frame);
/* If we can't determine the caller's PC, then it's not likely we can
really determine anything meaningful about its frame. We'll consider
if (caller_pc == (CORE_ADDR) 0)
return (CORE_ADDR) 0;
- caller_framesize = find_proc_framesize (FRAME_SAVED_PC (frame));
+ caller_framesize = find_proc_framesize (DEPRECATED_FRAME_SAVED_PC (frame));
/* If caller does not have a frame pointer, then its frame
can be found at current_frame - caller_framesize. */
|| (saved_regs.regs[FLAGS_REGNUM] == 0
&& read_register (FLAGS_REGNUM) & 0x2)))
{
- u = find_unwind_entry (FRAME_SAVED_PC (frame));
+ u = find_unwind_entry (DEPRECATED_FRAME_SAVED_PC (frame));
if (!u)
{
return read_memory_integer (saved_regs.regs[FP_REGNUM],
|| (saved_regs.regs[FLAGS_REGNUM] == 0
&& read_register (FLAGS_REGNUM) & 0x2)))
{
- u = find_unwind_entry (FRAME_SAVED_PC (frame));
+ u = find_unwind_entry (DEPRECATED_FRAME_SAVED_PC (frame));
if (!u)
{
return read_memory_integer (saved_regs.regs[FP_REGNUM],
indistinguishable (as nearly as I can tell) from the symbol for a function
which is (legitimately, since it is in the user's namespace)
named Ltext_end, so we can't just ignore it. */
- msym_us = lookup_minimal_symbol_by_pc (FRAME_SAVED_PC (thisframe));
+ msym_us = lookup_minimal_symbol_by_pc (DEPRECATED_FRAME_SAVED_PC (thisframe));
msym_start = lookup_minimal_symbol ("_start", NULL, NULL);
if (msym_us
&& msym_start
return 0;
}
-/*
- These functions deal with saving and restoring register state
- around a function call in the inferior. They keep the stack
- double-word aligned; eventually, on an hp700, the stack will have
- to be aligned to a 64-byte boundary. */
+/* These functions deal with saving and restoring register state
+ around a function call in the inferior. They keep the stack
+ double-word aligned; eventually, on an hp700, the stack will have
+ to be aligned to a 64-byte boundary. */
void
-hppa_push_dummy_frame (struct inferior_status *inf_status)
+hppa_push_dummy_frame (void)
{
CORE_ADDR sp, pc, pcspace;
register int regnum;
CORE_ADDR int_buffer;
double freg_buffer;
- /* Oh, what a hack. If we're trying to perform an inferior call
- while the inferior is asleep, we have to make sure to clear
- the "in system call" bit in the flag register (the call will
- start after the syscall returns, so we're no longer in the system
- call!) This state is kept in "inf_status", change it there.
-
- We also need a number of horrid hacks to deal with lossage in the
- PC queue registers (apparently they're not valid when the in syscall
- bit is set). */
pc = hppa_target_read_pc (inferior_ptid);
int_buffer = read_register (FLAGS_REGNUM);
if (int_buffer & 0x2)
{
- unsigned int sid;
- int_buffer &= ~0x2;
- write_inferior_status_register (inf_status, 0, int_buffer);
- write_inferior_status_register (inf_status, PCOQ_HEAD_REGNUM, pc + 0);
- write_inferior_status_register (inf_status, PCOQ_TAIL_REGNUM, pc + 4);
- sid = (pc >> 30) & 0x3;
+ const unsigned int sid = (pc >> 30) & 0x3;
if (sid == 0)
pcspace = read_register (SR4_REGNUM);
else
pcspace = read_register (SR4_REGNUM + 4 + sid);
- write_inferior_status_register (inf_status, PCSQ_HEAD_REGNUM, pcspace);
- write_inferior_status_register (inf_status, PCSQ_TAIL_REGNUM, pcspace);
}
else
pcspace = read_register (PCSQ_HEAD_REGNUM);
msymbol = lookup_minimal_symbol ("__shldp", NULL, NULL);
symbol2 = lookup_symbol ("__shldp", NULL, VAR_NAMESPACE, NULL, NULL);
endo_buff_addr = SYMBOL_VALUE_ADDRESS (buff_minsym);
- namelen = strlen (SYMBOL_NAME (function));
+ namelen = strlen (DEPRECATED_SYMBOL_NAME (function));
value_return_addr = endo_buff_addr + namelen;
ftype = check_typedef (SYMBOL_TYPE (get_sym));
/* set up stuff needed by __d_shl_get in buffer in end.o */
- target_write_memory (endo_buff_addr, SYMBOL_NAME (function), namelen);
+ target_write_memory (endo_buff_addr, DEPRECATED_SYMBOL_NAME (function), namelen);
target_write_memory (value_return_addr, (char *) &tmp, 4);
/* Cover routine for find_stub_with_shl_get to pass to catch_errors */
static int
-cover_find_stub_with_shl_get (PTR args_untyped)
+cover_find_stub_with_shl_get (void *args_untyped)
{
args_for_find_stub *args = args_untyped;
args->return_val = find_stub_with_shl_get (args->msym, args->solib_handle);
{
stub_symbol
= lookup_minimal_symbol_solib_trampoline
- (SYMBOL_NAME (funsymbol), NULL, objfile);
+ (DEPRECATED_SYMBOL_NAME (funsymbol), NULL, objfile);
if (!stub_symbol)
- stub_symbol = lookup_minimal_symbol (SYMBOL_NAME (funsymbol),
+ stub_symbol = lookup_minimal_symbol (DEPRECATED_SYMBOL_NAME (funsymbol),
NULL, objfile);
/* Found a symbol with the right name. */
new_stub = find_stub_with_shl_get (fmsymbol, solib_handle);
if (new_stub == 0)
- error ("Can't find an import stub for %s", SYMBOL_NAME (fmsymbol));
+ error ("Can't find an import stub for %s", DEPRECATED_SYMBOL_NAME (fmsymbol));
/* We have to store the address of the stub in __shlib_funcptr. */
msymbol = lookup_minimal_symbol ("__shlib_funcptr", NULL,
int start;
- char buf[MAX_REGISTER_RAW_SIZE];
+ char *buf = alloca (max_register_size (current_gdbarch));
long long reg_val;
if (!know_which)
static void
pa_print_fp_reg (int i)
{
- char raw_buffer[MAX_REGISTER_RAW_SIZE];
- char virtual_buffer[MAX_REGISTER_VIRTUAL_SIZE];
+ char *raw_buffer = alloca (max_register_size (current_gdbarch));
+ char *virtual_buffer = alloca (max_register_size (current_gdbarch));
/* Get 32bits of data. */
frame_register_read (deprecated_selected_frame, i, raw_buffer);
static void
pa_strcat_fp_reg (int i, struct ui_file *stream, enum precision_type precision)
{
- char raw_buffer[MAX_REGISTER_RAW_SIZE];
- char virtual_buffer[MAX_REGISTER_VIRTUAL_SIZE];
+ char *raw_buffer = alloca (max_register_size (current_gdbarch));
+ char *virtual_buffer = alloca (max_register_size (current_gdbarch));
fputs_filtered (REGISTER_NAME (i), stream);
print_spaces_filtered (8 - strlen (REGISTER_NAME (i)), stream);
if (precision == double_precision && (i % 2) == 0)
{
- char raw_buf[MAX_REGISTER_RAW_SIZE];
+ char *raw_buf = alloca (max_register_size (current_gdbarch));
/* Get the data in raw format for the 2nd half. */
frame_register_read (deprecated_selected_frame, i + 1, raw_buf);
return 1;
minsym = lookup_minimal_symbol_by_pc (pc);
- if (minsym && strcmp (SYMBOL_NAME (minsym), ".stub") == 0)
+ if (minsym && strcmp (DEPRECATED_SYMBOL_NAME (minsym), ".stub") == 0)
return 1;
/* Get the unwind descriptor corresponding to PC, return zero
ALL_MSYMBOLS (objfile, msymbol)
{
if (MSYMBOL_TYPE (msymbol) == mst_text
- && STREQ (SYMBOL_NAME (msymbol), SYMBOL_NAME (msym)))
+ && STREQ (DEPRECATED_SYMBOL_NAME (msymbol), DEPRECATED_SYMBOL_NAME (msym)))
{
function_found = 1;
break;
return orig_pc == pc ? 0 : pc & ~0x3;
}
- libsym = lookup_minimal_symbol (SYMBOL_NAME (stubsym), NULL, NULL);
+ libsym = lookup_minimal_symbol (DEPRECATED_SYMBOL_NAME (stubsym), NULL, NULL);
if (libsym == NULL)
{
warning ("Unable to find library symbol for %s\n",
- SYMBOL_NAME (stubsym));
+ DEPRECATED_SYMBOL_NAME (stubsym));
return orig_pc == pc ? 0 : pc & ~0x3;
}
/* Get the starting address of the function referred to by the PC
saved in frame. */
- pc = get_pc_function_start (frame_info->pc);
+ pc = get_frame_func (frame_info);
/* Yow! */
u = find_unwind_entry (pc);
args.return_val = 0;
recurse++;
- catch_errors (cover_find_stub_with_shl_get, (PTR) &args, message,
+ catch_errors (cover_find_stub_with_shl_get, &args, message,
RETURN_MASK_ALL);
eh_notify_callback_addr = args.return_val;
recurse--;
return ¤t_ex_event;
}
+/* Instead of this nasty cast, add a method pvoid() that prints out a
+ host VOID data type (remember %p isn't portable). */
+
+static CORE_ADDR
+hppa_pointer_to_address_hack (void *ptr)
+{
+ gdb_assert (sizeof (ptr) == TYPE_LENGTH (builtin_type_void_data_ptr));
+ return POINTER_TO_ADDRESS (builtin_type_void_data_ptr, &ptr);
+}
+
static void
unwind_command (char *exp, int from_tty)
{
}
printf_unfiltered ("unwind_table_entry (0x%s):\n",
- paddr_nz (host_pointer_to_address (u)));
+ paddr_nz (hppa_pointer_to_address_hack (u)));
printf_unfiltered ("\tregion_start = ");
print_address (u->region_start, gdb_stdout);
set_gdbarch_saved_pc_after_call (gdbarch, hppa_saved_pc_after_call);
set_gdbarch_inner_than (gdbarch, hppa_inner_than);
set_gdbarch_stack_align (gdbarch, hppa_stack_align);
- set_gdbarch_extra_stack_alignment_needed (gdbarch, 0);
set_gdbarch_decr_pc_after_break (gdbarch, 0);
set_gdbarch_register_size (gdbarch, 4);
set_gdbarch_num_regs (gdbarch, hppa_num_regs);
set_gdbarch_register_bytes (gdbarch, hppa_num_regs * 4);
set_gdbarch_register_byte (gdbarch, hppa_register_byte);
set_gdbarch_register_virtual_size (gdbarch, hppa_register_raw_size);
- set_gdbarch_max_register_raw_size (gdbarch, 4);
- set_gdbarch_max_register_virtual_size (gdbarch, 8);
+ set_gdbarch_deprecated_max_register_raw_size (gdbarch, 4);
+ set_gdbarch_deprecated_max_register_virtual_size (gdbarch, 8);
set_gdbarch_register_virtual_type (gdbarch, hppa_register_virtual_type);
- set_gdbarch_store_struct_return (gdbarch, hppa_store_struct_return);
+ set_gdbarch_deprecated_store_struct_return (gdbarch, hppa_store_struct_return);
set_gdbarch_deprecated_extract_return_value (gdbarch,
hppa_extract_return_value);
set_gdbarch_use_struct_convention (gdbarch, hppa_use_struct_convention);
set_gdbarch_deprecated_extract_struct_value_address
(gdbarch, hppa_extract_struct_value_address);
set_gdbarch_cannot_store_register (gdbarch, hppa_cannot_store_register);
- set_gdbarch_init_extra_frame_info (gdbarch, hppa_init_extra_frame_info);
- set_gdbarch_frame_chain (gdbarch, hppa_frame_chain);
- set_gdbarch_frame_chain_valid (gdbarch, hppa_frame_chain_valid);
+ set_gdbarch_deprecated_init_extra_frame_info (gdbarch, hppa_init_extra_frame_info);
+ set_gdbarch_deprecated_frame_chain (gdbarch, hppa_frame_chain);
+ set_gdbarch_deprecated_frame_chain_valid (gdbarch, hppa_frame_chain_valid);
set_gdbarch_frameless_function_invocation
(gdbarch, hppa_frameless_function_invocation);
- set_gdbarch_frame_saved_pc (gdbarch, hppa_frame_saved_pc);
+ set_gdbarch_deprecated_frame_saved_pc (gdbarch, hppa_frame_saved_pc);
set_gdbarch_frame_args_address (gdbarch, hppa_frame_args_address);
set_gdbarch_frame_locals_address (gdbarch, hppa_frame_locals_address);
set_gdbarch_frame_num_args (gdbarch, hppa_frame_num_args);
set_gdbarch_frame_args_skip (gdbarch, 0);
- /* set_gdbarch_push_dummy_frame (gdbarch, hppa_push_dummy_frame); */
- set_gdbarch_pop_frame (gdbarch, hppa_pop_frame);
+ set_gdbarch_deprecated_push_dummy_frame (gdbarch, hppa_push_dummy_frame);
+ set_gdbarch_deprecated_pop_frame (gdbarch, hppa_pop_frame);
set_gdbarch_call_dummy_length (gdbarch, INSTRUCTION_SIZE * 28);
- set_gdbarch_call_dummy_start_offset (gdbarch, 0);
/* set_gdbarch_fix_call_dummy (gdbarch, hppa_fix_call_dummy); */
- set_gdbarch_push_arguments (gdbarch, hppa_push_arguments);
+ set_gdbarch_deprecated_push_arguments (gdbarch, hppa_push_arguments);
set_gdbarch_smash_text_address (gdbarch, hppa_smash_text_address);
set_gdbarch_believe_pcc_promotion (gdbarch, 1);
set_gdbarch_read_pc (gdbarch, hppa_target_read_pc);
projects / deliverable / binutils-gdb.git / blobdiff