[SPARC] callfuncs.exp: avoid spurious register differences in sparc64 targets.

  Hi all!  Ok to commit?

commit 50fa72dabc43ba7fabbd5d213013d78cd22e2342
Author: Jose E. Marchesi <jose.marchesi@oracle.com>
Date:   Thu Nov 19 10:55:06 2015 -0500

    callfuncs.exp: avoid spurious register differences in sparc64 targets.
    
    The Linux kernel disables the FPU upon returning to userland.  This
    introduces spurious failures in the register preservation tests in
    callfuncs.exp, since the pstate.PEF bit gets cleared after system calls.
    
    This patch filters out the pstate register in sparc64-*-linux-gnu
    targets, so the relevant tests are no longer fooled and pass.
    
    gdb/testsuite/ChangeLog:
    
    2015-11-19  Jose E. Marchesi  <jose.marchesi@oracle.com>
    
    	* gdb.base/callfuncs.exp (fetch_all_registers): Filter out the
    	pstate register when comparing registers values in
    	sparc64-*-linux-gnu targets to avoid spurious differences.
  

On 11/19/2015 04:02 PM, Jose E. Marchesi wrote:
> 
> Hi all!  Ok to commit?
> 
> commit 50fa72dabc43ba7fabbd5d213013d78cd22e2342
> Author: Jose E. Marchesi <jose.marchesi@oracle.com>
> Date:   Thu Nov 19 10:55:06 2015 -0500
> 
>     callfuncs.exp: avoid spurious register differences in sparc64 targets.
>     
>     The Linux kernel disables the FPU upon returning to userland.  This
>     introduces spurious failures in the register preservation tests in
>     callfuncs.exp, since the pstate.PEF bit gets cleared after system calls.

> +	-re  "^pstate\[ \t\]+\[^\r\n\]+\r\n" {
> +	    if [istarget "sparc64-*-linux-gnu"] {
> +		# Filter out the pstate register, since in sparc64
> +		# targets the Linux kernel disables pstate.PEF when
> +		# returning from traps, giving spurious differences.

Isn't this a kernel bug?  It sounds like it's impossible to debug FPU
code if you e.g. step over FPU instructions?

> +	    } else {
> +		lappend all_registers_lines $expect_out(0,string)
> +	    }
> +	    exp_continue
> +	}

Thanks,
Pedro Alves
  

> +	-re  "^pstate\[ \t\]+\[^\r\n\]+\r\n" {
    > +	    if [istarget "sparc64-*-linux-gnu"] {
    > +		# Filter out the pstate register, since in sparc64
    > +		# targets the Linux kernel disables pstate.PEF when
    > +		# returning from traps, giving spurious differences.
    
    Isn't this a kernel bug?  It sounds like it's impossible to debug FPU
    code if you e.g. step over FPU instructions?

No, it is not a kernel bug.  It is a consequence of how the sparc
kernel port handles the restoring of FP registers clobbered by kernel
code.  As far as I understand it:

When an user program uses the FPU in any way (any instruction
referencing FP registers for example) a fp_disabled trap is triggered
and the kernel enables the FPU so the user program can happily continue
executing FPU instructions.

If at some point the user program traps into the kernel (syscall, or
whatever) with the FPU activated the kernel saves whatever FP registers
it may clobber in the corresponding thread struct.  Then it disables the
FPU and returns to the user program.

Then, if the user program uses the FPU again, another fp_disabled trap
is triggered, and the kernel will both re-activate the FPU and restore
all the "dirty" FP registers that were clobbered in the previous trap.
  

On 11/19/2015 05:19 PM, Jose E. Marchesi wrote:
> 
>     > +	-re  "^pstate\[ \t\]+\[^\r\n\]+\r\n" {
>     > +	    if [istarget "sparc64-*-linux-gnu"] {
>     > +		# Filter out the pstate register, since in sparc64
>     > +		# targets the Linux kernel disables pstate.PEF when
>     > +		# returning from traps, giving spurious differences.
>     
>     Isn't this a kernel bug?  It sounds like it's impossible to debug FPU
>     code if you e.g. step over FPU instructions?
> 
> No, it is not a kernel bug.  It is a consequence of how the sparc
> kernel port handles the restoring of FP registers clobbered by kernel
> code.  As far as I understand it:
> 
> When an user program uses the FPU in any way (any instruction
> referencing FP registers for example) a fp_disabled trap is triggered
> and the kernel enables the FPU so the user program can happily continue
> executing FPU instructions.
> 
> If at some point the user program traps into the kernel (syscall, or
> whatever) with the FPU activated the kernel saves whatever FP registers
> it may clobber in the corresponding thread struct.  Then it disables the
> FPU and returns to the user program.
> 
> Then, if the user program uses the FPU again, another fp_disabled trap
> is triggered, and the kernel will both re-activate the FPU and restore
> all the "dirty" FP registers that were clobbered in the previous trap.

Thanks for the explanation.

So until the program re-activates the FPU, when the user displays the FP
registers, gdb actually shows the fpu registers as saved in the thread
struct, right?  Not the values clobbered by the kernel?  I'd guess so,
otherwise people would have noticed the breakage sooner, and assuming
the kernel does use FPU instructions itself, then you'd get other
spurious register differences with callfuncs.exp too.  Patch is OK
assuming that.

Still sounds to me that it'd be better if ptrace traps left the FPU
activated if it was activate on entry, on principle of minimizing
program perturbation with a ptrace observer though ...

Thanks,
Pedro Alves
  

>     > +	-re  "^pstate\[ \t\]+\[^\r\n\]+\r\n" {
    >     > +	    if [istarget "sparc64-*-linux-gnu"] {
    >     > +		# Filter out the pstate register, since in sparc64
    >     > +		# targets the Linux kernel disables pstate.PEF when
    >     > +		# returning from traps, giving spurious differences.
    >     
    >     Isn't this a kernel bug?  It sounds like it's impossible to debug FPU
    >     code if you e.g. step over FPU instructions?
    > 
    > No, it is not a kernel bug.  It is a consequence of how the sparc
    > kernel port handles the restoring of FP registers clobbered by kernel
    > code.  As far as I understand it:
    > 
    > When an user program uses the FPU in any way (any instruction
    > referencing FP registers for example) a fp_disabled trap is triggered
    > and the kernel enables the FPU so the user program can happily continue
    > executing FPU instructions.
    > 
    > If at some point the user program traps into the kernel (syscall, or
    > whatever) with the FPU activated the kernel saves whatever FP registers
    > it may clobber in the corresponding thread struct.  Then it disables the
    > FPU and returns to the user program.
    > 
    > Then, if the user program uses the FPU again, another fp_disabled trap
    > is triggered, and the kernel will both re-activate the FPU and restore
    > all the "dirty" FP registers that were clobbered in the previous trap.
    
    Thanks for the explanation.
    
    So until the program re-activates the FPU, when the user displays the FP
    registers, gdb actually shows the fpu registers as saved in the thread
    struct, right?  Not the values clobbered by the kernel?  I'd guess so,
    otherwise people would have noticed the breakage sooner, and assuming
    the kernel does use FPU instructions itself, then you'd get other
    spurious register differences with callfuncs.exp too.

Right.  PTRACE_GETREGS[64] always fetches the floating-point registers
saved in the thread struct save area (if a thread is ptracing itself it
saves the registers in the save area first).  At the point GDB ptraces
the target process everything is saved.

    Patch is OK assuming that.

Pushed.
Thanks.