Do not panic generating accessors for large bitfields

[fitzgen]

This input

struct HasBigBitfield {
    __int128 x : 128;
};

results in this panic while generating bitfield accessor methods:

thread 'main' panicked at 'physical field containing bitfields should be sized 8, 4, 2, or 1 bytes'

But we should just skip the bitfield accessor method for such large bitfields instead of panicking. See Bitfield::codegen_fields inside src/codegen/mod.rs.

Happy to mentor someone on fixing this :)

[highfive]

Hi! If you have any questions regarding this issue, feel free to make a comment here, or ask it in the #servo channel in IRC.

If you intend to work on this issue, then add @highfive: assign me to your comment, and I'll assign this to you. 😄

[fitzgen]

@barrotsteindev, perhaps this is something you'd be interested in hacking on?

[chansuke]

@highfive assign me

[highfive]

Hey @chansuke! Thanks for your interest in working on this issue. It's now assigned to you!

[fitzgen]

@chansuke thanks for picking up this issue :) How is it going? Any questions I can answer for you?

[chansuke]

@fitzgen Oh, thank you:)I started reading the code and will start changing this part.

if field_size_in_bits != 0 {                           
    // Flush the last physical field and its bitfields.
    fields.push(flush_bitfields(ctx,                   
                                field_size_in_bits,    
                                last_field_align,      
                                &last_field_name,      
                                bitfields.drain(..),   
                                methods));             
}                                                      

I will stop calling flush_bitfields for large bitfields.Is this the right approach?

[fitzgen]

We still want to generate the correct physical field, so the struct containing it still has the correct layout (or at least has correct size, since we can't generate 128 bit alignment in Rust yet).

Here is what I would do. I would replace this panic:

            _ => panic!("physical field containing bitfields should be sized \
                         8, 4, 2, or 1 bytes")

with something like this:

_ => return field,

so we just generate the physical field of the appropriate size and do not generate any bitfield getters or setters.

I would also move the match that this is a part of outside the loop since it doesn't need to be recalculated on every iteration.

Does that make sense?

[jdm]

@chansuke Have you made any progress?

[fitzgen]

Unassigning due to radio silence.

@chansuke, if you're still planning on working on this issue, leave a comment and we can re-assign it to you :)

[Tiwalun]

@fitzgen Can I have a go at this?

[fitzgen]

@Tiwalun sure thing! Take a look at the backlog discussion, and if you have any questions, just ping me here or on IRC :)