#include "symfile.h"
#include "objfiles.h"
-/* To support asking "What CPU is this?" */
-#include <unistd.h>
-
/* To support detection of the pseudo-initial frame
that threads have. */
#define THREAD_INITIAL_FRAME_SYMBOL "__pthread_exit"
int gcc_p;
struct type *type;
{
- return (TYPE_LENGTH (type) > 8);
+ return (TYPE_LENGTH (type) > 2 * REGISTER_SIZE);
}
\f
low_text_segment_address = -1;
/* If addresses are 64 bits wide, then unwinds are supposed to
- be segment relative offsets instead of absolute addresses. */
- if (TARGET_PTR_BIT == 64)
+ be segment relative offsets instead of absolute addresses.
+
+ Note that when loading a shared library (text_offset != 0) the
+ unwinds are already relative to the text_offset that will be
+ passed in. */
+ if (TARGET_PTR_BIT == 64 && text_offset == 0)
{
bfd_map_over_sections (objfile->obfd,
record_text_segment_lowaddr, (PTR) NULL);
read_unwind_info (objfile)
struct objfile *objfile;
{
- asection *unwind_sec, *elf_unwind_sec, *stub_unwind_sec;
- unsigned unwind_size, elf_unwind_size, stub_unwind_size, total_size;
- unsigned index, unwind_entries, elf_unwind_entries;
+ asection *unwind_sec, *stub_unwind_sec;
+ unsigned unwind_size, stub_unwind_size, total_size;
+ unsigned index, unwind_entries;
unsigned stub_entries, total_entries;
CORE_ADDR text_offset;
struct obj_unwind_info *ui;
ui->cache = NULL;
ui->last = -1;
- /* Get hooks to all unwind sections. Note there is no linker-stub unwind
- section in ELF at the moment. */
- unwind_sec = bfd_get_section_by_name (objfile->obfd, "$UNWIND_START$");
- elf_unwind_sec = bfd_get_section_by_name (objfile->obfd, ".PARISC.unwind");
- stub_unwind_sec = bfd_get_section_by_name (objfile->obfd, "$UNWIND_END$");
-
- /* Get sizes and unwind counts for all sections. */
- if (unwind_sec)
+ /* For reasons unknown the HP PA64 tools generate multiple unwinder
+ sections in a single executable. So we just iterate over every
+ section in the BFD looking for unwinder sections intead of trying
+ to do a lookup with bfd_get_section_by_name.
+
+ First determine the total size of the unwind tables so that we
+ can allocate memory in a nice big hunk. */
+ total_entries = 0;
+ for (unwind_sec = objfile->obfd->sections;
+ unwind_sec;
+ unwind_sec = unwind_sec->next)
{
- unwind_size = bfd_section_size (objfile->obfd, unwind_sec);
- unwind_entries = unwind_size / UNWIND_ENTRY_SIZE;
- }
- else
- {
- unwind_size = 0;
- unwind_entries = 0;
- }
+ if (strcmp (unwind_sec->name, "$UNWIND_START$") == 0
+ || strcmp (unwind_sec->name, ".PARISC.unwind") == 0)
+ {
+ unwind_size = bfd_section_size (objfile->obfd, unwind_sec);
+ unwind_entries = unwind_size / UNWIND_ENTRY_SIZE;
- 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 */
- }
- else
- {
- elf_unwind_size = 0;
- elf_unwind_entries = 0;
+ total_entries += unwind_entries;
+ }
}
+ /* Now compute the size of the stub unwinds. Note the ELF tools do not
+ use stub unwinds at the curren time. */
+ stub_unwind_sec = bfd_get_section_by_name (objfile->obfd, "$UNWIND_END$");
+
if (stub_unwind_sec)
{
stub_unwind_size = bfd_section_size (objfile->obfd, stub_unwind_sec);
}
/* Compute total number of unwind entries and their total size. */
- total_entries = unwind_entries + elf_unwind_entries + stub_entries;
+ total_entries += stub_entries;
total_size = total_entries * sizeof (struct unwind_table_entry);
/* Allocate memory for the unwind table. */
obstack_alloc (&objfile->psymbol_obstack, total_size);
ui->last = total_entries - 1;
- /* Internalize the standard unwind entries. */
+ /* Now read in each unwind section and internalize the standard unwind
+ entries. */
index = 0;
- internalize_unwinds (objfile, &ui->table[index], unwind_sec,
- unwind_entries, unwind_size, text_offset);
- index += unwind_entries;
- internalize_unwinds (objfile, &ui->table[index], elf_unwind_sec,
- elf_unwind_entries, elf_unwind_size, text_offset);
- index += elf_unwind_entries;
-
- /* Now internalize the stub unwind entries. */
+ for (unwind_sec = objfile->obfd->sections;
+ unwind_sec;
+ unwind_sec = unwind_sec->next)
+ {
+ if (strcmp (unwind_sec->name, "$UNWIND_START$") == 0
+ || strcmp (unwind_sec->name, ".PARISC.unwind") == 0)
+ {
+ unwind_size = bfd_section_size (objfile->obfd, unwind_sec);
+ unwind_entries = unwind_size / UNWIND_ENTRY_SIZE;
+
+ internalize_unwinds (objfile, &ui->table[index], unwind_sec,
+ unwind_entries, unwind_size, text_offset);
+ index += unwind_entries;
+ }
+ }
+
+ /* Now read in and internalize the stub unwind entries. */
if (stub_unwind_size > 0)
{
unsigned int i;
{
read_unwind_info (objfile);
if (objfile->obj_private == NULL)
- error ("Internal error reading unwind information."); /* purecov: deadcode */
+ error ("Internal error reading unwind information.");
ui = ((obj_private_data_t *) (objfile->obj_private))->unwind_info;
}
}
/* Called when no unwind descriptor was found for PC. Returns 1 if it
- appears that PC is in a linker stub. */
+ appears that PC is in a linker stub.
+
+ ?!? Need to handle stubs which appear in PA64 code. */
static int
pc_in_linker_stub (pc)
return read_memory_integer (frame->frame + PC_REGNUM * 4,
TARGET_PTR_BIT / 8) & ~0x3;
+ if ((frame->pc >= frame->frame
+ && frame->pc <= (frame->frame
+ /* A call dummy is sized in words, but it is
+ actually a series of instructions. Account
+ for that scaling factor. */
+ + ((REGISTER_SIZE / INSTRUCTION_SIZE)
+ * CALL_DUMMY_LENGTH)
+ /* Similarly we have to account for 64bit
+ wide register saves. */
+ + (32 * REGISTER_SIZE)
+ /* We always consider FP regs 8 bytes long. */
+ + (NUM_REGS - FP0_REGNUM) * 8
+ /* Similarly we have to account for 64bit
+ wide register saves. */
+ + (6 * REGISTER_SIZE))))
+ {
+ return read_memory_integer ((frame->frame
+ + (TARGET_PTR_BIT == 64 ? -16 : -20)),
+ TARGET_PTR_BIT / 8) & ~0x3;
+ }
+
#ifdef FRAME_SAVED_PC_IN_SIGTRAMP
/* Deal with signal handler caller frames too. */
if (frame->signal_handler_caller)
CORE_ADDR frame_base;
struct frame_info *tmp_frame;
+ /* A frame in the current frame list, or zero. */
+ struct frame_info *saved_regs_frame = 0;
+ /* Where the registers were saved in saved_regs_frame.
+ If saved_regs_frame is zero, this is garbage. */
+ struct frame_saved_regs saved_regs;
+
CORE_ADDR caller_pc;
struct minimal_symbol *min_frame_symbol;
We use information from unwind descriptors to determine if %r3
is saved into the stack (Entry_GR field has this information). */
- tmp_frame = frame;
- while (tmp_frame)
+ for (tmp_frame = frame; tmp_frame; tmp_frame = tmp_frame->next)
{
u = find_unwind_entry (tmp_frame->pc);
return (CORE_ADDR) 0;
}
- /* Entry_GR specifies the number of callee-saved general registers
- saved in the stack. It starts at %r3, so %r3 would be 1. */
- if (u->Entry_GR >= 1 || u->Save_SP
+ if (u->Save_SP
|| tmp_frame->signal_handler_caller
|| pc_in_interrupt_handler (tmp_frame->pc))
break;
- else
- tmp_frame = tmp_frame->next;
+
+ /* Entry_GR specifies the number of callee-saved general registers
+ saved in the stack. It starts at %r3, so %r3 would be 1. */
+ if (u->Entry_GR >= 1)
+ {
+ /* The unwind entry claims that r3 is saved here. However,
+ in optimized code, GCC often doesn't actually save r3.
+ We'll discover this if we look at the prologue. */
+ get_frame_saved_regs (tmp_frame, &saved_regs);
+ saved_regs_frame = tmp_frame;
+
+ /* If we have an address for r3, that's good. */
+ if (saved_regs.regs[FP_REGNUM])
+ break;
+ }
}
if (tmp_frame)
/* %r3 was saved somewhere in the stack. Dig it out. */
else
{
- struct frame_saved_regs saved_regs;
-
/* Sick.
For optimization purposes many kernels don't have the
fail miserably if the function which performs the
system call has a variable sized stack frame. */
- get_frame_saved_regs (tmp_frame, &saved_regs);
+ if (tmp_frame != saved_regs_frame)
+ get_frame_saved_regs (tmp_frame, &saved_regs);
/* Abominable hack. */
if (current_target.to_has_execution == 0
}
else
{
- struct frame_saved_regs saved_regs;
-
/* Get the innermost frame. */
tmp_frame = frame;
while (tmp_frame->next != NULL)
tmp_frame = tmp_frame->next;
- get_frame_saved_regs (tmp_frame, &saved_regs);
+ if (tmp_frame != saved_regs_frame)
+ get_frame_saved_regs (tmp_frame, &saved_regs);
+
/* Abominable hack. See above. */
if (current_target.to_has_execution == 0
&& ((saved_regs.regs[FLAGS_REGNUM]
/* 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);
return 1;
}
+
+#ifdef PA20W_CALLING_CONVENTIONS
+
/* This function pushes a stack frame with arguments as part of the
inferior function calling mechanism.
- For PAs the stack always grows to higher addresses. However the arguments
- may grow to either higher or lower addresses depending on which ABI is
- currently in use.
+ This is the version for the PA64, in which later arguments appear
+ at higher addresses. (The stack always grows towards higher
+ addresses.)
We simply allocate the appropriate amount of stack space and put
arguments into their proper slots. The call dummy code will copy
arguments into registers as needed by the ABI.
- Note for the PA64 ABI we load up the argument pointer since the caller
- must provide the argument pointer to the callee. */
+ This ABI also requires that the caller provide an argument pointer
+ to the callee, so we do that too. */
CORE_ADDR
hppa_push_arguments (nargs, args, sp, struct_return, struct_addr)
/* Iterate over each argument provided by the user. */
for (i = 0; i < nargs; i++)
{
- lengths[i] = TYPE_LENGTH (VALUE_TYPE (args[i]));
+ struct type *arg_type = VALUE_TYPE (args[i]);
+
+ /* Integral scalar values smaller than a register are padded on
+ the left. We do this by promoting them to full-width,
+ although the ABI says to pad them with garbage. */
+ if (is_integral_type (arg_type)
+ && TYPE_LENGTH (arg_type) < REGISTER_SIZE)
+ {
+ args[i] = value_cast ((TYPE_UNSIGNED (arg_type)
+ ? builtin_type_unsigned_long
+ : builtin_type_long),
+ args[i]);
+ arg_type = VALUE_TYPE (args[i]);
+ }
+
+ lengths[i] = TYPE_LENGTH (arg_type);
/* Align the size of the argument to the word size for this
target. */
bytes_reserved = (lengths[i] + REGISTER_SIZE - 1) & -REGISTER_SIZE;
-#ifdef ARGS_GROW_DOWNWARD
- offset[i] = cum_bytes_reserved + lengths[i];
-#else
- /* If the arguments grow towards lower addresses, then we want
- offset[i] to point to the start of the argument rather than
- the end of the argument. */
offset[i] = cum_bytes_reserved;
- offset[i] += (lengths[i] < REGISTER_SIZE
- ? REGISTER_SIZE - lengths[i] : 0);
-#endif
+ /* Aggregates larger than eight bytes (the only types larger
+ than eight bytes we have) are aligned on a 16-byte boundary,
+ possibly padded on the right with garbage. This may leave an
+ empty word on the stack, and thus an unused register, as per
+ the ABI. */
+ if (bytes_reserved > 8)
+ {
+ /* Round up the offset to a multiple of two slots. */
+ int new_offset = ((offset[i] + 2*REGISTER_SIZE-1)
+ & -(2*REGISTER_SIZE));
- /* If the argument is a double word argument, then it needs to be
- double word aligned.
+ /* Note the space we've wasted, if any. */
+ bytes_reserved += new_offset - offset[i];
+ offset[i] = new_offset;
+ }
+
+ cum_bytes_reserved += bytes_reserved;
+ }
+
+ /* CUM_BYTES_RESERVED already accounts for all the arguments
+ passed by the user. However, the ABIs mandate minimum stack space
+ allocations for outgoing arguments.
+
+ The ABIs also mandate minimum stack alignments which we must
+ preserve. */
+ cum_bytes_aligned = STACK_ALIGN (cum_bytes_reserved);
+ sp += max (cum_bytes_aligned, REG_PARM_STACK_SPACE);
+
+ /* Now write each of the args at the proper offset down the stack. */
+ for (i = 0; i < nargs; i++)
+ write_memory (orig_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 (struct_return)
+ write_register (28, struct_addr);
+
+ /* For the PA64 we must pass a pointer to the outgoing argument list.
+ The ABI mandates that the pointer should point to the first byte of
+ storage beyond the register flushback area.
+
+ However, the call dummy expects the outgoing argument pointer to
+ be passed in register %r4. */
+ write_register (4, orig_sp + REG_PARM_STACK_SPACE);
+
+ /* ?!? This needs further work. We need to set up the global data
+ pointer for this procedure. This assumes the same global pointer
+ for every procedure. The call dummy expects the dp value to
+ be passed in register %r6. */
+ write_register (6, read_register (27));
+
+ /* The stack will have 64 bytes of additional space for a frame marker. */
+ return sp + 64;
+}
+
+#else
+
+/* This function pushes a stack frame with arguments as part of the
+ inferior function calling mechanism.
- ?!? I do not think this code is correct when !ARGS_GROW_DOWNWAR. */
+ This is the version of the function for the 32-bit PA machines, in
+ which later arguments appear at lower addresses. (The stack always
+ grows towards higher addresses.)
+
+ We simply allocate the appropriate amount of stack space and put
+ arguments into their proper slots. The call dummy code will copy
+ arguments into registers as needed by the ABI. */
+
+CORE_ADDR
+hppa_push_arguments (nargs, args, sp, struct_return, struct_addr)
+ int nargs;
+ value_ptr *args;
+ CORE_ADDR sp;
+ int struct_return;
+ CORE_ADDR struct_addr;
+{
+ /* array of arguments' offsets */
+ 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));
+
+ /* The number of stack bytes occupied by the current argument. */
+ int bytes_reserved;
+
+ /* The total number of bytes reserved for the arguments. */
+ int cum_bytes_reserved = 0;
+
+ /* Similarly, but aligned. */
+ int cum_bytes_aligned = 0;
+ int i;
+
+ /* Iterate over each argument provided by the user. */
+ for (i = 0; i < nargs; i++)
+ {
+ lengths[i] = TYPE_LENGTH (VALUE_TYPE (args[i]));
+
+ /* Align the size of the argument to the word size for this
+ target. */
+ bytes_reserved = (lengths[i] + REGISTER_SIZE - 1) & -REGISTER_SIZE;
+
+ offset[i] = cum_bytes_reserved + lengths[i];
+
+ /* If the argument is a double word argument, then it needs to be
+ double word aligned. */
if ((bytes_reserved == 2 * REGISTER_SIZE)
- && (offset[i] % 2 * REGISTER_SIZE))
+ && (offset[i] % 2 * REGISTER_SIZE))
{
int new_offset = 0;
/* BYTES_RESERVED is already aligned to the word, so we put
}
- /* CUM_BYTES_RESERVED already accounts for all the arguments
- passed by the user. However, the ABIs mandate minimum stack space
+ /* CUM_BYTES_RESERVED already accounts for all the arguments passed
+ by the user. However, the ABI mandates minimum stack space
allocations for outgoing arguments.
- The ABIs also mandate minimum stack alignments which we must
+ The ABI also mandates minimum stack alignments which we must
preserve. */
cum_bytes_aligned = STACK_ALIGN (cum_bytes_reserved);
sp += max (cum_bytes_aligned, REG_PARM_STACK_SPACE);
/* Now write each of the args at the proper offset down the stack.
-
- The two ABIs write arguments in different directions using different
- starting points. What fun.
-
?!? We need to promote values to a full register instead of skipping
words in the stack. */
-#ifndef ARGS_GROW_DOWNWARD
- for (i = 0; i < nargs; i++)
- write_memory (orig_sp + offset[i], VALUE_CONTENTS (args[i]), lengths[i]);
-#else
for (i = 0; i < nargs; i++)
write_memory (sp - offset[i], VALUE_CONTENTS (args[i]), lengths[i]);
-#endif
/* If a structure has to be returned, set up register 28 to hold its
address */
if (struct_return)
write_register (28, struct_addr);
-#ifndef ARGS_GROW_DOWNWARD
- /* For the PA64 we must pass a pointer to the outgoing argument list.
- The ABI mandates that the pointer should point to the first byte of
- storage beyond the register flushback area.
-
- However, the call dummy expects the outgoing argument pointer to
- be passed in register %r4. */
- write_register (4, orig_sp + REG_PARM_STACK_SPACE);
-
- /* ?!? This needs further work. We need to set up the global data
- pointer for this procedure. This assumes the same global pointer
- for every procedure. The call dummy expects the dp value to
- be passed in register %r6. */
- write_register (6, read_register (27));
-#endif
-
/* The stack will have 32 bytes of additional space for a frame marker. */
return sp + 32;
}
+#endif
/* elz: this function returns a value which is built looking at the given address.
It is called from call_function_by_hand, in case we need to return a
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 */
+ error ("call to __d_shl_get failed, error code is %d", err_value);
return (stub_addr);
}
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
- (the PIC register) before performing the call.
+ 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
are calling the target directly. When using __d_plt_call we want to
write_register (5, fun);
/* We need to see if this objfile has a different DP value than our
- own (it could be a shared library for example. */
+ own (it could be a shared library for example). */
ALL_OBJFILES (objfile)
{
struct obj_section *s;
funsymbol = lookup_minimal_symbol_by_pc (fun);
if (!funsymbol)
- error ("Unable to find minimal symbol for target fucntion.\n");
+ error ("Unable to find minimal symbol for target function.\n");
/* Search all the object files for an import symbol with the
right name. */
/* 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)
+ if (u == NULL
+ || (u->stub_unwind.stub_type != IMPORT
+#ifdef GDB_NATIVE_HPUX_11
+ /* Sigh. The hpux 10.20 dynamic linker will blow
+ chunks if we perform a call to an unbound function
+ via the IMPORT_SHLIB stub. The hpux 11.00 dynamic
+ linker will blow chunks if we do not call the
+ unbound function via the IMPORT_SHLIB stub.
+
+ We currently have no way to select bevahior on just
+ the target. However, we only support HPUX/SOM in
+ native mode. So we conditinalize on a native
+ #ifdef. Ugly. Ugly. Ugly */
+ && u->stub_unwind.stub_type != IMPORT_SHLIB
+#endif
+ ))
continue;
/* OK. Looks like the correct import stub. */
newfun = SYMBOL_VALUE (stub_symbol);
fun = newfun;
+
+ /* If we found an IMPORT stub, then we want to stop
+ searching now. If we found an IMPORT_SHLIB, we want
+ to continue the search in the hopes that we will find
+ an IMPORT stub. */
+ if (u->stub_unwind.stub_type == IMPORT)
+ break;
}
}
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 */
+#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 (sec->vma <= pc
+ && sec->vma + sec->_cooked_size < pc)
+ 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 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)
if (pc == dyncall || pc == sr4export)
return 1;
+ minsym = lookup_minimal_symbol_by_pc (pc);
+ if (minsym && strcmp (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);
}
/* 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");
+ return 0;
}
/* Unknown stub type. For now, just return zero. */
- return 0; /* purecov: deadcode */
+ return 0;
}
/* Return one if PC is in the return path of a trampoline, else return zero.
}
/* 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");
+ return 0;
}
/* Unknown stub type. For now, just return zero. */
- return 0; /* purecov: deadcode */
+ return 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 */
+ /* FIXME XXX - dyncall and sr4export must be initialized whenever we get a
+ new exec file */
if (!dyncall)
{
if ((inst & 0xffe00000) == 0x6fc00000)
return extract_14 (inst);
+ /* std,ma X,D(sp) */
+ if ((inst & 0xffe00008) == 0x73c00008)
+ return (inst & 0x1 ? -1 << 13 : 0) | (((inst >> 4) & 0x3ff) << 3);
+
/* addil high21,%r1; ldo low11,(%r1),%r30)
save high bits in save_high21 for later use. */
if ((inst & 0xffe00000) == 0x28200000)
if (inst == 0x6bc23fd9 || inst == 0x0fc212c1)
save_rp = 0;
- /* This is the only way we save SP into the stack. At this time
+ /* These are the only ways we save SP into the stack. At this time
the HP compilers never bother to save SP into the stack. */
- if ((inst & 0xffffc000) == 0x6fc10000)
+ if ((inst & 0xffffc000) == 0x6fc10000
+ || (inst & 0xffffc00c) == 0x73c10008)
save_sp = 0;
+ /* Are we loading some register with an offset from the argument
+ pointer? */
+ if ((inst & 0xffe00000) == 0x37a00000
+ || (inst & 0xffffffe0) == 0x081d0240)
+ {
+ pc += 4;
+ continue;
+ }
+
/* Account for general and floating-point register saves. */
reg_num = inst_saves_gr (inst);
save_gr &= ~(1 << reg_num);
FIXME. Can still die if we have a mix of GR and FR argument
stores! */
- if (reg_num >= 23 && reg_num <= 26)
+ if (reg_num >= (TARGET_PTR_BIT == 64 ? 19 : 23) && reg_num <= 26)
{
- while (reg_num >= 23 && reg_num <= 26)
+ while (reg_num >= (TARGET_PTR_BIT == 64 ? 19 : 23) && reg_num <= 26)
{
pc += 4;
status = target_read_memory (pc, buf, 4);
save. */
if ((inst & 0xfc000000) == 0x34000000
&& inst_saves_fr (next_inst) >= 4
- && inst_saves_fr (next_inst) <= 7)
+ && inst_saves_fr (next_inst) <= (TARGET_PTR_BIT == 64 ? 11 : 7))
{
/* So we drop into the code below in a reasonable state. */
reg_num = inst_saves_fr (next_inst);
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)
+ if (reg_num >= 4 && reg_num <= (TARGET_PTR_BIT == 64 ? 11 : 7))
{
- while (reg_num >= 4 && reg_num <= 7)
+ while (reg_num >= 4 && reg_num <= (TARGET_PTR_BIT == 64 ? 11 : 7))
{
pc += 8;
status = target_read_memory (pc, buf, 4);
int status, i, reg;
char buf[4];
int fp_loc = -1;
+ int final_iteration;
/* Zero out everything. */
memset (frame_saved_regs, '\0', sizeof (struct frame_saved_regs));
Some unexpected things are expected with debugging optimized code, so
we allow this routine to walk past user instructions in optimized
GCC code. */
- while (save_gr || save_fr || save_rp || save_sp || stack_remaining > 0)
+ final_iteration = 0;
+ while ((save_gr || save_fr || save_rp || save_sp || stack_remaining > 0)
+ && pc <= frame_info->pc)
{
status = target_read_memory (pc, buf, 4);
inst = extract_unsigned_integer (buf, 4);
/* Note the interesting effects of this instruction. */
stack_remaining -= prologue_inst_adjust_sp (inst);
- /* There is only one instruction used for saving RP into the stack. */
- if (inst == 0x6bc23fd9)
+ /* There are limited ways to store the return pointer into the
+ stack. */
+ if (inst == 0x6bc23fd9) /* stw rp,-0x14(sr0,sp) */
{
save_rp = 0;
frame_saved_regs->regs[RP_REGNUM] = frame_info->frame - 20;
}
+ else if (inst == 0x0fc212c1) /* std rp,-0x10(sr0,sp) */
+ {
+ save_rp = 0;
+ frame_saved_regs->regs[RP_REGNUM] = frame_info->frame - 16;
+ }
- /* Just note that we found the save of SP into the stack. The
- value for frame_saved_regs was computed above. */
- if ((inst & 0xffffc000) == 0x6fc10000)
- save_sp = 0;
+ /* Note if we saved SP into the stack. This also happens to indicate
+ the location of the saved frame pointer. */
+ if ( (inst & 0xffffc000) == 0x6fc10000 /* stw,ma r1,N(sr0,sp) */
+ || (inst & 0xffffc00c) == 0x73c10008) /* std,ma r1,N(sr0,sp) */
+ {
+ frame_saved_regs->regs[FP_REGNUM] = frame_info->frame;
+ save_sp = 0;
+ }
/* Account for general and floating-point register saves. */
reg = inst_saves_gr (inst);
if ((inst >> 26) == 0x1b
&& extract_14 (inst) >= 0)
frame_saved_regs->regs[reg] = frame_info->frame;
+ /* A std has explicit post_modify forms. */
+ else if ((inst & 0xfc00000c0) == 0x70000008)
+ frame_saved_regs->regs[reg] = frame_info->frame;
else
{
+ CORE_ADDR offset;
+
+ 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);
+ else
+ offset = extract_14 (inst);
+
/* Handle code with and without frame pointers. */
if (u->Save_SP)
frame_saved_regs->regs[reg]
- = frame_info->frame + extract_14 (inst);
+ = frame_info->frame + offset;
else
frame_saved_regs->regs[reg]
- = frame_info->frame + (u->Total_frame_size << 3)
- + extract_14 (inst);
+ = (frame_info->frame + (u->Total_frame_size << 3)
+ + offset);
}
}
}
}
- /* 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. */
- if (is_branch (inst))
+ /* Quit if we hit any kind of branch the previous iteration.
+ if (final_iteration)
break;
+ /* We want to look precisely one instruction beyond the branch
+ if we have not found everything yet. */
+ if (is_branch (inst))
+ final_iteration = 1;
+
/* Bump the PC. */
pc += 4;
}
}
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.");
+ return (struct symtab_and_line *) -1;
}
}
return (struct symtab_and_line *) -1;
}
break;
- default: /* purecov: deadcode */
- error ("Request to enable unknown or unsupported exception event."); /* purecov: deadcode */
+ default:
+ error ("Request to enable unknown or unsupported exception event.");
}
/* Copy break address into new sal struct, malloc'ing if needed. */
}
#endif /* PREPARE_TO_PROCEED */
+void
+hppa_skip_permanent_breakpoint ()
+{
+ /* To step over a breakpoint instruction on the PA takes some
+ fiddling with the instruction address queue.
+
+ When we stop at a breakpoint, the IA queue front (the instruction
+ we're executing now) points at the breakpoint instruction, and
+ the IA queue back (the next instruction to execute) points to
+ whatever instruction we would execute after the breakpoint, if it
+ were an ordinary instruction. This is the case even if the
+ breakpoint is in the delay slot of a branch instruction.
+
+ Clearly, to step past the breakpoint, we need to set the queue
+ front to the back. But what do we put in the back? What
+ instruction comes after that one? Because of the branch delay
+ slot, the next insn is always at the back + 4. */
+ write_register (PCOQ_HEAD_REGNUM, read_register (PCOQ_TAIL_REGNUM));
+ write_register (PCSQ_HEAD_REGNUM, read_register (PCSQ_TAIL_REGNUM));
+
+ write_register (PCOQ_TAIL_REGNUM, read_register (PCOQ_TAIL_REGNUM) + 4);
+ /* We can leave the tail's space the same, since there's no jump. */
+}
+
void
_initialize_hppa_tdep ()
{
projects / deliverable / binutils-gdb.git / blobdiff