COMPILER
A program that translates source
code into object code. The compiler derives its name from the way it works,
looking at the entire piece of source code and collecting and reorganizing the
instructions. A compiler is a computer program (or set of programs) that
transforms source code written in a programming language (the source language)
into another computer language (the target language, often having a binary form
known as object code). The most common reason for wanting to transform source
code is to create an executable program.
The name "compiler" is primarily used
for programs that translate source code from a high-level programming language
to a lower level language (e.g., assembly language or machine code). If the
compiled program can run on a computer whose CPU or operating system is different
from the one on which the compiler runs, the compiler is known as a cross-compiler.
A program that translates from a low level language to a higher level one is a decompiler.
A program that translates between high-level languages is usually called a language
translator, source to source translator, or language converter. A language
rewriter is usually a program that translates the form of
expressions without a change of language.
A compiler is likely to perform many or all of the
following operations: lexical analysis, preprocessing, parsing, semantic
analysis (Syntax-directed translation), code generation, and code optimization.
History:
Software for early computers was primarily written
in assembly language. Higher level programming languages were not invented
until the benefits of being able to reuse software on different kinds of CPUs
started to become significantly greater than the costs of writing a compiler.
The limited memory capacity of early computers led to substantial technical
challenges when the first compilers were being designed.
Towards the end of the 1950s, machine-independent
programming languages were first proposed. Subsequently several experimental
compilers were developed. It is believed that the first compiler was written by
Grace Hopper, in 1952, for the A-0 programming language.The A-0 functioned more
as a loader or linker than the modern notion of a compiler. The first autocode
and its compiler were developed by Alick Glennie in 1952 for the Mark 1
computer at the University of Manchester and is considered by some to be the
first compiled programming language. The FORTRAN team led by John Backus at IBM
is generally credited as having introduced the first complete compiler in 1957.
COBOL was an early language to be compiled on multiple architectures, in 1960.
Early compilers were written in assembly language.
The first self-hosting compiler – capable of compiling its own source code in a
high-level language – was created in 1962 for Lisp by Tim Hart and Mike Levin
at MIT. Since the 1970s it has become common practice to implement a compiler
in the language it compiles, although both Pascal and C have been popular
choices for implementation language. Building a self-hosting compiler is a
bootstrapping problem—the first such compiler for a language must be compiled
either by hand or by a compiler written in a different language, or (as in Hart
and Levin's Lisp compiler) compiled by running the compiler in an interpreter.
Structure of a compiler:
Compilers bridge source programs in high-level
languages with the underlying hardware. A compiler verifies code syntax,
generates efficient object code, performs run-time organization, and formats
the output according to assembler and linker conventions. A compiler consists
of:
1. The
front end: Verifies syntax and semantics, and generates an intermediate
representation or IR of the source code for processing by the middle-end.
Performs type checking by collecting type information. Generates errors and
warning, if any, in a useful way.
2. The
middle end: Performs optimizations, including removal of useless or unreachable
code, discovery and propagation of constant values, relocation of computation
to a less frequently executed place (e.g., out of a loop), or specialization of
computation based on the context. Generates another IR for the backend.
3. The
back end: Generates the assembly code, performing register allocation in
process. (Assigns processor registers for the program variables where
possible.) Optimizes target code utilization of the hardware by figuring out
how to keep parallel execution units busy, filling delay slots. Although most
algorithms for optimization are in NP, heuristic techniques are well-developed.
One classification of compilers is by the platform
on which their generated code executes. This is known as the target platform.
A native or hosted compiler is one which output
is intended to directly run on the same type of computer and operating system
that the compiler itself runs on. The output of a cross compiler is designed to
run on a different platform. Cross compilers are often used when developing
software for embedded systems that are not intended to support a software
development environment.
The output of a compiler that produces code for a virtual machine
(VM) may or may not be executed on the same platform as the compiler
that produced it. For this reason such compilers are not usually classified as
native or cross compilers.
INTERPRETER
A program that executes instructions written
in a high-level language. There are two ways to run programs written in a
high-level language. The most common is to compile the program; the other
method is to pass the program through an interpreter.
An interpreter translates high-level
instructions into an intermediate form, which it then executes. In contrast, a
compiler translates high-level instructions directly into machine language. The
advantage of an interpreter, however, is that it does not need to go through
the compilation stage during which machine instructions are generated. This
process can be time-consuming if the program is long. The interpreter, on the
other hand, can immediately execute high-level programs. For this reason,
interpreters are sometimes used during the development of a program, when a
programmer wants to add small sections at a time and test them quickly. In
addition, interpreters are often used in education because they allow students
to program interactively.
COMPILER
VS INTERPRETER::
A compiler differs from an interpreter, which
analyzes and executes each line of source code in succession, without looking
at the entire program. The advantage of interpreters is that they can execute a
program immediately. Compilers require some time before an executable program
emerges. However, programs produced by compilers run much faster than the same
programs executed by an interpreter. Compiled programs generally
run faster than interpreted programs.
Assembler
Assembler is a software or a tool that
translates Assembly language to machine code. So, an assembler is a type of a
compiler and the source code is written in Assembly language. Assembly is a
human readable language but it typically has a one to one relationship with the
corresponding machine code. Therefore an assembler is said to perform isomorphic
(one to one mapping) translation. Advanced assemblers provide additional
features that support program development and debugging processes.
What is the difference between an Assembler
and a Compiler?
Compiler is a computer program that reads a
program written in one language and translates it in to another language, while
an assembler can be considered a special type of compiler which translates only
Assembly language to machine code. Compilers usually produce the machine
executable code directly from a high level language, but assemblers produce an
object code which might have to be linked using linker programs in order to run
on a machine. Because Assembly language has a one to one mapping with machine
code, an assembler may be used for producing code that runs very efficiently
for occasions in which performance is very important (for e.g. graphics
engines, embedded systems with limited hardware resources compared to a
personal computer like microwaves, washing machines, etc.).
