Assembly Language Compiler Implementation

OUTLINE
INTRODUCTION
SYSTEM REQUIREMENTS
MODULES
IMPLEMENTATIONS
UML DIAGRAM(CLASS)
RESULTS
REFERENCES

INTRODUCTION
A compiler is a program that converts instructions into a machine-code or
lower-level form so that they can be read and executed by a computer. The
instruction set of the language is predefined and the datasheet corresponding
to the instructions is as follows:
• There are 8 registers namely:
• AX, BX, CX, DX, EX, FX, GX, HX
• Any arithmetic operation can be done only using registers.
• There are two input/output instruction.
• Supported Arithmetic operators are ADD, SUB, MUL ,DIV.
• Logic operations IF THEN ELSE are supported.
• JUMP instruction is used to jump to the corresponding label in the program
• Program execution starts with the keyword START and ends with the keyword
END

SYSTEM REQUIREMENTS
SOFTWARE REQUIREMENTS:
Operating system : WINDOWS
Language : C
IDE : Visual Studio

MODULES
Compilation Module
Execution Module
Compilation Module:
 First we check whether the file provided by the user is with .asm extension or not and
then we parse the assembly code line by line.
 Intermediate Language, Symbol Table, Block Address Table and Memory Table are
generated and stored in an .obj file.
 The instructions present in the assembly code are converted to their corresponding
opcodes.
Execution Module:
 The Intermediate Language generated and stored in the form of a table in the
Compilation module is used to execute the Operation Codes(opcodes) and finally the
output is generated in this module.

DATA SHEET
• Specifications for the assembler/simulator is code sheet/datasheet for the assemble
language.
• The instruction set of the language is predefined and the datasheet corresponding
to the instructions is as follows:
• There are 8 registers namely:
• AX, BX, CX, DX, EX, FX, GX, HX
• Any arithmetic operation can be done only using registers. Example :
• DATA A : This will be allocating 4 bytes for A
• CONST C =5 : This will make constant 5 assigned to C
• MOV instruction is used to move values between registers or between register and
variables. Example:
• MOV AX, C : Now AX has value of C
• MOV C, AX : Value of AX moves into C
• MOV AX, DX : Value of DX moves to AX

There are two input/output instructions in addition to these
READ AX : Value read and assigned to the register
PRINT AX : To print the values of AX
Supported Arithmetic operators are ADD, SUB, MUL ,DIV
ADD DX, AX, BX : DX= AX + BX
SUB EX, DX, CX : EX = DX - CX
MUL EX, DX, CX : EX = DX * CX
DIV EX, DX, CX : EX = DX / CX
Logic operations IF THEN ELSE are supported. Example:
IF condition THEN
Block of statements terminated with a semi colon;
ELSE
Block of statements terminated with a semi colon;
Condition checks supported are:
GT : Greater than.
LT : Less than.
EQ : Equal to.
GTEQ : Greater than equal to
LTEQ : Less than equal to.
Where condition can be between operators and registers only.

JMP instruction is used to jump to the corresponding label in the program.
X:
MOV AX, C
JMP X : Will jump the program execution to X
Program execution starts with the keyword START and ends with the keyword END.
START : Program execution starts here
END : Program execution ending.

INSTRUCTION SET
REGISTERS AX,BX,CX,DX,EF,FX,GX,HX
DECLARATION / INITIALIZATION DATA,CONSTANT
ARITHEMATIC ADD,SUB,MUL,DIV
CONDITIONAL IF THEN ELSE
UNCONDITIONAL JUMP JMP
INPUT / OUTPUT READ,PRINT
DATA PROCESSING MOV
CONDITION CHECKS GT, LT ,EQ ,GTEQ , LTEQ
OTHER KEYWORDS START,END, <label>:

Instruction Op code
MOV(Register to Mem) 1
MOV(Mem to Register) 2
ADD 3
SUB 4
MUL 5
JUMP/ ELSE 6
IF 7
EQ 8
LT 9
GT 10
LTEQ 11
GTEQ 12
PRINT 13
READ 14
OP CODES FOR INSTRUCTIONS

Sample Assembly Code
• DATA B
• DATA A
• DATA C[4]
• DATA D
• CONST E = 8
• START:
• READ AX
• READ BX
• MOV A, AX
• MOV B, BX
• ADD CX, AX, BX
• MOV DX, E
• X:
• IF CX EQ DX THEN
• MOV C[0], CX
• MOV D, CX
• ELSE
• MOV C[1], CX
• ENDIF
• JUMP X
• END

DATA A
DATA C[4]
DATA D
CONST E = 0
START:
READ AX
READ BX
MOV A, AX
MOV B, BX
ADD CX, AX, BX
MOV DX, E
X:
IF CX EQ DX THEN
MOV C[0], CX
MOV D, CX
ELSE
MOV C[1], CX
ENDIF
JUMP X
END
DATA B

MEMORY
Name Address Size
B 8 1
SYMBOL TABLE
Block name Address
BLOCK ADDRESSES
DATA B MEMORY CURRENT ADDRESS = 8
INTERMEDIATE LANGUAGE
AX BX CX DX EX FX GX HX
0 1 2 3 4 5 6 7
REGISTER CODES

DATA B
DATA C[4]
DATA D
CONST E = 0
START:
READ AX
READ BX
MOV A, AX
MOV B, BX
ADD CX, AX, BX
MOV DX, E
X:
IF CX EQ DX THEN
MOV C[0], CX
MOV D, CX
ELSE
MOV C[1], CX
ENDIF
JUMP X
END
DATA A

MEMORY
Name Address Size
B 8 1
A 9 1
SYMBOL TABLE
Block name Address
BLOCK ADDRESSES
DATA A MEMORY CURRENT ADDRESS = 9
0 1 2 3 4 5 6 7
REGISTER CODES

DATA B
DATA A
DATA D
CONST E = 0
START:
READ AX
READ BX
MOV A, AX
MOV B, BX
ADD CX, AX, BX
MOV DX, E
X:
IF CX EQ DX THEN
MOV C[0], CX
MOV D, CX
ELSE
MOV C[1], CX
ENDIF
JUMP X
END
DATA C[4]

MEMORY
Name Address Size
B 8 1
A 9 1
C 10 4
SYMBOL TABLE
Block name Address
BLOCK ADDRESSES
DATA C[4] MEMORY CURRENT ADDRESS = 10
0 1 2 3 4 5 6 7
REGISTER CODES

DATA B
DATA A
DATA C[4]
CONST E = 0
START:
READ AX
READ BX
MOV A, AX
MOV B, BX
ADD CX, AX, BX
MOV DX, E
X:
IF CX EQ DX THEN
MOV C[0], CX
MOV D, CX
ELSE
MOV C[1], CX
ENDIF
JUMP X
END
DATA D

MEMORY
Name Address Size
B 8 1
A 9 1
C 10 4
D 14 1
SYMBOL TABLE
Block name Address
BLOCK ADDRESSES
DATA D MEMORY CURRENT ADDRESS = 14
0 1 2 3 4 5 6 7
REGISTER CODES

DATA B
DATA A
DATA C[4]
DATA D
START:
READ AX
READ BX
MOV A, AX
MOV B, BX
ADD CX, AX, BX
MOV DX, E
X:
IF CX EQ DX THEN
MOV C[0], CX
MOV D, CX
ELSE
MOV C[1], CX
ENDIF
JUMP X
END
CONST E=0

0
MEMORY
Name Address Size
B 8 1
A 9 1
C 10 4
D 14 1
E 15 0
SYMBOL TABLE
Block name Address
BLOCK ADDRESSES
CONST E = 0 MEMORY CURRENT ADDRESS = 15
Here constant size is specified as 0 to
indicate it as a constant (given spec
specifies that constant is always 1 byte
and we store it in the respective
memory location)
0 1 2 3 4 5 6 7
REGISTER CODES

START
Till this point all the declarations are done.
From this point parse the code and generate intermediate code

DATA B
DATA A
DATA C[4]
DATA D
CONST E = 0
START:
READ BX
MOV A, AX
MOV B, BX
ADD CX, AX, BX
MOV DX, E
X:
IF CX EQ DX THEN
MOV C[0], CX
MOV D, CX
ELSE
MOV C[1], CX
ENDIF
JUMP X
END
READ AX

0
MEMORY
Name Address Size
B 8 1
A 9 1
C 10 4
D 14 1
E 15 0
SYMBOL TABLE
In No Op code PARAMETERS
1 14 0
Block name Address
BLOCK ADDRESSES
1. READ AX MEMORY CURRENT ADDRESS = 15
0 1 2 3 4 5 6 7
REGISTER CODES

DATA B
DATA A
DATA C[4]
DATA D
CONST E = 0
START:
READ AX
READ BX
MOV A, AX
MOV B, BX
ADD CX, AX, BX
MOV DX, E
X:
MOV C[0], CX
MOV D, CX
ELSE
MOV C[1], CX
ENDIF
JUMP X
END
IF CX EQ DX THEN

0
MEMORY
Name Address Size
B 8 1
A 9 1
C 10 4
D 14 1
E 15 0
SYMBOL TABLE
In No Op
code
PARAMETERS
1 14 0
2 14 1
3 2 1 0
4 2 0 1
5 3 2 0 1
6 1 3 7
7 7 2 3 8 *
Block name Address
X 7
LABEL TABLE
0 1 2 3 4 5 6 7
REGISTER CODES
STACK
7
7. IF CX EQ DX THEN

DATA B
DATA A
DATA C[4]
DATA D
CONST E = 0
START:
READ AX
READ BX
MOV A, AX
MOV B, BX
ADD CX, AX, BX
MOV DX, E
X:
IF CX EQ DX THEN
MOV C[0], CX
MOV D, CX
MOV C[1], CX
ENDIF
JUMP X
END
ELSE

0
MEMORY
Name Address Size
B 8 1
A 9 1
C 10 4
D 14 1
E 15 0
SYMBOL TABLE
In No Op
code
PARAMETERS
1 14 0
2 14 1
3 2 1 0
4 2 0 1
5 3 2 0 1
6 1 3 7
7 7 2 3 8 *
8 1 10 2
9 1 14 2
10 6 *
Block name Address
X 7
LABEL TABLE
0 1 2 3 4 5 6 7
REGISTER CODES
STACK
10
7
10. ELSE

DATA B
DATA A
DATA C[4]
DATA D
CONST E = 0
START:
READ AX
READ BX
MOV A, AX
MOV B, BX
ADD CX, AX, BX
MOV DX, E
X:
IF CX EQ DX THEN
MOV C[0], CX
MOV D, CX
ELSE
MOV C[1], CX
JUMP X
END
ENDIF

0
MEMORY
Name Address Size
B 8 1
A 9 1
C 10 4
D 14 1
E 15 0
SYMBOL TABLE
In No Op
code
PARAMETERS
1 14 0
2 14 1
3 2 1 0
4 2 0 1
5 3 2 0 1
6 1 3 7
7 7 2 3 8 *
8 2 10 2
9 2 14 2
10 6 *
11 2 11 2
Block name Address
X 7
LABEL TABLE
0 1 2 3 4 5 6 7
REGISTER CODES
STACK
10
7
11. MOV C[1], CX

0
MEMORY
Name Address Size
B 8 1
A 9 1
C 10 4
D 14 1
E 15 0
SYMBOL TABLE
In No Op
code
PARAMETERS
1 14 0
2 14 1
3 2 1 0
4 2 0 1
5 3 2 0 1
6 1 3 7
7 7 2 3 8 *
8 2 10 2
9 2 14 2
10 6 12
11 2 11 2
Block name Address
X 7
LABEL TABLE
0 1 2 3 4 5 6 7
REGISTER CODES
STACK
7
11. MOV C[1], CX
When we encounter
“ENDIF” we pop the
stack and store that
value in a temporary
variable. We move to
that Instruction in
Intermediate
Language and
replace the * with
current Instruction
Number

0
MEMORY
Name Address Size
B 8 1
A 9 1
C 10 4
D 14 1
E 15 0
SYMBOL TABLE
In No Op
code
PARAMETERS
1 14 0
2 14 1
3 2 1 0
4 2 0 1
5 3 2 0 1
6 1 3 7
7 7 2 3 8 11
8 2 10 2
9 2 14 2
10 6 12
11 2 11 2
Block name Address
X 7
LABEL TABLE
0 1 2 3 4 5 6 7
REGISTER CODES
STACK
11. MOV C[1], CX
We pop the stack
again and we move
to that Instruction in
Intermediate
Language and
replace the * with
previously popped
value (i.e. which is
stored in the
temporary variable)
+ 1

DATA B
DATA A
DATA C[4]
DATA D
CONST E = 0
START:
READ AX
READ BX
MOV A, AX
MOV B, BX
ADD CX, AX, BX
MOV DX, E
X:
IF CX EQ DX THEN
MOV C[0], CX
MOV D, CX
ELSE
MOV C[1], CX
ENDIF
END
JUMP X

0
MEMORY
Name Address Size
B 8 1
A 9 1
C 10 4
D 14 1
E 15 0
SYMBOL TABLE
In No Op
code
PARAMETERS
1 14 0
2 14 1
3 2 1 0
4 2 0 1
5 3 2 0 1
6 1 3 7
7 7 2 3 8 11
8 2 10 2
9 2 14 2
10 6 12
11 2 11 2
12 6 7
Block name Address
X 7
LABEL TABLE
0 1 2 3 4 5 6 7
REGISTER CODES
STACK
12. JUMP X

DATA B
DATA A
DATA C[4]
DATA D
CONST E = 0
START:
READ AX
READ BX
MOV A, AX
MOV B, BX
ADD CX, AX, BX
MOV DX, E
X:
IF CX EQ DX THEN
MOV C[0], CX
MOV D, CX
ELSE
MOV C[1], CX
ENDIF
JUMP X
END

Sample Object File(.obj)
• ---------------Symbol Table is----------
• B 8 1
• A 9 1
• C 10 4
• D 14 1
• E 15 0
• --------------Block Table is----------
• X 6
• ---------------Instruction Table is----------
• 1 14 0
• 2 14 1
• 3 1 12 0
• 4 1 8 1
• 5 3 2 0 1
• 6 14 0
• 7 4 3 0 1
• 8 13 3
• 9 13 2
• 10 7 2 3 8 14
• 11 1 10 2
• 12 13 10
• 13 6 17
• 14 1 11 3
• 15 13 11
• 16 6 6
• 17 13 15

REFERENCES
Compiler Design Concepts : https://www.tutorialspoint.com/compiler_design/
Alfred V Aho, Ravi Sethi, Jeffrey D.Ullman, “Compilers-Principles Techniques and
Tools”, 2nd Edition, Pearson Education,2008..
Kenneth C.Louden, “Compiler Construction-Principles and Practice”, 2nd Edition,
Cengage, 2010
C in Depth by Deepali Srivastava (Author), S. K. Srivastava

Assembly Language Compiler Implementation

More Related Content

What's hot

Similar to Assembly Language Compiler Implementation

Recently uploaded

Assembly Language Compiler Implementation