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

Elena Zannoni
2003-10-10T16:32:18Z

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.