diff options
Diffstat (limited to 'gdb/hppa-tdep.c')
| -rw-r--r-- | gdb/hppa-tdep.c | 1859 |
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, ®_val[0]); - - if(!is_pa_2) { - printf_unfiltered ("%s %x\n", REGISTER_NAME (regnum), reg_val[1]); - } - else { - /* Fancy % formats to prevent leading zeros. */ - if(reg_val[0] == 0) - printf_unfiltered("%s %x\n", REGISTER_NAME (regnum), reg_val[1]); + else if (regnum < FP4_REGNUM) + { + long reg_val[2]; + + /* Why is the value not passed through "extract_signed_integer" + as in "pa_print_registers" below? */ + pa_register_look_aside (raw_regs, regnum, ®_val[0]); + + if (!is_pa_2) + { + printf_unfiltered ("%s %x\n", REGISTER_NAME (regnum), reg_val[1]); + } else - printf_unfiltered("%s %x%8.8x\n", REGISTER_NAME (regnum), - reg_val[0], reg_val[1]); + { + /* Fancy % formats to prevent leading zeros. */ + if (reg_val[0] == 0) + printf_unfiltered ("%s %x\n", REGISTER_NAME (regnum), reg_val[1]); + else + printf_unfiltered ("%s %x%8.8x\n", REGISTER_NAME (regnum), + reg_val[0], reg_val[1]); + } } - } else - /* Note that real floating point values only start at - FP4_REGNUM. FP0 and up are just status and error - registers, which have integral (bit) values. */ + /* Note that real floating point values only start at + FP4_REGNUM. FP0 and up are just status and error + registers, which have integral (bit) values. */ pa_print_fp_reg (regnum); } @@ -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, ®_val[0]); + else if (regnum < FP4_REGNUM) + { + long reg_val[2]; + + /* Why is the value not passed through "extract_signed_integer" + as in "pa_print_registers" below? */ + pa_register_look_aside (raw_regs, regnum, ®_val[0]); - if(!is_pa_2) { - fprintf_unfiltered (stream, "%s %x", REGISTER_NAME (regnum), reg_val[1]); - } - else { - /* Fancy % formats to prevent leading zeros. */ - if(reg_val[0] == 0) - fprintf_unfiltered(stream, "%s %x", REGISTER_NAME (regnum), - reg_val[1]); + if (!is_pa_2) + { + fprintf_unfiltered (stream, "%s %x", REGISTER_NAME (regnum), reg_val[1]); + } else - fprintf_unfiltered(stream, "%s %x%8.8x", REGISTER_NAME (regnum), - reg_val[0], reg_val[1]); + { + /* Fancy % formats to prevent leading zeros. */ + if (reg_val[0] == 0) + fprintf_unfiltered (stream, "%s %x", REGISTER_NAME (regnum), + reg_val[1]); + else + fprintf_unfiltered (stream, "%s %x%8.8x", REGISTER_NAME (regnum), + reg_val[0], reg_val[1]); + } } - } else - /* Note that real floating point values only start at - FP4_REGNUM. FP0 and up are just status and error - registers, which have integral (bit) values. */ + /* Note that real floating point values only start at + FP4_REGNUM. FP0 and up are just status and error + registers, which have integral (bit) values. */ pa_strcat_fp_reg (regnum, stream, precision); } @@ -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; |