kcc and gcc disagree on well-defined program (packed offsetof)

[grosu]

The following program is well-defined according to kcc, yet they show different outputs.

$ gcc 3-array-in-struct.c
$ ./a.out ; echo $?
offsetof: 31
5
$ kcc 3-array-in-struct.c
$ ./a.out ; echo $?
offsetof: 32
5
$ 

Here is the program:

#include <stddef.h>
#include <stdio.h>

struct foo {
  char buffer[31];
  int secret __attribute__ ((packed));
};

int idx = 0;

void setIdx() {
  idx = 31;
}

int main() {
  setIdx();
  struct foo x = {0};
  printf("offsetof: %lu\n", offsetof(struct foo, secret));;
  x.secret = 5;
  char* d = (char*)(&x);
  d += offsetof(struct foo, secret);
  int * e = (int *)d;
  return *e;
}

@diekmann thinks: I specified the struct with the attribute packed, so the offset must be 31. kcc reports undefined behavior if I remove the offsetof and replace it with 31.

[diekmann]

By the way, in the example code above, setIdx and idx can be ignored (sorry for not cleaning up the example completely).

The gcc documentation says:

packed
The packed attribute specifies that a variable or structure field should have the smallest possible alignment—one byte for a variable, and one bit for a field, unless you specify a larger value with the aligned attribute.
Here is a structure in which the field x is packed, so that it immediately follows a:

          struct foo
          {
            char a;
            int x[2] __attribute__ ((packed));
          };

If we change char buffer[31]; to char buffer[127];, without the __attribute__ ((packed)), we can see that gcc (4.8.4-2ubuntu1~14.04.3) with optimizations is also aligning everything to the 128 byte boundary. Adding __attribute__ ((packed)) to the variable will force it to 127 again.

I did not test what happens if I pack the complete struct, i.e.:

struct foo {
  char buffer[127];
  int secret;
}  __attribute__ ((packed));

Does kcc support this?
This would be important for almost any implementation of binary network protocols.

[chathhorn]

Yeah, all __attribute__s are currently ignored, but support for packed structs is definitely something we should add.

[ellisonch]

To be clear, "packed" is an extension and is not part of the C standard
(it's not even mentioned), which is why it wasn't originally included. It
is a very commonly used extension, so it would be neat to formalize it for
different implementations.

On Sat, Aug 6, 2016 at 8:44 PM, Chris Hathhorn notifications@github.com
wrote:

Yeah, all __attribute__s are currently ignored, but support for packed
structs is definitely something we should add.

—
You are receiving this because you are subscribed to this thread.
Reply to this email directly, view it on GitHub
#255 (comment),
or mute the thread
https://github.com/notifications/unsubscribe-auth/ABOcp620ZknX4fqB8z_ZTb5BByGaSC4zks5qdSpTgaJpZM4JeRIq
.

[diekmann]

At least it shouldn't be silently ignored?

[chathhorn]

Added support in b3b1c78