diff options
| -rw-r--r-- | gdb/ChangeLog | 24 | ||||
| -rw-r--r-- | gdb/hppa-hpux-tdep.c | 522 | ||||
| -rw-r--r-- | gdb/hppa-tdep.c | 625 | ||||
| -rw-r--r-- | gdb/hppa-tdep.h | 12 |
4 files changed, 604 insertions, 579 deletions
diff --git a/gdb/ChangeLog b/gdb/ChangeLog index 03c4ebdc4d0..786b4fe9146 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,5 +1,29 @@ 2004-04-22 Randolph Chung <tausq@debian.org> + * hppa-tdep.h (find_unwind_entry, hppa_get_field, hppa_extract_5_load) + (hppa_extract_5R_store, hppa_extract_5r_store, hppa_extract_17) + (hppa_extract_21, hppa_extract_14, hppa_low_sign_extend) + (hppa_sign_extend): Add prototype. + * hppa-tdep.c (get_field, extract_5_load, extract_5R_store) + (extract_5r_store, extract_17, extract_21, extract_14, low_sign_extend) + (sign_extend): Rename with hppa_ prefix and make non-static. Other + hppa targets will also use these functions. + (find_unwind_entry): Remove prototype (moved to hppa-tdep.h). + (hppa_in_solib_call_trampoline, hppa_in_solib_return_trampoline) + (hppa_skip_trampoline_code): Move to hppa-hpux-tdep.c + (hppa_gdbarch_init): Remove gdbarch setting of + skip_trampoline_code, in_solib_call_trampoline and + in_solib_return_trampoline. + * hppa-hpux-tdep.c (hppa32_hpux_in_solib_call_trampoline) + (hppa64_hpux_in_solib_call_trampoline): New functions, split from + hppa_in_solib_call_trampoline. + (hppa_hpux_in_solib_return_trampoline, hppa_hpux_skip_trampoline_code): + Moved from hppa-tdep.c. + (hppa_hpux_init_abi): Set gdbarch for skip_trampoline_code, + in_solib_call_trampoline and in_solib_return_trampoline. + +2004-04-22 Randolph Chung <tausq@debian.org> + * hppa-tdep.c (hppa_debug): New variable. (find_unwind_entry, hppa_frame_cache): Add debug output. (_initialize_hppa_tdep): Add command to set debug flag. diff --git a/gdb/hppa-hpux-tdep.c b/gdb/hppa-hpux-tdep.c index cf5fccbb818..a047d42859e 100644 --- a/gdb/hppa-hpux-tdep.c +++ b/gdb/hppa-hpux-tdep.c @@ -164,6 +164,515 @@ hppa64_hpux_frame_find_saved_regs_in_sigtramp (struct frame_info *fi, } } +/* Return one if PC is in the call path of a trampoline, else return zero. + + Note we return one for *any* call trampoline (long-call, arg-reloc), not + just shared library trampolines (import, export). */ + +static int +hppa32_hpux_in_solib_call_trampoline (CORE_ADDR pc, char *name) +{ + struct minimal_symbol *minsym; + struct unwind_table_entry *u; + static CORE_ADDR dyncall = 0; + static CORE_ADDR sr4export = 0; + + /* FIXME XXX - dyncall and sr4export must be initialized whenever we get a + new exec file */ + + /* First see if PC is in one of the two C-library trampolines. */ + if (!dyncall) + { + minsym = lookup_minimal_symbol ("$$dyncall", NULL, NULL); + if (minsym) + dyncall = SYMBOL_VALUE_ADDRESS (minsym); + else + dyncall = -1; + } + + if (!sr4export) + { + minsym = lookup_minimal_symbol ("_sr4export", NULL, NULL); + if (minsym) + sr4export = SYMBOL_VALUE_ADDRESS (minsym); + else + sr4export = -1; + } + + if (pc == dyncall || pc == sr4export) + return 1; + + minsym = lookup_minimal_symbol_by_pc (pc); + if (minsym && strcmp (DEPRECATED_SYMBOL_NAME (minsym), ".stub") == 0) + return 1; + + /* Get the unwind descriptor corresponding to PC, return zero + if no unwind was found. */ + u = find_unwind_entry (pc); + if (!u) + return 0; + + /* If this isn't a linker stub, then return now. */ + if (u->stub_unwind.stub_type == 0) + return 0; + + /* By definition a long-branch stub is a call stub. */ + if (u->stub_unwind.stub_type == LONG_BRANCH) + return 1; + + /* The call and return path execute the same instructions within + an IMPORT stub! So an IMPORT stub is both a call and return + trampoline. */ + if (u->stub_unwind.stub_type == IMPORT) + return 1; + + /* Parameter relocation stubs always have a call path and may have a + return path. */ + if (u->stub_unwind.stub_type == PARAMETER_RELOCATION + || u->stub_unwind.stub_type == EXPORT) + { + CORE_ADDR addr; + + /* Search forward from the current PC until we hit a branch + or the end of the stub. */ + for (addr = pc; addr <= u->region_end; addr += 4) + { + unsigned long insn; + + insn = read_memory_integer (addr, 4); + + /* Does it look like a bl? If so then it's the call path, if + we find a bv or be first, then we're on the return path. */ + if ((insn & 0xfc00e000) == 0xe8000000) + return 1; + else if ((insn & 0xfc00e001) == 0xe800c000 + || (insn & 0xfc000000) == 0xe0000000) + return 0; + } + + /* Should never happen. */ + warning ("Unable to find branch in parameter relocation stub.\n"); + return 0; + } + + /* Unknown stub type. For now, just return zero. */ + return 0; +} + +static int +hppa64_hpux_in_solib_call_trampoline (CORE_ADDR pc, char *name) +{ + /* PA64 has a completely different stub/trampoline scheme. Is it + better? Maybe. It's certainly harder to determine with any + certainty that we are in a stub because we can not refer to the + unwinders to help. + + The heuristic is simple. Try to lookup the current PC value in th + minimal symbol table. If that fails, then assume we are not in a + stub and return. + + Then see if the PC value falls within the section bounds for the + section containing the minimal symbol we found in the first + step. If it does, then assume we are not in a stub and return. + + Finally peek at the instructions to see if they look like a stub. */ + struct minimal_symbol *minsym; + asection *sec; + CORE_ADDR addr; + int insn, i; + + minsym = lookup_minimal_symbol_by_pc (pc); + if (! minsym) + return 0; + + sec = SYMBOL_BFD_SECTION (minsym); + + if (bfd_get_section_vma (sec->owner, sec) <= pc + && pc < (bfd_get_section_vma (sec->owner, sec) + + bfd_section_size (sec->owner, sec))) + return 0; + + /* We might be in a stub. Peek at the instructions. Stubs are 3 + instructions long. */ + insn = read_memory_integer (pc, 4); + + /* Find out where we think we are within the stub. */ + if ((insn & 0xffffc00e) == 0x53610000) + addr = pc; + else if ((insn & 0xffffffff) == 0xe820d000) + addr = pc - 4; + else if ((insn & 0xffffc00e) == 0x537b0000) + addr = pc - 8; + else + return 0; + + /* Now verify each insn in the range looks like a stub instruction. */ + insn = read_memory_integer (addr, 4); + if ((insn & 0xffffc00e) != 0x53610000) + return 0; + + /* Now verify each insn in the range looks like a stub instruction. */ + insn = read_memory_integer (addr + 4, 4); + if ((insn & 0xffffffff) != 0xe820d000) + return 0; + + /* Now verify each insn in the range looks like a stub instruction. */ + insn = read_memory_integer (addr + 8, 4); + if ((insn & 0xffffc00e) != 0x537b0000) + return 0; + + /* Looks like a stub. */ + return 1; +} + +/* Return one if PC is in the return path of a trampoline, else return zero. + + Note we return one for *any* call trampoline (long-call, arg-reloc), not + just shared library trampolines (import, export). */ + +static int +hppa_hpux_in_solib_return_trampoline (CORE_ADDR pc, char *name) +{ + struct unwind_table_entry *u; + + /* Get the unwind descriptor corresponding to PC, return zero + if no unwind was found. */ + u = find_unwind_entry (pc); + if (!u) + return 0; + + /* If this isn't a linker stub or it's just a long branch stub, then + return zero. */ + if (u->stub_unwind.stub_type == 0 || u->stub_unwind.stub_type == LONG_BRANCH) + return 0; + + /* The call and return path execute the same instructions within + an IMPORT stub! So an IMPORT stub is both a call and return + trampoline. */ + if (u->stub_unwind.stub_type == IMPORT) + return 1; + + /* Parameter relocation stubs always have a call path and may have a + return path. */ + if (u->stub_unwind.stub_type == PARAMETER_RELOCATION + || u->stub_unwind.stub_type == EXPORT) + { + CORE_ADDR addr; + + /* Search forward from the current PC until we hit a branch + or the end of the stub. */ + for (addr = pc; addr <= u->region_end; addr += 4) + { + unsigned long insn; + + insn = read_memory_integer (addr, 4); + + /* Does it look like a bl? If so then it's the call path, if + we find a bv or be first, then we're on the return path. */ + if ((insn & 0xfc00e000) == 0xe8000000) + return 0; + else if ((insn & 0xfc00e001) == 0xe800c000 + || (insn & 0xfc000000) == 0xe0000000) + return 1; + } + + /* Should never happen. */ + warning ("Unable to find branch in parameter relocation stub.\n"); + return 0; + } + + /* Unknown stub type. For now, just return zero. */ + return 0; + +} + +/* Figure out if PC is in a trampoline, and if so find out where + the trampoline will jump to. If not in a trampoline, return zero. + + Simple code examination probably is not a good idea since the code + sequences in trampolines can also appear in user code. + + We use unwinds and information from the minimal symbol table to + determine when we're in a trampoline. This won't work for ELF + (yet) since it doesn't create stub unwind entries. Whether or + not ELF will create stub unwinds or normal unwinds for linker + stubs is still being debated. + + This should handle simple calls through dyncall or sr4export, + long calls, argument relocation stubs, and dyncall/sr4export + calling an argument relocation stub. It even handles some stubs + used in dynamic executables. */ + +static CORE_ADDR +hppa_hpux_skip_trampoline_code (CORE_ADDR pc) +{ + long orig_pc = pc; + long prev_inst, curr_inst, loc; + static CORE_ADDR dyncall = 0; + static CORE_ADDR dyncall_external = 0; + static CORE_ADDR sr4export = 0; + struct minimal_symbol *msym; + struct unwind_table_entry *u; + + /* FIXME XXX - dyncall and sr4export must be initialized whenever we get a + new exec file */ + + if (!dyncall) + { + msym = lookup_minimal_symbol ("$$dyncall", NULL, NULL); + if (msym) + dyncall = SYMBOL_VALUE_ADDRESS (msym); + else + dyncall = -1; + } + + if (!dyncall_external) + { + msym = lookup_minimal_symbol ("$$dyncall_external", NULL, NULL); + if (msym) + dyncall_external = SYMBOL_VALUE_ADDRESS (msym); + else + dyncall_external = -1; + } + + if (!sr4export) + { + msym = lookup_minimal_symbol ("_sr4export", NULL, NULL); + if (msym) + sr4export = SYMBOL_VALUE_ADDRESS (msym); + else + sr4export = -1; + } + + /* Addresses passed to dyncall may *NOT* be the actual address + of the function. So we may have to do something special. */ + if (pc == dyncall) + { + 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. */ + if (pc & 0x2) + pc = (CORE_ADDR) read_memory_integer (pc & ~0x3, TARGET_PTR_BIT / 8); + } + if (pc == dyncall_external) + { + pc = (CORE_ADDR) read_register (22); + pc = (CORE_ADDR) read_memory_integer (pc & ~0x3, TARGET_PTR_BIT / 8); + } + else if (pc == sr4export) + pc = (CORE_ADDR) (read_register (22)); + + /* Get the unwind descriptor corresponding to PC, return zero + if no unwind was found. */ + u = find_unwind_entry (pc); + if (!u) + return 0; + + /* If this isn't a linker stub, then return now. */ + /* elz: attention here! (FIXME) because of a compiler/linker + error, some stubs which should have a non zero stub_unwind.stub_type + have unfortunately a value of zero. So this function would return here + as if we were not in a trampoline. To fix this, we go look at the partial + symbol information, which reports this guy as a stub. + (FIXME): Unfortunately, we are not that lucky: it turns out that the + partial symbol information is also wrong sometimes. This is because + when it is entered (somread.c::som_symtab_read()) it can happen that + if the type of the symbol (from the som) is Entry, and the symbol is + in a shared library, then it can also be a trampoline. This would + be OK, except that I believe the way they decide if we are ina shared library + does not work. SOOOO..., even if we have a regular function w/o trampolines + 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. */ + 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); + + 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 + && DEPRECATED_STREQ (DEPRECATED_SYMBOL_NAME (msymbol), DEPRECATED_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. + Most (all?) other branches can be determined by examining the contents + of certain registers and the stack. */ + + loc = pc; + curr_inst = 0; + prev_inst = 0; + while (1) + { + /* Make sure we haven't walked outside the range of this stub. */ + if (u != find_unwind_entry (loc)) + { + warning ("Unable to find branch in linker stub"); + return orig_pc == pc ? 0 : pc & ~0x3; + } + + prev_inst = curr_inst; + 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. */ + if ((curr_inst & 0xffe0e000) == 0xe0202000) + { + /* Yup. See if the previous instruction loaded + a value into %r1. If so compute and return the jump address. */ + if ((prev_inst & 0xffe00000) == 0x20200000) + return (hppa_extract_21 (prev_inst) + hppa_extract_17 (curr_inst)) & ~0x3; + else + { + warning ("Unable to find ldil X,%%r1 before ble Y(%%sr4,%%r1)."); + return orig_pc == pc ? 0 : pc & ~0x3; + } + } + + /* Does it look like a be 0(sr0,%r21)? OR + Does it look like a be, n 0(sr0,%r21)? OR + 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. + + 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. + + 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. */ + if ((curr_inst == 0xe2a00000) || + (curr_inst == 0xe2a00002) || + (curr_inst == 0xeaa0d000) || + (curr_inst == 0xeaa0d002)) + { + struct minimal_symbol *stubsym, *libsym; + + stubsym = lookup_minimal_symbol_by_pc (loc); + if (stubsym == NULL) + { + warning ("Unable to find symbol for 0x%lx", loc); + return orig_pc == pc ? 0 : pc & ~0x3; + } + + libsym = lookup_minimal_symbol (DEPRECATED_SYMBOL_NAME (stubsym), NULL, NULL); + if (libsym == NULL) + { + warning ("Unable to find library symbol for %s\n", + DEPRECATED_SYMBOL_NAME (stubsym)); + return orig_pc == pc ? 0 : pc & ~0x3; + } + + return SYMBOL_VALUE (libsym); + } + + /* Does it look like bl X,%rp or bl X,%r0? Another way to do a + branch from the stub to the actual function. */ + /*elz */ + else if ((curr_inst & 0xffe0e000) == 0xe8400000 + || (curr_inst & 0xffe0e000) == 0xe8000000 + || (curr_inst & 0xffe0e000) == 0xe800A000) + return (loc + hppa_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) */ + else if ((curr_inst & 0xffe0f000) == 0xe840c000) + { + /* Yup. See if the previous instruction loaded + rp from sp - 8. */ + if (prev_inst == 0x4bc23ff1) + return (read_memory_integer + (read_register (HPPA_SP_REGNUM) - 8, 4)) & ~0x3; + else + { + warning ("Unable to find restore of %%rp before bv (%%rp)."); + return orig_pc == pc ? 0 : pc & ~0x3; + } + } + + /* elz: added this case to capture the new instruction + at the end of the return part of an export stub used by + the PA2.0: BVE, n (rp) */ + else if ((curr_inst & 0xffe0f000) == 0xe840d000) + { + return (read_memory_integer + (read_register (HPPA_SP_REGNUM) - 24, TARGET_PTR_BIT / 8)) & ~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. */ + 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 + (read_register (HPPA_SP_REGNUM) - 24, TARGET_PTR_BIT / 8)) & ~0x3; + } + + /* Haven't found the branch yet, but we're still in the stub. + Keep looking. */ + loc += 4; + } +} + + /* Exception handling support for the HP-UX ANSI C++ compiler. The compiler (aCC) provides a callback for exception events; GDB can set a breakpoint on this callback and find out what @@ -716,7 +1225,20 @@ child_get_current_exception_event (void) static void hppa_hpux_init_abi (struct gdbarch_info info, struct gdbarch *gdbarch) { + struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch); + set_gdbarch_deprecated_pc_in_sigtramp (gdbarch, hppa_hpux_pc_in_sigtramp); + + if (tdep->bytes_per_address == 4) + set_gdbarch_in_solib_call_trampoline (gdbarch, + hppa32_hpux_in_solib_call_trampoline); + else + set_gdbarch_in_solib_call_trampoline (gdbarch, + hppa64_hpux_in_solib_call_trampoline); + + set_gdbarch_in_solib_return_trampoline (gdbarch, + hppa_hpux_in_solib_return_trampoline); + set_gdbarch_skip_trampoline_code (gdbarch, hppa_hpux_skip_trampoline_code); } static void diff --git a/gdb/hppa-tdep.c b/gdb/hppa-tdep.c index 26b73dc551c..1ac25c84187 100644 --- a/gdb/hppa-tdep.c +++ b/gdb/hppa-tdep.c @@ -88,28 +88,8 @@ const struct objfile_data *hppa_objfile_priv_data = NULL; #define UNWIND_ENTRY_SIZE 16 #define STUB_UNWIND_ENTRY_SIZE 8 -static int get_field (unsigned word, int from, int to); - -static int extract_5_load (unsigned int); - -static unsigned extract_5R_store (unsigned int); - -static unsigned extract_5r_store (unsigned int); - -struct unwind_table_entry *find_unwind_entry (CORE_ADDR); - -static int extract_17 (unsigned int); - -static int extract_21 (unsigned); - -static int extract_14 (unsigned); - static void unwind_command (char *, int); -static int low_sign_extend (unsigned int, unsigned int); - -static int sign_extend (unsigned int, unsigned int); - static int hppa_alignof (struct type *); static int prologue_inst_adjust_sp (unsigned long); @@ -246,16 +226,16 @@ hppa64_return_value (struct gdbarch *gdbarch, /* This assumes that no garbage lies outside of the lower bits of value. */ -static int -sign_extend (unsigned val, unsigned bits) +int +hppa_sign_extend (unsigned val, unsigned bits) { return (int) (val >> (bits - 1) ? (-1 << bits) | val : val); } /* For many immediate values the sign bit is the low bit! */ -static int -low_sign_extend (unsigned val, unsigned bits) +int +hppa_low_hppa_sign_extend (unsigned val, unsigned bits) { return (int) ((val & 0x1 ? (-1 << (bits - 1)) : 0) | val >> 1); } @@ -263,74 +243,74 @@ low_sign_extend (unsigned val, unsigned bits) /* Extract the bits at positions between FROM and TO, using HP's numbering (MSB = 0). */ -static int -get_field (unsigned word, int from, int to) +int +hppa_get_field (unsigned word, int from, int to) { return ((word) >> (31 - (to)) & ((1 << ((to) - (from) + 1)) - 1)); } /* extract the immediate field from a ld{bhw}s instruction */ -static int -extract_5_load (unsigned word) +int +hppa_extract_5_load (unsigned word) { - return low_sign_extend (word >> 16 & MASK_5, 5); + return hppa_low_hppa_sign_extend (word >> 16 & MASK_5, 5); } /* extract the immediate field from a break instruction */ -static unsigned -extract_5r_store (unsigned word) +unsigned +hppa_extract_5r_store (unsigned word) { return (word & MASK_5); } /* extract the immediate field from a {sr}sm instruction */ -static unsigned -extract_5R_store (unsigned word) +unsigned +hppa_extract_5R_store (unsigned word) { return (word >> 16 & MASK_5); } /* extract a 14 bit immediate field */ -static int -extract_14 (unsigned word) +int +hppa_extract_14 (unsigned word) { - return low_sign_extend (word & MASK_14, 14); + return hppa_low_hppa_sign_extend (word & MASK_14, 14); } /* extract a 21 bit constant */ -static int -extract_21 (unsigned word) +int +hppa_extract_21 (unsigned word) { int val; word &= MASK_21; word <<= 11; - val = get_field (word, 20, 20); + val = hppa_get_field (word, 20, 20); val <<= 11; - val |= get_field (word, 9, 19); + val |= hppa_get_field (word, 9, 19); val <<= 2; - val |= get_field (word, 5, 6); + val |= hppa_get_field (word, 5, 6); val <<= 5; - val |= get_field (word, 0, 4); + val |= hppa_get_field (word, 0, 4); val <<= 2; - val |= get_field (word, 7, 8); - return sign_extend (val, 21) << 11; + val |= hppa_get_field (word, 7, 8); + return hppa_sign_extend (val, 21) << 11; } /* extract a 17 bit constant from branch instructions, returning the 19 bit signed value. */ -static int -extract_17 (unsigned word) +int +hppa_extract_17 (unsigned word) { - return sign_extend (get_field (word, 19, 28) | - get_field (word, 29, 29) << 10 | - get_field (word, 11, 15) << 11 | + return hppa_sign_extend (hppa_get_field (word, 19, 28) | + hppa_get_field (word, 29, 29) << 10 | + hppa_get_field (word, 11, 15) << 11 | (word & 0x1) << 16, 17) << 2; } @@ -1099,515 +1079,6 @@ hppa_alignof (struct type *type) } } -/* Return one if PC is in the call path of a trampoline, else return zero. - - Note we return one for *any* call trampoline (long-call, arg-reloc), not - just shared library trampolines (import, export). */ - -static int -hppa_in_solib_call_trampoline (CORE_ADDR pc, char *name) -{ - struct minimal_symbol *minsym; - struct unwind_table_entry *u; - static CORE_ADDR dyncall = 0; - static CORE_ADDR sr4export = 0; - -#ifdef GDB_TARGET_IS_HPPA_20W - /* PA64 has a completely different stub/trampoline scheme. Is it - better? Maybe. It's certainly harder to determine with any - certainty that we are in a stub because we can not refer to the - unwinders to help. - - The heuristic is simple. Try to lookup the current PC value in th - minimal symbol table. If that fails, then assume we are not in a - stub and return. - - Then see if the PC value falls within the section bounds for the - section containing the minimal symbol we found in the first - step. If it does, then assume we are not in a stub and return. - - Finally peek at the instructions to see if they look like a stub. */ - { - struct minimal_symbol *minsym; - asection *sec; - CORE_ADDR addr; - int insn, i; - - minsym = lookup_minimal_symbol_by_pc (pc); - if (! minsym) - return 0; - - sec = SYMBOL_BFD_SECTION (minsym); - - if (bfd_get_section_vma (sec->owner, sec) <= pc - && pc < (bfd_get_section_vma (sec->owner, sec) - + bfd_section_size (sec->owner, sec))) - return 0; - - /* We might be in a stub. Peek at the instructions. Stubs are 3 - instructions long. */ - insn = read_memory_integer (pc, 4); - - /* Find out where we think we are within the stub. */ - if ((insn & 0xffffc00e) == 0x53610000) - addr = pc; - else if ((insn & 0xffffffff) == 0xe820d000) - addr = pc - 4; - else if ((insn & 0xffffc00e) == 0x537b0000) - addr = pc - 8; - else - return 0; - - /* Now verify each insn in the range looks like a stub instruction. */ - insn = read_memory_integer (addr, 4); - if ((insn & 0xffffc00e) != 0x53610000) - return 0; - - /* Now verify each insn in the range looks like a stub instruction. */ - insn = read_memory_integer (addr + 4, 4); - if ((insn & 0xffffffff) != 0xe820d000) - return 0; - - /* Now verify each insn in the range looks like a stub instruction. */ - insn = read_memory_integer (addr + 8, 4); - if ((insn & 0xffffc00e) != 0x537b0000) - return 0; - - /* Looks like a stub. */ - return 1; - } -#endif - - /* FIXME XXX - dyncall and sr4export must be initialized whenever we get a - new exec file */ - - /* First see if PC is in one of the two C-library trampolines. */ - if (!dyncall) - { - minsym = lookup_minimal_symbol ("$$dyncall", NULL, NULL); - if (minsym) - dyncall = SYMBOL_VALUE_ADDRESS (minsym); - else - dyncall = -1; - } - - if (!sr4export) - { - minsym = lookup_minimal_symbol ("_sr4export", NULL, NULL); - if (minsym) - sr4export = SYMBOL_VALUE_ADDRESS (minsym); - else - sr4export = -1; - } - - if (pc == dyncall || pc == sr4export) - return 1; - - minsym = lookup_minimal_symbol_by_pc (pc); - if (minsym && strcmp (DEPRECATED_SYMBOL_NAME (minsym), ".stub") == 0) - return 1; - - /* Get the unwind descriptor corresponding to PC, return zero - if no unwind was found. */ - u = find_unwind_entry (pc); - if (!u) - return 0; - - /* If this isn't a linker stub, then return now. */ - if (u->stub_unwind.stub_type == 0) - return 0; - - /* By definition a long-branch stub is a call stub. */ - if (u->stub_unwind.stub_type == LONG_BRANCH) - return 1; - - /* The call and return path execute the same instructions within - an IMPORT stub! So an IMPORT stub is both a call and return - trampoline. */ - if (u->stub_unwind.stub_type == IMPORT) - return 1; - - /* Parameter relocation stubs always have a call path and may have a - return path. */ - if (u->stub_unwind.stub_type == PARAMETER_RELOCATION - || u->stub_unwind.stub_type == EXPORT) - { - CORE_ADDR addr; - - /* Search forward from the current PC until we hit a branch - or the end of the stub. */ - for (addr = pc; addr <= u->region_end; addr += 4) - { - unsigned long insn; - - insn = read_memory_integer (addr, 4); - - /* Does it look like a bl? If so then it's the call path, if - we find a bv or be first, then we're on the return path. */ - if ((insn & 0xfc00e000) == 0xe8000000) - return 1; - else if ((insn & 0xfc00e001) == 0xe800c000 - || (insn & 0xfc000000) == 0xe0000000) - return 0; - } - - /* Should never happen. */ - warning ("Unable to find branch in parameter relocation stub.\n"); - return 0; - } - - /* Unknown stub type. For now, just return zero. */ - return 0; -} - -/* Return one if PC is in the return path of a trampoline, else return zero. - - Note we return one for *any* call trampoline (long-call, arg-reloc), not - just shared library trampolines (import, export). */ - -static int -hppa_in_solib_return_trampoline (CORE_ADDR pc, char *name) -{ - struct unwind_table_entry *u; - - /* Get the unwind descriptor corresponding to PC, return zero - if no unwind was found. */ - u = find_unwind_entry (pc); - if (!u) - return 0; - - /* If this isn't a linker stub or it's just a long branch stub, then - return zero. */ - if (u->stub_unwind.stub_type == 0 || u->stub_unwind.stub_type == LONG_BRANCH) - return 0; - - /* The call and return path execute the same instructions within - an IMPORT stub! So an IMPORT stub is both a call and return - trampoline. */ - if (u->stub_unwind.stub_type == IMPORT) - return 1; - - /* Parameter relocation stubs always have a call path and may have a - return path. */ - if (u->stub_unwind.stub_type == PARAMETER_RELOCATION - || u->stub_unwind.stub_type == EXPORT) - { - CORE_ADDR addr; - - /* Search forward from the current PC until we hit a branch - or the end of the stub. */ - for (addr = pc; addr <= u->region_end; addr += 4) - { - unsigned long insn; - - insn = read_memory_integer (addr, 4); - - /* Does it look like a bl? If so then it's the call path, if - we find a bv or be first, then we're on the return path. */ - if ((insn & 0xfc00e000) == 0xe8000000) - return 0; - else if ((insn & 0xfc00e001) == 0xe800c000 - || (insn & 0xfc000000) == 0xe0000000) - return 1; - } - - /* Should never happen. */ - warning ("Unable to find branch in parameter relocation stub.\n"); - return 0; - } - - /* Unknown stub type. For now, just return zero. */ - return 0; - -} - -/* Figure out if PC is in a trampoline, and if so find out where - the trampoline will jump to. If not in a trampoline, return zero. - - Simple code examination probably is not a good idea since the code - sequences in trampolines can also appear in user code. - - We use unwinds and information from the minimal symbol table to - determine when we're in a trampoline. This won't work for ELF - (yet) since it doesn't create stub unwind entries. Whether or - not ELF will create stub unwinds or normal unwinds for linker - stubs is still being debated. - - This should handle simple calls through dyncall or sr4export, - long calls, argument relocation stubs, and dyncall/sr4export - calling an argument relocation stub. It even handles some stubs - used in dynamic executables. */ - -static CORE_ADDR -hppa_skip_trampoline_code (CORE_ADDR pc) -{ - long orig_pc = pc; - long prev_inst, curr_inst, loc; - static CORE_ADDR dyncall = 0; - static CORE_ADDR dyncall_external = 0; - static CORE_ADDR sr4export = 0; - struct minimal_symbol *msym; - struct unwind_table_entry *u; - - /* FIXME XXX - dyncall and sr4export must be initialized whenever we get a - new exec file */ - - if (!dyncall) - { - msym = lookup_minimal_symbol ("$$dyncall", NULL, NULL); - if (msym) - dyncall = SYMBOL_VALUE_ADDRESS (msym); - else - dyncall = -1; - } - - if (!dyncall_external) - { - msym = lookup_minimal_symbol ("$$dyncall_external", NULL, NULL); - if (msym) - dyncall_external = SYMBOL_VALUE_ADDRESS (msym); - else - dyncall_external = -1; - } - - if (!sr4export) - { - msym = lookup_minimal_symbol ("_sr4export", NULL, NULL); - if (msym) - sr4export = SYMBOL_VALUE_ADDRESS (msym); - else - sr4export = -1; - } - - /* Addresses passed to dyncall may *NOT* be the actual address - of the function. So we may have to do something special. */ - if (pc == dyncall) - { - 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. */ - if (pc & 0x2) - pc = (CORE_ADDR) read_memory_integer (pc & ~0x3, TARGET_PTR_BIT / 8); - } - if (pc == dyncall_external) - { - pc = (CORE_ADDR) read_register (22); - pc = (CORE_ADDR) read_memory_integer (pc & ~0x3, TARGET_PTR_BIT / 8); - } - else if (pc == sr4export) - pc = (CORE_ADDR) (read_register (22)); - - /* Get the unwind descriptor corresponding to PC, return zero - if no unwind was found. */ - u = find_unwind_entry (pc); - if (!u) - return 0; - - /* If this isn't a linker stub, then return now. */ - /* elz: attention here! (FIXME) because of a compiler/linker - error, some stubs which should have a non zero stub_unwind.stub_type - have unfortunately a value of zero. So this function would return here - as if we were not in a trampoline. To fix this, we go look at the partial - symbol information, which reports this guy as a stub. - (FIXME): Unfortunately, we are not that lucky: it turns out that the - partial symbol information is also wrong sometimes. This is because - when it is entered (somread.c::som_symtab_read()) it can happen that - if the type of the symbol (from the som) is Entry, and the symbol is - in a shared library, then it can also be a trampoline. This would - be OK, except that I believe the way they decide if we are ina shared library - does not work. SOOOO..., even if we have a regular function w/o trampolines - 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. */ - 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); - - 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 - && DEPRECATED_STREQ (DEPRECATED_SYMBOL_NAME (msymbol), DEPRECATED_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. - Most (all?) other branches can be determined by examining the contents - of certain registers and the stack. */ - - loc = pc; - curr_inst = 0; - prev_inst = 0; - while (1) - { - /* Make sure we haven't walked outside the range of this stub. */ - if (u != find_unwind_entry (loc)) - { - warning ("Unable to find branch in linker stub"); - return orig_pc == pc ? 0 : pc & ~0x3; - } - - prev_inst = curr_inst; - 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. */ - if ((curr_inst & 0xffe0e000) == 0xe0202000) - { - /* Yup. See if the previous instruction loaded - a value into %r1. If so compute and return the jump address. */ - if ((prev_inst & 0xffe00000) == 0x20200000) - return (extract_21 (prev_inst) + extract_17 (curr_inst)) & ~0x3; - else - { - warning ("Unable to find ldil X,%%r1 before ble Y(%%sr4,%%r1)."); - return orig_pc == pc ? 0 : pc & ~0x3; - } - } - - /* Does it look like a be 0(sr0,%r21)? OR - Does it look like a be, n 0(sr0,%r21)? OR - 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. - - 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. - - 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. */ - if ((curr_inst == 0xe2a00000) || - (curr_inst == 0xe2a00002) || - (curr_inst == 0xeaa0d000) || - (curr_inst == 0xeaa0d002)) - { - struct minimal_symbol *stubsym, *libsym; - - stubsym = lookup_minimal_symbol_by_pc (loc); - if (stubsym == NULL) - { - warning ("Unable to find symbol for 0x%lx", loc); - return orig_pc == pc ? 0 : pc & ~0x3; - } - - libsym = lookup_minimal_symbol (DEPRECATED_SYMBOL_NAME (stubsym), NULL, NULL); - if (libsym == NULL) - { - warning ("Unable to find library symbol for %s\n", - DEPRECATED_SYMBOL_NAME (stubsym)); - return orig_pc == pc ? 0 : pc & ~0x3; - } - - return SYMBOL_VALUE (libsym); - } - - /* Does it look like bl X,%rp or bl X,%r0? Another way to do a - branch from the stub to the actual function. */ - /*elz */ - else if ((curr_inst & 0xffe0e000) == 0xe8400000 - || (curr_inst & 0xffe0e000) == 0xe8000000 - || (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) */ - else if ((curr_inst & 0xffe0f000) == 0xe840c000) - { - /* Yup. See if the previous instruction loaded - rp from sp - 8. */ - if (prev_inst == 0x4bc23ff1) - return (read_memory_integer - (read_register (HPPA_SP_REGNUM) - 8, 4)) & ~0x3; - else - { - warning ("Unable to find restore of %%rp before bv (%%rp)."); - return orig_pc == pc ? 0 : pc & ~0x3; - } - } - - /* elz: added this case to capture the new instruction - at the end of the return part of an export stub used by - the PA2.0: BVE, n (rp) */ - else if ((curr_inst & 0xffe0f000) == 0xe840d000) - { - return (read_memory_integer - (read_register (HPPA_SP_REGNUM) - 24, TARGET_PTR_BIT / 8)) & ~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. */ - 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 - (read_register (HPPA_SP_REGNUM) - 24, TARGET_PTR_BIT / 8)) & ~0x3; - } - - /* Haven't found the branch yet, but we're still in the stub. - Keep looking. */ - loc += 4; - } -} - - /* For the given instruction (INST), return any adjustment it makes to the stack pointer or zero for no adjustment. @@ -1621,11 +1092,11 @@ prologue_inst_adjust_sp (unsigned long inst) /* The most common way to perform a stack adjustment ldo X(sp),sp */ if ((inst & 0xffffc000) == 0x37de0000) - return extract_14 (inst); + return hppa_extract_14 (inst); /* stwm X,D(sp) */ if ((inst & 0xffe00000) == 0x6fc00000) - return extract_14 (inst); + return hppa_extract_14 (inst); /* std,ma X,D(sp) */ if ((inst & 0xffe00008) == 0x73c00008) @@ -1635,16 +1106,16 @@ prologue_inst_adjust_sp (unsigned long inst) save high bits in save_high21 for later use. */ if ((inst & 0xffe00000) == 0x28200000) { - save_high21 = extract_21 (inst); + save_high21 = hppa_extract_21 (inst); return 0; } if ((inst & 0xffff0000) == 0x343e0000) - return save_high21 + extract_14 (inst); + return save_high21 + hppa_extract_14 (inst); /* fstws as used by the HP compilers. */ if ((inst & 0xffffffe0) == 0x2fd01220) - return extract_5_load (inst); + return hppa_extract_5_load (inst); /* No adjustment. */ return 0; @@ -1693,17 +1164,17 @@ inst_saves_gr (unsigned long inst) || (inst >> 26) == 0x1f || ((inst >> 26) == 0x1f && ((inst >> 6) == 0xa))) - return extract_5R_store (inst); + return hppa_extract_5R_store (inst); /* Does it look like a std? */ if ((inst >> 26) == 0x1c || ((inst >> 26) == 0x03 && ((inst >> 6) & 0xf) == 0xb)) - return extract_5R_store (inst); + return hppa_extract_5R_store (inst); /* Does it look like a stwm? GCC & HPC may use this in prologues. */ if ((inst >> 26) == 0x1b) - return extract_5R_store (inst); + return hppa_extract_5R_store (inst); /* Does it look like sth or stb? HPC versions 9.0 and later use these too. */ @@ -1711,7 +1182,7 @@ inst_saves_gr (unsigned long inst) || ((inst >> 26) == 0x3 && (((inst >> 6) & 0xf) == 0x8 || (inst >> 6) & 0xf) == 0x9)) - return extract_5R_store (inst); + return hppa_extract_5R_store (inst); return 0; } @@ -1729,14 +1200,14 @@ inst_saves_fr (unsigned long inst) { /* is this an FSTD ? */ if ((inst & 0xfc00dfc0) == 0x2c001200) - return extract_5r_store (inst); + return hppa_extract_5r_store (inst); if ((inst & 0xfc000002) == 0x70000002) - return extract_5R_store (inst); + return hppa_extract_5R_store (inst); /* is this an FSTW ? */ if ((inst & 0xfc00df80) == 0x24001200) - return extract_5r_store (inst); + return hppa_extract_5r_store (inst); if ((inst & 0xfc000002) == 0x7c000000) - return extract_5R_store (inst); + return hppa_extract_5R_store (inst); return 0; } @@ -2172,7 +1643,7 @@ hppa_frame_cache (struct frame_info *next_frame, void **this_cache) && (!u->Save_SP || reg != HPPA_FP_REGNUM)) { saved_gr_mask &= ~(1 << reg); - if ((inst >> 26) == 0x1b && extract_14 (inst) >= 0) + if ((inst >> 26) == 0x1b && hppa_extract_14 (inst) >= 0) /* stwm with a positive displacement is a _post_ _modify_. */ cache->saved_regs[reg].addr = 0; @@ -2186,9 +1657,9 @@ hppa_frame_cache (struct frame_info *next_frame, void **this_cache) if ((inst >> 26) == 0x1c) offset = (inst & 0x1 ? -1 << 13 : 0) | (((inst >> 4) & 0x3ff) << 3); else if ((inst >> 26) == 0x03) - offset = low_sign_extend (inst & 0x1f, 5); + offset = hppa_low_hppa_sign_extend (inst & 0x1f, 5); else - offset = extract_14 (inst); + offset = hppa_extract_14 (inst); /* Handle code with and without frame pointers. */ if (u->Save_SP) @@ -2210,7 +1681,7 @@ hppa_frame_cache (struct frame_info *next_frame, void **this_cache) /* ldo X(%r3),%r1 or ldo X(%r30),%r1. */ if ((inst & 0xffffc000) == 0x34610000 || (inst & 0xffffc000) == 0x37c10000) - fp_loc = extract_14 (inst); + fp_loc = hppa_extract_14 (inst); reg = inst_saves_fr (inst); if (reg >= 12 && reg <= 21) @@ -2690,10 +2161,6 @@ hppa_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) /* The following gdbarch vector elements do not depend on the address size, or in any other gdbarch element previously set. */ set_gdbarch_skip_prologue (gdbarch, hppa_skip_prologue); - set_gdbarch_skip_trampoline_code (gdbarch, hppa_skip_trampoline_code); - set_gdbarch_in_solib_call_trampoline (gdbarch, hppa_in_solib_call_trampoline); - set_gdbarch_in_solib_return_trampoline (gdbarch, - hppa_in_solib_return_trampoline); set_gdbarch_inner_than (gdbarch, core_addr_greaterthan); set_gdbarch_sp_regnum (gdbarch, HPPA_SP_REGNUM); set_gdbarch_fp0_regnum (gdbarch, HPPA_FP0_REGNUM); diff --git a/gdb/hppa-tdep.h b/gdb/hppa-tdep.h index 80742f0f648..48ea3537833 100644 --- a/gdb/hppa-tdep.h +++ b/gdb/hppa-tdep.h @@ -104,6 +104,8 @@ enum unwind_stub_types IMPORT_SHLIB = 12, }; +struct unwind_table_entry *find_unwind_entry (CORE_ADDR); + /* We use the objfile->obj_private pointer for two things: * 1. An unwind table; * @@ -134,4 +136,14 @@ struct hppa_objfile_private extern const struct objfile_data *hppa_objfile_priv_data; +int hppa_get_field (unsigned word, int from, int to); +int hppa_extract_5_load (unsigned int); +unsigned hppa_extract_5R_store (unsigned int); +unsigned hppa_extract_5r_store (unsigned int); +int hppa_extract_17 (unsigned int); +int hppa_extract_21 (unsigned); +int hppa_extract_14 (unsigned); +int hppa_low_sign_extend (unsigned int, unsigned int); +int hppa_sign_extend (unsigned int, unsigned int); + #endif /* HPPA_TDEP_H */ |