This is the mail archive of the gdb@sources.redhat.com mailing list for the GDB project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

Re: avr and frame unwinding


On Thu, 5 Jun 2003, Andrew Cagney wrote:

:)Can you try the exact same operation with a GDB that doesn't have the :)changes? That way it should be possible to compare the two traces :)side-by-side and see where things are going wrong.
:)
:)A guess is that it is getting the unwound PC value wrong. For the d10v


That was the problem. I've got it working, but the solution was ugly (see below).

:)I had to make two tweaks:
:)
:)- abort the prologue scanner when it reached PC if that is before the :)end of the prologue
:)This stopped the prologue getting the unwound PC's location wrong. It :)may not have yet executed the save PC instruction.


This seems to also hold for the avr. Adding the extra pc check before
prologue scanning like the d10v does got things working as far as stepping
and backtracing go.

:)
:)- track the register that the PC is in before it is saved
:)The code needs to be able to unwind the PC value in the prologue before :)it has been saved on the stack.
:)
:)Andrew
:)


Thanks for the nudge Andrew.

Any idea how to make this piece of code sane? I'm not thrilled with what I had to do to get the PC read and converted then finally stored in bufferp. This function is analogous to saved_regs_unwinder() in d10v-tdep.c.

static void
avr_saved_regs_unwinder (struct frame_info *next_frame,
                         CORE_ADDR *this_saved_regs,
                         int regnum, int *optimizedp,
                         enum lval_type *lvalp, CORE_ADDR *addrp,
                         int *realnump, void *bufferp)
{
  if (this_saved_regs[regnum] != 0)
    {
      *optimizedp = 0;
      *lvalp = lval_memory;
      *addrp = this_saved_regs[regnum];
      *realnump = -1;
      if (bufferp != NULL)
        {
          /* Read the value in from memory.  */

          if (regnum == AVR_PC_REGNUM)
            {
              /* Reading the return PC from the PC register is slightly
                 abnormal.  register_size(AVR_PC_REGNUM) says it is 4 bytes,
                 but in reality, only two bytes (3 in upcoming mega256) are
                 stored on the stack.

Is the PC 2 bytes, or that only two bytes are saved? You don't have a d10v PC which is 2 bytes but addresses words?


                 Also, note that the value on the stack is an addr to a word
                 not a byte, so we will need to multiply it by two at some
                 point.  */

              ULONGEST pc;
              unsigned char buf[2];

read_memory (this_saved_regs[regnum], buf, sizeof (buf));

Is this arrithmetic correct - I understand the ``* 2'' but not the ``>>8''.


pc = (extract_unsigned_integer (buf, 2) * 2) >> 8;

this memcpy will need to be a


store_unsigned_integer (bufferp, pc, SIZEOF_AVR_PC);

              memcpy (bufferp, &pc, sizeof(pc));
            }
          else
            {
              read_memory (this_saved_regs[regnum], bufferp,
                           register_size (current_gdbarch, regnum));
            }

The last problem I need to solve I think is also related to register
unwinding. If I step down into a function, then 'up' to move up the stack
frame, examining a local variable gives the wrong value. I need to do some
more research into why this is happening though. Am I on the right track
with thinking the register unwinding could be the problem? Maybe I'm setting the frame base incorrectly since it doesn't seem to resolve the variable's memory address?

Sounds like you're on the right track. The new unwind code typically has different:


	frame ID.stack_addr
	frame {base,locals,args} address

the former is the address of the previous frame's inner-most stack address while the latter is the clasic frame pointer.

Andrew



Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]