Aligning memory address of specific pragma packed struct member? - c++

Question

I have a struct with data members with types of different lengths (some ints, some words, some just single bytes). The struct is packed (using #pragma pack(1)).
My question is: Is it possible to have one of the struct's data members memory address be aligned in memory (for example, have the address be divisable by 16)?
I know it is possible to align the whole struct (or in other words, its first member) using attribute. I want to know if it's possible to align a specific member and not just the first one.
Basically I need the struct to be packed (every member follows the previous one without padding) and I need that the address of one of the members, not the first one, be divisable by 16.

Answer 1

There doesn't seem to be any possibility to align structures with an offset. You must create the offset (padding) by yourself.
typedef struct __attribute__((packed)) special_align {
char misc[3];
int align_me;
};
typedef struct __attribute__((packed, aligned(16))) pad_container {
char padding[13]; //16-3
struct special_align data;
};
Of course accessing the struct will become more cumbersome.
If you don't want to calculate by hand how much padding you need, you can use the offsetof() macro. In the example offsetof(struct special_align,align_me) will return 3, that is to be substracted from the align size. (of course if the offset is greater than align, you must use a corresponding pad size multiplier. `
pad_size = (sizeof(special_align) * align_size - offsetof(special_align,align_me)) % align_size;

Answer 2

#pragma pack(1) is nasty -- once it is set for a given structure, it will apply to every member of that structure. None of alignas, __attribute__((packed, aligned(8))), std::aligned_storage, std::aligned_union, #pragma pack() constructs inside that structure will affect the alignment, the original packing will be maintained for the whole structure (an intermediate #pragma pack() will apply to any inner structure that follows, but the outer structure will be packed with its original packing).
So the only solution is to pack your structure manually, by adding padding bytes where necessary.
I'm using something like this, it triggers a compiler error and also shows what the (incorrect) alignment is:
template<int s> struct OffsetIs;
template<int N>
struct CheckAlignment {
static constexpr size_t ok = sizeof(OffsetIs<N>);
};
template<>
struct CheckAlignment<0> {
static constexpr bool ok = true;
};
#pragma pack(1)
struct MyStruct
{
char a;
//char pad[3]; // uncomment to make it compile
long x;
};
#pragma pack()
static_assert(CheckAlignment<offsetof(MyStruct, x) % 4>::ok, "Alignment of x is wrong");