Assembler m/c

Independent Features
and Design options
CHAPTER NO. 3
Machine Independent
Features
LITERALS
SYMBOL DEFINING STATEMENT
EXPRESSIONS
PROGRAM BLOCKS
CONTROL SECTIONS AND PROGRAM LINKING
Literals
Design idea
◦ Let programmers to be able to write the value of a constant operand as a part of the
instruction that uses it.
◦ This avoids having to define the constant elsewhere in the program and make up a
label for it.
Example program
◦ e.g. 45 001A ENDFIL LDA =C’EOF’ 032010
◦ 93 LTORG
◦ 002D * =C’EOF’ 454F46
◦ e.g. 215 1062 WLOOP TD =X’05’ E32011
Literals vs. Immediate Operands
Immediate Operands
◦ The operand value is assembled as part of the machine instruction
◦ e.g. 55 0020 LDA #3 010003
Literals
◦ The assembler generates the specified value as a constant at some other memory location
◦ e.g. 45 001A ENDFIL LDA =C’EOF’ 032010
002D-
Compare (Fig. 2.6) 001D=0010
◦ e.g. 45 001A ENDFIL LDA EOF 032010
◦ 80 002D EOF BYTE C’EOF’ 454F46
Literal - Implementation (1/3)
Literal pools
◦ Normally literals are placed into a pool at the end of the
program
◦ see Fig. 2ss fig\2.10.doc.10 (END statement)
◦ In some cases, it is desirable to place literals into a pool at
some other location in the object program
◦ assembler directive LTORG
◦ reason: keep the literal operand close to the instruction
Literal - Implementation (2/3)
Duplicate literals
◦ e.g. 215 1062 WLOOP TD =X’05’
◦ e.g. 230 106B WD =X’05’
◦ The assemblers should recognize duplicate literals and store only
one copy of the specified data value
Literal - Implementation (3/3)
LITTAB
◦ literal name, the operand value and length, the address assigned to the operand

Pass 1
◦ build LITTAB with literal name, operand value and length, leaving the address
unassigned
◦ when LTORG statement is encountered, assign an address to each literal not yet
assigned an address
Pass 2
◦ search LITTAB for each literal operand encountered
◦ generate data values using BYTE or WORD statements
◦ generate modification record for literals that represent an address in the program
Symbol-Defining Statements
User defined symbols : Labels on instructions or data areas
◦ the value of such a label is the address assigned to the statement
Defining symbols :assembler directive EQU(equate)
◦ symbol EQU value
◦ value can be:  constant,  other symbol,  expression
◦ making the source program easier to understand
◦ no forward reference
Symbol-Defining Statements
Establish symbolic names to improve readability in place of numeric
values.
E.g., +LDT #4096 can be changed to :
MAXLEN EQU 4096
+LDT #MAXLEN
When the assembler encounters the EQU statement, it enters
MAXLEN into SYMTAB (with value 4096).
During assembly of the LDT instruction, the assembler searches
SYMTAB for the symbol MAXLEN, using its value as the operand in
the instruction.
Symbol-Defining Statements
Example 1
◦ MAXLEN EQU 4096 +LDT #4096
◦ +LDT #MAXLEN
Example 2 (Many general purpose registers)
◦ BASE EQU R1
◦ COUNTEQU R2
◦ INDEX EQU R3
Example 3
◦ MAXLEN EQU BUFEND-BUFFER
Symbol-Defining Statements
Define mnemonic names for registers:
ORG (origin)
Indirectly assign values to symbols
Reset the location counter to the specified value
◦ ORG value

Value can be:  constant,  other symbol,  expression

No forward reference
ORG (origin)
When this statement is encountered during assembly of a program,
the assembler resets its location counter to the specified value.

The ORG statement will thus affect the values of all labels defined
until the next ORG.

Normally when an ORG without specified value is encounter, the

previously saved location counter value is restored,
ORG Usage Example
Suppose that we have the following data structure and want to
access its fields:
Program without Using ORG

Show offsets, less

readable

We can then use LDA VALUE, X to fetch the VALUE field from the table entry
indicated by the content of register X.
To fetch the next record, X is added by 6 + 1 + 2.
Program with Using ORG

Show sizes, more

readable

Restore the location counter to the old value

 No Forward Reference
Allowed
For EQU and ORG, all symbols used on the right hand side of the
statement must have been defined previously in the program.
This is because in the two-pass assembler, we require that all
symbols must be defined in pass 1.

Allowed

Not allowed
ORG Restriction

Not allowed

Not allowed
Expression
So far, when we define the value of a symbol or label, only one term
is used.
◦ E.g., 106 BUFEND EQU*

Actually, we can also use expressions which contains many terms to

define a symbol’s value, evaluated by assembler to produce single
operand value or address
◦ E.g., 107 MAXLEN EQUBUFEND - BUFFER
 Relative v.s. Absolute Value
Generally, +, -, *, /, operations are allowed to be used in an
expression.
Division is defined to produce an integer.
Regarding program relocation, a symbol’s value can be classified as
◦ Relative
◦ Its value is relative to the beginning of the object program, and thus its value is dependent
of program location.
◦ E.g., labels or reference to location counter (*)
◦ Absolute
◦ Its value is independent of program location
◦ E.g., a constant.
 Relative v.s. Absolute Expression
Depending on the type of value they produce, expressions
are classified as:
◦ Absolute
◦ An expression that contains only absolute terms, or
◦ An expression that contains relative terms but the relative terms occur in
pairs and the terms in each pair have opposite signs. (/ and * operations are
not allowed)
◦ Relative
◦ An expression in which all relative terms except one can be paired as before
and the remaining unpaired term must have a positive sign. (/ and *
operations are not allowed)
Absolute Expression Example
107 MAXLEN EQU BUFEND – BUFFER
Although BUFEND and BUFFER are relative terms (because their values will
change when the program is loaded into a different place in memory), the
expression (BUFEND – BUFFER) is an absolute expression.
Why? the value of this expression is 0x1000, which is the same no matter where
this program is loaded.
Why? Because BUFEND and BUFFER can be represented as (startingaddr + x)
and (startingaddr + y), BUFEND – BUFFER becomes (x – y), which is a constant.
Illegal Expressions
BUFEND + BUFFER
100 – BUFFER
3 * BUFFER
These expressions represent neither absolute nor location within the
program
Therefore, these expression are considered illegal.
 Enhanced Symbol Table
To determine the type of an expression, we must keep track of the types of all symbols
defined in the program,
Therefore, we need a flag in the symbol table to indicate type of value (absolute or
relative) in addition to the value itself.
Easily determine the type of expression and generate M record in object program for
relative values
Program Blocks
Program blocks
◦ refer to segments of code that are rearranged within a single object program
unit
◦ USE [blockname]
◦ Default block
◦ Example: Figure 2.11
◦ Each program block may actually contain several separate segments of the
source program
Program Blocks - Implementation
Pass 1
◦ each program block has a separate location counter
◦ each label is assigned an address that is relative to the start of the block that
contains it
◦ at the end of Pass 1, the latest value of the location counter for each block
indicates the length of that block
◦ the assembler can then assign to each block a starting address in the object
program
Pass 2
◦ The address of each symbol can be computed by adding the assigned block
starting address and the relative address of the symbol to that block
Figure 2.12
Each source line is given a relative address assigned and a block number(end of
pass1)
Block name Block number Address Length
(default) 0 0000 0066
CDATA 1 0066 000B
CBLKS 2 0071 1000

For absolute symbol, there is no block number

◦ line 107

Example
◦ 20 0006 0 LDA LENGTH 032060
◦ LENGTH=(Block 1)+0003= 0066+0003= 0069
◦ LOCCTR=(Block 0)+0009= 0009
Program Readability
Program readability
◦ No extended format instructions on lines 15, 35, 65
◦ No needs for base relative addressing (line 13, 14)
◦ LTORG is used to make sure the literals are placed ahead of any
large data areas (line 253)
Object code
◦ It is not necessary to physically rearrange the generated code in the object
program
◦ see Fig. 2.13, Fig. 2.14
Object Program
Control Sections and Program Linking
Control Sections
◦ are most often used for subroutines or other logical subdivisions of
a program
◦ the programmer can assemble, load, and manipulate each of these
control sections separately
◦ instruction in one control section may need to refer to instructions
or data located in another section
◦ because of this, there should be some means for linking control
sections together
◦ Fig. 2.15, 2.16
External Definition and References
External definition
◦ EXTDEF name [, name]
◦ EXTDEF names symbols that are defined in this control section and may be used by other
sections

External reference
◦ EXTREF name [,name]
◦ EXTREF names symbols that are used in this control section and are defined elsewhere

Example
◦ 15 0003 CLOOP +JSUB RDREC 4B100000
◦ 160 0017 +STCH BUFFER,X 57900000
◦ 190 0028 MAXLEN WORD BUFEND-BUFFER 000000
Implementation
The assembler must include information in the object program that will
cause the loader to insert proper values where they are required
Define record
◦ Col. 1 D
◦ Col. 2-7 Name of external symbol defined in this control section
◦ Col. 8-13 Relative address within this control section (hexadecimal)
◦ Col.14-73 Repeat information in Col. 2-13 for other external symbols

Refer record
◦ Col. 1 D
◦ Col. 2-7 Name of external symbol referred to in this control section
◦ Col. 8-73 Name of other external reference symbols
Modification Record
◦ Col. 1 M
◦ Col. 2-7 Starting address of the field to be modified (hexadecimal)
◦ Col. 8-9 Length of the field to be modified, in half-bytes (hexadecimal)
◦ Col.11-16 External symbol whose value is to be added to or subtracted from the
indicated field
◦ Note: control section name is automatically an external symbol, i.e. it is available
for use in Modification records.
Example
◦ Figure 2.17
◦ M00000405+RDREC
◦ M00000705+COPY
External References in Expression
Earlier definitions
◦ required all of the relative terms be paired in an expression (an absolute
expression), or that all except one be paired (a relative expression)
New restriction
◦ Both terms in each pair must be relative within the same control section
◦ Ex: BUFEND-BUFFER
◦ Ex: RDREC-COPY
In general, the assembler cannot determine whether or not
the expression is legal at assembly time. This work will be
handled by a linking loader.
Assembler Design Options
ONE-PASS ASSEMBLERS
MULTI-PASS ASSEMBLERS
TWO-PASS ASSEMBLER WITH
OVERLAY STRUCTURE
Two-Pass Assembler with Overlay Structure
For small memory
◦ pass 1 and pass 2 are never required at the same time
◦ three segments
◦ root: driver program and shared tables and subroutines
◦ pass 1
◦ pass 2
◦ tree structure
◦ overlay program
One-Pass Assemblers
Main problem
◦ forward references
◦ data items
◦ labels on instructions

Solution
◦ data items: require all such areas be defined before they are
referenced
◦ labels on instructions: no good solution
One-Pass Assemblers
Main Problem
◦ forward reference
◦ data items
◦ labels on instructions

Two types of one-pass assembler

◦ load-and-go
◦ produces object code directly in memory for immediate execution
◦ the other
◦ produces usual kind of object code for later execution
Load-and-go Assembler
Characteristics
◦ Useful for program development and testing
◦ Avoids the overhead of writing the object program out and reading
it back
◦ Both one-pass and two-pass assemblers can be designed as load-
and-go.
◦ However one-pass also avoids the over head of an additional pass
over the source program
◦ For a load-and-go assembler, the actual address must be known at
assembly time, we can use an absolute program
Forward Reference in One-pass Assembler
For any symbol that has not yet been defined
1. omit the address translation
2. insert the symbol into SYMTAB, and mark this symbol undefined
3. the address that refers to the undefined symbol is added to a list
of forward references associated with the symbol table entry
4. when the definition for a symbol is encountered, the proper
address for the symbol is then inserted into any instructions
previous generated according to the forward reference list
Load-and-go Assembler (Cont.)
At the end of the program
◦ any SYMTAB entries that are still marked with * indicate undefined
symbols
◦ search SYMTAB for the symbol named in the END statement and
jump to this location to begin execution
The actual starting address must be specified at assembly
time
Example
◦ Figure 2.18, 2.19
Producing Object Code
When external working-storage devices are not available or too slow
(for the intermediate file between the two passes
Solution:
◦ When definition of a symbol is encountered, the assembler must generate
another Text record with the correct operand address
◦ The loader is used to complete forward references that could not be handled
by the assembler
◦ The object program records must be kept in their original order when they are
presented to the loader
Example: Figure 2.20
Multi-Pass Assemblers
Restriction on EQU and ORG
◦ no forward reference, since symbols’ value can’t be defined during the first
pass
Example
◦ Use link list to keep track of whose value depend on an undefined symbol

Figure 2.21
End of Chapter 03