Re: [RFA] sh-tdep.c (sh_use_struct_convention): Restructure and fix

[Elena Zannoni <ezannoni at redhat dot com>]

Corinna Vinschen writes:
 > On Fri, Oct 10, 2003 at 09:29:29AM +0200, Corinna Vinschen wrote:
 > > And even though I have to admit, that I'm not 100% sure (perhaps
 > > I miss a case) I think the implementation should match at least 99%
 > > of the description. 
 > > 
 > > The difference between the old and the new code is given by allowing
 > > 4 byte structs (erm, aggregates) with more than one element, but a size
 > > of 4 byte for the first element.  This sounds somewhat weird, but that's
 > > exactly the case if the 4 byte agregate is a bitfield or contains a
 > > bitfield.  So the change in this patch solves exactly these bitfields
 > > as return type problem.
 > 
 > ...and I just found out what this patch does *not* cover.  It does
 > not cover the case of bitfields of size 1 or 2 bytes :-(
 > 

Argh, I just noticed this mail. 

 > I rewrote the implementation of sh_use_struct_convention and tested it
 > again.  Below is the entire implementation instead of the patch.  I think
 > this is easier to read.  I also tried to match the comments even better
 > to the actual code.  Is that ok to check in?
 > 
 > Btw., this time, there *are* tests missing.  The testsuite doesn't check
 > for returning bitfield types of size 1 and 2 bytes.  I'm going to add
 > two tests to call-rt-st.exp which I hope to submit at least Monday.
 > 
 > Corinna
 > 
 > ========== SNIP ===========
 > static int
 > sh_use_struct_convention (int gcc_p, struct type *type)
 > {
 >   int len = TYPE_LENGTH (type);
 >   int nelem = TYPE_NFIELDS (type);
 > 
 >   /* Non-power of 2 length types and types bigger than 8 bytes (which don't
 >      fit in two registers anyway) use struct convention.  */
 >   if (len != 1 && len != 2 && len != 4 && len != 8)
 >     return 1;
 > 
 >   /* Scalar types and aggregate types with exactly one field are aligned
 >      by definition.  They are returned in registers.  */
 >   if (nelem <= 1)
 >     return 0;
 > 
 >   /* If the first field in the aggregate has the same length as the entire
 >      aggregate type, the type is returned in registers.  */
 >   if (TYPE_LENGTH (TYPE_FIELD_TYPE (type, 0)) == len)
 >     return 0;
 > 
 >   /* If the size of the aggregate is 8 bytes and the first field is
 >      of size 4 bytes its alignment is equal to long long's alignment,
 >      so it's returned in registers.  */
 >   if (len == 8 && TYPE_LENGTH (TYPE_FIELD_TYPE (type, 0)) == 4)
 >     return 0;
 > 
 >   /* Otherwise use struct convention.  */
 >   return 1;
 > }


Much better, however, I would still like to know what the behavior is
for a struct of 2 chars.  Probably this needs another test case.

elena


 > ========== SNAP ===========
 > 
 > 
 > -- 
 > Corinna Vinschen
 > Cygwin Developer
 > Red Hat, Inc.