Questions on bitfields and struct

[sarathy]

Hi,

1. How it that the results for the size of struct1 and struct2 (below)
are 4 and 3

# include <stdio.h>

struct struct1
{
const :16;
volatile :4;
};

struct struct2
{
int :1;
unsigned :1;
const :16;
volatile :4;
};

int main()
{
printf ("Size of struct 1 = %d\n",sizeof(struct struct1)); /*
Prints 4 */
printf ("Size of struct 2 = %d\n",sizeof(struct struct2)); /*
Prints 3 */

}

2. Also what is meant by "incomplete type" in C?
3. What does tag refer to in a struct/union declaration?

Regards,
Sarathy

 

[Walter Roberson]

1. How it that the results for the size of struct1 and struct2 (below)
are 4 and 3

struct struct1
{
const :16;
volatile :4;
};

struct struct2
{
int :1;
unsigned :1;
const :16;
volatile :4;
};

With SGI's IRIX cc compiler, both are 3. With gcc 3.3 on the same
machine, the first is 4 and the second is 3. Which is to say that the
alignment mechanisms are implementation dependant, and are not required
to be consistant.

It is, for example, entirely legal for the compiler to examine the
first structure, note that the first field is the same size as a short
int on that implementation, and decide that the structure shall be
built for fast access as a pair of shorts aligned on a short boundary,
for a total of 4 bytes.

The same compiler could look at the second structure and decide that it
is complicated enough that space is the important factor rather than
speed, and decide to pull bits out of 3 bytes.

But compilers are not required to allow bitfields to cross word
boundaries, so the compiler -could- have decided to put the first two
fields into one short, the third field into a second short, and the
fourth field into a third short, for a total of 6 bytes. Or it could
have decided that since the total fits within 32 bits that it would
pull bits out of a long, for a total of 4 bytes.

Decisions about when to move to the next word and how much padding
to use before that word are completely up to the compiler: the
closest that the C standard comes on this point is to say "if it fits".

2. Also what is meant by "incomplete type" in C?

The C faq probably talks about that in better words than I could
come up with in a reasonable time.

3. What does tag refer to in a struct/union declaration?

A structure tag is a programmer-given name for that variety of
structure. It is not a variable, but rather a reference to the type.
As a rough analogy: "Form 37/J" might be a name given to a particular
layout of income tax form, but "Form 37/J" is not a particular -copy-
of the form, it is the name of the -kind- of form.

 

[sarathy]

With SGI's IRIX cc compiler, both are 3. With gcc 3.3 on the same
machine, the first is 4 and the second is 3. Which is to say that the
alignment mechanisms are implementation dependant, and are not required
to be consistant.

It is, for example, entirely legal for the compiler to examine the
first structure, note that the first field is the same size as a short
int on that implementation, and decide that the structure shall be
built for fast access as a pair of shorts aligned on a short boundary,
for a total of 4 bytes.

The same compiler could look at the second structure and decide that it
is complicated enough that space is the important factor rather than
speed, and decide to pull bits out of 3 bytes.

But compilers are not required to allow bitfields to cross word
boundaries, so the compiler -could- have decided to put the first two
fields into one short, the third field into a second short, and the
fourth field into a third short, for a total of 6 bytes. Or it could
have decided that since the total fits within 32 bits that it would
pull bits out of a long, for a total of 4 bytes.

Decisions about when to move to the next word and how much padding
to use before that word are completely up to the compiler: the
closest that the C standard comes on this point is to say "if it fits".



The C faq probably talks about that in better words than I could
come up with in a reasonable time.



A structure tag is a programmer-given name for that variety of
structure. It is not a variable, but rather a reference to the type.
As a rough analogy: "Form 37/J" might be a name given to a particular
layout of income tax form, but "Form 37/J" is not a particular -copy-
of the form, it is the name of the -kind- of form.

Thanks a lot. I got the things clear now. The next fun starts...
Consider the code

struct struct1
{
short a1:16;
short b1:4;
};



struct struct2
{
int a2:16;
unsigned b2:1;
short c2 :16;
short d2 :4;
};



int main()
{
struct struct1 *str1=(struct struct1 *)malloc(sizeof(struct
struct1));
str1->a1=24;
str1->b1=4;
print_bits(str1,sizeof(str1));
printf ("Size of struct1 = %d\n",sizeof(struct struct1));
/* Prints 4 */
printf ("Size of str1 = %d\n",sizeof(str1)); /* Prints 4
*/



struct struct2 *str2=(struct struct2 *)malloc(sizeof(struct
struct2));
str2->a2=1;
str2->b2=1;
str2->c2=6;
str2->d2=12;
print_bits(str2,sizeof(struct struct2));
printf ("Size of struct2 = %d\n",sizeof(struct struct2));
/* Prints 8 */
printf ("Size of str2 = %d\n",sizeof(str2)); /* Prints 4
*/
}


Output:
----------

00000000 00000100 00000000 00011000
Size of struct1 = 4
Size of str1 = 4
00000000 00001100 00000000 00000110 00000000 00000001 00000000 00000001
Size of struct2 = 8
Size of str2 = 4

Is there any difference in sizeof (struct tag_name) and
sizeof(struct_instance_identifier)
In the third case, clearly from the results, 8 is correct due to
padding. But why is 4 being printed in the last printf.

 

[Walter Roberson]

Walter Roberson wrote:

[lots]

Please trim down quotations to just the portion needed for discussion.

Consider the code

struct struct2 *str2=(struct struct2 *)malloc(sizeof(struct
struct2));

printf ("Size of str2 = %d\n",sizeof(str2)); /* Prints 4
*/

Size of str2 = 4

Is there any difference in sizeof (struct tag_name) and
sizeof(struct_instance_identifier)
No.


In the third case, clearly from the results, 8 is correct due to
padding. But why is 4 being printed in the last printf.

Because str2 is not an instance of struct struct2.
str2 is a *pointer* to an instance of struct struct2.
sizeof(str2) is printing out the size of the pointer.

 

[sarathy]

Hi,
Does the 4 imply that the machine is 32 bit using 32 bit
addressing?
Does this have any impact on wordlength of the machine, because

in Turbo C in Windows(DOS environment) int --> 16 bit == address
length
in gcc in i386 Linux int --> 32 bits == address length

Regards,
Sarathy

 

[Barry Schwarz]

Hi,
Does the 4 imply that the machine is 32 bit using 32 bit
addressing?

I give up - what 4?

Does this have any impact on wordlength of the machine, because

And what this?

in Turbo C in Windows(DOS environment) int --> 16 bit == address
length
in gcc in i386 Linux int --> 32 bits == address length

We normally avoid issues regarding specific compilers and operating
systems. There are groups where those subjects are topical.


Remove del for email

 

[Mark McIntyre]

Hi,
Does the 4 imply that the machine is 32 bit using 32 bit
addressing?

Which 4?

 

[Andrew Poelstra]

Does the 4 imply that the machine is 32 bit using 32 bit addressing?

What 4 are you talking about?

Does this have any impact on wordlength of the machine, because in
Turbo C in Windows(DOS environment) int --> 16 bit == address length

C has no concept of "wordlength".

in gcc in i386 Linux int --> 32 bits == address length

This is true to the best of my knowledge, but your other questions make
me wonder how you arrived at that figure. Not by multiplying anything by
8, right?