Contributed by the Center for Software Science at the
University of Utah (pa-gdb-bugs@cs.utah.edu).
-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 "frame.h"
#else
#endif
-/*#include <sys/user.h> After a.out.h */
+/*#include <sys/user.h> After a.out.h */
#include <sys/file.h>
#include "gdb_stat.h"
#include "wait.h"
that threads have. */
#define THREAD_INITIAL_FRAME_SYMBOL "__pthread_exit"
#define THREAD_INITIAL_FRAME_SYM_LEN sizeof(THREAD_INITIAL_FRAME_SYMBOL)
-
+
static int extract_5_load PARAMS ((unsigned int));
static unsigned extract_5R_store PARAMS ((unsigned int));
static void pa_print_fp_reg PARAMS ((int));
static void pa_strcat_fp_reg PARAMS ((int, GDB_FILE *, enum precision_type));
-typedef struct {
- struct minimal_symbol * msym;
- CORE_ADDR solib_handle;
-} args_for_find_stub;
+typedef struct
+ {
+ struct minimal_symbol *msym;
+ CORE_ADDR solib_handle;
+ }
+args_for_find_stub;
static CORE_ADDR cover_find_stub_with_shl_get PARAMS ((args_for_find_stub *));
-static int is_pa_2 = 0; /* False */
+static int is_pa_2 = 0; /* False */
-/* This is declared in symtab.c; set to 1 in hp-symtab-read.c */
+/* This is declared in symtab.c; set to 1 in hp-symtab-read.c */
extern int hp_som_som_object_present;
/* In breakpoint.c */
/* This is defined in valops.c. */
extern value_ptr
-find_function_in_inferior PARAMS((char *));
+ find_function_in_inferior PARAMS ((char *));
/* Should call_function allocate stack space for a struct return? */
int
{
return (TYPE_LENGTH (type) > 8);
}
-
\f
+
/* Routines to extract various sized constants out of hppa
instructions. */
sign_extend (val, bits)
unsigned val, bits;
{
- return (int)(val >> (bits - 1) ? (-1 << bits) | val : val);
+ return (int) (val >> (bits - 1) ? (-1 << bits) | val : val);
}
/* For many immediate values the sign bit is the low bit! */
low_sign_extend (val, bits)
unsigned val, bits;
{
- return (int)((val & 0x1 ? (-1 << (bits - 1)) : 0) | val >> 1);
+ return (int) ((val & 0x1 ? (-1 << (bits - 1)) : 0) | val >> 1);
}
/* extract the immediate field from a ld{bhw}s instruction */
return low_sign_extend (word & MASK_5, 5);
}
-#endif /* 0 */
-
+#endif /* 0 */
+
/* extract the immediate field from a break instruction */
static unsigned
{
unsigned sign = (opnd < 0 ? 1 : 0);
- return word | ((unsigned)opnd << 1 & MASK_14) | sign;
+ return word | ((unsigned) opnd << 1 & MASK_14) | sign;
}
/* extract a 21 bit constant */
deposit_17 (opnd, word)
unsigned opnd, word;
{
- word |= GET_FIELD (opnd, 15 + 0, 15 + 0); /* w */
- word |= GET_FIELD (opnd, 15 + 1, 15 + 5) << 16; /* w1 */
- word |= GET_FIELD (opnd, 15 + 6, 15 + 6) << 2; /* w2[10] */
- word |= GET_FIELD (opnd, 15 + 7, 15 + 16) << 3; /* w2[0..9] */
+ word |= GET_FIELD (opnd, 15 + 0, 15 + 0); /* w */
+ word |= GET_FIELD (opnd, 15 + 1, 15 + 5) << 16; /* w1 */
+ word |= GET_FIELD (opnd, 15 + 6, 15 + 6) << 2; /* w2[10] */
+ word |= GET_FIELD (opnd, 15 + 7, 15 + 16) << 3; /* w2[0..9] */
return word;
}
bfd_get_section_contents (objfile->obfd, section, buf, 0, size);
/* Now internalize the information being careful to handle host/target
- endian issues. */
+ endian issues. */
for (i = 0; i < entries; i++)
{
table[i].region_start = bfd_get_32 (objfile->obfd,
- (bfd_byte *)buf);
+ (bfd_byte *) buf);
table[i].region_start += text_offset;
buf += 4;
- table[i].region_end = bfd_get_32 (objfile->obfd, (bfd_byte *)buf);
+ table[i].region_end = bfd_get_32 (objfile->obfd, (bfd_byte *) buf);
table[i].region_end += text_offset;
buf += 4;
- tmp = bfd_get_32 (objfile->obfd, (bfd_byte *)buf);
+ tmp = bfd_get_32 (objfile->obfd, (bfd_byte *) buf);
buf += 4;
table[i].Cannot_unwind = (tmp >> 31) & 0x1;
table[i].Millicode = (tmp >> 30) & 0x1;
table[i].Save_MRP_in_frame = (tmp >> 2) & 0x1;
table[i].extn_ptr_defined = (tmp >> 1) & 0x1;
table[i].Cleanup_defined = tmp & 0x1;
- tmp = bfd_get_32 (objfile->obfd, (bfd_byte *)buf);
+ tmp = bfd_get_32 (objfile->obfd, (bfd_byte *) buf);
buf += 4;
table[i].MPE_XL_interrupt_marker = (tmp >> 31) & 0x1;
table[i].HP_UX_interrupt_marker = (tmp >> 30) & 0x1;
table[i].reserved4 = (tmp >> 27) & 0x1;
table[i].Total_frame_size = tmp & 0x7ffffff;
- /* Stub unwinds are handled elsewhere. */
+ /* Stub unwinds are handled elsewhere. */
table[i].stub_unwind.stub_type = 0;
table[i].stub_unwind.padding = 0;
}
obj_private_data_t *obj_private;
text_offset = ANOFFSET (objfile->section_offsets, 0);
- ui = (struct obj_unwind_info *)obstack_alloc (&objfile->psymbol_obstack,
- sizeof (struct obj_unwind_info));
+ ui = (struct obj_unwind_info *) obstack_alloc (&objfile->psymbol_obstack,
+ sizeof (struct obj_unwind_info));
ui->table = NULL;
ui->cache = NULL;
if (elf_unwind_sec)
{
- elf_unwind_size = bfd_section_size (objfile->obfd, elf_unwind_sec); /* purecov: deadcode */
- elf_unwind_entries = elf_unwind_size / UNWIND_ENTRY_SIZE; /* purecov: deadcode */
+ elf_unwind_size = bfd_section_size (objfile->obfd, elf_unwind_sec); /* purecov: deadcode */
+ elf_unwind_entries = elf_unwind_size / UNWIND_ENTRY_SIZE; /* purecov: deadcode */
}
else
{
/* Allocate memory for the unwind table. */
ui->table = (struct unwind_table_entry *)
obstack_alloc (&objfile->psymbol_obstack, total_size);
- ui->last = total_entries - 1;
+ ui->last = total_entries - 1;
/* Internalize the standard unwind entries. */
index = 0;
ui->table[index].region_start += text_offset;
buf += 4;
ui->table[index].stub_unwind.stub_type = bfd_get_8 (objfile->obfd,
- (bfd_byte *) buf);
+ (bfd_byte *) buf);
buf += 2;
ui->table[index].region_end
- = ui->table[index].region_start + 4 *
- (bfd_get_16 (objfile->obfd, (bfd_byte *) buf) - 1);
+ = ui->table[index].region_start + 4 *
+ (bfd_get_16 (objfile->obfd, (bfd_byte *) buf) - 1);
buf += 2;
}
compare_unwind_entries);
/* Keep a pointer to the unwind information. */
- if(objfile->obj_private == NULL)
+ if (objfile->obj_private == NULL)
{
obj_private = (obj_private_data_t *)
- obstack_alloc(&objfile->psymbol_obstack,
- sizeof(obj_private_data_t));
+ obstack_alloc (&objfile->psymbol_obstack,
+ sizeof (obj_private_data_t));
obj_private->unwind_info = NULL;
- obj_private->so_info = NULL;
-
+ obj_private->so_info = NULL;
+
objfile->obj_private = (PTR) obj_private;
}
- obj_private = (obj_private_data_t *)objfile->obj_private;
+ obj_private = (obj_private_data_t *) objfile->obj_private;
obj_private->unwind_info = ui;
}
search of the unwind tables, we depend upon them to be sorted. */
struct unwind_table_entry *
-find_unwind_entry(pc)
+find_unwind_entry (pc)
CORE_ADDR pc;
{
int first, middle, last;
return NULL;
ALL_OBJFILES (objfile)
- {
- struct obj_unwind_info *ui;
- ui = NULL;
- if (objfile->obj_private)
- ui = ((obj_private_data_t *)(objfile->obj_private))->unwind_info;
+ {
+ struct obj_unwind_info *ui;
+ ui = NULL;
+ if (objfile->obj_private)
+ ui = ((obj_private_data_t *) (objfile->obj_private))->unwind_info;
- if (!ui)
- {
- read_unwind_info (objfile);
- if (objfile->obj_private == NULL)
- error ("Internal error reading unwind information."); /* purecov: deadcode */
- ui = ((obj_private_data_t *)(objfile->obj_private))->unwind_info;
- }
+ if (!ui)
+ {
+ read_unwind_info (objfile);
+ if (objfile->obj_private == NULL)
+ error ("Internal error reading unwind information."); /* purecov: deadcode */
+ ui = ((obj_private_data_t *) (objfile->obj_private))->unwind_info;
+ }
- /* First, check the cache */
+ /* First, check the cache */
- if (ui->cache
- && pc >= ui->cache->region_start
- && pc <= ui->cache->region_end)
- return ui->cache;
+ if (ui->cache
+ && pc >= ui->cache->region_start
+ && pc <= ui->cache->region_end)
+ return ui->cache;
- /* Not in the cache, do a binary search */
+ /* Not in the cache, do a binary search */
- first = 0;
- last = ui->last;
+ first = 0;
+ last = ui->last;
- while (first <= last)
- {
- middle = (first + last) / 2;
- if (pc >= ui->table[middle].region_start
- && pc <= ui->table[middle].region_end)
- {
- ui->cache = &ui->table[middle];
- return &ui->table[middle];
- }
+ while (first <= last)
+ {
+ middle = (first + last) / 2;
+ if (pc >= ui->table[middle].region_start
+ && pc <= ui->table[middle].region_end)
+ {
+ ui->cache = &ui->table[middle];
+ return &ui->table[middle];
+ }
- if (pc < ui->table[middle].region_start)
- last = middle - 1;
- else
- first = middle + 1;
- }
- } /* ALL_OBJFILES() */
+ if (pc < ui->table[middle].region_start)
+ last = middle - 1;
+ else
+ first = middle + 1;
+ }
+ } /* ALL_OBJFILES() */
return NULL;
}
break;
/* Check for ldsid (rp),r1 which is the magic instruction for a
- return from a cross-space function call. */
+ return from a cross-space function call. */
if (read_memory_integer (pc + i * 4, 4) == 0x004010a1)
{
found_magic_instruction = 1;
break;
}
/* Add code to handle long call/branch and argument relocation stubs
- here. */
+ here. */
}
if (found_magic_instruction != 0)
break;
/* Check for ldsid (rp),r1 which is the magic instruction for a
- return from a cross-space function call. */
+ return from a cross-space function call. */
if (read_memory_integer (pc - i * 4, 4) == 0x004010a1)
{
found_magic_instruction = 1;
break;
}
/* Add code to handle long call/branch and argument relocation stubs
- here. */
+ here. */
}
return found_magic_instruction;
}
static int
-find_return_regnum(pc)
+find_return_regnum (pc)
CORE_ADDR pc;
{
struct unwind_table_entry *u;
struct minimal_symbol *msym_us;
/* This may indicate a bug in our callers... */
- if (pc == (CORE_ADDR)0)
+ if (pc == (CORE_ADDR) 0)
return -1;
-
+
u = find_unwind_entry (pc);
if (!u)
ret_regnum = find_return_regnum (get_frame_pc (frame));
pc = read_register (ret_regnum) & ~0x3;
-
+
/* If PC is in a linker stub, then we need to dig the address
the stub will return to out of the stack. */
u = find_unwind_entry (pc);
CORE_ADDR pc = get_frame_pc (frame);
struct unwind_table_entry *u;
CORE_ADDR old_pc;
- int spun_around_loop = 0;
- int rp_offset = 0;
+ int spun_around_loop = 0;
+ int rp_offset = 0;
/* BSD, HPUX & OSF1 all lay out the hardware state in the same manner
at the base of the frame in an interrupt handler. Registers within
ret_regnum = find_return_regnum (pc);
/* If the next frame is an interrupt frame or a signal
- handler caller, then we need to look in the saved
- register area to get the return pointer (the values
- in the registers may not correspond to anything useful). */
- if (frame->next
+ handler caller, then we need to look in the saved
+ register area to get the return pointer (the values
+ in the registers may not correspond to anything useful). */
+ if (frame->next
&& (frame->next->signal_handler_caller
|| pc_in_interrupt_handler (frame->next->pc)))
{
pc = read_memory_integer (saved_regs.regs[31], 4) & ~0x3;
/* Syscalls are really two frames. The syscall stub itself
- with a return pointer in %rp and the kernel call with
- a return pointer in %r31. We return the %rp variant
- if %r31 is the same as frame->pc. */
+ with a return pointer in %rp and the kernel call with
+ a return pointer in %r31. We return the %rp variant
+ if %r31 is the same as frame->pc. */
if (pc == frame->pc)
pc = read_memory_integer (saved_regs.regs[RP_REGNUM], 4) & ~0x3;
}
else
{
spun_around_loop = 0;
- old_pc = pc;
+ old_pc = pc;
-restart:
+ restart:
rp_offset = rp_saved (pc);
/* Similar to code in frameless function case. If the next
- frame is a signal or interrupt handler, then dig the right
- information out of the saved register info. */
+ frame is a signal or interrupt handler, then dig the right
+ information out of the saved register info. */
if (rp_offset == 0
&& frame->next
&& (frame->next->signal_handler_caller
pc = read_memory_integer (saved_regs.regs[31], 4) & ~0x3;
/* Syscalls are really two frames. The syscall stub itself
- with a return pointer in %rp and the kernel call with
- a return pointer in %r31. We return the %rp variant
- if %r31 is the same as frame->pc. */
+ with a return pointer in %rp and the kernel call with
+ a return pointer in %r31. We return the %rp variant
+ if %r31 is the same as frame->pc. */
if (pc == frame->pc)
pc = read_memory_integer (saved_regs.regs[RP_REGNUM], 4) & ~0x3;
}
pc = read_memory_integer (saved_regs.regs[RP_REGNUM], 4) & ~0x3;
}
else if (rp_offset == 0)
- {
- old_pc = pc;
- pc = read_register (RP_REGNUM) & ~0x3;
- }
+ {
+ old_pc = pc;
+ pc = read_register (RP_REGNUM) & ~0x3;
+ }
else
- {
- old_pc = pc;
- pc = read_memory_integer (frame->frame + rp_offset, 4) & ~0x3;
- }
+ {
+ old_pc = pc;
+ pc = read_memory_integer (frame->frame + rp_offset, 4) & ~0x3;
+ }
}
/* If PC is inside a linker stub, then dig out the address the stub
unsigned int insn;
/* If this is a dynamic executable, and we're in a signal handler,
- then the call chain will eventually point us into the stub for
- _sigreturn. Unlike most cases, we'll be pointed to the branch
- to the real sigreturn rather than the code after the real branch!.
+ then the call chain will eventually point us into the stub for
+ _sigreturn. Unlike most cases, we'll be pointed to the branch
+ to the real sigreturn rather than the code after the real branch!.
- Else, try to dig the address the stub will return to in the normal
- fashion. */
+ Else, try to dig the address the stub will return to in the normal
+ fashion. */
insn = read_memory_integer (pc, 4);
if ((insn & 0xfc00e000) == 0xe8000000)
return (pc + extract_17 (insn) + 8) & ~0x3;
else
{
- if (old_pc == pc)
- spun_around_loop++;
-
- if (spun_around_loop > 1)
- {
- /* We're just about to go around the loop again with
- no more hope of success. Die. */
- error("Unable to find return pc for this frame");
- }
- else
- goto restart;
+ if (old_pc == pc)
+ spun_around_loop++;
+
+ if (spun_around_loop > 1)
+ {
+ /* We're just about to go around the loop again with
+ no more hope of success. Die. */
+ error ("Unable to find return pc for this frame");
+ }
+ else
+ goto restart;
}
}
if (fromleaf)
{
/* Find the framesize of *this* frame without peeking at the PC
- in the current frame structure (it isn't set yet). */
+ in the current frame structure (it isn't set yet). */
framesize = find_proc_framesize (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
- frame. (we always want frame->frame to point at the lowest address
- in the frame). */
+ use it, else subtract the size of this frame from the current
+ frame. (we always want frame->frame to point at the lowest address
+ in the frame). */
if (framesize == -1)
frame->frame = TARGET_READ_FP ();
else
}
flags = read_register (FLAGS_REGNUM);
- if (flags & 2) /* In system call? */
+ if (flags & 2) /* In system call? */
frame->pc = read_register (31) & ~0x3;
/* The outermost frame is always derived from PC-framesize
explain, but the parent *always* creates some stack space for
the child. So the child actually does have a frame of some
sorts, and its base is the high address in its parent's frame. */
- framesize = find_proc_framesize(frame->pc);
+ framesize = find_proc_framesize (frame->pc);
if (framesize == -1)
frame->frame = TARGET_READ_FP ();
else
CORE_ADDR frame_base;
struct frame_info *tmp_frame;
- CORE_ADDR caller_pc;
+ CORE_ADDR caller_pc;
struct minimal_symbol *min_frame_symbol;
- struct symbol *frame_symbol;
- char *frame_symbol_name;
+ struct symbol *frame_symbol;
+ char *frame_symbol_name;
/* If this is a threaded application, and we see the
routine "__pthread_exit", treat it as the stack root
for this thread. */
- min_frame_symbol = lookup_minimal_symbol_by_pc (frame->pc);
- frame_symbol = find_pc_function(frame->pc);
+ min_frame_symbol = lookup_minimal_symbol_by_pc (frame->pc);
+ frame_symbol = find_pc_function (frame->pc);
- if ((min_frame_symbol != 0) /* && (frame_symbol == 0) */)
+ if ((min_frame_symbol != 0) /* && (frame_symbol == 0) */ )
{
- /* The test above for "no user function name" would defend
- against the slim likelihood that a user might define a
- routine named "__pthread_exit" and then try to debug it.
-
- If it weren't commented out, and you tried to debug the
- pthread library itself, you'd get errors.
-
- So for today, we don't make that check. */
- frame_symbol_name = SYMBOL_NAME(min_frame_symbol);
- if (frame_symbol_name != 0) {
- if (0 == strncmp(frame_symbol_name,
- THREAD_INITIAL_FRAME_SYMBOL,
- THREAD_INITIAL_FRAME_SYM_LEN)) {
- /* Pretend we've reached the bottom of the stack. */
- return (CORE_ADDR) 0;
- }
- }
- } /* End of hacky code for threads. */
-
+ /* The test above for "no user function name" would defend
+ against the slim likelihood that a user might define a
+ routine named "__pthread_exit" and then try to debug it.
+
+ If it weren't commented out, and you tried to debug the
+ pthread library itself, you'd get errors.
+
+ So for today, we don't make that check. */
+ frame_symbol_name = SYMBOL_NAME (min_frame_symbol);
+ if (frame_symbol_name != 0)
+ {
+ if (0 == strncmp (frame_symbol_name,
+ THREAD_INITIAL_FRAME_SYMBOL,
+ THREAD_INITIAL_FRAME_SYM_LEN))
+ {
+ /* Pretend we've reached the bottom of the stack. */
+ return (CORE_ADDR) 0;
+ }
+ }
+ } /* End of hacky code for threads. */
+
/* Handle HPUX, BSD, and OSF1 style interrupt frames first. These
are easy; at *sp we have a full save state strucutre which we can
pull the old stack pointer from. Also see frame_saved_pc for
/* 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 = 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 (FRAME_SAVED_PC (frame));
/* If caller does not have a frame pointer, then its frame
can be found at current_frame - caller_framesize. */
think anyone has actually written any tools (not even "strip")
which leave them out of an executable, so maybe this is a moot
point. */
- /* ??rehrauer: Actually, it's quite possible to stepi your way into
- code that doesn't have unwind entries. For example, stepping into
- the dynamic linker will give you a PC that has none. Thus, I've
- disabled this warning. */
+ /* ??rehrauer: Actually, it's quite possible to stepi your way into
+ code that doesn't have unwind entries. For example, stepping into
+ the dynamic linker will give you a PC that has none. Thus, I've
+ disabled this warning. */
#if 0
warning ("Unable to find unwind for PC 0x%x -- Help!", tmp_frame->pc);
#endif
}
/* Entry_GR specifies the number of callee-saved general registers
- saved in the stack. It starts at %r3, so %r3 would be 1. */
+ saved in the stack. It starts at %r3, so %r3 would be 1. */
if (u->Entry_GR >= 1 || u->Save_SP
|| tmp_frame->signal_handler_caller
|| pc_in_interrupt_handler (tmp_frame->pc))
if (tmp_frame)
{
/* We may have walked down the chain into a function with a frame
- pointer. */
+ pointer. */
if (u->Save_SP
&& !tmp_frame->signal_handler_caller
&& !pc_in_interrupt_handler (tmp_frame->pc))
return read_memory_integer (tmp_frame->frame, 4);
}
/* %r3 was saved somewhere in the stack. Dig it out. */
- else
+ else
{
struct frame_saved_regs saved_regs;
is usually turned off if the process is being traced so
that the debugger can get full register state for the
process.
-
+
This scheme works well except for two cases:
- * Attaching to a process when the process is in the
- kernel performing a system call (debugger can't get
- full register state for the inferior process since
- the process wasn't being traced when it entered the
- system call).
+ * Attaching to a process when the process is in the
+ kernel performing a system call (debugger can't get
+ full register state for the inferior process since
+ the process wasn't being traced when it entered the
+ system call).
- * Register state is not complete if the system call
- causes the process to core dump.
+ * Register state is not complete if the system call
+ causes the process to core dump.
The following heinous code is an attempt to deal with
/* Abominable hack. */
if (current_target.to_has_execution == 0
&& ((saved_regs.regs[FLAGS_REGNUM]
- && (read_memory_integer (saved_regs.regs[FLAGS_REGNUM], 4)
+ && (read_memory_integer (saved_regs.regs[FLAGS_REGNUM], 4)
& 0x2))
|| (saved_regs.regs[FLAGS_REGNUM] == 0
&& read_register (FLAGS_REGNUM) & 0x2)))
return frame_base - (u->Total_frame_size << 3);
}
}
-
+
return read_memory_integer (saved_regs.regs[FP_REGNUM], 4);
}
}
&& (read_memory_integer (saved_regs.regs[FLAGS_REGNUM], 4)
& 0x2))
|| (saved_regs.regs[FLAGS_REGNUM] == 0
- && read_register (FLAGS_REGNUM) & 0x2)))
+ && read_register (FLAGS_REGNUM) & 0x2)))
{
u = find_unwind_entry (FRAME_SAVED_PC (frame));
if (!u)
{
return read_memory_integer (saved_regs.regs[FP_REGNUM], 4);
}
- else
- {
- return frame_base - (u->Total_frame_size << 3);
- }
+ else
+ {
+ return frame_base - (u->Total_frame_size << 3);
+ }
}
-
+
/* The value in %r3 was never saved into the stack (thus %r3 still
- holds the value of the previous frame pointer). */
+ holds the value of the previous frame pointer). */
return TARGET_READ_FP ();
}
}
-
\f
+
/* To see if a frame chain is valid, see if the caller looks like it
was compiled with gcc. */
/* Space for "arguments"; the RP goes in here. */
sp = read_register (SP_REGNUM) + 48;
int_buffer = read_register (RP_REGNUM) | 0x3;
- write_memory (sp - 20, (char *)&int_buffer, 4);
+ write_memory (sp - 20, (char *) &int_buffer, 4);
int_buffer = TARGET_READ_FP ();
- write_memory (sp, (char *)&int_buffer, 4);
+ write_memory (sp, (char *) &int_buffer, 4);
write_register (FP_REGNUM, sp);
for (regnum = FP0_REGNUM; regnum < NUM_REGS; regnum++)
{
- read_register_bytes (REGISTER_BYTE (regnum), (char *)&freg_buffer, 8);
- sp = push_bytes (sp, (char *)&freg_buffer, 8);
+ read_register_bytes (REGISTER_BYTE (regnum), (char *) &freg_buffer, 8);
+ sp = push_bytes (sp, (char *) &freg_buffer, 8);
}
sp = push_word (sp, read_register (IPSW_REGNUM));
sp = push_word (sp, read_register (SAR_REGNUM));
get_frame_saved_regs (frame, &fsr);
#ifndef NO_PC_SPACE_QUEUE_RESTORE
- if (fsr.regs[IPSW_REGNUM]) /* Restoring a call dummy frame */
+ if (fsr.regs[IPSW_REGNUM]) /* Restoring a call dummy frame */
restore_pc_queue (&fsr);
#endif
if (fsr.regs[regnum])
write_register (regnum, read_memory_integer (fsr.regs[regnum], 4));
- for (regnum = NUM_REGS - 1; regnum >= FP0_REGNUM ; regnum--)
+ for (regnum = NUM_REGS - 1; regnum >= FP0_REGNUM; regnum--)
if (fsr.regs[regnum])
{
- read_memory (fsr.regs[regnum], (char *)&freg_buffer, 8);
- write_register_bytes (REGISTER_BYTE (regnum), (char *)&freg_buffer, 8);
+ read_memory (fsr.regs[regnum], (char *) &freg_buffer, 8);
+ write_register_bytes (REGISTER_BYTE (regnum), (char *) &freg_buffer, 8);
}
if (fsr.regs[IPSW_REGNUM])
write_register (IPSW_REGNUM,
- read_memory_integer (fsr.regs[IPSW_REGNUM], 4));
+ read_memory_integer (fsr.regs[IPSW_REGNUM], 4));
if (fsr.regs[SAR_REGNUM])
write_register (SAR_REGNUM,
- read_memory_integer (fsr.regs[SAR_REGNUM], 4));
+ read_memory_integer (fsr.regs[SAR_REGNUM], 4));
/* If the PC was explicitly saved, then just restore it. */
if (fsr.regs[PCOQ_TAIL_REGNUM])
write_register (PCOQ_TAIL_REGNUM, npc);
}
/* Else use the value in %rp to set the new PC. */
- else
+ else
{
npc = read_register (RP_REGNUM);
write_pc (npc);
write_register (FP_REGNUM, read_memory_integer (fp, 4));
- if (fsr.regs[IPSW_REGNUM]) /* call dummy */
+ if (fsr.regs[IPSW_REGNUM]) /* call dummy */
write_register (SP_REGNUM, fp - 48);
else
write_register (SP_REGNUM, fp);
struct cleanup *old_chain;
/* Set up our breakpoint. Set it to be silent as the MI code
- for "return_command" will print the frame we returned to. */
+ for "return_command" will print the frame we returned to. */
sal = find_pc_line (target_pc, 0);
sal.pc = target_pc;
breakpoint = set_momentary_breakpoint (sal, NULL, bp_finish);
/* Start up the inferior. */
clear_proceed_status ();
proceed_to_finish = 1;
- proceed ((CORE_ADDR) -1, TARGET_SIGNAL_DEFAULT, 0);
+ proceed ((CORE_ADDR) - 1, TARGET_SIGNAL_DEFAULT, 0);
/* Perform our cleanups. */
do_cleanups (old_chain);
registers of the PC queue through ptrace. Boo, hiss.
Conveniently, the call dummy has this sequence of instructions
after the break:
- mtsp r21, sr0
- ble,n 0(sr0, r22)
-
+ mtsp r21, sr0
+ ble,n 0(sr0, r22)
+
So, load up the registers and single step until we are in the
right place. */
for (insn_count = 0; insn_count < 3; insn_count++)
{
/* FIXME: What if the inferior gets a signal right now? Want to
- merge this into wait_for_inferior (as a special kind of
- watchpoint? By setting a breakpoint at the end? Is there
- any other choice? Is there *any* way to do this stuff with
- ptrace() or some equivalent?). */
+ merge this into wait_for_inferior (as a special kind of
+ watchpoint? By setting a breakpoint at the end? Is there
+ any other choice? Is there *any* way to do this stuff with
+ ptrace() or some equivalent?). */
resume (1, 0);
target_wait (inferior_pid, &w);
if (w.kind == TARGET_WAITKIND_SIGNALLED)
- {
- stop_signal = w.value.sig;
- terminal_ours_for_output ();
- printf_unfiltered ("\nProgram terminated with signal %s, %s.\n",
+ {
+ stop_signal = w.value.sig;
+ terminal_ours_for_output ();
+ printf_unfiltered ("\nProgram terminated with signal %s, %s.\n",
target_signal_to_name (stop_signal),
target_signal_to_string (stop_signal));
- gdb_flush (gdb_stdout);
- return 0;
- }
+ gdb_flush (gdb_stdout);
+ return 0;
+ }
}
target_terminal_ours ();
target_fetch_registers (-1);
CORE_ADDR struct_addr;
{
/* array of arguments' offsets */
- int *offset = (int *)alloca(nargs * sizeof (int));
+ int *offset = (int *) alloca (nargs * sizeof (int));
int cum = 0;
int i, alignment;
-
+
for (i = 0; i < nargs; i++)
{
int x = 0;
/* cum is the sum of the lengths in bytes of
- the arguments seen so far */
+ the arguments seen so far */
cum += TYPE_LENGTH (VALUE_TYPE (args[i]));
- /* value must go at proper alignment. Assume alignment is a
- power of two. */
+ /* value must go at proper alignment. Assume alignment is a
+ power of two. */
alignment = hppa_alignof (VALUE_TYPE (args[i]));
if (cum % alignment)
CORE_ADDR struct_addr;
{
/* array of arguments' offsets */
- int *offset = (int *)alloca(nargs * sizeof (int));
+ int *offset = (int *) alloca (nargs * sizeof (int));
/* array of arguments' lengths: real lengths in bytes, not aligned to word size */
- int *lengths = (int *)alloca(nargs * sizeof (int));
+ int *lengths = (int *) alloca (nargs * sizeof (int));
- int bytes_reserved; /* this is the number of bytes on the stack occupied by an
- argument. This will be always a multiple of 4 */
+ int bytes_reserved; /* this is the number of bytes on the stack occupied by an
+ argument. This will be always a multiple of 4 */
- int cum_bytes_reserved = 0; /* this is the total number of bytes reserved by the args
- seen so far. It is a multiple of 4 always */
- int cum_bytes_aligned = 0; /* same as above, but aligned on 8 bytes */
- int i;
+ int cum_bytes_reserved = 0; /* this is the total number of bytes reserved by the args
+ seen so far. It is a multiple of 4 always */
+ int cum_bytes_aligned = 0; /* same as above, but aligned on 8 bytes */
+ int i;
/* When an arg does not occupy a whole word, for instance in bitfields:
if the arg is x bits (0<x<32), it must be written
starting from the (x-1)-th position down until the 0-th position.
- It is enough to align it to the word. */
+ It is enough to align it to the word. */
/* if an arg occupies 8 bytes, it must be aligned on the 64-bits
high order word in odd arg word. */
/* if an arg is larger than 64 bits, we need to pass a pointer to it, and
The argument that is received in this function here has already be converted
to a pointer to whatever is needed, so that it just can be pushed
as a word argument */
-
+
for (i = 0; i < nargs; i++)
{
lengths[i] = TYPE_LENGTH (VALUE_TYPE (args[i]));
if (lengths[i] % 4)
- bytes_reserved = (lengths[i] / 4) * 4 + 4;
- else
- bytes_reserved = lengths[i];
+ bytes_reserved = (lengths[i] / 4) * 4 + 4;
+ else
+ bytes_reserved = lengths[i];
offset[i] = cum_bytes_reserved + lengths[i];
- if ((bytes_reserved == 8) && (offset[i] % 8)) /* if 64-bit arg is not 64 bit aligned */
- {
- int new_offset=0;
- /* bytes_reserved is already aligned to the word, so we put it at one word
- more down the stack. This will leave one empty word on the
- stack, and one unused register. This is OK, see the calling
- convention doc */
- /* the offset may have to be moved to the corresponding position
- one word down the stack, to maintain
- alignment. */
- new_offset = (offset[i] / 8) * 8 + 8;
- if ((new_offset - offset[i]) >=4)
- {
- bytes_reserved += 4;
- offset[i] += 4;
- }
- }
+ if ((bytes_reserved == 8) && (offset[i] % 8)) /* if 64-bit arg is not 64 bit aligned */
+ {
+ int new_offset = 0;
+ /* bytes_reserved is already aligned to the word, so we put it at one word
+ more down the stack. This will leave one empty word on the
+ stack, and one unused register. This is OK, see the calling
+ convention doc */
+ /* the offset may have to be moved to the corresponding position
+ one word down the stack, to maintain
+ alignment. */
+ new_offset = (offset[i] / 8) * 8 + 8;
+ if ((new_offset - offset[i]) >= 4)
+ {
+ bytes_reserved += 4;
+ offset[i] += 4;
+ }
+ }
cum_bytes_reserved += bytes_reserved;
/* now write each of the args at the proper offset down the stack */
for (i = 0; i < nargs; i++)
write_memory (sp - offset[i], VALUE_CONTENTS (args[i]), lengths[i]);
-
- /* if a structure has to be returned, set up register 28 to hold its address */
+
+ /* if a structure has to be returned, set up register 28 to hold its address */
if (struct_return)
write_register (28, struct_addr);
- /* the stack will have other 8 words on top of the args */
+ /* the stack will have other 8 words on top of the args */
return sp + 32;
}
gets the value from the stack rather than from the buffer where all the
registers were saved when the function called completed. */
value_ptr
-hppa_value_returned_from_stack (valtype , addr)
+hppa_value_returned_from_stack (valtype, addr)
register struct type *valtype;
CORE_ADDR addr;
{
val = allocate_value (valtype);
CHECK_TYPEDEF (valtype);
- target_read_memory(addr, VALUE_CONTENTS_RAW (val), TYPE_LENGTH (valtype));
+ target_read_memory (addr, VALUE_CONTENTS_RAW (val), TYPE_LENGTH (valtype));
return val;
}
/* elz: Used to lookup a symbol in the shared libraries.
- This function calls shl_findsym, indirectly through a
- call to __d_shl_get. __d_shl_get is in end.c, which is always
- linked in by the hp compilers/linkers.
- The call to shl_findsym cannot be made directly because it needs
- to be active in target address space.
- inputs: - minimal symbol pointer for the function we want to look up
- - address in target space of the descriptor for the library
- where we want to look the symbol up.
- This address is retrieved using the
- som_solib_get_solib_by_pc function (somsolib.c).
- output: - real address in the library of the function.
- note: the handle can be null, in which case shl_findsym will look for
- the symbol in all the loaded shared libraries.
- files to look at if you need reference on this stuff:
- dld.c, dld_shl_findsym.c
- end.c
- man entry for shl_findsym */
+ This function calls shl_findsym, indirectly through a
+ call to __d_shl_get. __d_shl_get is in end.c, which is always
+ linked in by the hp compilers/linkers.
+ The call to shl_findsym cannot be made directly because it needs
+ to be active in target address space.
+ inputs: - minimal symbol pointer for the function we want to look up
+ - address in target space of the descriptor for the library
+ where we want to look the symbol up.
+ This address is retrieved using the
+ som_solib_get_solib_by_pc function (somsolib.c).
+ output: - real address in the library of the function.
+ note: the handle can be null, in which case shl_findsym will look for
+ the symbol in all the loaded shared libraries.
+ files to look at if you need reference on this stuff:
+ dld.c, dld_shl_findsym.c
+ end.c
+ man entry for shl_findsym */
CORE_ADDR
-find_stub_with_shl_get(function, handle)
- struct minimal_symbol *function;
- CORE_ADDR handle;
+find_stub_with_shl_get (function, handle)
+ struct minimal_symbol *function;
+ CORE_ADDR handle;
{
- struct symbol *get_sym, *symbol2;
- struct minimal_symbol *buff_minsym, *msymbol;
- struct type *ftype;
- value_ptr *args;
- value_ptr funcval, val;
-
- int x, namelen, err_value, tmp = -1;
- CORE_ADDR endo_buff_addr, value_return_addr, errno_return_addr;
- CORE_ADDR stub_addr;
-
-
- args = (value_ptr *) alloca (sizeof (value_ptr) * 8); /* 6 for the arguments and one null one??? */
- funcval = find_function_in_inferior("__d_shl_get");
- get_sym = lookup_symbol("__d_shl_get", NULL, VAR_NAMESPACE, NULL, NULL);
- buff_minsym = lookup_minimal_symbol("__buffer", NULL, NULL);
- 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));
- value_return_addr = endo_buff_addr + namelen;
- ftype = check_typedef(SYMBOL_TYPE(get_sym));
-
- /* do alignment */
- if ((x=value_return_addr % 64) !=0)
- value_return_addr = value_return_addr + 64 - x;
-
- errno_return_addr = value_return_addr + 64;
-
-
- /* 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(value_return_addr, (char *) &tmp, 4);
-
- target_write_memory(errno_return_addr, (char *) &tmp, 4);
-
- target_write_memory(SYMBOL_VALUE_ADDRESS(msymbol),
- (char *)&handle, 4);
-
- /* now prepare the arguments for the call */
-
- args[0] = value_from_longest (TYPE_FIELD_TYPE(ftype, 0), 12);
- args[1] = value_from_longest (TYPE_FIELD_TYPE(ftype, 1), SYMBOL_VALUE_ADDRESS(msymbol));
- args[2] = value_from_longest (TYPE_FIELD_TYPE(ftype, 2), endo_buff_addr);
- args[3] = value_from_longest (TYPE_FIELD_TYPE(ftype, 3), TYPE_PROCEDURE);
- args[4] = value_from_longest (TYPE_FIELD_TYPE(ftype, 4), value_return_addr);
- args[5] = value_from_longest (TYPE_FIELD_TYPE(ftype, 5), errno_return_addr);
-
- /* now call the function */
-
- val = call_function_by_hand(funcval, 6, args);
-
- /* now get the results */
-
- target_read_memory(errno_return_addr, (char *) &err_value, sizeof(err_value));
-
- target_read_memory(value_return_addr, (char *) &stub_addr, sizeof(stub_addr));
- if (stub_addr <= 0)
- error("call to __d_shl_get failed, error code is %d", err_value); /* purecov: deadcode */
-
- return(stub_addr);
+ struct symbol *get_sym, *symbol2;
+ struct minimal_symbol *buff_minsym, *msymbol;
+ struct type *ftype;
+ value_ptr *args;
+ value_ptr funcval, val;
+
+ int x, namelen, err_value, tmp = -1;
+ CORE_ADDR endo_buff_addr, value_return_addr, errno_return_addr;
+ CORE_ADDR stub_addr;
+
+
+ args = (value_ptr *) alloca (sizeof (value_ptr) * 8); /* 6 for the arguments and one null one??? */
+ funcval = find_function_in_inferior ("__d_shl_get");
+ get_sym = lookup_symbol ("__d_shl_get", NULL, VAR_NAMESPACE, NULL, NULL);
+ buff_minsym = lookup_minimal_symbol ("__buffer", NULL, NULL);
+ 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));
+ value_return_addr = endo_buff_addr + namelen;
+ ftype = check_typedef (SYMBOL_TYPE (get_sym));
+
+ /* do alignment */
+ if ((x = value_return_addr % 64) != 0)
+ value_return_addr = value_return_addr + 64 - x;
+
+ errno_return_addr = value_return_addr + 64;
+
+
+ /* 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 (value_return_addr, (char *) &tmp, 4);
+
+ target_write_memory (errno_return_addr, (char *) &tmp, 4);
+
+ target_write_memory (SYMBOL_VALUE_ADDRESS (msymbol),
+ (char *) &handle, 4);
+
+ /* now prepare the arguments for the call */
+
+ args[0] = value_from_longest (TYPE_FIELD_TYPE (ftype, 0), 12);
+ args[1] = value_from_longest (TYPE_FIELD_TYPE (ftype, 1), SYMBOL_VALUE_ADDRESS (msymbol));
+ args[2] = value_from_longest (TYPE_FIELD_TYPE (ftype, 2), endo_buff_addr);
+ args[3] = value_from_longest (TYPE_FIELD_TYPE (ftype, 3), TYPE_PROCEDURE);
+ args[4] = value_from_longest (TYPE_FIELD_TYPE (ftype, 4), value_return_addr);
+ args[5] = value_from_longest (TYPE_FIELD_TYPE (ftype, 5), errno_return_addr);
+
+ /* now call the function */
+
+ val = call_function_by_hand (funcval, 6, args);
+
+ /* now get the results */
+
+ target_read_memory (errno_return_addr, (char *) &err_value, sizeof (err_value));
+
+ target_read_memory (value_return_addr, (char *) &stub_addr, sizeof (stub_addr));
+ if (stub_addr <= 0)
+ error ("call to __d_shl_get failed, error code is %d", err_value); /* purecov: deadcode */
+
+ return (stub_addr);
}
-/* Cover routine for find_stub_with_shl_get to pass to catch_errors */
+/* Cover routine for find_stub_with_shl_get to pass to catch_errors */
static CORE_ADDR
cover_find_stub_with_shl_get (args)
- args_for_find_stub * args;
+ args_for_find_stub *args;
{
return find_stub_with_shl_get (args->msym, args->solib_handle);
}
CORE_ADDR solib_handle = 0;
/* Nonzero if we will use GCC's PLT call routine. This routine must be
- passed an import stub, not a PLABEL. It is also necessary to set %r19
+ passed an import stub, not a PLABEL. It is also necessary to set %r19
(the PIC register) before performing the call.
If zero, then we are using __d_plt_call (HP's PLT call routine) or we
int using_gcc_plt_call = 1;
/* Prefer __gcc_plt_call over the HP supplied routine because
- __gcc_plt_call works for any number of arguments. */
+ __gcc_plt_call works for any number of arguments. */
trampoline = NULL;
if (lookup_minimal_symbol ("__gcc_plt_call", NULL, NULL) == NULL)
using_gcc_plt_call = 0;
if ((fun & 0x2) && using_gcc_plt_call)
{
/* Get the GOT/DP value for the target function. It's
- at *(fun+4). Note the call dummy is *NOT* allowed to
- trash %r19 before calling the target function. */
+ at *(fun+4). Note the call dummy is *NOT* allowed to
+ trash %r19 before calling the target function. */
write_register (19, read_memory_integer ((fun & ~0x3) + 4, 4));
/* Now get the real address for the function we are calling, it's
- at *fun. */
+ at *fun. */
fun = (CORE_ADDR) read_memory_integer (fun & ~0x3, 4);
}
else
#ifndef GDB_TARGET_IS_PA_ELF
/* FUN could be an export stub, the real address of a function, or
- a PLABEL. When using gcc's PLT call routine we must call an import
- stub rather than the export stub or real function for lazy binding
- to work correctly
+ a PLABEL. When using gcc's PLT call routine we must call an import
+ stub rather than the export stub or real function for lazy binding
+ to work correctly
- /* If we are using the gcc PLT call routine, then we need to
- get the import stub for the target function. */
+ /* If we are using the gcc PLT call routine, then we need to
+ get the import stub for the target function. */
if (using_gcc_plt_call && som_solib_get_got_by_pc (fun))
{
struct objfile *objfile;
/* Search all the object files for an import symbol with the
right name. */
ALL_OBJFILES (objfile)
- {
- stub_symbol
- = lookup_minimal_symbol_solib_trampoline
- (SYMBOL_NAME (funsymbol), NULL, objfile);
-
- if (! stub_symbol)
- stub_symbol = lookup_minimal_symbol (SYMBOL_NAME (funsymbol),
- NULL, objfile);
-
- /* Found a symbol with the right name. */
- if (stub_symbol)
- {
- struct unwind_table_entry *u;
- /* It must be a shared library trampoline. */
- if (MSYMBOL_TYPE (stub_symbol) != mst_solib_trampoline)
- continue;
-
- /* It must also be an import stub. */
- u = find_unwind_entry (SYMBOL_VALUE (stub_symbol));
- if (!u
- || (u->stub_unwind.stub_type != IMPORT)
- && u->stub_unwind.stub_type != IMPORT_SHLIB)
- continue;
-
- /* OK. Looks like the correct import stub. */
- newfun = SYMBOL_VALUE (stub_symbol);
- fun = newfun;
- }
- }
+ {
+ stub_symbol
+ = lookup_minimal_symbol_solib_trampoline
+ (SYMBOL_NAME (funsymbol), NULL, objfile);
+
+ if (!stub_symbol)
+ stub_symbol = lookup_minimal_symbol (SYMBOL_NAME (funsymbol),
+ NULL, objfile);
+
+ /* Found a symbol with the right name. */
+ if (stub_symbol)
+ {
+ struct unwind_table_entry *u;
+ /* It must be a shared library trampoline. */
+ if (MSYMBOL_TYPE (stub_symbol) != mst_solib_trampoline)
+ continue;
+
+ /* It must also be an import stub. */
+ u = find_unwind_entry (SYMBOL_VALUE (stub_symbol));
+ if (!u
+ || (u->stub_unwind.stub_type != IMPORT)
+ && u->stub_unwind.stub_type != IMPORT_SHLIB)
+ continue;
+
+ /* OK. Looks like the correct import stub. */
+ newfun = SYMBOL_VALUE (stub_symbol);
+ fun = newfun;
+ }
+ }
/* Ouch. We did not find an import stub. Make an attempt to
do the right thing instead of just croaking. Most of the
write_register (19, som_solib_get_got_by_pc (fun));
u = find_unwind_entry (fun);
- if (u
+ if (u
&& (u->stub_unwind.stub_type == IMPORT
|| u->stub_unwind.stub_type == IMPORT_SHLIB))
trampoline = lookup_minimal_symbol ("__gcc_plt_call", NULL, NULL);
Also, query the dynamic linker in the inferior to provide a suitable
PLABEL for the target function. */
- if (! using_gcc_plt_call)
+ if (!using_gcc_plt_call)
{
CORE_ADDR new_fun;
/* Get a handle for the shared library containing FUN. Given the
- handle we can query the shared library for a PLABEL. */
+ handle we can query the shared library for a PLABEL. */
solib_handle = som_solib_get_solib_by_pc (fun);
if (solib_handle)
get a PLABEL for the target function. */
new_stub = find_stub_with_shl_get (fmsymbol, solib_handle);
- if (new_stub == 0)
+ if (new_stub == 0)
error ("Can't find an import stub for %s", SYMBOL_NAME (fmsymbol));
/* We have to store the address of the stub in __shlib_funcptr. */
msymbol = lookup_minimal_symbol ("__shlib_funcptr", NULL,
- (struct objfile *)NULL);
+ (struct objfile *) NULL);
if (msymbol == NULL)
error ("Can't find an address for __shlib_funcptr");
target_write_memory (SYMBOL_VALUE_ADDRESS (msymbol),
- (char *)&new_stub, 4);
+ (char *) &new_stub, 4);
/* We want sr4export to call __d_plt_call, so we claim it is
the final target. Clear trampoline. */
and cause a warning. */
CORE_ADDR
target_read_fp (pid)
- int pid;
+ int pid;
{
int flags = read_register (FLAGS_REGNUM);
- if (flags & 2) {
- return (CORE_ADDR) 0;
- }
+ if (flags & 2)
+ {
+ return (CORE_ADDR) 0;
+ }
/* This is the only site that may directly read_register () the FP
register. All others must use TARGET_READ_FP (). */
{
/* Bit fields have no real alignment. */
/* if (!TYPE_FIELD_BITPOS (type, i)) */
- if (!TYPE_FIELD_BITSIZE (type, i)) /* elz: this should be bitsize */
+ if (!TYPE_FIELD_BITSIZE (type, i)) /* elz: this should be bitsize */
{
align = hppa_alignof (TYPE_FIELD_TYPE (type, i));
max_align = max (max_align, align);
int regnum;
int fpregs;
{
- char raw_regs [REGISTER_BYTES];
+ char raw_regs[REGISTER_BYTES];
int i;
/* Make a copy of gdb's save area (may cause actual
if (regnum == -1)
pa_print_registers (raw_regs, regnum, fpregs);
- else if (regnum < FP4_REGNUM) {
- long reg_val[2];
-
- /* Why is the value not passed through "extract_signed_integer"
- as in "pa_print_registers" below? */
- pa_register_look_aside(raw_regs, regnum, ®_val[0]);
-
- if(!is_pa_2) {
- printf_unfiltered ("%s %x\n", REGISTER_NAME (regnum), reg_val[1]);
- }
- else {
- /* Fancy % formats to prevent leading zeros. */
- if(reg_val[0] == 0)
- printf_unfiltered("%s %x\n", REGISTER_NAME (regnum), reg_val[1]);
+ else if (regnum < FP4_REGNUM)
+ {
+ long reg_val[2];
+
+ /* Why is the value not passed through "extract_signed_integer"
+ as in "pa_print_registers" below? */
+ pa_register_look_aside (raw_regs, regnum, ®_val[0]);
+
+ if (!is_pa_2)
+ {
+ printf_unfiltered ("%s %x\n", REGISTER_NAME (regnum), reg_val[1]);
+ }
else
- printf_unfiltered("%s %x%8.8x\n", REGISTER_NAME (regnum),
- reg_val[0], reg_val[1]);
+ {
+ /* Fancy % formats to prevent leading zeros. */
+ if (reg_val[0] == 0)
+ printf_unfiltered ("%s %x\n", REGISTER_NAME (regnum), reg_val[1]);
+ else
+ printf_unfiltered ("%s %x%8.8x\n", REGISTER_NAME (regnum),
+ reg_val[0], reg_val[1]);
+ }
}
- }
else
- /* Note that real floating point values only start at
- FP4_REGNUM. FP0 and up are just status and error
- registers, which have integral (bit) values. */
+ /* Note that real floating point values only start at
+ FP4_REGNUM. FP0 and up are just status and error
+ registers, which have integral (bit) values. */
pa_print_fp_reg (regnum);
}
GDB_FILE *stream;
enum precision_type precision;
{
- char raw_regs [REGISTER_BYTES];
+ char raw_regs[REGISTER_BYTES];
int i;
/* Make a copy of gdb's save area (may cause actual
- reads from the target). */
+ reads from the target). */
for (i = 0; i < NUM_REGS; i++)
read_relative_register_raw_bytes (i, raw_regs + REGISTER_BYTE (i));
if (regnum == -1)
pa_strcat_registers (raw_regs, regnum, fpregs, stream);
- else if (regnum < FP4_REGNUM) {
- long reg_val[2];
-
- /* Why is the value not passed through "extract_signed_integer"
- as in "pa_print_registers" below? */
- pa_register_look_aside(raw_regs, regnum, ®_val[0]);
+ else if (regnum < FP4_REGNUM)
+ {
+ long reg_val[2];
+
+ /* Why is the value not passed through "extract_signed_integer"
+ as in "pa_print_registers" below? */
+ pa_register_look_aside (raw_regs, regnum, ®_val[0]);
- if(!is_pa_2) {
- fprintf_unfiltered (stream, "%s %x", REGISTER_NAME (regnum), reg_val[1]);
- }
- else {
- /* Fancy % formats to prevent leading zeros. */
- if(reg_val[0] == 0)
- fprintf_unfiltered(stream, "%s %x", REGISTER_NAME (regnum),
- reg_val[1]);
+ if (!is_pa_2)
+ {
+ fprintf_unfiltered (stream, "%s %x", REGISTER_NAME (regnum), reg_val[1]);
+ }
else
- fprintf_unfiltered(stream, "%s %x%8.8x", REGISTER_NAME (regnum),
- reg_val[0], reg_val[1]);
+ {
+ /* Fancy % formats to prevent leading zeros. */
+ if (reg_val[0] == 0)
+ fprintf_unfiltered (stream, "%s %x", REGISTER_NAME (regnum),
+ reg_val[1]);
+ else
+ fprintf_unfiltered (stream, "%s %x%8.8x", REGISTER_NAME (regnum),
+ reg_val[0], reg_val[1]);
+ }
}
- }
else
- /* Note that real floating point values only start at
- FP4_REGNUM. FP0 and up are just status and error
- registers, which have integral (bit) values. */
+ /* Note that real floating point values only start at
+ FP4_REGNUM. FP0 and up are just status and error
+ registers, which have integral (bit) values. */
pa_strcat_fp_reg (regnum, stream, precision);
}
Note that reg_val is really expected to be an array of longs,
with two elements. */
static void
-pa_register_look_aside(raw_regs, regnum, raw_val)
+pa_register_look_aside (raw_regs, regnum, raw_val)
char *raw_regs;
- int regnum;
+ int regnum;
long *raw_val;
{
- static int know_which = 0; /* False */
+ static int know_which = 0; /* False */
- int regaddr;
+ int regaddr;
unsigned int offset;
register int i;
- int start;
-
-
+ int start;
+
+
char buf[MAX_REGISTER_RAW_SIZE];
long long reg_val;
- if(!know_which) {
- if(CPU_PA_RISC2_0 == sysconf(_SC_CPU_VERSION)) {
- is_pa_2 = (1==1);
- }
-
- know_which = 1; /* True */
- }
+ if (!know_which)
+ {
+ if (CPU_PA_RISC2_0 == sysconf (_SC_CPU_VERSION))
+ {
+ is_pa_2 = (1 == 1);
+ }
+
+ know_which = 1; /* True */
+ }
raw_val[0] = 0;
raw_val[1] = 0;
- if(!is_pa_2) {
- raw_val[1] = *(long *)(raw_regs + REGISTER_BYTE(regnum));
+ if (!is_pa_2)
+ {
+ raw_val[1] = *(long *) (raw_regs + REGISTER_BYTE (regnum));
return;
- }
+ }
/* Code below copied from hppah-nat.c, with fixes for wide
registers, using different area of save_state, etc. */
if (regnum == FLAGS_REGNUM || regnum >= FP0_REGNUM ||
- !HAVE_STRUCT_SAVE_STATE_T || !HAVE_STRUCT_MEMBER_SS_WIDE) {
+ !HAVE_STRUCT_SAVE_STATE_T || !HAVE_STRUCT_MEMBER_SS_WIDE)
+ {
/* Use narrow regs area of save_state and default macro. */
- offset = U_REGS_OFFSET;
- regaddr = register_addr(regnum, offset);
- start = 1;
- }
- else {
+ offset = U_REGS_OFFSET;
+ regaddr = register_addr (regnum, offset);
+ start = 1;
+ }
+ else
+ {
/* Use wide regs area, and calculate registers as 8 bytes wide.
We'd like to do this, but current version of "C" doesn't
permit "offsetof":
- offset = offsetof(save_state_t, ss_wide);
+ offset = offsetof(save_state_t, ss_wide);
Note that to avoid "C" doing typed pointer arithmetic, we
have to cast away the type in our offset calculation:
otherwise we get an offset of 1! */
/* NB: save_state_t is not available before HPUX 9.
- The ss_wide field is not available previous to HPUX 10.20,
+ The ss_wide field is not available previous to HPUX 10.20,
so to avoid compile-time warnings, we only compile this for
PA 2.0 processors. This control path should only be followed
if we're debugging a PA 2.0 processor, so this should not cause
offset = ((int) &temp.ss_wide) - ((int) &temp);
regaddr = offset + regnum * 8;
- start = 0;
+ start = 0;
#endif
- }
-
- for(i = start; i < 2; i++)
+ }
+
+ for (i = start; i < 2; i++)
{
errno = 0;
raw_val[i] = call_ptrace (PT_RUREGS, inferior_pid,
- (PTRACE_ARG3_TYPE) regaddr, 0);
+ (PTRACE_ARG3_TYPE) regaddr, 0);
if (errno != 0)
{
/* Warning, not error, in case we are attached; sometimes the
regaddr += sizeof (long);
}
-
+
if (regnum == PCOQ_HEAD_REGNUM || regnum == PCOQ_TAIL_REGNUM)
- raw_val[1] &= ~0x3; /* I think we're masking out space bits */
+ raw_val[1] &= ~0x3; /* I think we're masking out space bits */
error_exit:
;
}
/* "Info all-reg" command */
-
+
static void
pa_print_registers (raw_regs, regnum, fpregs)
char *raw_regs;
int regnum;
int fpregs;
{
- int i,j;
- long raw_val[2]; /* Alas, we are compiled so that "long long" is 32 bits */
+ int i, j;
+ long raw_val[2]; /* Alas, we are compiled so that "long long" is 32 bits */
long long_val;
for (i = 0; i < 18; i++)
{
for (j = 0; j < 4; j++)
{
- /* Q: Why is the value passed through "extract_signed_integer",
- while above, in "pa_do_registers_info" it isn't?
- A: ? */
- pa_register_look_aside(raw_regs, i+(j*18), &raw_val[0]);
-
- /* Even fancier % formats to prevent leading zeros
- and still maintain the output in columns. */
- if(!is_pa_2) {
- /* Being big-endian, on this machine the low bits
- (the ones we want to look at) are in the second longword. */
- long_val = extract_signed_integer (&raw_val[1], 4);
- printf_filtered ("%8.8s: %8x ",
- REGISTER_NAME (i+(j*18)), long_val);
- }
- else {
- /* raw_val = extract_signed_integer(&raw_val, 8); */
- if(raw_val[0] == 0)
- printf_filtered("%8.8s: %8x ",
- REGISTER_NAME (i+(j*18)), raw_val[1]);
- else
- printf_filtered("%8.8s: %8x%8.8x ", REGISTER_NAME (i+(j*18)),
- raw_val[0], raw_val[1]);
- }
+ /* Q: Why is the value passed through "extract_signed_integer",
+ while above, in "pa_do_registers_info" it isn't?
+ A: ? */
+ pa_register_look_aside (raw_regs, i + (j * 18), &raw_val[0]);
+
+ /* Even fancier % formats to prevent leading zeros
+ and still maintain the output in columns. */
+ if (!is_pa_2)
+ {
+ /* Being big-endian, on this machine the low bits
+ (the ones we want to look at) are in the second longword. */
+ long_val = extract_signed_integer (&raw_val[1], 4);
+ printf_filtered ("%8.8s: %8x ",
+ REGISTER_NAME (i + (j * 18)), long_val);
+ }
+ else
+ {
+ /* raw_val = extract_signed_integer(&raw_val, 8); */
+ if (raw_val[0] == 0)
+ printf_filtered ("%8.8s: %8x ",
+ REGISTER_NAME (i + (j * 18)), raw_val[1]);
+ else
+ printf_filtered ("%8.8s: %8x%8.8x ", REGISTER_NAME (i + (j * 18)),
+ raw_val[0], raw_val[1]);
+ }
}
printf_unfiltered ("\n");
}
-
+
if (fpregs)
- for (i = FP4_REGNUM; i < NUM_REGS; i++) /* FP4_REGNUM == 72 */
+ for (i = FP4_REGNUM; i < NUM_REGS; i++) /* FP4_REGNUM == 72 */
pa_print_fp_reg (i);
}
-/************* new function ******************/
+/************* new function ******************/
static void
pa_strcat_registers (raw_regs, regnum, fpregs, stream)
char *raw_regs;
int fpregs;
GDB_FILE *stream;
{
- int i,j;
- long raw_val[2]; /* Alas, we are compiled so that "long long" is 32 bits */
+ int i, j;
+ long raw_val[2]; /* Alas, we are compiled so that "long long" is 32 bits */
long long_val;
enum precision_type precision;
{
for (j = 0; j < 4; j++)
{
- /* Q: Why is the value passed through "extract_signed_integer",
- while above, in "pa_do_registers_info" it isn't?
- A: ? */
- pa_register_look_aside(raw_regs, i+(j*18), &raw_val[0]);
-
- /* Even fancier % formats to prevent leading zeros
- and still maintain the output in columns. */
- if(!is_pa_2) {
- /* Being big-endian, on this machine the low bits
- (the ones we want to look at) are in the second longword. */
- long_val = extract_signed_integer(&raw_val[1], 4);
- fprintf_filtered (stream, "%8.8s: %8x ", REGISTER_NAME (i+(j*18)), long_val);
- }
- else {
- /* raw_val = extract_signed_integer(&raw_val, 8); */
- if(raw_val[0] == 0)
- fprintf_filtered(stream, "%8.8s: %8x ", REGISTER_NAME (i+(j*18)),
- raw_val[1]);
- else
- fprintf_filtered(stream, "%8.8s: %8x%8.8x ", REGISTER_NAME (i+(j*18)),
- raw_val[0], raw_val[1]);
- }
+ /* Q: Why is the value passed through "extract_signed_integer",
+ while above, in "pa_do_registers_info" it isn't?
+ A: ? */
+ pa_register_look_aside (raw_regs, i + (j * 18), &raw_val[0]);
+
+ /* Even fancier % formats to prevent leading zeros
+ and still maintain the output in columns. */
+ if (!is_pa_2)
+ {
+ /* Being big-endian, on this machine the low bits
+ (the ones we want to look at) are in the second longword. */
+ long_val = extract_signed_integer (&raw_val[1], 4);
+ fprintf_filtered (stream, "%8.8s: %8x ", REGISTER_NAME (i + (j * 18)), long_val);
+ }
+ else
+ {
+ /* raw_val = extract_signed_integer(&raw_val, 8); */
+ if (raw_val[0] == 0)
+ fprintf_filtered (stream, "%8.8s: %8x ", REGISTER_NAME (i + (j * 18)),
+ raw_val[1]);
+ else
+ fprintf_filtered (stream, "%8.8s: %8x%8.8x ", REGISTER_NAME (i + (j * 18)),
+ raw_val[0], raw_val[1]);
+ }
}
fprintf_unfiltered (stream, "\n");
}
-
+
if (fpregs)
- for (i = FP4_REGNUM; i < NUM_REGS; i++) /* FP4_REGNUM == 72 */
+ for (i = FP4_REGNUM; i < NUM_REGS; i++) /* FP4_REGNUM == 72 */
pa_strcat_fp_reg (i, stream, precision);
}
if (precision == double_precision && (i % 2) == 0)
{
- char raw_buf[MAX_REGISTER_RAW_SIZE];
-
- /* Get the data in raw format for the 2nd half. */
- read_relative_register_raw_bytes (i + 1, raw_buf);
-
- /* Copy it into the appropriate part of the virtual buffer. */
- memcpy (virtual_buffer + REGISTER_RAW_SIZE(i), raw_buf, REGISTER_RAW_SIZE (i));
+ char raw_buf[MAX_REGISTER_RAW_SIZE];
+
+ /* Get the data in raw format for the 2nd half. */
+ read_relative_register_raw_bytes (i + 1, raw_buf);
+
+ /* Copy it into the appropriate part of the virtual buffer. */
+ memcpy (virtual_buffer + REGISTER_RAW_SIZE (i), raw_buf, REGISTER_RAW_SIZE (i));
- val_print (builtin_type_double, virtual_buffer, 0, 0 , stream, 0,
- 1, 0, Val_pretty_default);
+ val_print (builtin_type_double, virtual_buffer, 0, 0, stream, 0,
+ 1, 0, Val_pretty_default);
}
- else {
- val_print (REGISTER_VIRTUAL_TYPE (i), virtual_buffer, 0, 0, stream, 0,
- 1, 0, Val_pretty_default);
- }
+ else
+ {
+ val_print (REGISTER_VIRTUAL_TYPE (i), virtual_buffer, 0, 0, stream, 0,
+ 1, 0, Val_pretty_default);
+ }
}
CORE_ADDR addr;
/* Search forward from the current PC until we hit a branch
- or the end of the stub. */
+ or the end of the stub. */
for (addr = pc; addr <= u->region_end; addr += 4)
{
unsigned long insn;
}
/* Should never happen. */
- warning ("Unable to find branch in parameter relocation stub.\n"); /* purecov: deadcode */
- return 0; /* purecov: deadcode */
+ warning ("Unable to find branch in parameter relocation stub.\n"); /* purecov: deadcode */
+ return 0; /* purecov: deadcode */
}
/* Unknown stub type. For now, just return zero. */
- return 0; /* purecov: deadcode */
+ return 0; /* purecov: deadcode */
}
/* Return one if PC is in the return path of a trampoline, else return zero.
CORE_ADDR addr;
/* Search forward from the current PC until we hit a branch
- or the end of the stub. */
+ or the end of the stub. */
for (addr = pc; addr <= u->region_end; addr += 4)
{
unsigned long insn;
}
/* Should never happen. */
- warning ("Unable to find branch in parameter relocation stub.\n"); /* purecov: deadcode */
- return 0; /* purecov: deadcode */
+ warning ("Unable to find branch in parameter relocation stub.\n"); /* purecov: deadcode */
+ return 0; /* purecov: deadcode */
}
/* Unknown stub type. For now, just return zero. */
- return 0; /* purecov: deadcode */
+ return 0; /* purecov: deadcode */
}
calling an argument relocation stub. It even handles some stubs
used in dynamic executables. */
-# if 0
+#if 0
CORE_ADDR
skip_trampoline_code (pc, name)
CORE_ADDR pc;
char *name;
{
- return find_solib_trampoline_target(pc);
+ return find_solib_trampoline_target (pc);
}
#endif
pc = (CORE_ADDR) read_register (22);
/* If bit 30 (counting from the left) is on, then pc is the address of
- the PLT entry for this function, not the address of the function
- itself. Bit 31 has meaning too, but only for MPE. */
+ the PLT entry for this function, not the address of the function
+ itself. Bit 31 has meaning too, but only for MPE. */
if (pc & 0x2)
pc = (CORE_ADDR) read_memory_integer (pc & ~0x3, 4);
}
its minimal symbol can be assigned type mst_solib_trampoline.
Also, if we find that the symbol is a real stub, then we fix the unwind
descriptor, and define the stub type to be EXPORT.
- Hopefully this is correct most of the times. */
+ Hopefully this is correct most of the times. */
if (u->stub_unwind.stub_type == 0)
- {
+ {
/* elz: NOTE (FIXME!) once the problem with the unwind information is fixed
we can delete all the code which appears between the lines */
/*--------------------------------------------------------------------------*/
- msym = lookup_minimal_symbol_by_pc (pc);
+ msym = lookup_minimal_symbol_by_pc (pc);
- if (msym == NULL || MSYMBOL_TYPE (msym) != mst_solib_trampoline)
- return orig_pc == pc ? 0 : pc & ~0x3;
+ if (msym == NULL || MSYMBOL_TYPE (msym) != mst_solib_trampoline)
+ return orig_pc == pc ? 0 : pc & ~0x3;
+
+ else if (msym != NULL && MSYMBOL_TYPE (msym) == mst_solib_trampoline)
+ {
+ struct objfile *objfile;
+ struct minimal_symbol *msymbol;
+ int function_found = 0;
+
+ /* go look if there is another minimal symbol with the same name as
+ this one, but with type mst_text. This would happen if the msym
+ is an actual trampoline, in which case there would be another
+ symbol with the same name corresponding to the real function */
+
+ ALL_MSYMBOLS (objfile, msymbol)
+ {
+ if (MSYMBOL_TYPE (msymbol) == mst_text
+ && STREQ (SYMBOL_NAME (msymbol), SYMBOL_NAME (msym)))
+ {
+ function_found = 1;
+ break;
+ }
+ }
+
+ if (function_found)
+ /* the type of msym is correct (mst_solib_trampoline), but
+ the unwind info is wrong, so set it to the correct value */
+ u->stub_unwind.stub_type = EXPORT;
+ else
+ /* the stub type info in the unwind is correct (this is not a
+ trampoline), but the msym type information is wrong, it
+ should be mst_text. So we need to fix the msym, and also
+ get out of this function */
+ {
+ MSYMBOL_TYPE (msym) = mst_text;
+ return orig_pc == pc ? 0 : pc & ~0x3;
+ }
+ }
- else if (msym != NULL && MSYMBOL_TYPE (msym) == mst_solib_trampoline)
- {
- struct objfile *objfile;
- struct minimal_symbol *msymbol;
- int function_found = 0;
-
- /* go look if there is another minimal symbol with the same name as
- this one, but with type mst_text. This would happen if the msym
- is an actual trampoline, in which case there would be another
- symbol with the same name corresponding to the real function */
-
- ALL_MSYMBOLS (objfile, msymbol)
- {
- if (MSYMBOL_TYPE (msymbol) == mst_text
- && STREQ (SYMBOL_NAME (msymbol) , SYMBOL_NAME (msym)))
- {
- function_found = 1;
- break;
- }
- }
-
- if (function_found)
- /* the type of msym is correct (mst_solib_trampoline), but
- the unwind info is wrong, so set it to the correct value */
- u->stub_unwind.stub_type = EXPORT;
- else
- /* the stub type info in the unwind is correct (this is not a
- trampoline), but the msym type information is wrong, it
- should be mst_text. So we need to fix the msym, and also
- get out of this function */
- {
- MSYMBOL_TYPE (msym) = mst_text;
- return orig_pc == pc ? 0 : pc & ~0x3;
- }
- }
-
/*--------------------------------------------------------------------------*/
- }
+ }
/* It's a stub. Search for a branch and figure out where it goes.
Note we have to handle multi insn branch sequences like ldil;ble.
curr_inst = read_memory_integer (loc, 4);
/* Does it look like a branch external using %r1? Then it's the
- branch from the stub to the actual function. */
+ branch from the stub to the actual function. */
if ((curr_inst & 0xffe0e000) == 0xe0202000)
{
/* Yup. See if the previous instruction loaded
Does it look like a bve (r21)? (this is on PA2.0)
Does it look like a bve, n(r21)? (this is also on PA2.0)
That's the branch from an
- import stub to an export stub.
+ import stub to an export stub.
- It is impossible to determine the target of the branch via
- simple examination of instructions and/or data (consider
- that the address in the plabel may be the address of the
- bind-on-reference routine in the dynamic loader).
+ It is impossible to determine the target of the branch via
+ simple examination of instructions and/or data (consider
+ that the address in the plabel may be the address of the
+ bind-on-reference routine in the dynamic loader).
- So we have try an alternative approach.
+ So we have try an alternative approach.
- Get the name of the symbol at our current location; it should
- be a stub symbol with the same name as the symbol in the
- shared library.
+ Get the name of the symbol at our current location; it should
+ be a stub symbol with the same name as the symbol in the
+ shared library.
- Then lookup a minimal symbol with the same name; we should
- get the minimal symbol for the target routine in the shared
- library as those take precedence of import/export stubs. */
+ Then lookup a minimal symbol with the same name; we should
+ get the minimal symbol for the target routine in the shared
+ library as those take precedence of import/export stubs. */
if ((curr_inst == 0xe2a00000) ||
- (curr_inst == 0xe2a00002) ||
- (curr_inst == 0xeaa0d000) ||
- (curr_inst == 0xeaa0d002))
+ (curr_inst == 0xe2a00002) ||
+ (curr_inst == 0xeaa0d000) ||
+ (curr_inst == 0xeaa0d002))
{
struct minimal_symbol *stubsym, *libsym;
}
/* Does it look like bl X,%rp or bl X,%r0? Another way to do a
- branch from the stub to the actual function. */
- /*elz*/
+ branch from the stub to the actual function. */
+ /*elz */
else if ((curr_inst & 0xffe0e000) == 0xe8400000
|| (curr_inst & 0xffe0e000) == 0xe8000000
- || (curr_inst & 0xffe0e000) == 0xe800A000)
+ || (curr_inst & 0xffe0e000) == 0xe800A000)
return (loc + extract_17 (curr_inst) + 8) & ~0x3;
/* Does it look like bv (rp)? Note this depends on the
- current stack pointer being the same as the stack
- pointer in the stub itself! This is a branch on from the
- stub back to the original caller. */
- /*else if ((curr_inst & 0xffe0e000) == 0xe840c000)*/
+ current stack pointer being the same as the stack
+ pointer in the stub itself! This is a branch on from the
+ stub back to the original caller. */
+ /*else if ((curr_inst & 0xffe0e000) == 0xe840c000) */
else if ((curr_inst & 0xffe0f000) == 0xe840c000)
{
/* Yup. See if the previous instruction loaded
the PA2.0: BVE, n (rp) */
else if ((curr_inst & 0xffe0f000) == 0xe840d000)
{
- return (read_memory_integer
+ return (read_memory_integer
(read_register (SP_REGNUM) - 24, 4)) & ~0x3;
}
/* What about be,n 0(sr0,%rp)? It's just another way we return to
- the original caller from the stub. Used in dynamic executables. */
+ the original caller from the stub. Used in dynamic executables. */
else if (curr_inst == 0xe0400002)
{
/* The value we jump to is sitting in sp - 24. But that's
loaded several instructions before the be instruction.
I guess we could check for the previous instruction being
mtsp %r1,%sr0 if we want to do sanity checking. */
- return (read_memory_integer
+ return (read_memory_integer
(read_register (SP_REGNUM) - 24, 4)) & ~0x3;
}
/* Haven't found the branch yet, but we're still in the stub.
- Keep looking. */
+ Keep looking. */
loc += 4;
}
}
too. */
if ((inst >> 26) == 0x19 || (inst >> 26) == 0x18)
return extract_5R_store (inst);
-
+
return 0;
}
inst_saves_fr (inst)
unsigned long inst;
{
- /* is this an FSTDS ?*/
+ /* is this an FSTDS ? */
if ((inst & 0xfc00dfc0) == 0x2c001200)
return extract_5r_store (inst);
- /* is this an FSTWS ?*/
+ /* is this an FSTWS ? */
if ((inst & 0xfc00df80) == 0x24001200)
return extract_5r_store (inst);
return 0;
if (!u)
return pc;
- /* If we are not at the beginning of a function, then return now. */
+ /* If we are not at the beginning of a function, then return now. */
if ((pc & ~0x3) != u->region_start)
return pc;
unsigned long old_save_rp, old_save_sp, next_inst;
/* Save copies of all the triggers so we can compare them later
- (only for HPC). */
+ (only for HPC). */
old_save_gr = save_gr;
old_save_fr = save_fr;
old_save_rp = save_rp;
status = target_read_memory (pc, buf, 4);
inst = extract_unsigned_integer (buf, 4);
-
+
/* Yow! */
if (status != 0)
return pc;
save_rp = 0;
/* This is the only way we save SP into the stack. At this time
- the HP compilers never bother to save SP into the stack. */
+ the HP compilers never bother to save SP into the stack. */
if ((inst & 0xffffc000) == 0x6fc10000)
save_sp = 0;
save_gr &= ~(1 << reg_num);
/* Ugh. Also account for argument stores into the stack.
- Unfortunately args_stored only tells us that some arguments
- where stored into the stack. Not how many or what kind!
+ Unfortunately args_stored only tells us that some arguments
+ where stored into the stack. Not how many or what kind!
- This is a kludge as on the HP compiler sets this bit and it
- never does prologue scheduling. So once we see one, skip past
- all of them. We have similar code for the fp arg stores below.
+ This is a kludge as on the HP compiler sets this bit and it
+ never does prologue scheduling. So once we see one, skip past
+ all of them. We have similar code for the fp arg stores below.
- FIXME. Can still die if we have a mix of GR and FR argument
- stores! */
+ FIXME. Can still die if we have a mix of GR and FR argument
+ stores! */
if (reg_num >= 23 && reg_num <= 26)
{
while (reg_num >= 23 && reg_num <= 26)
status = target_read_memory (pc + 4, buf, 4);
next_inst = extract_unsigned_integer (buf, 4);
-
+
/* Yow! */
if (status != 0)
return pc;
/* We've got to be read to handle the ldo before the fp register
- save. */
+ save. */
if ((inst & 0xfc000000) == 0x34000000
&& inst_saves_fr (next_inst) >= 4
&& inst_saves_fr (next_inst) <= 7)
}
/* Ugh. Also account for argument stores into the stack.
- This is a kludge as on the HP compiler sets this bit and it
- never does prologue scheduling. So once we see one, skip past
- all of them. */
+ This is a kludge as on the HP compiler sets this bit and it
+ never does prologue scheduling. So once we see one, skip past
+ all of them. */
if (reg_num >= 4 && reg_num <= 7)
{
while (reg_num >= 4 && reg_num <= 7)
}
/* Quit if we hit any kind of branch. This can happen if a prologue
- instruction is in the delay slot of the first call/branch. */
+ instruction is in the delay slot of the first call/branch. */
if (is_branch (inst))
break;
/* What a crock. The HP compilers set args_stored even if no
- arguments were stored into the stack (boo hiss). This could
- cause this code to then skip a bunch of user insns (up to the
- first branch).
-
- To combat this we try to identify when args_stored was bogusly
- set and clear it. We only do this when args_stored is nonzero,
- all other resources are accounted for, and nothing changed on
- this pass. */
+ arguments were stored into the stack (boo hiss). This could
+ cause this code to then skip a bunch of user insns (up to the
+ first branch).
+
+ To combat this we try to identify when args_stored was bogusly
+ set and clear it. We only do this when args_stored is nonzero,
+ all other resources are accounted for, and nothing changed on
+ this pass. */
if (args_stored
- && ! (save_gr || save_fr || save_rp || save_sp || stack_remaining > 0)
+ && !(save_gr || save_fr || save_rp || save_sp || stack_remaining > 0)
&& old_save_gr == save_gr && old_save_fr == save_fr
&& old_save_rp == save_rp && old_save_sp == save_sp
&& old_stack_remaining == stack_remaining)
break;
-
+
/* Bump the PC. */
pc += 4;
}
but never were, mask them out and restart.
This should only happen in optimized code, and should be very rare. */
- if (save_gr || (save_fr && ! (restart_fr || restart_gr)))
+ if (save_gr || (save_fr && !(restart_fr || restart_gr)))
{
pc = orig_pc;
restart_gr = save_gr;
struct symbol *f;
if (!find_pc_partial_function (pc, NULL, &func_addr, &func_end))
- return 0; /* Unknown */
+ return 0; /* Unknown */
f = find_pc_function (pc);
if (!f)
sal = find_pc_line (func_addr, 0);
if (sal.end < func_end)
- {
- /* this happens when the function has no prologue, because the way
- find_pc_line works: elz. Note: this may not be a very good
- way to decide whether a function has a prologue or not, but
- it is the best I can do with the info available
- Also, this will work for functions like: int f()
- {
- return 2;
- }
- I.e. the bp will be inserted at the first open brace.
- For functions where the body is only one line written like this:
- int f()
- { return 2; }
- this will make the breakpoint to be at the last brace, after the body
- has been executed already. What's the point of stepping through a function
- without any variables anyway?? */
-
- if ((SYMBOL_LINE(f) > 0) && (SYMBOL_LINE(f) < sal.line))
- return pc; /*no adjusment will be made*/
- else
- return sal.end; /* this is the end of the prologue */
- }
+ {
+ /* this happens when the function has no prologue, because the way
+ find_pc_line works: elz. Note: this may not be a very good
+ way to decide whether a function has a prologue or not, but
+ it is the best I can do with the info available
+ Also, this will work for functions like: int f()
+ {
+ return 2;
+ }
+ I.e. the bp will be inserted at the first open brace.
+ For functions where the body is only one line written like this:
+ int f()
+ { return 2; }
+ this will make the breakpoint to be at the last brace, after the body
+ has been executed already. What's the point of stepping through a function
+ without any variables anyway?? */
+
+ if ((SYMBOL_LINE (f) > 0) && (SYMBOL_LINE (f) < sal.line))
+ return pc; /*no adjusment will be made */
+ else
+ return sal.end; /* this is the end of the prologue */
+ }
/* The line after the prologue is after the end of the function. In this
case, put the end of the prologue is the beginning of the function. */
/* This should happen only when the function is prologueless and has no
code in it. For instance void dumb(){} Note: this kind of function
is used quite a lot in the test system */
- else return pc; /* no adjustment will be made */
+ else
+ return pc; /* no adjustment will be made */
}
/* To skip prologues, I use this predicate. Returns either PC itself
hppa_skip_prologue (pc)
CORE_ADDR pc;
{
- unsigned long inst;
- int offset;
- CORE_ADDR post_prologue_pc;
- char buf[4];
+ unsigned long inst;
+ int offset;
+ CORE_ADDR post_prologue_pc;
+ char buf[4];
#ifdef GDB_TARGET_HAS_SHARED_LIBS
- /* Silently return the unaltered pc upon memory errors.
- This could happen on OSF/1 if decode_line_1 tries to skip the
- prologue for quickstarted shared library functions when the
- shared library is not yet mapped in.
- Reading target memory is slow over serial lines, so we perform
- this check only if the target has shared libraries. */
- if (target_read_memory (pc, buf, 4))
- return pc;
+ /* Silently return the unaltered pc upon memory errors.
+ This could happen on OSF/1 if decode_line_1 tries to skip the
+ prologue for quickstarted shared library functions when the
+ shared library is not yet mapped in.
+ Reading target memory is slow over serial lines, so we perform
+ this check only if the target has shared libraries. */
+ if (target_read_memory (pc, buf, 4))
+ return pc;
#endif
- /* See if we can determine the end of the prologue via the symbol table.
- If so, then return either PC, or the PC after the prologue, whichever
- is greater. */
+ /* See if we can determine the end of the prologue via the symbol table.
+ If so, then return either PC, or the PC after the prologue, whichever
+ is greater. */
- post_prologue_pc = after_prologue (pc);
+ post_prologue_pc = after_prologue (pc);
- if (post_prologue_pc != 0)
- return max (pc, post_prologue_pc);
+ if (post_prologue_pc != 0)
+ return max (pc, post_prologue_pc);
- /* Can't determine prologue from the symbol table, (this can happen if there
- is no debug information) so we need to fall back on the old code, which
- looks at the instructions */
+ /* Can't determine prologue from the symbol table, (this can happen if there
+ is no debug information) so we need to fall back on the old code, which
+ looks at the instructions */
/* FIXME (elz) !!!!: this may create a problem if, once the bp is hit, the user says
where: the backtrace info is not right: this is because the point at which we
break is at the very first instruction of the function. At this time the stuff that
cannot know all it needs to know. This will need to be fixed in the
actual backtrace code. (Note: this is what DDE does) */
- else
-
- return (skip_prologue_hard_way(pc));
+ else
+ return (skip_prologue_hard_way (pc));
#if 0
/* elz: I am keeping this code around just in case, but remember, all the
instructions are for alpha: you should change all to the hppa instructions */
- /* Can't determine prologue from the symbol table, need to examine
- instructions. */
+ /* Can't determine prologue from the symbol table, need to examine
+ instructions. */
- /* Skip the typical prologue instructions. These are the stack adjustment
- instruction and the instructions that save registers on the stack
- or in the gcc frame. */
- for (offset = 0; offset < 100; offset += 4)
- {
- int status;
+ /* Skip the typical prologue instructions. These are the stack adjustment
+ instruction and the instructions that save registers on the stack
+ or in the gcc frame. */
+ for (offset = 0; offset < 100; offset += 4)
+ {
+ int status;
- status = read_memory_nobpt (pc + offset, buf, 4);
- if (status)
- memory_error (status, pc + offset);
- inst = extract_unsigned_integer (buf, 4);
+ status = read_memory_nobpt (pc + offset, buf, 4);
+ if (status)
+ memory_error (status, pc + offset);
+ inst = extract_unsigned_integer (buf, 4);
- /* The alpha has no delay slots. But let's keep the lenient stuff,
- we might need it for something else in the future. */
- if (lenient && 0)
- continue;
+ /* The alpha has no delay slots. But let's keep the lenient stuff,
+ we might need it for something else in the future. */
+ if (lenient && 0)
+ continue;
- if ((inst & 0xffff0000) == 0x27bb0000) /* ldah $gp,n($t12) */
- continue;
- if ((inst & 0xffff0000) == 0x23bd0000) /* lda $gp,n($gp) */
- continue;
- if ((inst & 0xffff0000) == 0x23de0000) /* lda $sp,n($sp) */
- continue;
- else if ((inst & 0xfc1f0000) == 0xb41e0000
- && (inst & 0xffff0000) != 0xb7fe0000)
- continue; /* stq reg,n($sp) */
- /* reg != $zero */
- else if ((inst & 0xfc1f0000) == 0x9c1e0000
- && (inst & 0xffff0000) != 0x9ffe0000)
- continue; /* stt reg,n($sp) */
- /* reg != $zero */
- else if (inst == 0x47de040f) /* bis sp,sp,fp */
- continue;
- else
- break;
- }
- return pc + offset;
+ if ((inst & 0xffff0000) == 0x27bb0000) /* ldah $gp,n($t12) */
+ continue;
+ if ((inst & 0xffff0000) == 0x23bd0000) /* lda $gp,n($gp) */
+ continue;
+ if ((inst & 0xffff0000) == 0x23de0000) /* lda $sp,n($sp) */
+ continue;
+ else if ((inst & 0xfc1f0000) == 0xb41e0000
+ && (inst & 0xffff0000) != 0xb7fe0000)
+ continue; /* stq reg,n($sp) */
+ /* reg != $zero */
+ else if ((inst & 0xfc1f0000) == 0x9c1e0000
+ && (inst & 0xffff0000) != 0x9ffe0000)
+ continue; /* stt reg,n($sp) */
+ /* reg != $zero */
+ else if (inst == 0x47de040f) /* bis sp,sp,fp */
+ continue;
+ else
+ break;
+ }
+ return pc + offset;
#endif /* 0 */
}
for the saved registers. */
if ((frame_info->pc >= frame_info->frame
&& frame_info->pc <= (frame_info->frame + CALL_DUMMY_LENGTH
- + 32 * 4 + (NUM_REGS - FP0_REGNUM) * 8
- + 6 * 4)))
+ + 32 * 4 + (NUM_REGS - FP0_REGNUM) * 8
+ + 6 * 4)))
find_dummy_frame_regs (frame_info, frame_saved_regs);
/* Interrupt handlers are special too. They lay out the register
}
/* Just note that we found the save of SP into the stack. The
- value for frame_saved_regs was computed above. */
+ value for frame_saved_regs was computed above. */
if ((inst & 0xffffc000) == 0x6fc10000)
save_sp = 0;
else
frame_saved_regs->regs[reg]
= frame_info->frame + (u->Total_frame_size << 3)
- + extract_14 (inst);
+ + extract_14 (inst);
}
}
/* GCC handles callee saved FP regs a little differently.
- It emits an instruction to put the value of the start of
- the FP store area into %r1. It then uses fstds,ma with
- a basereg of %r1 for the stores.
+ It emits an instruction to put the value of the start of
+ the FP store area into %r1. It then uses fstds,ma with
+ a basereg of %r1 for the stores.
- HP CC emits them at the current stack pointer modifying
- the stack pointer as it stores each register. */
+ HP CC emits them at the current stack pointer modifying
+ the stack pointer as it stores each register. */
/* ldo X(%r3),%r1 or ldo X(%r30),%r1. */
if ((inst & 0xffffc000) == 0x34610000
|| (inst & 0xffffc000) == 0x37c10000)
fp_loc = extract_14 (inst);
-
+
reg = inst_saves_fr (inst);
if (reg >= 12 && reg <= 21)
{
if (fp_loc == -1)
{
/* 1st HP CC FP register store. After this instruction
- we've set enough state that the GCC and HPCC code are
- both handled in the same manner. */
+ we've set enough state that the GCC and HPCC code are
+ both handled in the same manner. */
frame_saved_regs->regs[reg + FP4_REGNUM + 4] = frame_info->frame;
fp_loc = 8;
}
}
/* Quit if we hit any kind of branch. This can happen if a prologue
- instruction is in the delay slot of the first call/branch. */
+ instruction is in the delay slot of the first call/branch. */
if (is_branch (inst))
break;
exception event has occurred. */
/* The name of the hook to be set to point to the callback function */
-static char HP_ACC_EH_notify_hook[] = "__eh_notify_hook";
-/* The name of the function to be used to set the hook value */
-static char HP_ACC_EH_set_hook_value[] = "__eh_set_hook_value";
-/* The name of the callback function in end.o */
+static char HP_ACC_EH_notify_hook[] = "__eh_notify_hook";
+/* The name of the function to be used to set the hook value */
+static char HP_ACC_EH_set_hook_value[] = "__eh_set_hook_value";
+/* The name of the callback function in end.o */
static char HP_ACC_EH_notify_callback[] = "__d_eh_notify_callback";
-/* Name of function in end.o on which a break is set (called by above) */
-static char HP_ACC_EH_break[] = "__d_eh_break";
-/* Name of flag (in end.o) that enables catching throws */
-static char HP_ACC_EH_catch_throw[] = "__d_eh_catch_throw";
-/* Name of flag (in end.o) that enables catching catching */
-static char HP_ACC_EH_catch_catch[] = "__d_eh_catch_catch";
-/* The enum used by aCC */
-typedef enum {
- __EH_NOTIFY_THROW,
- __EH_NOTIFY_CATCH
-} __eh_notification;
+/* Name of function in end.o on which a break is set (called by above) */
+static char HP_ACC_EH_break[] = "__d_eh_break";
+/* Name of flag (in end.o) that enables catching throws */
+static char HP_ACC_EH_catch_throw[] = "__d_eh_catch_throw";
+/* Name of flag (in end.o) that enables catching catching */
+static char HP_ACC_EH_catch_catch[] = "__d_eh_catch_catch";
+/* The enum used by aCC */
+typedef enum
+ {
+ __EH_NOTIFY_THROW,
+ __EH_NOTIFY_CATCH
+ }
+__eh_notification;
/* Is exception-handling support available with this executable? */
static int hp_cxx_exception_support = 0;
/* Address of __d_eh_catch_throw */
static CORE_ADDR eh_catch_throw_addr = NULL;
/* Sal for __d_eh_break */
-static struct symtab_and_line * break_callback_sal = NULL;
+static struct symtab_and_line *break_callback_sal = NULL;
/* Code in end.c expects __d_pid to be set in the inferior,
otherwise __d_eh_notify_callback doesn't bother to call
__d_eh_break! So we poke the pid into this symbol
ourselves.
0 => success
- 1 => failure */
+ 1 => failure */
int
setup_d_pid_in_inferior ()
{
CORE_ADDR anaddr;
- struct minimal_symbol * msymbol;
- char buf[4]; /* FIXME 32x64? */
-
+ struct minimal_symbol *msymbol;
+ char buf[4]; /* FIXME 32x64? */
+
/* Slam the pid of the process into __d_pid; failing is only a warning! */
msymbol = lookup_minimal_symbol ("__d_pid", NULL, symfile_objfile);
if (msymbol == NULL)
}
anaddr = SYMBOL_VALUE_ADDRESS (msymbol);
- store_unsigned_integer (buf, 4, inferior_pid); /* FIXME 32x64? */
- if (target_write_memory (anaddr, buf, 4)) /* FIXME 32x64? */
+ store_unsigned_integer (buf, 4, inferior_pid); /* FIXME 32x64? */
+ if (target_write_memory (anaddr, buf, 4)) /* FIXME 32x64? */
{
warning ("Unable to write __d_pid");
warning ("Suggest linking executable with -g (links in /opt/langtools/lib/end.o).");
point to the required debug function
Return 0 => failure
- 1 => success */
+ 1 => success */
static int
initialize_hp_cxx_exception_support ()
{
struct symtabs_and_lines sals;
- struct cleanup * old_chain;
- struct cleanup * canonical_strings_chain = NULL;
+ struct cleanup *old_chain;
+ struct cleanup *canonical_strings_chain = NULL;
int i;
- char * addr_start;
- char * addr_end = NULL;
- char ** canonical = (char **) NULL;
+ char *addr_start;
+ char *addr_end = NULL;
+ char **canonical = (char **) NULL;
int thread = -1;
- struct symbol * sym = NULL;
- struct minimal_symbol * msym = NULL;
- struct objfile * objfile;
+ struct symbol *sym = NULL;
+ struct minimal_symbol *msym = NULL;
+ struct objfile *objfile;
asection *shlib_info;
/* Detect and disallow recursion. On HP-UX with aCC, infinite
callbacks involves making a call in the inferior, which means
re-inserting breakpoints which can re-invoke this code */
- static int recurse = 0;
- if (recurse > 0)
+ static int recurse = 0;
+ if (recurse > 0)
{
hp_cxx_exception_support_initialized = 0;
exception_support_initialized = 0;
will decide to try the g++ exception-handling support instead. */
if (!hp_som_som_object_present)
return 0;
-
+
/* We have a SOM executable with SOM debug info; find the hooks */
/* First look for the notify hook provided by aCC runtime libs */
If this symbol is found but the other symbols we require are
not found, there is something weird going on, and g++ support
should *not* be tried as an alternative.
-
+
ASSUMPTION: Only HP aCC code will have __eh_notify_hook defined.
ASSUMPTION: HP aCC and g++ modules cannot be linked together. */
-
+
/* libCsup has this hook; it'll usually be non-debuggable */
msym = lookup_minimal_symbol (HP_ACC_EH_notify_hook, NULL, NULL);
if (msym)
{
eh_notify_hook_addr = SYMBOL_VALUE_ADDRESS (msym);
hp_cxx_exception_support = 1;
- }
+ }
else
{
warning ("Unable to find exception callback hook (%s).", HP_ACC_EH_notify_hook);
}
/* Next look for the notify callback routine in end.o */
- /* This is always available in the SOM symbol dictionary if end.o is linked in */
+ /* This is always available in the SOM symbol dictionary if end.o is linked in */
msym = lookup_minimal_symbol (HP_ACC_EH_notify_callback, NULL, NULL);
if (msym)
{
eh_notify_callback_addr = SYMBOL_VALUE_ADDRESS (msym);
hp_cxx_exception_support = 1;
- }
- else
+ }
+ else
{
warning ("Unable to find exception callback routine (%s).", HP_ACC_EH_notify_callback);
warning ("Suggest linking executable with -g (links in /opt/langtools/lib/end.o).");
can be the target of a call through $$dyncall from the aCC runtime support
library (libCsup) which is linked shared by default by aCC. */
/* This test below was copied from somsolib.c/somread.c. It may not be a very
- reliable one to test that an executable is linked shared. pai/1997-07-18 */
+ reliable one to test that an executable is linked shared. pai/1997-07-18 */
shlib_info = bfd_get_section_by_name (symfile_objfile->obfd, "$SHLIB_INFO$");
if (shlib_info && (bfd_section_size (symfile_objfile->obfd, shlib_info) != 0))
{
plabel that can be used by an inter-load-module call. */
/* Find solib handle for main image (which has end.o), and use that
and the min sym as arguments to __d_shl_get() (which does the equivalent
- of shl_findsym()) to find the plabel. */
+ of shl_findsym()) to find the plabel. */
args_for_find_stub args;
static char message[] = "Error while finding exception callback hook:\n";
-
+
args.solib_handle = som_solib_get_solib_by_pc (eh_notify_callback_addr);
args.msym = msym;
-
+
recurse++;
- eh_notify_callback_addr = catch_errors ((int (*) PARAMS ((char *))) cover_find_stub_with_shl_get,
- (char *) &args,
- message, RETURN_MASK_ALL);
+ eh_notify_callback_addr = catch_errors ((int (*)PARAMS ((char *))) cover_find_stub_with_shl_get,
+ (char *) &args,
+ message, RETURN_MASK_ALL);
recurse--;
-
+
exception_catchpoints_are_fragile = 1;
-
+
if (!eh_notify_callback_addr)
- {
- /* We can get here either if there is no plabel in the export list
- for the main image, or if something strange happened (??) */
- warning ("Couldn't find a plabel (indirect function label) for the exception callback.");
- warning ("GDB will not be able to intercept exception events.");
- return 0;
- }
+ {
+ /* We can get here either if there is no plabel in the export list
+ for the main image, or if something strange happened (??) */
+ warning ("Couldn't find a plabel (indirect function label) for the exception callback.");
+ warning ("GDB will not be able to intercept exception events.");
+ return 0;
+ }
}
else
exception_catchpoints_are_fragile = 0;
/* Now, look for the breakpointable routine in end.o */
- /* This should also be available in the SOM symbol dict. if end.o linked in */
+ /* This should also be available in the SOM symbol dict. if end.o linked in */
msym = lookup_minimal_symbol (HP_ACC_EH_break, NULL, NULL);
if (msym)
{
eh_break_addr = SYMBOL_VALUE_ADDRESS (msym);
hp_cxx_exception_support = 1;
- }
+ }
else
{
warning ("Unable to find exception callback routine to set breakpoint (%s).", HP_ACC_EH_break);
/* Next look for the catch enable flag provided in end.o */
sym = lookup_symbol (HP_ACC_EH_catch_catch, (struct block *) NULL,
- VAR_NAMESPACE, 0, (struct symtab **) NULL);
- if (sym) /* sometimes present in debug info */
+ VAR_NAMESPACE, 0, (struct symtab **) NULL);
+ if (sym) /* sometimes present in debug info */
{
eh_catch_catch_addr = SYMBOL_VALUE_ADDRESS (sym);
hp_cxx_exception_support = 1;
}
- else /* otherwise look in SOM symbol dict. */
+ else
+ /* otherwise look in SOM symbol dict. */
{
msym = lookup_minimal_symbol (HP_ACC_EH_catch_catch, NULL, NULL);
if (msym)
- {
- eh_catch_catch_addr = SYMBOL_VALUE_ADDRESS (msym);
- hp_cxx_exception_support = 1;
- }
+ {
+ eh_catch_catch_addr = SYMBOL_VALUE_ADDRESS (msym);
+ hp_cxx_exception_support = 1;
+ }
else
- {
- warning ("Unable to enable interception of exception catches.");
- warning ("Executable may not have been compiled debuggable with HP aCC.");
- warning ("Suggest linking executable with -g (link in /opt/langtools/lib/end.o).");
- return 0;
- }
+ {
+ warning ("Unable to enable interception of exception catches.");
+ warning ("Executable may not have been compiled debuggable with HP aCC.");
+ warning ("Suggest linking executable with -g (link in /opt/langtools/lib/end.o).");
+ return 0;
+ }
}
/* Next look for the catch enable flag provided end.o */
sym = lookup_symbol (HP_ACC_EH_catch_catch, (struct block *) NULL,
- VAR_NAMESPACE, 0, (struct symtab **) NULL);
- if (sym) /* sometimes present in debug info */
+ VAR_NAMESPACE, 0, (struct symtab **) NULL);
+ if (sym) /* sometimes present in debug info */
{
eh_catch_throw_addr = SYMBOL_VALUE_ADDRESS (sym);
hp_cxx_exception_support = 1;
}
- else /* otherwise look in SOM symbol dict. */
+ else
+ /* otherwise look in SOM symbol dict. */
{
msym = lookup_minimal_symbol (HP_ACC_EH_catch_throw, NULL, NULL);
if (msym)
- {
- eh_catch_throw_addr = SYMBOL_VALUE_ADDRESS (msym);
- hp_cxx_exception_support = 1;
- }
+ {
+ eh_catch_throw_addr = SYMBOL_VALUE_ADDRESS (msym);
+ hp_cxx_exception_support = 1;
+ }
else
- {
- warning ("Unable to enable interception of exception throws.");
- warning ("Executable may not have been compiled debuggable with HP aCC.");
- warning ("Suggest linking executable with -g (link in /opt/langtools/lib/end.o).");
- return 0;
- }
+ {
+ warning ("Unable to enable interception of exception throws.");
+ warning ("Executable may not have been compiled debuggable with HP aCC.");
+ warning ("Suggest linking executable with -g (link in /opt/langtools/lib/end.o).");
+ return 0;
+ }
}
- /* Set the flags */
- hp_cxx_exception_support = 2; /* everything worked so far */
+ /* Set the flags */
+ hp_cxx_exception_support = 2; /* everything worked so far */
hp_cxx_exception_support_initialized = 1;
exception_support_initialized = 1;
Return value is NULL if no support found;
-1 if something went wrong,
or a pointer to a symtab/line struct if the breakpointable
- address was found. */
+ address was found. */
-struct symtab_and_line *
+struct symtab_and_line *
child_enable_exception_callback (kind, enable)
- enum exception_event_kind kind;
- int enable;
+ enum exception_event_kind kind;
+ int enable;
{
char buf[4];
switch (hp_cxx_exception_support)
{
- case 0:
- /* Assuming no HP support at all */
- return NULL;
- case 1:
- /* HP support should be present, but something went wrong */
- return (struct symtab_and_line *) -1; /* yuck! */
- /* there may be other cases in the future */
+ case 0:
+ /* Assuming no HP support at all */
+ return NULL;
+ case 1:
+ /* HP support should be present, but something went wrong */
+ return (struct symtab_and_line *) -1; /* yuck! */
+ /* there may be other cases in the future */
}
-
+
/* Set the EH hook to point to the callback routine */
- store_unsigned_integer (buf, 4, enable ? eh_notify_callback_addr : 0); /* FIXME 32x64 problem */
+ store_unsigned_integer (buf, 4, enable ? eh_notify_callback_addr : 0); /* FIXME 32x64 problem */
/* pai: (temp) FIXME should there be a pack operation first? */
- if (target_write_memory (eh_notify_hook_addr, buf, 4)) /* FIXME 32x64 problem */
+ if (target_write_memory (eh_notify_hook_addr, buf, 4)) /* FIXME 32x64 problem */
{
warning ("Could not write to target memory for exception event callback.");
warning ("Interception of exception events may not work.");
- return (struct symtab_and_line *) -1;
+ return (struct symtab_and_line *) -1;
}
if (enable)
{
- /* Ensure that __d_pid is set up correctly -- end.c code checks this. :-(*/
+ /* Ensure that __d_pid is set up correctly -- end.c code checks this. :-( */
if (inferior_pid > 0)
- {
- if (setup_d_pid_in_inferior ())
- return (struct symtab_and_line *) -1;
- }
+ {
+ if (setup_d_pid_in_inferior ())
+ return (struct symtab_and_line *) -1;
+ }
else
- {
- warning ("Internal error: Invalid inferior pid? Cannot intercept exception events."); /* purecov: deadcode */
- return (struct symtab_and_line *) -1; /* purecov: deadcode */
- }
+ {
+ warning ("Internal error: Invalid inferior pid? Cannot intercept exception events."); /* purecov: deadcode */
+ return (struct symtab_and_line *) -1; /* purecov: deadcode */
+ }
}
-
+
switch (kind)
{
- case EX_EVENT_THROW:
- store_unsigned_integer (buf, 4, enable ? 1 : 0);
- if (target_write_memory (eh_catch_throw_addr, buf, 4)) /* FIXME 32x64? */
- {
- warning ("Couldn't enable exception throw interception.");
- return (struct symtab_and_line *) -1;
- }
- break;
- case EX_EVENT_CATCH:
- store_unsigned_integer (buf, 4, enable ? 1 : 0);
- if (target_write_memory (eh_catch_catch_addr, buf, 4)) /* FIXME 32x64? */
- {
- warning ("Couldn't enable exception catch interception.");
- return (struct symtab_and_line *) -1;
- }
- break;
- default: /* purecov: deadcode */
- error ("Request to enable unknown or unsupported exception event."); /* purecov: deadcode */
+ case EX_EVENT_THROW:
+ store_unsigned_integer (buf, 4, enable ? 1 : 0);
+ if (target_write_memory (eh_catch_throw_addr, buf, 4)) /* FIXME 32x64? */
+ {
+ warning ("Couldn't enable exception throw interception.");
+ return (struct symtab_and_line *) -1;
+ }
+ break;
+ case EX_EVENT_CATCH:
+ store_unsigned_integer (buf, 4, enable ? 1 : 0);
+ if (target_write_memory (eh_catch_catch_addr, buf, 4)) /* FIXME 32x64? */
+ {
+ warning ("Couldn't enable exception catch interception.");
+ return (struct symtab_and_line *) -1;
+ }
+ break;
+ default: /* purecov: deadcode */
+ error ("Request to enable unknown or unsupported exception event."); /* purecov: deadcode */
}
-
+
/* Copy break address into new sal struct, malloc'ing if needed. */
if (!break_callback_sal)
{
break_callback_sal = (struct symtab_and_line *) xmalloc (sizeof (struct symtab_and_line));
}
- INIT_SAL(break_callback_sal);
+ INIT_SAL (break_callback_sal);
break_callback_sal->symtab = NULL;
break_callback_sal->pc = eh_break_addr;
break_callback_sal->line = 0;
break_callback_sal->end = eh_break_addr;
-
+
return break_callback_sal;
}
-/* Record some information about the current exception event */
+/* Record some information about the current exception event */
static struct exception_event_record current_ex_event;
-/* Convenience struct */
-static struct symtab_and_line null_symtab_and_line = { NULL, 0, 0, 0 };
+/* Convenience struct */
+static struct symtab_and_line null_symtab_and_line =
+{NULL, 0, 0, 0};
/* Report current exception event. Returns a pointer to a record
that describes the kind of the event, where it was thrown from,
and where it will be caught. More information may be reported
- in the future */
+ in the future */
struct exception_event_record *
child_get_current_exception_event ()
{
- CORE_ADDR event_kind;
- CORE_ADDR throw_addr;
- CORE_ADDR catch_addr;
+ CORE_ADDR event_kind;
+ CORE_ADDR throw_addr;
+ CORE_ADDR catch_addr;
struct frame_info *fi, *curr_frame;
int level = 1;
- curr_frame = get_current_frame();
+ curr_frame = get_current_frame ();
if (!curr_frame)
return (struct exception_event_record *) NULL;
/* Read in the arguments */
/* __d_eh_notify_callback() is called with 3 arguments:
- 1. event kind catch or throw
- 2. the target address if known
- 3. a flag -- not sure what this is. pai/1997-07-17 */
- event_kind = read_register (ARG0_REGNUM);
+ 1. event kind catch or throw
+ 2. the target address if known
+ 3. a flag -- not sure what this is. pai/1997-07-17 */
+ event_kind = read_register (ARG0_REGNUM);
catch_addr = read_register (ARG1_REGNUM);
/* Now go down to a user frame */
/* For a throw, __d_eh_break is called by
- __d_eh_notify_callback which is called by
- __notify_throw which is called
- from user code.
+ __d_eh_notify_callback which is called by
+ __notify_throw which is called
+ from user code.
For a catch, __d_eh_break is called by
- __d_eh_notify_callback which is called by
- <stackwalking stuff> which is called by
- __throw__<stuff> or __rethrow_<stuff> which is called
- from user code. */
- /* FIXME: Don't use such magic numbers; search for the frames */
+ __d_eh_notify_callback which is called by
+ <stackwalking stuff> which is called by
+ __throw__<stuff> or __rethrow_<stuff> which is called
+ from user code. */
+ /* FIXME: Don't use such magic numbers; search for the frames */
level = (event_kind == EX_EVENT_THROW) ? 3 : 4;
fi = find_relative_frame (curr_frame, &level);
if (level != 0)
o User hits bp, deletes bp, switches threads -- NO
o User hits bp, deletes one of two or more bps
- at that PC, user switches threads -- YES
+ at that PC, user switches threads -- YES
o Plus, since we're buffering events, the user may have hit a
- breakpoint, deleted the breakpoint and then gotten another
- hit on that same breakpoint on another thread which
- actually hit before the delete. (FIXME in breakpoint.c
- so that "dead" breakpoints are ignored?) -- NO
+ breakpoint, deleted the breakpoint and then gotten another
+ hit on that same breakpoint on another thread which
+ actually hit before the delete. (FIXME in breakpoint.c
+ so that "dead" breakpoints are ignored?) -- NO
For these reasons, we have to violate information hiding and
call "breakpoint_here_p". If core gdb thinks there is a bpt
here, that's what counts, as core gdb is the one which is
putting the BPT instruction in and taking it out. */
int
-hppa_prepare_to_proceed()
+hppa_prepare_to_proceed ()
{
pid_t old_thread;
pid_t current_thread;
- old_thread = hppa_switched_threads(inferior_pid);
+ old_thread = hppa_switched_threads (inferior_pid);
if (old_thread != 0)
{
/* Switched over from "old_thread". Try to do
as little work as possible, 'cause mostly
we're going to switch back. */
CORE_ADDR new_pc;
- CORE_ADDR old_pc = read_pc();
+ CORE_ADDR old_pc = read_pc ();
/* Yuk, shouldn't use global to specify current
thread. But that's how gdb does it. */
current_thread = inferior_pid;
- inferior_pid = old_thread;
+ inferior_pid = old_thread;
- new_pc = read_pc();
- if (new_pc != old_pc /* If at same pc, no need */
+ new_pc = read_pc ();
+ if (new_pc != old_pc /* If at same pc, no need */
&& breakpoint_here_p (new_pc))
- {
+ {
/* User hasn't deleted the BP.
- Return TRUE, finishing switch to "old_thread". */
+ Return TRUE, finishing switch to "old_thread". */
flush_cached_frames ();
registers_changed ();
#if 0
- printf("---> PREPARE_TO_PROCEED (was %d, now %d)!\n",
+ printf ("---> PREPARE_TO_PROCEED (was %d, now %d)!\n",
current_thread, inferior_pid);
#endif
-
+
return 1;
- }
+ }
/* Otherwise switch back to the user-chosen thread. */
inferior_pid = current_thread;
- new_pc = read_pc(); /* Re-prime register cache */
+ new_pc = read_pc (); /* Re-prime register cache */
}
return 0;
projects / thirdparty / binutils-gdb.git / blobdiff