Computer History  

Custom Search

Computer History
Tracing the History of the Computer - Assembler (Translate Assembly Code into Object Code)


An assembler is a computer program for translating assembly language - essentially, a mnemonic representation of machine language - into object code. A cross assembler produces code for one type of processor, but runs on another. The computational step where an assembler is run is known as assembly time.

As well as translating assembly instruction mnemonics into opcodes, assemblers provide the ability to use symbolic names for memory locations (saving tedious calculations and manually updating addresses when a program is slightly modified), and macro facilities for performing textual substitution - typically used to encode common short sequences of instructions to run inline instead of in a subroutine.

Assemblers are far simpler to write than compilers for high-level languages, and have been available since the 1950s. Modern assemblers, especially for RISC based architectures, such as MIPS, Sun SPARC and HP PA-RISC, optimize instruction scheduling to exploit the CPU pipeline efficiently.

High-level assemblers provide high-level-language abstractions such as advanced control structures, high-level procedure/function declarations and invocations, and high-level abstract data types including structures/records, unions, classes, and sets.


For any given personal computer, mainframe, embedded system, and game console, both past and present, at least one--possibly dozens--of assemblers have been written.

On Unix systems, the assembler is traditionally called as, although it is not a single body of code, being typically written anew for each port. A number of Unix variants use GAS.

Within processor groups, each assembler has its own dialect. Sometimes, some assemblers can read another assembler's dialect, for example, TASM can read old MASM code, but not the reverse. FASM and NASM have similar syntax, but each support different macros that could make them difficult to translate to each other. The basics are all the same, but the advanced features will differ.

Also, assembly can sometimes be portable across different operating systems on the same type of CPU. Calling conventions between operating systems often differ slightly to none at all, and with care it is possible to gain some portability in assembly language, usually by linking with a C library that does not change between operating systems.


However, it is not possible to link portably with C libraries that require the caller to use preprocessor macros that may change between operating systems.

For example, many things in libc depend on the preprocessor to do OS-specific, C-specific things to the program before compiling. In fact, some functions and symbols are not even guaranteed to exist outside of the preprocessor. Worse, the size and field order of structs, as well as the size of certain typedefs such as off_t, are entirely unavailable in assembly language, and differ even between versions of Linux, making it impossible to portably call functions in libc other than ones that only take simple integers and pointers as parameters.

Some higher level computer languages, such as C, support Inline assembly where relatively brief sections of assembly code can be embedded into the high level language code.

Many people use an emulator to debug assembly-language programs.


History of Programming Languages

Programming Timeline

Assembly Language

Machine Code


Copyright Notice for Computer Nostalgia


  Privacy Policy 

 GNU License