BCS Assembler
An assembler is a program which creates object code by translating
combinations of mnemonics and syntax for operations and addressing
modes into their numerical equivalents. This representation typically
includes an operation code ("opcode") as well as other control bits.[1]
The assembler also calculates constant expressions and resolves
symbolic names for memory locations and other entities.[2] The use of
symbolic references is a key feature of assemblers, saving tedious
calculations and manual address updates after program modifications.
Most assemblers also include macro facilities for performing textual
substitution—e.g., to generate common short sequences of instructions
as inline, instead of called subroutines.
Some assemblers may also be able to perform some simple types of
instruction set-specific optimizations. One concrete example of this
may be the ubiquitous x86 assemblers from various vendors. Most of them
are able to perform jump-instruction replacements (long jumps replaced
by short or relative jumps) in any number of passes, on request. Others
may even do simple rearrangement or insertion of instructions, such as
some assemblers for RISC architectures that can help optimize a
sensible instruction scheduling to exploit the CPU pipeline as
efficiently as possible.[citation needed]
Like early programming languages such as Fortran, Algol, Cobol and
Lisp, assemblers have been available since the 1950s and the first
generations of text based computer interfaces. However, assemblers came
first as they are far simpler to write than compilers for high-level
languages. This is because each mnemonic along with the addressing
modes and operands of an instruction translates rather directly into
the numeric representations of that particular instruction, without
much context or analysis. There have also been several classes of
translators and semi automatic code generators with properties similar
to both assembly and high level languages, with speedcode as perhaps
one of the better known examples.