In computer programming , the Arm Image Format ( AIF ) is an object file format used primarily for software intended to run on ARM microprocessors . It was introduced by Acorn Computers for use with their Archimedes computer. It can optionally facilitate debugging, including under operating systems running on other processor architectures.
10-514: The file can be either executable or non-executable and is loaded at 0x8000 unless otherwise specified. Executable files can relocate themselves if necessary and non-executable files are prepared for execution by an image loader. An extended AIF is a type of non-executable which includes information to enable the placement of code and data within specific areas of memory. The file includes a header and separate areas of read-only and read-write code/data. It can optionally include data for debugging and
20-412: A runtime system , which implements runtime language features (such as task scheduling , exception handling , calling static constructors and destructors, etc.) and interactions with the operating system, notably passing arguments, environment, and returning an exit status , together with other startup and shutdown features such as releasing resources like file handles . For C, this is done by linking in
30-512: A computer "to perform indicated tasks according to encoded instructions ", as opposed to a data file that must be interpreted ( parsed ) by an interpreter to be functional. The exact interpretation depends upon the use. "Instructions" is traditionally taken to mean machine code instructions for a physical CPU . In some contexts, a file containing scripting instructions (such as bytecode ) may also be considered executable. Executable files can be hand-coded in machine language, although it
40-555: A file is executed by loading it into memory and jumping to the start of the address space and executing from there. In more complicated interfaces, executable files have additional metadata specifying a separate entry point . For example, in ELF, the entry point is defined in the header's e_entry field, which specifies the (virtual) memory address at which to start execution. In the GNU Compiler Collection , this field
50-444: Is far more convenient to develop software as source code in a high-level language that can be easily understood by humans. In some cases, source code might be specified in assembly language instead, which remains human-readable while being closely associated with machine code instructions. The high-level language is compiled into either an executable machine code file or a non-executable machine code – object file of some sort;
60-593: The ARM Windowing Debugger . Microsoft's MMLite modular system architecture supports the loading of various image formats, including AIF files. Porting of Wind River Systems' VxWorks operating system to the StrongARM EBSA-285 board involved using AIF files. Executable In computer science , executable code , an executable file , or an executable program , sometimes simply referred to as an executable or binary , causes
70-452: The crt0 object, which contains the actual entry point and does setup and shutdown by calling the runtime library . Executable files thus normally contain significant additional machine code beyond that directly generated from the specific source code. In some cases, it is desirable to omit this, for example for embedded systems development, or simply to understand how compilation, linking, and loading work. In C, this can be done by omitting
80-459: The code (with list) for self-relocation . The header includes information about self-relocation, entry point , exit instruction, area sizes and locations, debug type, addressing mode and memory placement (in the case of the extended file). An allocation was later made in the header to mark executables as being " StrongARM -ready", to address some backward compatibility issues. The files can be run for debugging under DOS and SunOS using
90-617: The equivalent process on assembly language source code is called assembly . Several object files are linked to create the executable. Object files -- executable or not -- are typically stored in a container format , such as Executable and Linkable Format (ELF) or Portable Executable (PE) which is operating system -specific. This gives structure to the generated machine code, for example dividing it into sections such as .text (executable code), .data (initialized global and static variables), and .rodata (read-only data, such as constants and strings). Executable files typically also include
100-436: The usual runtime, and instead explicitly specifying a linker script, which generates the entry point and handles startup and shutdown, such as calling main to start and returning exit status to the kernel at the end. In order to be executed by the system (such as an operating system , firmware , or boot loader ), an executable file must conform to the system's application binary interface (ABI). In simple interfaces,
#651348