Here is an excellent doc.
Answer from zhigang on Stack OverflowTool chains have a loose name convention like arch [-vendor] [-os] - eabi
arch - refers to target architecture (which in our case is ARM) vendor - refers to toolchain supplier os - refers to the target operating system eabi - refers to Embedded Application Binary Interfacesome illustrations as follows :
- arm-none-eabi - This tool chain targets for ARM architecture, has no vendor, does not target an operating system and complies with the ARM EABI.
- arm-none-linux-gnueabi - This toolchain targets the ARM architecture, has no vendor, creates binaries that run on the Linux operating system, and uses the GNU EABI. It is used to target ARM-based Linux systems.
Here is an excellent doc.
Tool chains have a loose name convention like arch [-vendor] [-os] - eabi
arch - refers to target architecture (which in our case is ARM) vendor - refers to toolchain supplier os - refers to the target operating system eabi - refers to Embedded Application Binary Interfacesome illustrations as follows :
- arm-none-eabi - This tool chain targets for ARM architecture, has no vendor, does not target an operating system and complies with the ARM EABI.
- arm-none-linux-gnueabi - This toolchain targets the ARM architecture, has no vendor, creates binaries that run on the Linux operating system, and uses the GNU EABI. It is used to target ARM-based Linux systems.
Each architecture or architecture/os couple has an ABI. The ABI (Application binary Interface) describes how functions should be called, syscalls numbers, arguments passed, which registers can be used ...
The abi describes how the compiler should generate the assembly.
If you use only assembler you don't need to care about the ABI.
arm-elf and arm-none-eabi just use two versions of the Arm ABI. The eabi toolchain uses a newer revision, but could also be called arm-elf-eabi, as it generates elf too.
difference gcc-arm-none-eabi and arm-none-eabi-gcc
embedded - Difference between arm-none-eabi and arm-linux-gnueabi? - Stack Overflow
What are the purposes of the ARM ABI and EABI? - Stack Overflow
embedded - What is the difference between aarch64-none-elf and arm-none-eabi? - Stack Overflow
gcc-arm-none-eabi toolchain, my major question is, why is it made and for what problem to solve ? before toolchains existed, what were the methods used to program a chip ??
also, who makes toolchains and how are they doing it ??
An ABI (Application Binary Interface) is a standard that defines a mapping between low-level concepts in high-level languages and the abilities of a specific hardware/OS platform's machine code. That includes things like:
- how C/C++/Fortran/... data types are laid out in memory (data sizes / alignments)
- how nested function calls work (where and how the information on how to return to a function's caller is stored, where in the CPU registers and/or in memory function arguments are passed)
- how program startup / initialization works (what data format an "executable" has, how the code / data is loaded from there, how DLLs work ...)
The answers to these are:
- language-specific (hence you've got a C ABI, C++ ABI, Fortran ABI, Pascal ABI, ... even the Java bytecode spec, although targeting a "virtual" processor instead of real hardware, is an ABI),
- operating-system specific (MS Windows and Linux on the same hardware use a different ABI),
- hardware/CPU-specific (the ARM and x86 ABIs are different).
- evolving over (long) time (existing ABIs have often been updated / rev'ed so that new CPU features could be made use of, like, say, specifying how the x86 SSE registers are to be used by apps was of course only possible once CPUs had these regs, therefore existing ABIs needed to be clarified).
Without some kind of this standardization, (machine) code created by different compilers couldn't use the same kind of libraries (how would you know in which way the library code expects function arguments or data structures to be passed ?).
Every platform (a combination of specific hardware, operating system software and code written in specific programming languages / compiled with specific compilers) defines a whole set of ABIs to make things interoperable. The terminology in this area isn't clear, sometimes people just talk about "the ABI", other times it's called the "platform supplement", or one mentions the programming language and says e.g. "the C++ ABI". Keep in mind, there is not one such thing.
The documents that you linked to in your question are all specific examples of this (language- / operating-system / hardware-specific ABIs).
Even on a specific platform, there's no necessity to have one and only one ABI (set) because different such conventions might have different advantages (and therefore provide better performance / smaller code / better memory usage / ... - depending on the program) and system designers usually try to be flexible / permissible.
On 32bit Microsoft Windows, for example, there's a multitude of ABIs (fastcall, stdcall, pascal, ...) for the function calling convention parts.
Anyway, a generic stackoverflow search for "ABI" (included the links under the "Related" sidebar) gives so many leads to researching this question that I close my answer at this point.
ARM ABI should be referred when an OS kernel port on ARM is used.
EABI is when the processor boots to load an application with no intermediate kernel. (Something like there used to be ROM-BASIC when DOS came about), i. e. the firmware itself is the free-standing application, no board-specific monitor or anything.
The first link is to detailed sub-part related to procedure-calls of the ARM ABI. As the programmers' model advances with each version of ARM CPU, such topics are important and covered by ABI.
The second link is about binary format specification for object files generated by compiler called ELF that's specified by an OS vendor brand SCO. Perhaps SCO is Santa Cruz Organization that makes its own flavors of Unix as well as Linux, however that story deviates from the question. You should be interested in this if you intend to implement linker supporting ELF targeting ARM.
Unless you are directly concerned with implementation details of build tool-chain for ARM, EABI should be of little concern, and unless you are accounting for OS specific aspects of such tool-chain ARM ABI should also be of little concern.