CORE_ADDR prologue_start, prologue_end;
int insn;
- fi->extra_info = (struct frame_extra_info *)
- frame_obstack_alloc (sizeof (struct frame_extra_info));
+ frame_extra_info_zalloc (fi, sizeof (struct frame_extra_info));
frame_saved_regs_zalloc (fi);
- fi->extra_info->bottom =
- (fi->next ?
- (fi->frame == fi->next->frame ? fi->next->extra_info->bottom :
- fi->next->frame) : read_sp ());
+ get_frame_extra_info (fi)->bottom =
+ (get_next_frame (fi)
+ ? (get_frame_base (fi) == get_frame_base (get_next_frame (fi))
+ ? get_frame_extra_info (get_next_frame (fi))->bottom
+ : get_frame_base (get_next_frame (fi)))
+ : read_sp ());
/* If fi->next is NULL, then we already set ->frame by passing read_fp()
to create_new_frame. */
- if (fi->next)
+ if (get_next_frame (fi))
{
char *buf;
/* Compute ->frame as if not flat. If it is flat, we'll change
it later. */
- if (fi->next->next != NULL
- && ((get_frame_type (fi->next->next) == SIGTRAMP_FRAME)
- || deprecated_frame_in_dummy (fi->next->next))
- && frameless_look_for_prologue (fi->next))
+ if (get_next_frame (get_next_frame (fi)) != NULL
+ && ((get_frame_type (get_next_frame (get_next_frame (fi))) == SIGTRAMP_FRAME)
+ || deprecated_frame_in_dummy (get_next_frame (get_next_frame (fi))))
+ && frameless_look_for_prologue (get_next_frame (fi)))
{
/* A frameless function interrupted by a signal did not change
the frame pointer, fix up frame pointer accordingly. */
- deprecated_update_frame_base_hack (fi, get_frame_base (fi->next));
- fi->extra_info->bottom = fi->next->extra_info->bottom;
+ deprecated_update_frame_base_hack (fi, get_frame_base (get_next_frame (fi)));
+ get_frame_extra_info (fi)->bottom =
+ get_frame_extra_info (get_next_frame (fi))->bottom;
}
else
{
get_saved_register (buf, 0, 0, fi, FP_REGNUM, 0);
deprecated_update_frame_base_hack (fi, extract_address (buf, REGISTER_RAW_SIZE (FP_REGNUM)));
- if (GDB_TARGET_IS_SPARC64 && (fi->frame & 1))
- deprecated_update_frame_base_hack (fi, fi->frame + 2047);
+ if (GDB_TARGET_IS_SPARC64 && (get_frame_base (fi) & 1))
+ deprecated_update_frame_base_hack (fi, get_frame_base (fi) + 2047);
}
}
/* Decide whether this is a function with a ``flat register window''
frame. For such functions, the frame pointer is actually in %i7. */
- fi->extra_info->flat = 0;
- fi->extra_info->in_prologue = 0;
+ get_frame_extra_info (fi)->flat = 0;
+ get_frame_extra_info (fi)->in_prologue = 0;
if (find_pc_partial_function (get_frame_pc (fi), &name, &prologue_start, &prologue_end))
{
/* See if the function starts with an add (which will be of a
buf = alloca (MAX_REGISTER_RAW_SIZE);
/* We definitely have a flat frame now. */
- fi->extra_info->flat = 1;
+ get_frame_extra_info (fi)->flat = 1;
- fi->extra_info->sp_offset = offset;
+ get_frame_extra_info (fi)->sp_offset = offset;
/* Overwrite the frame's address with the value in %i7. */
get_saved_register (buf, 0, 0, fi, I7_REGNUM, 0);
deprecated_update_frame_base_hack (fi, extract_address (buf, REGISTER_RAW_SIZE (I7_REGNUM)));
- if (GDB_TARGET_IS_SPARC64 && (fi->frame & 1))
- deprecated_update_frame_base_hack (fi, fi->frame + 2047);
+ if (GDB_TARGET_IS_SPARC64 && (get_frame_base (fi) & 1))
+ deprecated_update_frame_base_hack (fi, get_frame_base (fi) + 2047);
/* Record where the fp got saved. */
- fi->extra_info->fp_addr =
- fi->frame + fi->extra_info->sp_offset + X_SIMM13 (insn);
+ get_frame_extra_info (fi)->fp_addr =
+ get_frame_base (fi) + get_frame_extra_info (fi)->sp_offset + X_SIMM13 (insn);
/* Also try to collect where the pc got saved to. */
- fi->extra_info->pc_addr = 0;
+ get_frame_extra_info (fi)->pc_addr = 0;
insn = fetch_instruction (prologue_start + 12);
if (X_OP (insn) == 3
&& X_RD (insn) == 15
&& X_OP3 (insn) == 4
&& X_RS1 (insn) == 14)
- fi->extra_info->pc_addr =
- fi->frame + fi->extra_info->sp_offset + X_SIMM13 (insn);
+ get_frame_extra_info (fi)->pc_addr =
+ get_frame_base (fi) + get_frame_extra_info (fi)->sp_offset + X_SIMM13 (insn);
}
}
else
}
if (addr >= get_frame_pc (fi))
{
- fi->extra_info->in_prologue = 1;
+ get_frame_extra_info (fi)->in_prologue = 1;
deprecated_update_frame_base_hack (fi, read_register (SP_REGNUM));
}
}
}
}
- if (fi->next && fi->frame == 0)
+ if (get_next_frame (fi) && get_frame_base (fi) == 0)
{
/* Kludge to cause init_prev_frame_info to destroy the new frame. */
- deprecated_update_frame_base_hack (fi, fi->next->frame);
- deprecated_update_frame_pc_hack (fi, get_frame_pc (fi->next));
+ deprecated_update_frame_base_hack (fi, get_frame_base (get_next_frame (fi)));
+ deprecated_update_frame_pc_hack (fi, get_frame_pc (get_next_frame (fi)));
}
}
{
/* Value that will cause FRAME_CHAIN_VALID to not worry about the chain
value. If it really is zero, we detect it later in
- sparc_init_prev_frame. */
- return (CORE_ADDR) 1;
+ sparc_init_prev_frame.
+
+ Note: kevinb/2003-02-18: The constant 1 used to be returned
+ here, but, after some recent changes to frame_chain_valid(),
+ this value is no longer suitable for causing frame_chain_valid()
+ to "not worry about the chain value." The constant ~0 (i.e,
+ 0xfff...) causes the failing test in frame_chain_valid() to
+ succeed thus preserving the "not worry" property. I had considered
+ using something like ``get_frame_base (frame) + 1''. However, I think
+ a constant value is better, because when debugging this problem,
+ I knew that something funny was going on as soon as I saw the
+ constant 1 being used as the frame chain elsewhere in GDB. */
+
+ return ~ (CORE_ADDR) 0;
}
CORE_ADDR
scbuf, sizeof (scbuf));
return extract_address (scbuf, sizeof (scbuf));
}
- else if (frame->extra_info->in_prologue ||
- (frame->next != NULL &&
- ((get_frame_type (frame->next) == SIGTRAMP_FRAME) ||
- deprecated_frame_in_dummy (frame->next)) &&
+ else if (get_frame_extra_info (frame)->in_prologue ||
+ (get_next_frame (frame) != NULL &&
+ ((get_frame_type (get_next_frame (frame)) == SIGTRAMP_FRAME) ||
+ deprecated_frame_in_dummy (get_next_frame (frame))) &&
frameless_look_for_prologue (frame)))
{
/* A frameless function interrupted by a signal did not save
frame, O7_REGNUM, (enum lval_type *) NULL);
return PC_ADJUST (extract_address (buf, SPARC_INTREG_SIZE));
}
- if (frame->extra_info->flat)
- addr = frame->extra_info->pc_addr;
+ if (get_frame_extra_info (frame)->flat)
+ addr = get_frame_extra_info (frame)->pc_addr;
else
- addr = frame->extra_info->bottom + FRAME_SAVED_I0 +
+ addr = get_frame_extra_info (frame)->bottom + FRAME_SAVED_I0 +
SPARC_INTREG_SIZE * (I7_REGNUM - I0_REGNUM);
if (addr == 0)
internal_error (__FILE__, __LINE__,
"create_new_frame returned invalid frame");
- frame->extra_info->bottom = argv[1];
+ get_frame_extra_info (frame)->bottom = argv[1];
deprecated_update_frame_pc_hack (frame, FRAME_SAVED_PC (frame));
return frame;
}
{
if (saved_regs && X_I (insn))
saved_regs[X_RD (insn)] =
- fi->frame + fi->extra_info->sp_offset + X_SIMM13 (insn);
+ get_frame_base (fi) + get_frame_extra_info (fi)->sp_offset + X_SIMM13 (insn);
}
else
break;
}
- frame1 = frame->next;
+ frame1 = get_next_frame (frame);
/* Get saved PC from the frame info if not in innermost frame. */
if (regnum == PC_REGNUM && frame1 != NULL)
{
/* FIXME MVS: wrong test for dummy frame at entry. */
- if (get_frame_pc (frame1) >= (frame1->extra_info->bottom ?
- frame1->extra_info->bottom : read_sp ())
+ if (get_frame_pc (frame1) >= (get_frame_extra_info (frame1)->bottom
+ ? get_frame_extra_info (frame1)->bottom
+ : read_sp ())
&& get_frame_pc (frame1) <= get_frame_base (frame1))
{
/* Dummy frame. All but the window regs are in there somewhere.
The window registers are saved on the stack, just like in a
normal frame. */
if (regnum >= G1_REGNUM && regnum < G1_REGNUM + 7)
- addr = frame1->frame + (regnum - G0_REGNUM) * SPARC_INTREG_SIZE
+ addr = get_frame_base (frame1) + (regnum - G0_REGNUM) * SPARC_INTREG_SIZE
- (FP_REGISTER_BYTES + 8 * SPARC_INTREG_SIZE);
else if (regnum >= I0_REGNUM && regnum < I0_REGNUM + 8)
/* NOTE: cagney/2002-05-04: The call to get_prev_frame()
This is because frame1 is initialized to frame->next
(frame1->prev == frame) and is then advanced towards
the innermost (next) frame. */
- addr = (get_prev_frame (frame1)->extra_info->bottom
+ addr = (get_frame_extra_info (get_prev_frame (frame1))->bottom
+ (regnum - I0_REGNUM) * SPARC_INTREG_SIZE
+ FRAME_SAVED_I0);
else if (regnum >= L0_REGNUM && regnum < L0_REGNUM + 8)
This is because frame1 is initialized to frame->next
(frame1->prev == frame) and is then advanced towards
the innermost (next) frame. */
- addr = (get_prev_frame (frame1)->extra_info->bottom
+ addr = (get_frame_extra_info (get_prev_frame (frame1))->bottom
+ (regnum - L0_REGNUM) * SPARC_INTREG_SIZE
+ FRAME_SAVED_L0);
else if (regnum >= O0_REGNUM && regnum < O0_REGNUM + 8)
- addr = frame1->frame + (regnum - O0_REGNUM) * SPARC_INTREG_SIZE
+ addr = get_frame_base (frame1) + (regnum - O0_REGNUM) * SPARC_INTREG_SIZE
- (FP_REGISTER_BYTES + 16 * SPARC_INTREG_SIZE);
else if (SPARC_HAS_FPU &&
regnum >= FP0_REGNUM && regnum < FP0_REGNUM + 32)
- addr = frame1->frame + (regnum - FP0_REGNUM) * 4
+ addr = get_frame_base (frame1) + (regnum - FP0_REGNUM) * 4
- (FP_REGISTER_BYTES);
else if (GDB_TARGET_IS_SPARC64 && SPARC_HAS_FPU &&
regnum >= FP0_REGNUM + 32 && regnum < FP_MAX_REGNUM)
- addr = frame1->frame + 32 * 4 + (regnum - FP0_REGNUM - 32) * 8
+ addr = get_frame_base (frame1) + 32 * 4 + (regnum - FP0_REGNUM - 32) * 8
- (FP_REGISTER_BYTES);
else if (regnum >= Y_REGNUM && regnum < NUM_REGS)
- addr = frame1->frame + (regnum - Y_REGNUM) * SPARC_INTREG_SIZE
+ addr = get_frame_base (frame1) + (regnum - Y_REGNUM) * SPARC_INTREG_SIZE
- (FP_REGISTER_BYTES + 24 * SPARC_INTREG_SIZE);
}
- else if (frame1->extra_info->flat)
+ else if (get_frame_extra_info (frame1)->flat)
{
if (regnum == RP_REGNUM)
- addr = frame1->extra_info->pc_addr;
+ addr = get_frame_extra_info (frame1)->pc_addr;
else if (regnum == I7_REGNUM)
- addr = frame1->extra_info->fp_addr;
+ addr = get_frame_extra_info (frame1)->fp_addr;
else
{
CORE_ADDR func_start;
{
/* Normal frame. Local and In registers are saved on stack. */
if (regnum >= I0_REGNUM && regnum < I0_REGNUM + 8)
- addr = (get_prev_frame (frame1)->extra_info->bottom
+ addr = (get_frame_extra_info (get_prev_frame (frame1))->bottom
+ (regnum - I0_REGNUM) * SPARC_INTREG_SIZE
+ FRAME_SAVED_I0);
else if (regnum >= L0_REGNUM && regnum < L0_REGNUM + 8)
- addr = (get_prev_frame (frame1)->extra_info->bottom
+ addr = (get_frame_extra_info (get_prev_frame (frame1))->bottom
+ (regnum - L0_REGNUM) * SPARC_INTREG_SIZE
+ FRAME_SAVED_L0);
else if (regnum >= O0_REGNUM && regnum < O0_REGNUM + 8)
}
if (addr != 0)
break;
- frame1 = frame1->next;
+ frame1 = get_next_frame (frame1);
}
if (addr != 0)
{
memset (saved_regs_addr, 0, NUM_REGS * sizeof (CORE_ADDR));
- if (get_frame_pc (fi) >= (fi->extra_info->bottom ?
- fi->extra_info->bottom : read_sp ())
+ if (get_frame_pc (fi) >= (get_frame_extra_info (fi)->bottom
+ ? get_frame_extra_info (fi)->bottom
+ : read_sp ())
&& get_frame_pc (fi) <= get_frame_base (fi))
{
/* Dummy frame. All but the window regs are in there somewhere. */
frame_addr + (regnum - Y_REGNUM) * SPARC_INTREG_SIZE
- DUMMY_STACK_REG_BUF_SIZE;
- frame_addr = fi->extra_info->bottom ?
- fi->extra_info->bottom : read_sp ();
+ frame_addr = (get_frame_extra_info (fi)->bottom
+ ? get_frame_extra_info (fi)->bottom
+ : read_sp ());
}
- else if (fi->extra_info->flat)
+ else if (get_frame_extra_info (fi)->flat)
{
CORE_ADDR func_start;
find_pc_partial_function (get_frame_pc (fi), NULL, &func_start, NULL);
examine_prologue (func_start, 0, fi, saved_regs_addr);
/* Flat register window frame. */
- saved_regs_addr[RP_REGNUM] = fi->extra_info->pc_addr;
- saved_regs_addr[I7_REGNUM] = fi->extra_info->fp_addr;
+ saved_regs_addr[RP_REGNUM] = get_frame_extra_info (fi)->pc_addr;
+ saved_regs_addr[I7_REGNUM] = get_frame_extra_info (fi)->fp_addr;
}
else
{
/* Normal frame. Just Local and In registers */
- frame_addr = fi->extra_info->bottom ?
- fi->extra_info->bottom : read_sp ();
+ frame_addr = (get_frame_extra_info (fi)->bottom
+ ? get_frame_extra_info (fi)->bottom
+ : read_sp ());
for (regnum = L0_REGNUM; regnum < L0_REGNUM + 8; regnum++)
saved_regs_addr[regnum] =
(frame_addr + (regnum - L0_REGNUM) * SPARC_INTREG_SIZE
(frame_addr + (regnum - I0_REGNUM) * SPARC_INTREG_SIZE
+ FRAME_SAVED_I0);
}
- if (fi->next)
+ if (get_next_frame (fi))
{
- if (fi->extra_info->flat)
+ if (get_frame_extra_info (fi)->flat)
{
- saved_regs_addr[O7_REGNUM] = fi->extra_info->pc_addr;
+ saved_regs_addr[O7_REGNUM] = get_frame_extra_info (fi)->pc_addr;
}
else
{
/* Pull off either the next frame pointer or the stack pointer */
CORE_ADDR next_next_frame_addr =
- (fi->next->extra_info->bottom ?
- fi->next->extra_info->bottom : read_sp ());
+ (get_frame_extra_info (get_next_frame (fi))->bottom
+ ? get_frame_extra_info (get_next_frame (fi))->bottom
+ : read_sp ());
for (regnum = O0_REGNUM; regnum < O0_REGNUM + 8; regnum++)
saved_regs_addr[regnum] =
(next_next_frame_addr
7 * SPARC_INTREG_SIZE);
}
- if (frame->extra_info->flat)
+ if (get_frame_extra_info (frame)->flat)
{
/* Each register might or might not have been saved, need to test
individually. */
read_memory_integer (fsr[O0_REGNUM + 7],
SPARC_INTREG_SIZE));
- write_sp (frame->frame);
+ write_sp (get_frame_base (frame));
}
else if (fsr[I0_REGNUM])
{
read_memory_integer (fsr[NPC_REGNUM],
REGISTER_RAW_SIZE (NPC_REGNUM)));
}
- else if (frame->extra_info->flat)
+ else if (get_frame_extra_info (frame)->flat)
{
- if (frame->extra_info->pc_addr)
+ if (get_frame_extra_info (frame)->pc_addr)
pc = PC_ADJUST ((CORE_ADDR)
- read_memory_integer (frame->extra_info->pc_addr,
+ read_memory_integer (get_frame_extra_info (frame)->pc_addr,
REGISTER_RAW_SIZE (PC_REGNUM)));
else
{
}
}
-/* PRINT_REGISTER_HOOK routine.
- Pretty print various registers. */
+/* Pretty print various registers. */
/* FIXME: Would be nice if this did some fancy things for 32 bit sparc. */
static void
extern void
sparc_print_extra_frame_info (struct frame_info *fi)
{
- if (fi && fi->extra_info && fi->extra_info->flat)
+ if (fi && get_frame_extra_info (fi) && get_frame_extra_info (fi)->flat)
printf_filtered (" flat, pc saved at 0x%s, fp saved at 0x%s\n",
- paddr_nz (fi->extra_info->pc_addr),
- paddr_nz (fi->extra_info->fp_addr));
+ paddr_nz (get_frame_extra_info (fi)->pc_addr),
+ paddr_nz (get_frame_extra_info (fi)->fp_addr));
}
/* MULTI_ARCH support */
set_gdbarch_frameless_function_invocation (gdbarch,
frameless_look_for_prologue);
set_gdbarch_get_saved_register (gdbarch, sparc_get_saved_register);
- set_gdbarch_init_extra_frame_info (gdbarch, sparc_init_extra_frame_info);
+ set_gdbarch_deprecated_init_extra_frame_info (gdbarch, sparc_init_extra_frame_info);
set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
set_gdbarch_int_bit (gdbarch, 4 * TARGET_CHAR_BIT);
set_gdbarch_long_double_bit (gdbarch, 16 * TARGET_CHAR_BIT);
set_gdbarch_max_register_virtual_size (gdbarch, 8);
set_gdbarch_pop_frame (gdbarch, sparc_pop_frame);
set_gdbarch_push_return_address (gdbarch, sparc_push_return_address);
- set_gdbarch_push_dummy_frame (gdbarch, sparc_push_dummy_frame);
+ set_gdbarch_deprecated_push_dummy_frame (gdbarch, sparc_push_dummy_frame);
set_gdbarch_read_pc (gdbarch, generic_target_read_pc);
set_gdbarch_register_convert_to_raw (gdbarch, sparc_convert_to_raw);
set_gdbarch_register_convert_to_virtual (gdbarch,
fprintf_unfiltered (file, "sparc_dump_tdep: call_dummy_call_offset = %d\n",
tdep->call_dummy_call_offset);
fprintf_unfiltered (file, "sparc_dump_tdep: print_insn_match = %d\n",
- tdep->print_insn_match);
+ tdep->print_insn_mach);
}
projects / deliverable / binutils-gdb.git / blobdiff