StructLocalVariable.c — a struct on the stack

StructLocalVariable.c takeaways

• Struct members keep their declaration order in memory. Compare with 004: the bare locals a, b, c got shuffled to a, c, b. Wrap the same three in a struct and the C standard pins them: a, then b, then c, at increasing offsets. Structs are a contract about layout; loose locals are not.
• The access code is byte-for-byte the same skeleton as ArrayLocalVariable — same imul index math, same movsx/movsxd/movzx, same values — only the displacements changed (rows marked Δ004 above).
• And the course's rotated-slide gag: in a stack diagram drawn with high addresses on top, offset 0 sits at the bottom — so the struct reads bottom-up. Flip the declaration and it lines up with the diagram:

The plot twist — expected layout vs. what the disassembly says

Draw the struct by MS' documented alignment & padding rules and you get the left diagram. But the disassembly stores c at [rsp+1Ah] and bases b at +2 — this build used 1-byte structure packing (#pragma pack(1) / /Zp1), so the real layout is the right diagram: no padding anywhere, nothing aligned, values straddling the 4-byte rows.

• How to spot packing from asm alone: the displacements. Default rules put b at +4 and c at +20h; this binary uses +2 and +1Ah. Odd/unrounded struct offsets in disassembly ⇒ somebody set #pragma pack.
• The misaligned qword: mov qword ptr [rsp+1Ah], rax writes 8 bytes at an address ≡ 2 (mod 8), spanning three of our 4-byte rows. x86 shrugs and does it (slower, possibly split across cache lines, no atomicity guarantee) — plenty of other CPUs would raise an alignment fault instead.
• Why pack at all? Wire formats, file formats, and protocol structs where every byte's position is law — the same reason reverse engineers care: a packed struct in a binary usually means "this memory is an external data format".

MS' struct alignment & padding rules — the 60-second version

From the x64 software conventions doc: scalar types align to their own size; each member is placed at the next multiple of min(its alignment, the packing level); the whole struct's size is rounded up to a multiple of its strictest member's alignment.

Frame-size coincidence: 0x28 and 0x22 both round up to 0x30 in 16-byte chunks, + 8 alignment = sub rsp, 38h either way — you can't tell the packing from the prologue, only from the member displacements.