aboutsummaryrefslogtreecommitdiff
path: root/gdb/hppa-tdep.c
diff options
context:
space:
mode:
Diffstat (limited to 'gdb/hppa-tdep.c')
-rw-r--r--gdb/hppa-tdep.c1859
1 files changed, 943 insertions, 916 deletions
diff --git a/gdb/hppa-tdep.c b/gdb/hppa-tdep.c
index 288f085..82ac67b 100644
--- a/gdb/hppa-tdep.c
+++ b/gdb/hppa-tdep.c
@@ -5,21 +5,22 @@
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"
@@ -46,7 +47,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
#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"
@@ -64,7 +65,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
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));
@@ -129,16 +130,18 @@ static void pa_register_look_aside PARAMS ((char *, int, long *));
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 */
@@ -146,7 +149,7 @@ extern int exception_catchpoints_are_fragile;
/* 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
@@ -156,8 +159,8 @@ hppa_use_struct_convention (gcc_p, type)
{
return (TYPE_LENGTH (type) > 8);
}
-
+
/* Routines to extract various sized constants out of hppa
instructions. */
@@ -168,7 +171,7 @@ static int
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! */
@@ -177,7 +180,7 @@ static int
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 */
@@ -229,8 +232,8 @@ extract_5_store (word)
return low_sign_extend (word & MASK_5, 5);
}
-#endif /* 0 */
-
+#endif /* 0 */
+
/* extract the immediate field from a break instruction */
static unsigned
@@ -280,7 +283,7 @@ deposit_14 (opnd, word)
{
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 */
@@ -346,10 +349,10 @@ unsigned int
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;
}
@@ -409,17 +412,17 @@ internalize_unwinds (objfile, table, section, entries, size, text_offset)
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;
@@ -445,7 +448,7 @@ internalize_unwinds (objfile, table, section, entries, size, text_offset)
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;
@@ -454,7 +457,7 @@ internalize_unwinds (objfile, table, section, entries, size, text_offset)
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;
}
@@ -480,8 +483,8 @@ read_unwind_info (objfile)
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;
@@ -507,8 +510,8 @@ read_unwind_info (objfile)
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
{
@@ -534,7 +537,7 @@ read_unwind_info (objfile)
/* 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;
@@ -568,11 +571,11 @@ read_unwind_info (objfile)
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;
}
@@ -583,17 +586,17 @@ read_unwind_info (objfile)
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;
}
@@ -603,7 +606,7 @@ read_unwind_info (objfile)
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;
@@ -614,48 +617,48 @@ find_unwind_entry(pc)
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;
}
@@ -734,14 +737,14 @@ pc_in_linker_stub (pc)
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)
@@ -756,20 +759,20 @@ pc_in_linker_stub (pc)
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;
@@ -794,9 +797,9 @@ find_proc_framesize (pc)
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)
@@ -886,7 +889,7 @@ saved_pc_after_call (frame)
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);
@@ -903,8 +906,8 @@ hppa_frame_saved_pc (frame)
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
@@ -930,10 +933,10 @@ hppa_frame_saved_pc (frame)
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)))
{
@@ -945,9 +948,9 @@ hppa_frame_saved_pc (frame)
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;
}
@@ -960,14 +963,14 @@ hppa_frame_saved_pc (frame)
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
@@ -981,9 +984,9 @@ restart:
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;
}
@@ -991,15 +994,15 @@ restart:
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
@@ -1014,28 +1017,28 @@ restart:
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;
}
}
@@ -1062,13 +1065,13 @@ init_extra_frame_info (fromleaf, frame)
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
@@ -1077,7 +1080,7 @@ init_extra_frame_info (fromleaf, frame)
}
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
@@ -1089,7 +1092,7 @@ init_extra_frame_info (fromleaf, frame)
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
@@ -1113,39 +1116,41 @@ frame_chain (frame)
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
@@ -1164,7 +1169,7 @@ frame_chain (frame)
/* 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
@@ -1172,7 +1177,7 @@ frame_chain (frame)
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. */
@@ -1214,10 +1219,10 @@ frame_chain (frame)
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
@@ -1225,7 +1230,7 @@ frame_chain (frame)
}
/* 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))
@@ -1237,7 +1242,7 @@ frame_chain (frame)
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))
@@ -1245,7 +1250,7 @@ frame_chain (frame)
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;
@@ -1257,17 +1262,17 @@ frame_chain (frame)
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
@@ -1280,7 +1285,7 @@ frame_chain (frame)
/* 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)))
@@ -1295,7 +1300,7 @@ frame_chain (frame)
return frame_base - (u->Total_frame_size << 3);
}
}
-
+
return read_memory_integer (saved_regs.regs[FP_REGNUM], 4);
}
}
@@ -1315,26 +1320,26 @@ frame_chain (frame)
&& (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 ();
}
}
-
+
/* To see if a frame chain is valid, see if the caller looks like it
was compiled with gcc. */
@@ -1442,10 +1447,10 @@ push_dummy_frame (inf_status)
/* 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);
@@ -1459,8 +1464,8 @@ push_dummy_frame (inf_status)
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));
@@ -1517,7 +1522,7 @@ hppa_pop_frame ()
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
@@ -1525,20 +1530,20 @@ hppa_pop_frame ()
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])
@@ -1547,7 +1552,7 @@ hppa_pop_frame ()
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);
@@ -1555,7 +1560,7 @@ hppa_pop_frame ()
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);
@@ -1575,7 +1580,7 @@ hppa_pop_frame ()
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);
@@ -1587,7 +1592,7 @@ hppa_pop_frame ()
/* 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);
@@ -1615,9 +1620,9 @@ restore_pc_queue (fsr)
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. */
@@ -1627,23 +1632,23 @@ restore_pc_queue (fsr)
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);
@@ -1660,19 +1665,19 @@ hppa_push_arguments (nargs, args, sp, struct_return, struct_addr)
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)
@@ -1718,22 +1723,22 @@ hppa_push_arguments (nargs, args, sp, struct_return, struct_addr)
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
@@ -1742,36 +1747,36 @@ hppa_push_arguments (nargs, args, sp, struct_return, struct_addr)
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;
@@ -1786,13 +1791,13 @@ hppa_push_arguments (nargs, args, sp, struct_return, struct_addr)
/* 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;
}
@@ -1805,7 +1810,7 @@ hppa_push_arguments (nargs, args, sp, struct_return, struct_addr)
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;
{
@@ -1813,7 +1818,7 @@ hppa_value_returned_from_stack (valtype , 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;
}
@@ -1821,97 +1826,97 @@ hppa_value_returned_from_stack (valtype , addr)
/* 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);
}
@@ -1959,7 +1964,7 @@ hppa_fix_call_dummy (dummy, pc, fun, nargs, args, type, gcc_p)
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
@@ -1968,7 +1973,7 @@ hppa_fix_call_dummy (dummy, pc, fun, nargs, args, type, gcc_p)
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;
@@ -1985,12 +1990,12 @@ hppa_fix_call_dummy (dummy, pc, fun, nargs, args, type, gcc_p)
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
@@ -1998,12 +2003,12 @@ hppa_fix_call_dummy (dummy, pc, fun, nargs, args, type, gcc_p)
#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;
@@ -2017,35 +2022,35 @@ hppa_fix_call_dummy (dummy, pc, fun, nargs, args, type, gcc_p)
/* 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
@@ -2054,7 +2059,7 @@ hppa_fix_call_dummy (dummy, pc, fun, nargs, args, type, gcc_p)
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);
@@ -2077,12 +2082,12 @@ hppa_fix_call_dummy (dummy, pc, fun, nargs, args, type, gcc_p)
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)
@@ -2103,17 +2108,17 @@ hppa_fix_call_dummy (dummy, pc, fun, nargs, args, type, gcc_p)
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. */
@@ -2205,13 +2210,14 @@ hppa_fix_call_dummy (dummy, pc, fun, nargs, args, type, gcc_p)
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 (). */
@@ -2283,7 +2289,7 @@ hppa_alignof (type)
{
/* 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);
@@ -2302,7 +2308,7 @@ pa_do_registers_info (regnum, fpregs)
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
@@ -2312,29 +2318,32 @@ pa_do_registers_info (regnum, fpregs)
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, &reg_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, &reg_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);
}
@@ -2346,41 +2355,44 @@ pa_do_strcat_registers_info (regnum, fpregs, stream, precision)
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, &reg_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, &reg_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);
}
@@ -2390,61 +2402,66 @@ pa_do_strcat_registers_info (regnum, fpregs, 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
@@ -2458,15 +2475,15 @@ pa_register_look_aside(raw_regs, regnum, raw_val)
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
@@ -2480,63 +2497,65 @@ pa_register_look_aside(raw_regs, regnum, raw_val)
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;
@@ -2544,8 +2563,8 @@ pa_strcat_registers (raw_regs, regnum, fpregs, stream)
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;
@@ -2555,34 +2574,36 @@ pa_strcat_registers (raw_regs, regnum, fpregs, stream)
{
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);
}
@@ -2651,22 +2672,23 @@ 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);
+ }
}
@@ -2738,7 +2760,7 @@ in_solib_call_trampoline (pc, name)
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;
@@ -2755,12 +2777,12 @@ in_solib_call_trampoline (pc, name)
}
/* 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.
@@ -2800,7 +2822,7 @@ in_solib_return_trampoline (pc, name)
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;
@@ -2817,12 +2839,12 @@ in_solib_return_trampoline (pc, name)
}
/* 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 */
}
@@ -2843,13 +2865,13 @@ in_solib_return_trampoline (pc, name)
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
@@ -2905,8 +2927,8 @@ skip_trampoline_code (pc, name)
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);
}
@@ -2940,56 +2962,56 @@ skip_trampoline_code (pc, name)
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.
@@ -3012,7 +3034,7 @@ skip_trampoline_code (pc, name)
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
@@ -3031,26 +3053,26 @@ skip_trampoline_code (pc, name)
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;
@@ -3073,18 +3095,18 @@ skip_trampoline_code (pc, name)
}
/* 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
@@ -3104,24 +3126,24 @@ skip_trampoline_code (pc, name)
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;
}
}
@@ -3215,7 +3237,7 @@ inst_saves_gr (inst)
too. */
if ((inst >> 26) == 0x19 || (inst >> 26) == 0x18)
return extract_5R_store (inst);
-
+
return 0;
}
@@ -3231,10 +3253,10 @@ static int
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;
@@ -3265,7 +3287,7 @@ restart:
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;
@@ -3321,7 +3343,7 @@ restart:
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;
@@ -3330,7 +3352,7 @@ restart:
status = target_read_memory (pc, buf, 4);
inst = extract_unsigned_integer (buf, 4);
-
+
/* Yow! */
if (status != 0)
return pc;
@@ -3343,7 +3365,7 @@ restart:
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;
@@ -3352,15 +3374,15 @@ restart:
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)
@@ -3381,13 +3403,13 @@ restart:
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)
@@ -3398,9 +3420,9 @@ restart:
}
/* 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)
@@ -3423,26 +3445,26 @@ restart:
}
/* 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;
}
@@ -3454,7 +3476,7 @@ restart:
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;
@@ -3481,7 +3503,7 @@ after_prologue (pc)
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)
@@ -3490,35 +3512,36 @@ after_prologue (pc)
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
@@ -3534,35 +3557,35 @@ CORE_ADDR
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
@@ -3570,54 +3593,53 @@ hppa_skip_prologue (pc)
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 */
}
@@ -3648,8 +3670,8 @@ hppa_frame_find_saved_regs (frame_info, frame_saved_regs)
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
@@ -3748,7 +3770,7 @@ hppa_frame_find_saved_regs (frame_info, frame_saved_regs)
}
/* 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;
@@ -3772,25 +3794,25 @@ hppa_frame_find_saved_regs (frame_info, frame_saved_regs)
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)
{
@@ -3801,8 +3823,8 @@ hppa_frame_find_saved_regs (frame_info, frame_saved_regs)
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;
}
@@ -3815,7 +3837,7 @@ hppa_frame_find_saved_regs (frame_info, frame_saved_regs)
}
/* 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;
@@ -3831,22 +3853,24 @@ hppa_frame_find_saved_regs (frame_info, frame_saved_regs)
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;
@@ -3865,21 +3889,21 @@ static CORE_ADDR eh_catch_catch_addr = NULL;
/* 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)
@@ -3890,8 +3914,8 @@ setup_d_pid_in_inferior ()
}
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).");
@@ -3905,22 +3929,22 @@ setup_d_pid_in_inferior ()
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
@@ -3928,8 +3952,8 @@ initialize_hp_cxx_exception_support ()
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;
@@ -3945,7 +3969,7 @@ initialize_hp_cxx_exception_support ()
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 */
@@ -3958,17 +3982,17 @@ initialize_hp_cxx_exception_support ()
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);
@@ -3980,14 +4004,14 @@ initialize_hp_cxx_exception_support ()
}
/* 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).");
@@ -4003,7 +4027,7 @@ initialize_hp_cxx_exception_support ()
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))
{
@@ -4011,42 +4035,42 @@ initialize_hp_cxx_exception_support ()
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);
@@ -4058,56 +4082,58 @@ initialize_hp_cxx_exception_support ()
/* 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;
@@ -4121,12 +4147,12 @@ initialize_hp_cxx_exception_support ()
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];
@@ -4136,94 +4162,95 @@ child_enable_exception_callback (kind, enable)
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;
@@ -4238,23 +4265,23 @@ child_get_current_exception_event ()
/* 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)
@@ -4368,57 +4395,57 @@ unwind_command (exp, from_tty)
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;