Jump to content

Application binary interface

From Wikipedia, the free encyclopedia
This is an old revision of this page, as edited by 86.56.42.155 (talk) at 21:02, 18 December 2007. The present address (URL) is a permanent link to this revision, which may differ significantly from the current revision.

In computer software, an application binary interface (ABI) describes the low-level interface between an application program and the operating system, or the interface between an application and its libraries, or that between component parts of an application. An ABI is similar to an application programming interface (API), however the latter defines a source code interface.[1] Simply put, ABIs enable binary compatibility, whereas APIs enable source code compatibility.

For example, the POSIX standard defines an API that allows a wide range of common computing functions to be written such that they may operate on many different systems (Mac OS X, various BSDs and Microsoft Windows all implement this interface), however, making use of this requires re-compilation for each platform. A compatible ABI, on the other hand, allows compiled object code to function without any changes, on any system implementing that ABI. This is advantagous to both software providers (where they may distribute existing software on new systems without producing/distributing upgrades) and users (where they may install older software on their new systems without purchasing upgrades), although this generally requires various software libraries implementing the necessary APIs too.

Microsoft have shown significant commitment to a backward compatible ABI, particularly within their Win32 library, such that older applications may run on newer versions of Windows. Apple have shown less propensity to this concern, expiring compatibility or implementing ABI in a slower "emulation mode"; many argue that this allows greater freedom in development at the cost of obsoleting older software. Among Unix-like operating systems, there are many related but incompatible operating systems running on a common hardware platform (particularly Intel 80386-compatible systems). There have been several attempts to standardise the ABI such that software vendors may distribute one binary application for all these systems, however to date, none of these have met with much success. The Linux Standard Base is attempting to do this for the Linux platform whilst many of the BSD unices (OpenBSD/NetBSD/FreeBSD) implement various levels of ABI compatibility for both backward compatibility (allowing applications written for older versions to run on newer distributions of the system) as well cross platform compatibility (allowing the execution of foreign code without recompilation).

ABIs cover details such as the calling convention, which controls how functions' arguments are passed and return values retrieved; the system call numbers and how an application should make system calls to the operating system; and in the case of a complete operating system ABI, the binary format of object files, program libraries and so on. A complete ABI, such as the Intel Binary Compatibility Standard (iBCS),[2] allows a program from one operating system supporting that ABI to run without modifications on any other such system. Other ABIs standardize details such as the C++ name decoration,[3] exception propagation,[4] and calling convention between compilers on the same platform, but do not require cross-platform compatibility.

See also

References

  1. ^ allowing e.g. the same source code to compile on any system supporting that API
  2. ^ Intel Binary Compatibility Standard (iBCS)
  3. ^ Itanium C++ ABI (compatible with multiple architectures)
  4. ^ Itanium C++ ABI: Exception Handling (compatible with multiple architectures)
Retrieved from "https://en.wikipedia.org/w/index.php?title=Application_binary_interface&oldid=178798459"