pico-bootrom VS abi-aa

Espressif is years ahead.

Original RPi-pico has only few one-ups on ESP - BSD-licensed bootrom [0] and PIO.

PicoW doesn't have any, at all. Disappointingly lazy move from pi foundation.

[0] https://github.com/raspberrypi/pico-bootrom/

Crosslinking the two posts: https://github.com/raspberrypi/pico-bootrom/issues/17

I would think that the bootloader code wouldn't use any funky IP blocks - it's not some sort of driver code into which applications call, it's just a special application that runs before anything else. It has to be able to talk UART (or some other interface), check signatures, and write flash. All of these the user code can do as well.

There are many "user-space" bootloaders as well for various chips. The factory bootloader is only different in that it sits in ROM. For example, RP2040 ROM bootloader is here https://github.com/raspberrypi/pico-bootrom

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?