System Programming Lab

CS244

May 5, 2018

ABHISHEK KUMAR - 160101007

ABHISHEK RANJAN - 160101008
HEMANT YADAV - 160101034

1
 The following report is the explanation of working of a two pass assembler given as a part of
project in System Programming Lab (CS244). The report includes detailed explanation of how
the two pass assembler is different from a single pass assembler. It also includes explanation of
working of macros, linker, loader with respect to our project. The report provides a detailed
explanation on how our assembler operates and the methods, notations and data structures used
along with the sources.

1 Introduction
As part of System Programming lab project on assembler, we created a two pass assembler. The
project uses notations an data structures used in IBM 8085 microprocessor. The simulator is
custom made. The compiler can compile upto 2 nested loops, if-else nested statements, for- while
loops. Basic arithmetic and logical operations are supported.

2 Assembly Language
An assembly language is a low-level programming language for microprocessors and other pro-
grammable devices. It is not just a single language, but rather a group of languages. An assembly
language implements a symbolic representation of the machine code needed to program a given
CPU architecture.

An assembly language is the most basic programming language available for any processor. With
assembly language, a programmer works only with operations that are implemented directly on
the physical CPU.

Assembly languages generally lack high-level conveniences such as variables and functions, and
they are not portable between various families of processors. They have the same structures and
set of commands as machine language, but allow a programmer to use names instead of numbers.
This language is still useful for programmers when speed is necessary or when they need to carry
out an operation that is not possible in high-level languages.

A program written in assembly language consists of a series of mnemonic processor instructions and
meta-statements (known variously as directives, pseudo-instructions and pseudo-ops), comments
and data. Assembly language instructions usually consist of an opcode mnemonic followed by a
list of data, arguments or parameters. These are translated by an assembler into machine language
instructions that can be loaded into memory and executed. For example, the instruction below
tells an x86/IA-32 processor to move an immediate 8-bit value into a register. The binary code for
this instruction is 10110 followed by a 3-bit identifier for which register to use. The identifier for
the AL register is 000, so the following machine code loads the AL register with the data 01100001.

10110000 01100001

This binary computer code can be made more human-readable by expressing it in hexadecimal as
follows.

B0 61

Here, B0 means ’Move a copy of the following value into AL’, and 61 is a hexadecimal repre-
sentation of the value 01100001, which is 97 in decimal. Assembly language for the 8086 family
provides the mnemonic MOV (an abbreviation of move) for instructions such as this, so the ma-
chine code above can be written as follows in assembly language, complete with an explanatory
comment if required, after the semicolon. This is much easier to read and to remember.

MOV AL, 61h ; Load AL with 97 decimal (61 hex)

2
3 8085 Programming Model
• It uses English like words to convey the action/meaning called as MNEMONICS
• For e.g. MOV to indicate data transfer ADD to add two values SUB to subtract two values
• Assembly language is specific to a given processor.

• 8085 microprocessor contains the following

1. 6 general Purpose Registers
2. Accumulator Register
3. Program Counter Register
4. Stack Pointer Register
• Six general purpose registers can be combined.
• Accumulator, identified by name ’A’, is a part of ALU. It stores the result of an operation
performed by ALU.

• 8085 uses the flags in decision making process.

• Program counter is used to sequence execution of program instruction.

3.1 Instruction Set of 8085

It consists of 74 codes e.g MOV and 246 instructions e.g. MOV A B. 8085 instructions can be
classified as following
• Data Transfer
• Arithmetic

• Logical and bit manipulation

• Branch
• Machine Control

• Example of a data transfer operation is given

MOV B 4FH
MOV A B
LXI H 2050H
MOV M B
OUT 01H
IN 07H

• Example of arithmetic operation is given below

ADD 32H
ADD B
SUB 32H
SUB C
INCR D
DCR E

• Example of branching operation is given below

JMP 2080H
CALL 2050H
BNZ

3
 • Machine control instructions are HLT, NOP etc.
An example of an assembly language program to add two no. and store them in a register is given
below
MVI D 2H
MVI E 3H
MOV A D
ADD E
MOV C A
HLT

3.2 Addressing Modes of 8085

1. Register Addressing
(a) Operands are one of the internal registers of 8085
2. Immediate Addressing
(a) Value of the operand is given in the instruction itself
3. Memory Addressing
(a) One of the operands is memory location.
(b) Depending on how address of memory location is specified, memory addressing is of two
types viz direct addressing and indirect addressing.
4. Input/Output Addressing
5. Instruction and data formats

3.3 Statement Format

An assembly language has following format
[label] < opcode > < operandspec. > [< operandspec. > ...]
where the notation
[..]
indicates the enclosed specification is optional.
Operand spec. has the following syntax
< symbolic name > [+ < displacement >][(indexregister)]
Various mnemonic opcodes for machine instruction are as follows
Instruction opcode Assembly Mnemonic Remarks
00 STOP Stop execution
01 ADD First operand is modified
02 SUB First operand is modified
03 MULT First operand is modified
04 MOVER Register ←Memory move
05 MOVEM Memory ←Register move
06 COMP Sets condition code
07 BC Branch on condition
08 DIV Analogous to MULT
09 READ First operand is not used
10 WRITE First operand is not used
An assembly program contains three kinds of statements:
• Imperative Statement
• Declarative Statement
• Assembler Directive

4
3.4 Imperative Statement
An imperative statement indicates an action to be performed during the execution of the assembled
program. Each imperative statement typically translates into one machine instruction.

3.5 Declarative Statement

The syntax of declaration statements is as follows:

[Label] DS < constant >

0
[Label] DS < value >0
The DS statement reserves areas of memory and associates names with them. The DC statement
constructs memory words containing constants.

4 Linker
4.1 What is a linker ?
In computing, a linker or link editor is a computer utility program that takes one or more object
files generated by a compiler and combines them into a single executable file, library file, or another
’object’ file.
Computer programs typically are composed of several parts or modules; these parts/modules
need not all be contained within a single object file, and in such cases refer to each other by means
of symbols. Typically, an object file can contain three kinds of symbols:

• defined "external" symbols, sometimes called "public" or "entry" symbols, which allow it to
be called by other modules,
• undefined "external" symbols, which reference other modules where these symbols are de-
fined, and
• local symbols, used internally within the object file to facilitate relocation.

Computer programs are usually made up of multiple modules that span separate object files,
each being a compiled computer program. The program as a whole refers to these separately-
compiled object files using symbols. The linker combines these separate files into a single, unified
program; resolving the symbolic references as it goes along.

4.2 Static linking

Static linking is the result of the linker copying all library routines used in the program into the
executable image. This may require more disk space and memory than dynamic linking, but is
more portable, since it does not require the presence of the library on the system where it runs.
Static linking also prevents "DLL Hell", since each program includes exactly the versions of library
routines that it requires, with no conflict with other programs. In addition, a program using just
a few routines from a library does not require the entire library to be installed.

4.3 Dynamic linking

Dynamic linking is a similar process, available on many operating systems, which postpones
the resolution of some symbols until the program is executed. When the program is run, these
dynamic link libraries are loaded as well. Dynamic linking does not require a linker.
Dynamic linking is accomplished by placing the name of a sharable library in the executable
image. Actual linking with the library routines does not occur until the image is run, when both
the executable and the library are placed in memory. An advantage of dynamic linking is that
multiple programs can share a single copy of the library.

5
4.4 Linker: Part 1
We mentioned earlier that a declaration of a function or a variable is a promise to the C compiler
that somewhere else in the program is a definition for that function or variable, and that the linkers
jobs is to make good on that promise. With the diagram of an object file in front of us, we can
also describe this as "filling in the blanks".
With these two diagrams, we can see that all of the dots can joined up (if they couldn’t be,
then the linker would emit an error message). Every thing has its place, and every place has its
thing, and the linker can fill in all of the blanks as shown (on a UNIX system, the linker is typically
invoked with ld).

As for object files, we can use nm to examine the resulting executable file: This has all of the
symbols from the two objects, and all of the undefined references have vanished. The symbols
have also all been reordered so that similar types of things are together, and there are a few added
extras to help the operating system deal with the whole thing as an executable program.

4.5 Linker : Part 2

Now that we’ve covered the very basics of the operation of a linker, we can plough on to describe
some more complicating details-roughly in the order that these features were historically added to
linkers.

The main observation that affected the function of the linker is this: if lots of different programs
need to do the same sorts of things (write output to the screen, read files from the hard disk, etc),
then it clearly makes sense to commonize this code in one place and have lots of different programs
use it.

This is perfectly feasible to do by just using the same object files when linking different pro-
grams, but it makes life much easier if whole collections of related object files are kept together in
one easily accessible place: a library

4.6 What The Operating System Does

Now that the linker has produced an executable program with all of the references to symbols
joined up to suitable definitions of those symbols, we need to pause briefly to understand what the
operating system does when you run the program.

Running the program obviously involves executing the machine code, so the operating system
clearly has to transfer the machine code from the executable file on the hard disk into the computer’s
memory, where the CPU can get at it. This chunk of the program’s memory is known as the code
segment or text segment.

4.7 Initialization of Statics

The next feature that C++ has over C that affects the linker is the ability to have object con-
structors. A constructor is a piece of code that sets up the contents of an object; as such it is
conceptually equivalent to an initializer value for a variable but with the key practical difference
that it involves arbitrary pieces of code.

Recall from an earlier section that a global variable can start off with a particular value. In
C, constructing the initial value of such a global variable is easy: the particular value is just
copied from the data segment of the executable file into the relevant place in the memory for the
soon-to-be-running program.

6
 In C++, the construction process is allowed to be much more complicated than just copying
in a fixed value; all of the code in the various constructors for the class hierarchy has to be run,
before the program itself starts running properly.

To deal with this, the compiler includes some extra information in the object files for each
C++ file; specifically, the list of constructors that need to be called for this particular file. At link
time, the linker combines all of these individual lists into one big list, and includes code that goes
through the list one by one, calling all of these global object constructors.

Note that the order in which all of these constructors for global objects get called is not defined-
it’s entirely at the mercy of what the linker chooses to do. (See Scott Meyers’ Effective C++ for
more details-Item 47 in the second edition, Item 4 in the third edition).

There are various things here, but the one we’re interested in is the two entries with class as W
(which indicates a "weak" symbol) and with section names like ".gnu.linkonce.t.stuff ". These are
the markers for global object constructors, and we can see that the corresponding "Name" fields
look sensible-one for each of the two constructors used.

5 LOADER
5.1 Definition - What does Loader mean?
A loader is a major component of an operating system that ensures all necessary programs and
libraries are loaded, which is essential during the startup phase of running a program. It places
the libraries and programs into the main memory in order to prepare them for execution. Loading
involves reading the contents of the executable file that contains the instructions of the program
and then doing other preparatory tasks that are required in order to prepare the executable for
running, all of which takes anywhere from a few seconds to minutes depending on the size of the
program that needs to run.

The loader is a component of an operating system that carries out the task of preparing a pro-
gram or application for execution by the OS. It does this by reading the contents of the executable
file and then storing these instructions into the RAM, as well as any library elements that are
required to be in memory for the program to execute. This is the reason a splash screen appears
right before most programs start, often showing what is happening in the background, which is
what the loader is currently loading into the memory. When all of that is done, the program
is ready to execute. For small programs, this process is almost instantaneous, but for large and
complex applications with large libraries required for execution, such as games as well as 3D and
CAD software, this could take longer. The loading speed is also dependent on the speed of the
CPU and RAM.

Not all code and libraries are loaded at program startup, only the ones required for actually running
the program. Other libraries are loaded as the program runs, or only as required. This is especially
true for applications such as games that only need assets loaded for the current level or location
that the player is in.

7
 Though loaders in different operating systems might have their own nuances and specialized
functions native to that particular operating system, they still serve basically the same function.
The following are the responsibilities of a loader:

1. Validate the program for memory requirements, permissions, etc.

2. Copy necessary files, such as the program image or required libraries, from the disk into the
memory
3. Copy required command-line arguments into the stack
4. Link the starting point of the program and link any other required library

5. Initialize the registers

6. Jump to the program starting point in memory

6 Assembler
WHAT IS ASSEMBLER?
An assembler is a program that converts an assembly level language code (also called as
mnemonic code) into machine language code and provides necessary information for the loader
to load the
programme.

Assembly Language Programming

. Writing a program in assembly lang is more convenient than in machine lang.
. Assembly program is more readable.
. Assembly lang is machine dependent.
. Assembly program is written using symbols(Mnemonics).
. Assembly program is translated into machine code before execution.

Example:
MOV AX, X
–MOV is a mnemonic opcode.
–AX is a register operand in symbolic form.
–X is a memory operand in symbolic form.

Elements of Assembly Language

1. Mnemonic Operation Code:-
Eliminates the need to memorize numeric operation code.
2. Symbolic Operands:-
Symbolic names can be used.
3. Data Declarations:-
Data can be declared in any form
Eg: -5, 10.5 etc.

8
Assembler languages-structure
<Label> <Mnemomic> <Operand> Comments
. Label - symbolic labeling of an assembler address (command address at Machine level)
. Mnemomic - Symbolic description of an operation
. Operands - Contains of variables or addresse if necessary
. Comments
- ignored by assembler
- used by humans to document/understand programs
- tips for useful comments:
. avoid restating the obvious, as " decrement R1"
. provide additional insight, as in " accumulate product in R6"

Assembly Lang to M/C lang Program

1. Find address of variables and labels.
2. Replace Symbolic addr by numeric addr.
3. Replace Symbolic opcodes by machine opcode.
4. Reserve storage for data.

Sample program to find X+Y

START 101
READ
READ
MOVER
ADD
MOVEM
PRINT
STOP
DS
DS
DS
END

TYPES OF STATEMENT OF ASSEMBLER STATEMENTS

. Imperative Statements:-
- Indicates an action to be taken during execution of a
program.
- Eg: MOV, ADD, MULT, etc.
. Declaration Statement:-
- To reserve memory for variable.
[Label] DS <constant>
eg: X DS 5
[Label] DC ’<value>’
eg: X DC 3
. Assembler Directives:-
- Instructs the assembler to perform ceratin action during
assembly of a program.
START <constant>
END

9
Literals & Constants
int z=5;
x = x + 5;
1. Literal cannot be changed during program execution
2. Literal is more safe and protected than a constant.
3. Literals appear as a part of the instruction.

Advanced Assembler Directives

. ORIGIN
- ORIGIN <address specification>
. EQU
- <symbol> EQU <address specification>
. LTORG
- Allocates address for literals.

Two Pass Translation

. Handles forward references easily.
. Requires 2 scans of the source program.
. LC processing is performed in the 1 st pass and symbols are stored in the symbol
. Second pass synthesis Target Program.
Single Pass Translation
. The problem of forward reference can be handled using a technique called as back
patching.

Design of a Two Pass Assembler

. Pass I:-
1. Separate the symbol, mnemonic, opcode and operand.
2. Build Symbol Table.
3. Perform LC Processing.
4. Construct Intermediate Representation.
. Pass II:-
1.Process IR to synthesize the target program.

Pass I
. Pass I uses the following data structures
1. Machine Opcode table (OPTAB)
2.Symbol Table (ST)
3.Literal Table (LT)
4.Pool Table (PT)

1. OPTAB contains opcode, class and opcode length.

2. SYMTAB contains symbol and address.
3. LITTAB contains literal and address.
4. POOLTAB contains starting literal number of each pool.

10
7 MACROS
. Macro instructions are single-line abbreviations for group of
instructions.
. Macro is an abbreviation for a sequence of operations .
. Syntax/structure

start of definition MACRO

macro name
Sequence to be abbreviated
End of definition

CONDITIONAL MACRO EXPANSION

Two pseudo-ops are used
AIF:- It is conditional branch pseudo-op that performs an
arithmetic test and branches to specified macro-label only if test is
true.
AGO:- It is unconditional branch pseudo-op. It is equivalent to go-to statement
.
.FINI:- Labels starting with a period(.), such as .FINI, are macro
label do not appear in the output of the macro processor.

IMPLEMENTATION
STATEMENT OF PROBLEM
SPECIFICATION OF DATA BASES
SPECIFICATION OF DATA BASE FORMAT
ALGORITHM

ADVANTAGES & DISADVANTAGES

OF INCORPORATING MACRO INTO
PASS1

Advantages
functions do not have to implemented twice Less overhead during processing
More flexible for programmer

Disadvantages
Large program
More complex

11
7.1 Basic Introduction
A macro (short for "macroinstruction", from Greek ?????? ’long’) in computer science is a rule
or pattern that specifies how a certain input sequence (often a sequence of characters) should be
mapped to a replacement output sequence (also often a sequence of characters) according to a
defined procedure. The mapping process that instantiates (transforms) a macro use into a specific
sequence is known as macro expansion. A facility for writing macros may be provided as part of a
software application or as a part of a programming language. In the former case, macros are used
to make tasks using the application less repetitive. In the latter case, they are a tool that allows
a programmer to enable code reuse or even to design domain-specific languages.
Macros are used to make a sequence of computing instructions available to the programmer as
a single program statement, making the programming task less tedious and less error-prone.[1][2]
(Thus, they are called "macros" because a "big" block of code can be expanded from a "small"
sequence of characters.) Macros often allow positional or keyword parameters that dictate what
the conditional assembler program generates and have been used to create entire programs or
program suites according to such variables as operating system, platform or other factors. The
term derives from "macro instruction", and such expansions were originally used in generating
assembly language code.

7.2 Macros for machine-independent software

Macros are normally used to map a short string (macro invocation) to a longer sequence of instruc-
tions. Another, less common, use of macros is to do the reverse: to map a sequence of instructions
to a macro string. This was the approach taken by the STAGE2 Mobile Programming System,
which used a rudimentary macro compiler (called SIMCMP) to map the specific instruction set of
a given computer to counterpart machine-independent macros. Applications (notably compilers)
written in these machine-independent macros can then be run without change on any computer
equipped with the rudimentary macro compiler. The first application run in such a context is a
more sophisticated and powerful macro compiler, written in the machine-independent macro lan-
guage. This macro compiler is applied to itself, in a bootstrap fashion, to produce a compiled and
much more efficient version of itself. The advantage of this approach is that complex applications
can be ported from one computer to a very different computer with very little effort (for each target
machine architecture, just the writing of the rudimentary macro compiler).[17][18] The advent of
modern programming languages, notably C, for which compilers are available on virtually all com-
puters, has rendered such an approach superfluous. This was, however, one of the first instances
(if not the first) of compiler bootstrapping.

7.2.1 Early Lisp macros

Before Lisp had macros, it had so-called FEXPRs, function-like operators whose inputs were not
the values computed by the arguments but rather the syntactic forms of the arguments, and whose
output were values to be used in the computation. In other words, FEXPRs were implemented at
the same level as EVAL, and provided a window into the meta-evaluation layer. This was generally
found to be a difficult model to reason about effectively.[9]
In 1963, Timothy Hart proposed adding macros to Lisp 1.5 in AI Memo 57: MACRO Definitions
for LISP.[10]

7.2.2 Anaphoric macros

Main article: Anaphoric macro
An anaphoric macro is a type of programming macro that deliberately captures some form
supplied to the macro which may be referred to by an anaphor (an expression referring to another).
Anaphoric macros first appeared in Paul Graham’s On Lisp and their name is a reference to
linguistic anaphora-the use of words as a substitute for preceding words.

7.2.3 Hygienic macros

Main article: Hygienic macro
In the mid-eighties, a number of papers[11][12] introduced the notion of hygienic macro ex-
pansion (syntax-rules), a pattern-based system where the syntactic environments of the macro

12
definition and the macro use are distinct, allowing macro definers and users not to worry about in-
advertent variable capture (cf. referential transparency). Hygienic macros have been standardized
for Scheme in both the R5RS and R6RS standards. The upcoming R7RS standard will also include
hygienic macros. A number of competing implementations of hygienic macros exist such as syntax-
rules, syntax-case, explicit renaming, and syntactic closures. Both syntax-rules and syntax-case
have been standardized in the Scheme standards.
Recently, Racket has combined the notions of hygienic macros with a "tower of evaluators", so
that the syntactic expansion time of one macro system is the ordinary runtime of another block
of code,[13] and showed how to apply interleaved expansion and parsing in a non-parenthesized
language.[14]

7.2.4 Applications
Evaluation order
Macro systems have a range of uses. Being able to choose the order of evaluation (see lazy
evaluation and non-strict functions) enables the creation of new syntactic constructs (e.g. control
structures) indistinguishable from those built into the language. For instance, in a Lisp dialect
that has cond but lacks if, it is possible to define the latter in terms of the former using macros.
For example, Scheme has both continuations and hygienic macros, which enables a programmer to
design their own control abstractions, such as looping and early exit constructs, without the need
to build them into the language.
Data sub-languages and domain-specific languages
Next, macros make it possible to define data languages that are immediately compiled into
code, which means that constructs such as state machines can be implemented in a way that is
both natural and efficient.[15]
Binding constructs
Macros can also be used to introduce new binding constructs. The most well-known example
is the transformation of let into the application of a function to a set of arguments.
Felleisen conjectures[16] that these three categories make up the primary legitimate uses of
macros in such a system. Others have proposed alternative uses of macros, such as anaphoric
macros in macro systems that are unhygienic or allow selective unhygienic transformation.
The interaction of macros and other language features has been a productive area of research.
For example, components and modules are useful for large-scale programming, but the interac-
tion of macros and these other constructs must be defined for their use together. Module and
component-systems that can interact with macros have been proposed for Scheme and other lan-
guages with macros. For example, the Racket language extends the notion of a macro system to
a syntactic tower, where macros can be written in languages including macros, using hygiene to
ensure that syntactic layers are distinct and allowing modules to export macros to other modules.

13