abi-aa VS x86-64-ABI

As far as I know, kernel modules are ordinary relocatable ELF executables, so the best resource will be the ELF specifications. The ARM-specific parts can be found here.

Yes, that would be the case when your code's entry-point executes, and from then on it is your responsibility to maintain the alignment. It has nothing to do with AHB. This advisory has some examples of what can go wrong if your stack isn't 8-byte aligned. The alignment does not make much of a difference in your little function, but it's something to keep in mind as you write more complex code.

Normally you'd save more than just PC as AAPCS (https://github.com/ARM-software/abi-aa/blob/main/aapcs32/aap...) mandates stack to be aligned to 8 bytes for "public interface" functions. But this is is not a "public" function so it's fine to only save lr here.

"bx lr" is only used on it's own when the function doesn't call another function (altering lr), and doesn't need to save any registers.

If you see pop {lr}; bx lr then that's code that's being compiled to explicitly support Armv4 (e.g. Arm7TDMI)

The Arm Procedure Call Standards have "Arm C and C++ Language Mappings" sections that all say char is an "unsigned byte".

eabi: many pages in this official ARM repository define it as "An ABI suited to the needs of embedded, and deeply embedded (sometimes called free standing), applications." It seems to be the name of an ABI, or maybe the ABI, that code compiled for ARM chips is expected to use? Except there's also AEABI, the first A stands for ARM, and that's something different? ARM's naming conventions confuse me endlessly.

Latest versions of the ABI specifications linked in the Machine Specific section

ARM: https://github.com/ARM-software/abi-aa/releases

x86-64: https://gitlab.com/x86-psABIs/x86-64-ABI (go to most recent CI job and download artifacts for a compiled PDF)

> Apple changed some things that impact PyPy, like the register uses and ffi calling conventions.

I thought everyone who used 64-bit ARM used ARM's AAPCS64 (https://github.com/ARM-software/abi-aa/blob/master/aapcs64/a...), so the register usage and FFI calling convention should be the same as on Linux and Windows. What did Apple do that would affect the PyPy JIT?

Linux uses the sysv calling convention. I believe these are the official or semi-official documents for x86 64-bit and 32-bit, respectively:

https://gitlab.com/x86-psABIs/x86-64-ABI (Table 3.4 in section 3.2.3 lists which registers may be clobbered and which must be saved)

System V Application Binary Interface AMD64 Architecture Processor Supplement

ABI is just the name for any stable binary interface between parts of a program, eg in C there is a well-defined ABI for calling functions: https://gitlab.com/x86-psABIs/x86-64-ABI/-/jobs/artifacts/ma... https://www.agner.org/optimize/calling_conventions.pdf

If you combine that with a stable set of C function names and parameters, then you could define an ABI for kernel modules if you (and the Linux developers) wanted. While it sounds like a good idea, the outcome probably wouldn't be great for users.

But in the same breath, that paragraph's footnote points directly to the Itanium C++ ABI specification which seems to do precisely what they said has never been done. (I've filed a bug...).

The supposed latest psABI specs (https://gitlab.com/x86-psABIs/x86-64-ABI) contain the following, with regards to classifying aggregates for argument passing (section 3.2.3, page 24, of the AMD64 ABI 1.0 – December 6, 2022 specs):

RHEL, from version 9, requires x86-64 v2. The levels are a common effort between several companies, AMD included. The definitions can be found in this repo, and here is the latest PDF.

Note that this isn't the most up-to-date version of the x86-64 SysV ABI--if you want that, go to https://gitlab.com/x86-psABIs/x86-64-ABI/-/jobs/artifacts/ma... .

Although I think the only updates since the version linked here are effectively editorial in note. The last big updates are adding AMX registers to the ABI, and the addition of microarchitecture levels, both of which are in this version.

As far as calling conventions go, it's explained very thoroughly in the AMD64 psABI. I know it's not the easiest read, but it does say that the first integer parameter is passed in RDI.

Latest versions of the ABI specifications linked in the Machine Specific section

ARM: https://github.com/ARM-software/abi-aa/releases

x86-64: https://gitlab.com/x86-psABIs/x86-64-ABI (go to most recent CI job and download artifacts for a compiled PDF)

For x86_64-linux-gnu, you can read the table in this TeX source file (I'm not aware of an up-to-date rendered PDF yet - when development moved from github to gitlab the wiki seems to have been abandoned without replacement)