History of compiler development

1953 IBM develops

the 701 EDPM
(Electronic Data
Processing Machine),
the first general
purpose computer,
built as a “defense

calculator” in the
1
 History of compilers (cont’d)

No high-level languages were available, so all

programming was done in machine and assembly
language.

2
 History of compilers (cont’d)

As expensive as these early computers were, most

of the money companies spent was for software
development, due to the complexities of assembly.

3
 History of compilers (cont’d)

In 1953, John Backus came up with the

idea of “speed coding”, and
developed the first
interpreter. Unfortunately, this
was 10-20 times slower than programs
written in assembly.

He was sure he could do better. John Backus

4
 History of compilers (cont’d)

In 1954, Backus and his team released a research

paper titled “Preliminary Report, Specifications for
the IBM Mathematical FORmula TRANslating
System, FORTRAN.”
The initial release of FORTRAN was in 1956,
totaling 25,000 lines of assembly code. Compiled
programs run almost as fast as handwritten
assembly!

5
 History of compilers (cont’d)

Projects that had taken two weeks to write now took

only 2 hours. By 1958 more than half of all
software was written in FORTRAN.

6
 Why study compilers?

 You may never write a commercial compiler,

but that's not why we study compilers. We
study compiler construction for the following
reasons:

7
 Why study compilers? (cont’d)

1) Writing a compiler gives a student experience

with large-scale applications development.
Your compiler program may be the largest
program you write as a student. Experience
working with really big data structures and
complex interactions between algorithms will
help you out on your next big programming
project

8
 Why study compilers? (cont’d)

• Compiler writing is one of the shining triumphs

of CS theory. It is very helpfull in
the solutions of different problems.

9
 Why study compilers? (cont’d)

3) Compiler writing is a basic element of

programming language research. Many
language researchers write compilers for the
languages they design.

10
 Why study compilers? (cont’d)

4) Many applications have similar properties to

one or more phases of a compiler, and
compiler expertise and tools can help an
application programmer working on other
projects besides compilers

11
 Cousins Of The Compiler

12
  Interpreters: Interpreters are programs that
read and execute source code directly, line by
line, without generating an intermediate
machine code or binary file. While compilers
translate the entire source code into machine
code, interpreters execute code directly.
Examples include the Python interpreter and
the JavaScript engine in web browsers.

13
  Assemblers: Assemblers are tools that
convert assembly language code into machine
code. They are used for low-level programming
and are specific to a particular computer
architecture. Assemblers play a role in the
translation of assembly language instructions
into binary machine code.

14
  Linkers: Linkers are programs that take object
files (generated by compilers) and combine
them into a single executable program. They
resolve references between different object
files and libraries, ensuring that functions and
variables are correctly linked together.

15
  Loaders: Loaders are responsible for loading
executable programs into memory so they can
be executed by the operating system. They
handle tasks like memory allocation, relocation,
and initializing program data.

16
  Preprocessors: Preprocessors are used in
conjunction with compilers to perform text
transformations on the source code before
compilation. They are commonly used to
include header files, perform macro
substitutions, and conditionally compile code.
The C preprocessor (cpp) is a well-known
example.

17
  Just-In-Time (JIT) Compilers: JIT compilers
translate source code or intermediate code into
machine code at runtime, just before
execution. They are commonly used in virtual
machines and interpreted languages to
improve performance by compiling code on-
the-fly.

18
  Dynamic Analysis Tools: Dynamic analysis
tools, such as profilers and debuggers, analyze
code as it runs. Profilers measure performance
characteristics, while debuggers help
developers find and fix bugs in running
programs.

19
  Cross-Compilers: Cross-compilers are
compilers that generate code for a different
target platform or architecture than the one
they run on. They are often used in embedded
systems and cross-platform development.

20
  Code Generators: Code generators produce
code or configuration files based on a high-
level specification. They are often used in code
generation tools and domain-specific language
(DSL) compilers.

21
 PRE-PROCESSOR

Pre-processors produce input to compilers they

might perform the following functions
I. Macro Processing
A pre-processor may allow a user define macros that
are Short hands for a longer construction,pre-processor
expand a Macros into source language statements.

22
  Optimizers: Optimizers are tools or
components within compilers that perform
optimizations on the generated code to
improve its efficiency and performance.

23
 PRE-PROCESSOR (cont’d)

II. File Inclusion

A pre-processor may include header files into the
program text.

24
 PRE-PROCESSOR (cont’d)

III. Rational pre-processors

These pre-processor augment older languages with
more modern flow of control and data structuring
facilities.
For example such a pre-processor might provide
the user with built-in macros for constructs like while
statements or if-statements ,where none exits in the
program language itself.

25
 PRE-PROCESSOR (cont’d)

IV. Language Extensions

These processors attempt add capabilities to the language.
For example, the language EQUEL is a database query
language embedded in C.

26
 2-ASSEMBLERS
Some compiler produce assembly code that is passed to an
Assembler for further processing. Other compiler perform the
Job of the assembler ,producing relocatable machine code
That can be passed directly to the loader /link –editor

27
 Assembly Code
Assembly code is a mnemonic version of machine code ,in
Which names are used instead of binary code for operation
And names are also given to memory addresses. A typical
Sequence of assembly instruction might be :

28
 Assembly Code (cont’d)

Move R1, a
Add R1, #2
Move b, R1

29
 Assembly Code (cont’d)

This code moves the contents of the address

into register 1.Then adds the constant 2 to it
and finally stores the result in the location
named b.Thus it computes

b = a+2

30
 Two –Pass Assembler

The simplest form of assembler makes two

passes over the input, where a pass consists
of reading on input file once.In the first pass all
the identifiers that denote storage locations are
found and stored in a symbol table.Identifiers
are assigned storage locations as they are
encountered for the first time. For example ,
the symbol table might contain the entries as
follows.

31
 Two –Pass Assembler (cont’d)

IDENTIFIER ADDRESS

a 0

b 4

32
 Two –Pass Assembler (cont’d)

Here we have assumed that a word ,consisting

Of four bytes ,is set for each identifier,and that
Addresses are assigned starting from byte 0.

33
 Two –Pass Assembler (cont’d)

Second pass
In the second pass ,the assembler scans the
input Again.This time it translates each
operation code into the sequence of bits
representing a location into the address given
for the identifier in the symbol table. The output
of the 2nd pass is usually relocatable m/c code.

34
 3-Loaders and Link Editor

Using a program called a loader performs the Two

functions of loading and link editing. The process
of loading consists of taking relocatable M/c
code, Altering the relocatable addresses and Placing
the altered instructions and data in memory at Proper
locations.
The link editor allows us to make a Single program from
several files of relocatable m/c Code.

35
 Loaders and Link Editor(cont’d)

These files may have been the result of several

different compilations and one or more may be
library files of routines provided by the system
And available to any program that need them.

36
 Modern Compilers

Compilers have not changed a great deal since the

days of Backus. They still consist of two main
components:

The FRONT-END reads in the program in the

source languages, makes sense of it, and stores it in
an internal representation…

37
 Modern Compilers(cont’d)

The BACK-END, which converts the internal

representation into the target language, perhaps with
optimizations. The target language used is typically
an assembly language.

38
 Source Language

Structure
of a
Compiler
?

Target Language
39
 Source Language

Structure
of a Front End
Compiler

Back End

Target Language
40
 Source Language

Lexical Analyzer

Syntax Analyzer Front

End
Semantic Analyzer
Structure
of a Int. Code Generator
Compiler Intermediate Code

Back End

Target Language
41
 Source Language

Lexical Analyzer

Syntax Analyzer Front

End
Semantic Analyzer
Structure
of a Int. Code Generator
Compiler
Intermediate Code

Code Optimizer Back

Target Code Generator End

Target Language
42
 THANKS

43