Re: IA32: printing FP register variables

[Robert Lipe <robertlipe@usa.net>]

>   > Hmm.  What other IA32 compilers produce STABS?  How do they number FP
>   > registers?
> Dunno.  Robert -- can you see what the SCO compilers do with this stuff?
> That might be interesting.

I know of zero SCO-supplied compilers that produce stabs.  There are
tools that do COFF (a.k.a. SDB) and tools that do ELF (dwarf-1 and
dwarf-2).  Is the really stab-specific, or do you want to know in
general how they're numbered in whatever format is used?

Since I speak no debugging formats and I speak zero floating point I'll
have to dig for an answer.   If, OTOH, there's some program I can build 
that'll help answer the question, shoot it my way.

RJL
From amylaar@cygnus.co.uk Mon Jul 12 17:24:00 1999
From: Joern Rennecke <amylaar@cygnus.co.uk>
To: law@cygnus.com
Cc: amylaar@cygnus.co.uk, jimb@cygnus.com, egcs@egcs.cygnus.com, gdb@sourceware.cygnus.com
Subject: Re: IA32: printing FP register variables
Date: Mon, 12 Jul 1999 17:24:00 -0000
Message-id: <199907130023.BAA25804@phal.cygnus.co.uk>
References: <9384.931824345@upchuck.cygnus.com>
X-SW-Source: 1999-q3/msg00059.html
Content-length: 1137

> Consider two threads of control, each with one variable on the FP stack.
> 
> At some point they merge.  One variable has to be on the bottom, the other
> on the top.
> 
> regstack has to track this stuff and emit appropriate code at block boundaries
> to move stuff around via copies.

Currently, flow will consider both variables live in the predecessor blocks
if they are live in the successor block.  We'd need better data & control
flow analysis to find cases where a varaible is indeed live only in a
subset of the predecessor blocks.

So I guess that you are talking about the case when the variables were
allocated in different positions in the register stack in the different
predecessor blocks.  That means that the number of live registers in the
FP stack doesn't change at the basic block boundary, but but the positions of
two or more variables change.  Since the stack usage stays the same,
the number of variables that change location is the same no matter if
we count from the top or from the bottom of the stack.
We'll have to emit enough debugging information as it takes then to
describe all these position changes.
From law@cygnus.com Mon Jul 12 17:49:00 1999
From: Jeffrey A Law <law@cygnus.com>
To: Robert Lipe <robertlipe@usa.net>
Cc: Jim Blandy <jimb@cygnus.com>, egcs@egcs.cygnus.com, gdb@sourceware.cygnus.com
Subject: Re: IA32: printing FP register variables 
Date: Mon, 12 Jul 1999 17:49:00 -0000
Message-id: <9500.931826533@upchuck.cygnus.com>
References: <19990712191723.E3871@rjlhome.sco.com>
X-SW-Source: 1999-q3/msg00060.html
Content-length: 1045

  In message < 19990712191723.E3871@rjlhome.sco.com >you write:
  > >   > Hmm.  What other IA32 compilers produce STABS?  How do they number FP
  > >   > registers?
  > > Dunno.  Robert -- can you see what the SCO compilers do with this stuff?
  > > That might be interesting.
  > 
  > I know of zero SCO-supplied compilers that produce stabs.  There are
  > tools that do COFF (a.k.a. SDB) and tools that do ELF (dwarf-1 and
  > dwarf-2).  Is the really stab-specific, or do you want to know in
  > general how they're numbered in whatever format is used?
The general case would be good to know as a starting point.  Particularly
what gets inencoded into the register # field in the dwarf records.

  > Since I speak no debugging formats and I speak zero floating point I'll
  > have to dig for an answer.   If, OTOH, there's some program I can build 
  > that'll help answer the question, shoot it my way.
Not really.  I suspect you could probably take just about anything with a few
FP ops from the gcc testsuite as a sample program.

jeff