I don't think this is something that should be measured, because what you see could easily be an artefact of coincidence.

I hate to point out the obvious but either the source code or the documentation, or both, should tell you what the alignment is expected to be.

format ELF64 executable 3

entry $

;The stack is consistently aligned to 16 by default here
;Now you can safely access any syscalls with guaranteed alignment
;no external alignment needed. Any attempt to align will break the whole alignment ecosystem.

;exit    

format ELF64
public something

something:

;The stack is NOT GUARANTEED to be aligned to 16 by default here
;Now we're not sure anymore. Should we aligned the stack externally b4 using syscalls / C library? 

;exit    

Linux doesn't require 16-byte alignment. Perhaps you are confusing things with Windows fastcall convention.

Okay, maybe you are right. There often seems to be conflicting information about Linux.

In that case I would hesitate to always rely upon the test results to "confirm" that the stack is, or isn't, aligned correctly at the application entry point. Instead, just add the appropriate and rsp,-16 once as the first instruction and then you don't have to care about it again.

revolution is half-right. The Linux Kernel does not require stack alignment. i.e. syscalls don't.

However, shared libraries do, since they follow the stupid AMD ABI.

If you only use the Linux Kernel (which is technically "Linux", libraries aren't), then you don't need alignment of stack. If you call into GNU libraries or whatever you'll need alignment though.

But Linux kernel is fully backwards compatible and they never introduce breaking changes. I don't understand your worry though? If the specification says it doesn't require 16-byte alignment, then it will always work without 16-byte alignment, unless they break the spec (which they won't, like I said, Linus values backwards compatibility; his words "we never break userland")

As a matter of fact they had a bug suggestion on GCC to allow 8-byte aligned stack for the kernel, to not waste space: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=53383

Yes, the kernel barely uses SSE, and when it does it aligns the stack properly by itself. If in the future it will use more SSE, it will align the stack itself, so you don't have to worry about it when using syscall.

Then again, who's to say it won't use AVX or AVX512 in the future instead of SSE? (to be honest, they probably already do). The kernel is known to use the latest instruction sets, anyway, quite early might I add. Are you going to align the stack to 64-bytes? What if they add 128-byte vectors? See where I'm going?

I don't think you have to worry when doing syscalls, unless I misunderstand your situation? If the kernel will use vectors, it will align the stack itself, like a sane ABI.

If you need some particular alignment then do it yourself. and rsp,-16: done. Just assume the alignment from the kernel is random, and make it what you need. It is only one single instruction, no big deal.

Calling conventions are more than just the stack alignment. And in fact you would be complying with the convention (not disregarding it) if you align accordingly.