RE: [PATCH V2] PowerPC: fix for gdb.base/eh_return.exp

[Carl Love <cel@us.ibm.com>]

Pedro:

I reached out to the GCC team to see if I could get more information on
this.  I have inserted the answers to your questions below in your
reply.


On Tue, 2022-05-10 at 12:43 +0100, Pedro Alves wrote:
> On 2022-05-09 21:57, will schmidt wrote:
> > On Mon, 2022-05-09 at 12:17 -0700, Carl Love wrote:
> > > Will, Pedro, Kevin, GDB maintainers:
> > > 
> > > Sorry, resend, the first attempt was missing the mailing list.
> > > 
> > > I have updated the patch per the comments from Will.  The new
> > > version
> > > of the patch uses a PowerPC specific gcc option to suppress the
> > > generation of the Traceback Table information.  The Traceback
> > > information is contained in the .long statements following the
> > > last
> > > instruction in the function.  Now the existing test to locate the
> > > last
> > > instruction in the function works without any changes.
> > 
> > In this cases the disassembly is presenting the traceback table
> > contents as .long values, but with an (un)lucky combination of
> > bits, it
> > may also represent parts of that table as instructions.  Thats all
> > chance on which bits/fields are set.  That can show up readily with
> > the
> > "-mtraceback=full" option, probably unlikely with the default trace
> > table contents.   (tldr; it won't always be represented as .long
> > 0xfoo...).
> 
> OOC, does the ABI specify that the size of the function covers the
> Traceback information as well? 

The size of the function includes the traceback table.

>  I didn't find anything about that, and my initial
> reading of the wording used in the ABI "following the end of the
> code" would
> make me think that it should not.  If it wasn't, then of course
> disassembling
> a function would not run into the table.  Maybe it's done this way
> today to make it
> easier on the linker.
> 
> Regardless, I was wondering whether there's any way for GDB to know
> that
> a given PC range is a traceback table, so that it wouldn't try to
> disassemble
> such a range as instructions?  

GDB would have to determine the PC range of the traceback table.  You
start in the function and scan for a word of zeros that falls between
the function start address and the function start address plus the size
of the function.  So, if the traceback table was generated, you will
find a word of zeros.  In the case where the compiler flags were set to
not generate the traceback table, there will not be a word of zeros
before the function start address plus the size of the function.

> The ABI you pointed out says:
> 
> "Compilers should generate a traceback table following the end of the
> code for every function. Debuggers
> and exception handlers can locate the traceback tables by scanning
> forward from the instruction address
> at the point of interruption. The beginning of the traceback table is
> marked by a word of zeroes, which is
> an illegal instruction. If read-only constants are compiled into the
> same section as the function code, they
> must follow the traceback table. A word of zeroes as read-only data
> must not be the first word following
> the code for a function. A traceback table is word-aligned."
> 
> Naively, we could use the "word of zeroes" marker to see where the
> table starts, but it
> wouldn't work when you're disassembling a PC range instead of the
> whole function.

Basically you have to scan thru the function to find the word of zeros.

> 
> Is there perhaps some symbol that points to the start of the table, 

No

> or some section with the list
> of traceback tables in the program or some such?

Unfortunately the answer is again no.


I looked into the original problem report.  The issue had to do with
setting a break point on the last instruction in the function.  This
triggered an assert which was later fixed by commit 547ce8f00b
"[gdb/backtrace] Fix printing of fortran string args".  The commit adds
a call to select_frame in print_frame_args() in gdb/stack.c.  I tried
to dig into the specifics of how this change fixed the issue but I
don't see exactly how it fixed things.  Not sure knowing the details of
the fix is really necessary in this case, just interesting.

The test was added to check if the assert failed in the future due to
some code change.  The key thing is setting the break on the last
instruction in the function and verifying that gdb reaches the
breakpoint.  So, disabling the traceback table generation on PowerPC
allows the existing expect test to set the breakpoint on the last
instruction in the function, blr for PowerPC.  The test now behaves the
same on PowerPC as it does on other architectures.  I don't see that
not generating the traceback table on PowerPC would somehow invalidate
the ability of this test to verify the gdb code had not regressed.

I will fix up version 2 of the patch that disables the traceback table
per Will's comments and post version 3.

                           Carl Love