CROSSASSEMBLER FOR 8085 MICROPROCESSOR INSTRUCTION SET BHARAT by dfsdf224s

VIEWS: 196 PAGES: 48

									                            A REPORT 

                                 ON 

      CROSS­ASSEMBLER FOR 8085 MICROPROCESSOR 

                      INSTRUCTION SET 




                                 BY 



M.P.SUMANTH                                           2004B2A7623 

A. ANIL KUMAR                                         2004P7PS165 

D.DEEPAK                                              2004P7PS175 

K.GIRIDHAR                                            2004T6PS351 




                                 AT 


                 BHARAT DYNAMICS LIMITED 
                  KANCHANBAGH, HYDERABAD 




                    A Practice School­I station of 


       BIRLA INSTITUTE OF TECHNOLOGY & SCIENCE, PILANI 


                             (July, 2006)




                                  1 
                             A REPORT 

                                  ON 

      CROSS­ASSEMBLER FOR 8085 MICROPROCESSOR 

                       INSTRUCTION SET 



                                  BY 



M.P.SUMANTH                 2004B2A7623           M.Sc Chemistry with C.S.E 

A.ANIL KUMAR                2004P7PS165           B.E (Hons) C.S.E 

D.DEEPAK                    2004P7PS175           B.E (Hons) C.S.E 

K.GIRIDHAR                  2004T6PS351           M.Sc (Tech) Information 
                                                  Systems 




                 Prepared in partial fulfillment of the 
                Practice School – I Course (BITS C221) 

                                  AT 


                BHARAT DYNAMICS LIMITED 
                  KANCHANBAGH, HYDERABAD 


                     A Practice School­I station of 


      BIRLA INSTITUTE OF TECHNOLOGY & SCIENCE, PILANI 


                              (July, 2006)



                                   2 
                    BIRLA INSTITUTE OF TECHNOLOGY & SCIENCE 
                                         PILANI (RAJASTHAN) 
                                          Practice School Division 


Station: Bharat Dynamics Limited, Kanchanbagh                            Centre: Hyderabad 
                                                                                          th 
Duration: 53 Days                                                        Date of Start: 24  May, 2006 
                      th 
Date of Submission: 12  July, 2006 
Title of the Project: CROSS­ASSEMBLER FOR 8085 MICROPROCESSOR 
                               INSTRUCTION SET 
Names and Identification Numbers: 
M.P.SUMANTH                                      2004B2A7623                  M.Sc Chemistry with C.S.E 
A.ANIL KUMAR                                     2004P7PS165                  B.E (Hons) C.S.E 
D.DEEPAK                                         2004P7PS175                  B.E (Hons) C.S.E 
K.GIRIDHAR                                       2004T6PS351                  M.Sc (Tech) Information 
                                                                              Systems 
Name and Designation of the expert: 
Mr. M. JAGADISH                                       Manager, Information Technology Division, B.D.L 
Name of the PS Faculty: Dr. T.Solomon Raju 
Key Words: assembly language, instruction set, assembler, algorithm, coding. 
Project Areas: Assembler 
Abstract: The report includes definitions of assembling process related terms and the instruction 
set of Intel 8085 Microprocessor. The report also presents an algorithm and ‘C’ language code 
for an assembler with certain limitations along with an example. 


Signature of the Students:                                                        Signature of PS Faculty: 
M.P. Sumanth                                                                              T. Solomon Raju 
                                                                                          th 
A. Anil Kumar                                                                     Date: 12  July, 2006 
D. Deepak 
K. Giridhar 
        th 
Date: 12  July, 2006




                                                          3 
ACKNOWLEDGEMENTS 


We acknowledge our special gratitude to Maj.General (Retd.) Rajnish Gossain, Chairman 

and Managing Director, BDL, Kanchanbagh for providing us with an opportunity of 

undergoing our Practice School­I program at this reputed company. 

We are extremely thankful to DEAN PRACTICE SCHOOL DIVISION who was 

generous to allot us this PS station. 

We  are  thankful  to  Mr.M.S.K.Sharma,  General  Manager  P&A,  who  gave  his  valuable 

guidance,  support  and  coordination  to  shape  this  PS  programme.  We  are  thankful  to 

Mr.N.Satyanarayana,  Dy.Manager  HRD,  who  had  allotted  us  various  divisions  and 

introduced us to them. 

We are also thankful to Mr.G.Satynarayana, DGM, ITD, for his valuable guidance in the 

PS  program.  We  are  thankful  to  Mr.  M.Jagadish,  Manager,  ITD  who  has  given  his 

constant  support  through  out  the  PS  program  and  for  giving  us  insight  into  various 

concepts of programming. 

We express our deep sense of gratitude to our beloved instructor Dr.T.Solomon Raju and 

student  instructor  Mr.  Srikanth  for  guiding  us  in  bringing  out  the  report  with  beautiful 

results.




                                                 4 
                                 TABLE OF CONTENTS 
Abstract                                              3 
Acknowledgements                                      4 
1.  Introduction 
   1.0 About the Organization                         6 
   1.1 Information Technology Division (ITD)          7 
        1.1.0 Introduction                            7 
        1.1.1 Servers and Network systems in ITD      8 
        1.1.2 Organization of ITD                     9 
2. The Assembler 
   2.0 The Assembly Language                          10 
   2.1 About the Assembler                            10 
        2.1.0 Introduction                            10 
        2.1.1 History of Assemblers                   10 
        2.1.2 Types of Assemblers                     11 
3. The Assembling Process                             13 
4. The Intel 8085 Microprocessor 
   4.0 Introduction                                   15 
   4.1 Instruction Set of 8085 Microprocessor         15 
5. Algorithm for the Coding of Cross­Assembler        21 
6. Coding for Cross­Assembler 
   6.0 ‘C’ code for Assembler                         24 
   6.1 Lookup Table for the Assembler                 42 
   6.2 Keywords Table                                 44 
   6.3 Jump/Label Instructions Table                  45 
   6.4 Sample Assembly Code.                          45 
References                                            47




                                           5 
                                     1. INTRODUCTION 


1.0    ABOUT THE ORGANISATION: 


BDL was incorporated in July 1970 with the prime objective of establishing a production 
base for guided missiles and for the development of production technology in India. An 
ambitious  program  to  produce  first  generation  anti  tank  wire  guided  missiles  as  a 
forerunner  for  more  sophisticated  weapons  was  taken  up  under  the  license  agreement 
with M/s Aerospatiale, France. 
        BDL proved its mettle when its first batch of missiles produced was accepted by 
the Indian army within one year of production. With this, India joined the select group of 
countries in the field of missiles production. 
        In the meanwhile the mastering of missiles production technology has installed a 
lot of confidence to go in for sophisticated anti tank second generation missiles, namely 
Milan  weapon  system.  To  this  effect  a  license  agreement  was  signed  with  Europe’s 
leading agreement manufacturing company M/s Euro missiles, France and the production 
of the same has been commenced from January 1985 onwards. The Milan weapon system 
is today the  most widely used and envied weapon  system  in  its class  in the world. The 
sensitivity and accuracy is unsurpassed with hit probability of 97%. Only four countries 
in the world, India being the one of them today manufactures this weapon. 
        BDL  has  been  assigned  the  production  of  Konkurs  weapon  system  (Heavy 
Armour  Long  Range  second  generation  anti  tank  guided  missiles)  under  the  license 
agreement  entered  into  by  Government  of  India,  with  the  government  of  USSR.  The 
missiles are semi automatic command to line of sight guidance weapon. The project site 
for  the  production  of  this  weapon  system  is  located  in  Bhanur  village,  Medak  district, 
Andhra Pradesh. The production of the same has commenced from June 1989 onwards. 
        Further, BDL has been nominated as the prime production agency for the projects 
developed  by  the  Defence  Research  Development  Organization  (DRDO)  under  the 
IGMDP. The IGMDP of the DRDO envisages the development and establishing




                                                6 
Development Fabrication Facility (DFF) and limited series of production facility for the 
following missile systems: 




Table 1.1   Missiles and their characteristics 
PRITHVI                                           Surface to Surface missiles 
TRISHUL                                           Multi role tactile core vehicle 
AKASH                                             Medium range surface to air missile 
NAG                                               Third generation anti tank missiles 


          BDL has also diversified into the fields of rocket and electronics for the navy. A 
number  of  systems  like  sonar  modification  kit,  sonic  ray  plotter,  RGB­25  rocket,  range 
strobe unit and deep suspended target, project­4 and NST­58 torpedo have been produced 
and delivered. 
          The  dedicated  mini  computers  along  with  NC  operating  system  came  into  the 
market has  computer  numerical control  system. This  interesting  feature of memory, the 
computer numerical control systems gave the new technology (software oriented system). 
The  invention  of  semiconductor  memory  devices  has  reduced  in  size  of  the  system  as 
compared to the core memories used in the earlier mini computers. In the initial stage the 
computer was associated as an offline data processing aid in the computer programming 
parts. 
1.1. INFORMATION TECHNOLOGY DIVISION (ITD) 
1.1.0 Introduction to the ITD: 
ITD with team of highly qualified experienced computer professionals provides campus­ 
wide  network  based  S/W  solutions  in  the  areas  of  production,  finance,  personnel  and 
administration. Its core competence is in the areas of RDBMS and diverse range of front­ 
end tools­spanning D2K, VB, VC++, JAVA, ASP etc.




                                                7 
Some of the prime S/W solutions: 
SAMAY                        Access control system linked from punch to pay 
MANAV                        Complete HRM (Human Resource Management) information 
                             from recruitment to retirement. 
CHANAKYA                     Integrated  product  costing,  budgeting  and  financial 
                             accounting 
VIKALPA                      ERP solution for manufacturing and materials 
DHANVANTRY                   Hospital management system 
VIGNAN                       Caters to the need of computerized library information system 


                      Table 2.1 Names and the purpose of S/W solutions 
1.1.1 Servers and Network systems in ITD
     ·  There are 3 servers in ITD of which 2 systems are of Linux with 2GB RAM and 1 
        system of  windows 2003 server with 1GB RAM. These are highly configured of 
        BULL Company imported from France. 
        Their main features are: 
            Ø  The parallel computing feature 
        10 instructions can be executed at a time and the T­state is very less. 
            Ø  There are 4 processors on the motherboard.
     ·  8 GHz speed for Linux systems and 1.3 GHz for windows server with 64 GB 
         Hard disk.
     ·  There are few other systems of low configuration of 256MB RAM 20GB hard 
        Disk.
     ·  There are around 300­400 systems covering the entire BDL kanchanbagh unit.
     ·  All the buildings are connected to the main server through optical fibred system. 
        These run only one channel at a time. In India maximum 8 channels run 
        (Corresponding to VIBGYOR) but in other countries the channels may exceed 65,000 . 
         There is a printer in ITD that prints 1200 lines per minute. This is used for bulk 
.        Printing processes like pre printed pay rolls, bulk reports etc




                                              8 
     ·  Information  goes  out  from  the  main  server  to  different  buildings  using  optical 
          fibred system. From there the computer network can access the data by converting 
          the optical signals and through a series of HUBS and SWITCHES. 
  In  switches  the  rate  of  data  transfer  remains  same  for  all  the  computers  in  network 
 (100 Mbps or  mega  bits per  second) unlike the  hubs where the speed  is distributed (10 
 Mbps).
     ·  In  BDL  the  switches  are  cascaded  with  hubs  for  effective  data  transfer  and  to 
          retain  performance.  3  hubs  are  connected  to  a  switch.  The  database  in  BDL  is 
          mainly Oracle both in front and back end. 
 1.1.2 ORGANIZATION OF ITD 


 DEPUTY GENERAL MANAGER (G.SATYANARAYANA) 




 MANAGERS 




Subbaraju    Jagadish     Pullanna        Srinivasulu       G.Cheena          Rammohan gupta 




                           Senior most team coordinator. Next to DGM and looks after ITD 
 SUBBARAJU 
                           in his absence 
 PULLANNA                  hardware 
                           online attendance system, HRMS(human resource management 
 R M GUPTA 
                           system) 
 CHEENA                    system administration 
 SREENIVASULU              ISO 
 JAGADISH:                 ERM ( Enterprise Resource Management ) module 




                       Table 2.2 ITD members and the area of their work


                                                 9
                                     2. THE ASSEMBLER 
2.0 The Assembly Language 
   Assembly language, commonly called assembly, asm or symbolic machine code, is a 
human­readable  notation  for  the  machine  language  that  specific  computer  architecture 
uses.  It  is  one  step  away  from  machine  language.    Machine  language,  a  pattern  of  bits 
encoding machine operations, is made readable by replacing the raw values with symbols 
called  mnemonics.  Each  assembly  language  statement  is  translated  into  one  machine 
instruction  before  it  is  executed  on  a  machine.  Assembly  language  is  hardware 
dependent; there is a different assembly language for each CPU series. 
  The  distinguishing  feature  of  assembly  language  is  that  corresponding  to  one 
mnemonic there is only one machine code. 
  Instructions  in  assembly  language  are  generally  very  simple.  Any  instruction  that 
references  memory  (for  data or  as  a  jump  target)  will  also  have  an  addressing  mode  to 
determine how to calculate the required memory address 


2.1 About the Assembler 
2.1.0. Introduction to assemblers 
Assembler  is  a  computer  program  that  takes  as  input  a  set  of  instructions  written  in 
assembly  language,  and  produces  a  corresponding  executable  computer  program  in 
machine  language.  Assembler  translates  assembly  instruction  mnemonics  into  opcodes. 
Besides,  It  provides  the  ability  to  use  symbolic  names  for  memory  locations  (saving 
tedious  calculations  and  manually  updating  addresses  when  a  program  is  slightly 
modified), and macro facilities for performing textual substitution. 


2.1.1 History of Assemblers 
      Ø  One of the first stored program computers was the EDSAC (Electronic Delay 
      Storage  Automatic  Calculator)  developed  at  Cambridge  University  in  1949  by 
      Maurice  Wilkes  and  W.  Renwick.  EDSAC  which  had  an assembler,  called  Initial 
      Orders.  It  was  implemented  in  a  read­only  memory  formed  from  a  set  of  rotary 
      telephone  selectors,  and  it  accepted  symbolic  instructions.  Each  instruction 
      consisted of a one letter mnemonic, a decimal address, and a third field that was a



                                                10 
      letter.  The  third  field  caused  one  of  12  constants  preset  by  the  programmer  to  be 
      added to the address at assembly time. 
      Ø  One of the first commercially successful computers was the IBM 704. It had 
      features such as floating­point hardware and index registers. It was first delivered in 
      1956 and its assembler, the UASAP­1, was written in the same year by Roy Nutt of 
      United Aircraft Corp. It was a simple binary assembler, did practically nothing but 
      one­to­one  translation,  and  left  the  programmer  in  complete  control  over  the 
      program. 
      Ø  By the late fifties, IBM had released the 7000 series of computers. These came 
      with a macro assembler, SCAT that had all the features of modern assemblers. The 
      GAS  (Generalized  Assembly  System)  assembler  was  another  powerful  7090 
      assembler. 


2.1.2. Types of Assemblers 
1.  Based on the portability of the assemblers they are divided into two categories. 
Self Assembler: 
 A  self­assembler  or  resident  assembler  is  an  assembler  which  runs  on  the 
microcomputer for which  it produces object  codes (machine codes).It is specific  for the 
system on which it is developed. It is permanently loaded in memory. Typically this kind 
of assembler resides  in ROM and  is very simple  (supports only  a  few directives and  no 
macros) 


Cross Assembler: 
A cross assembler generates machine language for a different type of computer than the 
one the assembler  is running  in. To be clear  it runs on a computer other than that  for 
which it produces object codes. It is used to develop programs for computers on a chip 
or  microprocessors  used  in  specialized  applications  that  are  either  too  small  or  are 
otherwise incapable of handling the development software. Many cross­assemblers are 
written in a higher­level language to make them portable. They run on a large machine 
and produce object code for a small machine.




                                                 11 
2. Based on assembly process there are two types of assemblers. 
One­Pass Assembler: 
An assembler which goes through an assembly language program only once is known as 
one­pass  assembler.  Such  an  assembler  must  have  some  technique  to  take  the  forward 
references into account. Assembly language programs use labels that may appear later on 
in the program. Such  labels point to forward references. It is  faster as  it goes through a 
program only once. 
Two­Pass Assembler: 
An assembler that goes through an assembly language program twice is called a two­pass 
assembler.  Such  an  assembler  does  not  face  difficulty  with  forward  references.  During 
the  first  pass  it  collects  all  the  labels.  During  the  second  pass  it  produces  the  machine 
code for each instruction and assigns addresses to each of them. 


3. Other categories of Assemblers 
A Macro­Assembler: One that supports macros 
A Meta­Assembler: One that can handle many different instruction sets. 
A Disassembler: This, in a sense, is the opposite of an assembler. It translates machine 
code into a source program in assembler language. 
A high­level assembler: This  is a translator for a  language combining the  features of a 
higher­level  language  with  some  features  of  assembler  language.  Such  a  language  can 
also be considered a machine dependent higher­level language. 
A Micro­Assembler: Used to assemble microinstructions. It is not different in principle 
from  an  assembler.  Note  that  microinstructions  have  nothing  to  do  with  programming 
microcomputers.




                                                  12 
                          3.THE ASSEMBLING PROCESS 
The two pass assembly, the simplest to understand is described in the following flow 
charts. 
Process in pass­one: 




            Figure 3.1   Flow chart describing first pass in two pass assembler




                                            13 
Process in pass­two: 




    Picture 3.2     Flow chart describing second pass in two pass assembling process




                                          14 
                       4. THE INTEL 8085 MICROROCESSOR 


4.0  Introduction to 8085 Microprocessor 
  Intel 8085 is an 8­bit, NMOS microprocessor. It is a 40 pin IC. package fabricated on a 
single LSI chip. Its clock speed is about 3 MHz. The clock cycle is of 320 ns. It has 80 
basic instructions and 246 opcodes. It consists of three main sections. 
                        1. Arithmetic and Logic unit 
                        2. Timing and Control unit 
                        3. Set of registers 
4.1 Instruction set of 8085 Microprocessor 
Instruction Naming Conventions: 

The mnemonics assigned to the instructions are designed to indicate the function of the 
instruction. The instructions fall into the following functional categories: 

Data Transfer Group: 

The data transfer instructions move data between registers or between memory and 
registers. 

MOV           Move 

MVI           Move Immediate 

LDA           Load Accumulator Directly from Memory 

STA           Store Accumulator Directly in Memory 

LHLD          Load H & L Registers Directly from Memory 

SHLD          Store H & L Registers Directly in Memory 

An 'X' in the name of a data transfer instruction implies that it deals with a register pair 
(16­bits);



                                               15 
LXI          Load Register Pair with Immediate data 

LDAX         Load Accumulator from Address in Register Pair 

STAX         Store Accumulator in Address in Register Pair 

XCHG         Exchange H & L with D & E 

XTHL         Exchange Top of Stack with H & L 

Arithmetic Group: 

The arithmetic instructions add, subtract, increment, or decrement data in registers or 
memory 

ADD         Add to Accumulator 

ADI         Add Immediate Data to Accumulator 

ADC         Add to Accumulator Using Carry Flag 

ACI         Add immediate data to Accumulator Using Carry 

SUB         Subtract from Accumulator 

SUI         Subtract Immediate Data from Accumulator 

SBB         Subtract from Accumulator Using Borrow (Carry) Flag 

SBI          Subtract Immediate from Accumulator Using Borrow (Carry) Flag 

INR         Increment Specified Byte by One 

DCR         Decrement Specified Byte by One 

INX         Increment Register Pair by One



                                            16 
DCX         Decrement Register Pair by One 

DAD         Double Register Add; Add Content of Register 

             Pair to H & L Register Pair 

Logical Group: 

This group performs logical (Boolean) operations on data in registers and memory and on 
condition flags. 

The logical AND, OR, and Exclusive OR instructions enable you to set specific bits in 
the accumulator ON or OFF. 

ANA         Logical AND with Accumulator 

ANI         Logical AND with Accumulator Using Immediate Data 

ORA         Logical OR with Accumulator 

OR          Logical OR with Accumulator Using Immediate Data 

XRA         Exclusive Logical OR with Accumulator 

XRI          Exclusive OR Using Immediate Data 

The Compare instructions compare the content of an 8­bit value with the contents of the 
accumulator; 

CMP         Compare 

CPI         Compare Using Immediate Data 

The rotate instructions shift the contents of the accumulator one bit position to the left or 
right:




                                              17 
RLC         Rotate Accumulator Left 

RRC         Rotate Accumulator Right 

RAL          Rotate Left through Carry 

RAR          Rotate Right through Carry 

Complement and carry flag instructions: 

CMA          Complement Accumulator 

CMC          Complement Carry Flag 

STC          Set Carry Flag 

Branch Group: The branching instructions alter normal sequential program flow, either 
unconditionally or conditionally. The unconditional branching instructions are as follows: 

JMP         Jump 

CALL         Call 

RET         Return 

Conditional branching instructions examine the status of one of four condition flags to 
determine whether the specified branch is to be executed. The conditions that may be 
specified are as follows: 

NZ         Not Zero (Z = 0) 

Z          Zero (Z = 1) 

NC         No Carry (C = 0) 

C          Carry (C = 1)



                                            18 
PO          Parity Odd (P = 0) 

PE          Parity Even (P = 1) 

P           Plus (S = 0) 

M           Minus (S = 1) 

The conditional branching instructions are specified as follows: 


Jumps                   Calls                    Returns 
C                       CC                       RC                  (Carry) 
INC                     CNC                      RNC                 (No Carry) 
JZ                      CZ                       RZ                  (Zero) 
JNZ                     CNZ                      RNZ                 (Not Zero) 
JP                      CP                       RP                  (Plus) 
JM                      CM                       RM                  (Minus) 
JPE                     CPE                      RPE                 (Parity Even) 

Table 4.1  Conditional branching instructions 




Two other instructions can affect a branch by replacing the contents or the program 
counter: 

PCHL         Move H & L to Program Counter 

RST          Special Restart Instruction Used with Interrupts 

Stack I/O, and Machine Control Instructions: 

The following instructions affect the Stack and/or Stack Pointer: 

PUSH          Push Two bytes of Data onto the Stack


                                             19 
POP          Pop Two Bytes of Data off the Stack 

XTHL          Exchange Top of Stack with H & L 

SPHL          Move content of H & L to Stack Pointer 

The I/0 instructions are as follows: 

IN           Initiate Input Operation 

OUT          Initiate Output Operation 

The Machine Control instructions are as follows: 

EI          Enable Interrupt System 

DI          Disable Interrupt System 

HLT         Halt 

NOP         No Operation




                                           20 
           5. ALGORITHM FOR THE CODING OF CROSS­ASSEMBLER 


The algorithm presented below is to write code for a two pass cross­assembler in high level 
languages(C,C++,JAVA etc). 
ALGORITHM 
The algorithm is divided into two parts namely PASS 1 and PASS 2. 
PASS 1: 
§  IN THE MAIN FUNCTION 
       Ø  Start 
       Ø  Read a line from the source code into array named arr. 
       Ø  Read the first word into array named arr1 and sends it to the search_lab 
           Function. 
§  IN THE SEARCH_LAB FUNCTION 
       Ø  The arr1 contents are compared with ‘.ORIG’. 
           ü  If match is found then ‘m’ value is set to ‘4’ and the function returns ‘0’ to 
           the main function. 
           ü  If no match found then a ‘keyword’ file is accessed and its contents are 
           Compared to the arr1 content. If match is found then the function Returns ‘1’ 
            to the main Function. 
       Ø  Before returning ‘1’ to the main function, a ‘jump’ file is accessed and 
           Its contents are compared with the arr1 content. 
           ü  If match is found, the 
           Address is updated, bytes are updated and m value is set to ‘2’and the 
           Function returns ‘0’ to the main function. 
           ü  If match is not found then it compares the arr1 contents with ’IN’ and 
           ‘OUT’ instructions. 
           ü  If match is found then address is updated, bytes are updated and m value is 
            set to ‘3’and returns ‘0’ to the main function. 
       Ø  If no match is found in ‘keyword’ file, then ‘valid_lab’ function is called, 
           It checks the validity of the label. If valid then the functions returns 
           ‘0’.if not the function prints ‘invalid label’ and returns ‘1’.



                                              21 
           The function checks the returned value from the valid_lab function. 
           ü  If it is ‘0’, a file named ‘label_tab’ is opened, the arr1 contents and the 
            Address are printed into the file and the search_lab functions returns ‘0’  to the 
             Main function. 
           ü  If it is ‘1’, the search_lab function just returns ‘0’ to the main function. 
§  IN THE MAIN FUNCTION 
      Ø  The function checks the value returned by search_lab function. 
           ü  If it is ‘0’, arr1 is cleared. 
           ü  If not, the whole line is read into the array arr1 and sent to the function 
           Chg_data_addr. 
           . 
      Ø  The content of ‘m’ is checked, if it is ‘4’,then the main function calls a 
           Function named hex. And the address is updated. 
§  IN THE CHG_DATA_ADDR FUNCTION 
      Ø  In this function the array arr1 is checked if it contains any address instruction 
           Or any data instruction. 
           ü  If it contains any data instruction then the value of v is Set to ‘1’. 
           ü  If it contains any address instruction then the value of v is set to ‘0’ and the 
           Value of n is set to ‘1’. 
      Ø  Then the bytes are updated and the address is updated. The arr1 content is 
           compared with the ‘HLT’, if match is found then the function  Returns ‘1’, 
           other wise it returns ‘0’. 
§  IN THE HEX FUNCTION 
      Ø  The hex value is converted into numeric value and stored in address. 
                                        The PASS 1 ends. 


PASS 2: 
                §  IN THE MAIN FUNCTION 
      Ø  Start 
      Ø  Read a line from the source code into array named arr. 
      Ø  Read the first word into array named arr1 and sends it to the search_lab



                                                22 
         Function. 
§  IN THE SEARCH_LAB FUNCTION 
     Ø  The process continues same as in pass1 and returns values to the main function. 
        Except that it won’t open and write the labels and their addresses into a 
        Label_tab file as in Pass1. 
     Ø  In pass2, this function calls look_search to update 
        the bytes, which  prints the address and opcode into the output file. 
§  IN THE MAIN FUNCTION 
     Ø  The function checks the value returned by search_lab function. 
        ü  If it is ‘0’, arr1 is cleared. 
        ü  If not, the whole line is read into the array ‘arr1’ and sent to the function 
         chg_data_addr. 
     Ø  The value of ‘m’ is compared. 
        ü  If it is ‘2’ then the main function calls a function named branch. 
        ü  If it is ‘3’ then the main function calls a function named port. 
        ü  If it is ‘4’ then the main function calls a function named hex. 
     Ø  The output file is printed on the screen and any temporary files used are deleted. 


§  IN THE CHG_DATA_ADDR FUNCTION 
     Ø  The same process continues as in pass1 and the function at the end compares 
         The values of ‘v’ and accordingly it prints the address or data given in the 
         instruction into the output file. 
§  IN THE BRANCHI FUNCTION 
     Ø  The function opens the label_tab file and compares the contents of the file with 
        the arr1 content. If match is found then the function prints the address of that 
        Label into the output file. 
§  IN THE PORT FUNCTION 
     Ø  The function just prints the value of port address into the output file. 
§  IN THE HEX FUNCTION 
     Ø  The process continues same as in pass1. 
                                     The PASS 2 ends



                                              23 
                             6. CODING FOR CROSS­ASSEMBLER 


6.0 ‘C’ CODE FOR ASSEMBLER 
Filename: assembler.c 
#include<stdio.h> 
#include<string.h> 
                  /*functions declarations*/ 
int search_lab(char []);         /*to deal with appropriate tokens*/ 
int valid_lab(char []);          /*search for labels validity*/ 
int look_search(char []);        /*fetch opcode from lookuptable*/ 
char *addr_update(int);          /*for updating address*/ 
int chg_data_addr(char *);       /*for dealing with data and address involved instructions*/ 
void branch(char []);            /*to deal with branch instructions*/ 
void port(char []);             /*to deal with port instructions*/ 
void hex(char []);               /*for converting hex to decimal numbers*/ 
                  /*global variables declarations*/ 
int PASS=1;                      /*keeps track of the pass*/ 
int bytes=0,m=0;                 /*bytes:keeps track of total number of bytes of code read*/ 
char *p="1000";                  /*it is the default address where the assembled code 
starts*/ 
int  ADDR=4096;                  /*decimal value of 1000H*/ 
FILE *fp3;                       /*file pointer for file in which machine code is put*/ 


void main(int argc,char *argv[]) 
{ int i=0,k=0,j=0,l=0,d=0,x=2,lines=0;     /*lines:  is used to keep track of the number of 
                                             lines*/ 
char arr[50]={'\0'},arr1[10]={'\0'},c=' ';  /*arr: to read a line,arr1: to read a token*/ 
FILE *fp,*fp1; 
fp3=fopen("argv[2]","w");                   /*opening the output file(machine code file)*/ 
fp=fopen(argv[1],"r+");                    /*open the input file*/ 
if((fp1=fopen("label_tab","w"))==0)        /*close labels file if it exits*/



                                                24 
{remove("label_tab"); 
fclose(fp1); 
} 
while(feof(fp)==0)                              /* first pass starts*/ 
{   j=0; 
     while(j<=49)                             /*clearing arr*/ 
     {arr[j]='\0'; 
       j++;} 
     j=0; 
     while(j<=9)                             /*clearing arr1*/ 
     {arr1[j]='\0'; 
       j++;} 
     k=0;   j=0;                             /*reinitializing the variables*/ 
     i=0;    d=0; 
fgets(arr,50,fp);                            /*reading a line from the input file*/ 
     while(i<50)                             /*loop to break the line into tokens*/ 
 { if(arr[i]==';')                           /*terminate to read the line if ';' is encountered*/ 
      break; 
else if((arr[i])==' ')                          /*skip spaces*/ 
 { 
if(j==1)                                    /*a string is read*/ 
 { l=search_lab(arr1);                        /*send a string/token to search_lab() function*/ 
     if(l==0)                                 /*continue to read the next string*/ 
     {k=0; 
     j=0; 
while(d<9)                                  /*clear arr1*/ 
     { arr1[d]='\0'; 
          d++; 
     } 
          i++; 
       continue;



                                                      25 
     } 
else 
     {  j++; 
          i++; 
      continue; } } } 
     else 
 { 
          arr1[k]=arr[i];      /*copy character from arr into arr1*/ 
          i++; 
          k++; 
          arr1[k]='\0'; 
          if(j==0) 
          j=1;                 /*indicator for a string completion*/ 
     } 
     }


 if(l==1)                      /*deal with mnemonic concatenated with 
operands*/ 
{ 
     x=chg_data_addr(arr1);    /*deals with address and data involved instructions*/ 
     p=addr_update(bytes);     /*update the address*/ 
     if(x==1) 
     break;                    /*break when HALT instruction is encountered*/ 
} 
if(m==4)                       /*to check if input file starts with an address*/ 
{ 
 hex(arr1);                    /*to change address from default 1000 to specified*/ 
 p=addr_update(bytes); 
} 
m=0; 
}                              /*loop to read the lines stops*/



                                     26 
fclose(fp);                  /*closing the input file*/ 
bytes=0;                      /*reinitializing variables after pass 1*/ 
i=0; 
while(i<4) 
{ 
  p[i]='\0'; 
  i++; 
} 
i=0; 
PASS=2;                       /*changing PASS from 1 to 2*/ 
fp=fopen(argv[1],"r+");       /*reopening the input file*/ 
 while(feof(fp)==0)          /*PASS 2 starts*/ 
{  j=0; 
     while(j<=49)             /*clearing arr*/ 
     {arr[j]='\0'; 
      j++;} 
     j=0; 
     while(j<=9)             /*clearing arr1*/ 
     {arr1[j]='\0'; 
      j++;} 
  k=0;   j=0;                /*reinitializing the variables*/ 
  i=0;    d=0; 
 fgets(arr,50,fp);           /*reading a line from the input file*/ 
 lines++;                    /*update the number of lines read*/ 
  while(i<50)                /*loop to break the line into tokens*/ 
 { if(arr[i]==';')           /*terminate to read the line if ';' is encountered*/ 
      break; 
  else if((arr[i])==' ')     /*skip spaces*/ 
 { 
  if(j==1)                   /*a string is read*/ 
  {   l=search_lab(arr1);    /*send a string/token to search_lab() function*/



                                    27 
          if(l==0)           /*continue to read the next string*/ 
          {k=0; 
          j=0; 
          while(d<9)         /*clear arr1*/ 
          { arr1[d]='\0'; 
          d++; 
            } 
               i++; 
               continue; 
           } 
     else 
          {  j++; 
               i++; 
               continue; 
           } 
 }
} 
     else 
     { 
          arr1[k]=arr[i];       /*copy character from arr into arr1*/ 
          i++; 
          k++; 
          arr1[k]='\0'; 
          if(j==0)              /*indicator for a string completion*/ 
          j=1; 
          } 
 } 
 if(l==1)                    /*deal with mnemonic concatenated with 
operands*/ 
{   p=addr_update(bytes);      /*update the address*/ 
     x=chg_data(arr1);



                                   28 
                                           /*deals with address and data involved 
                                            instructions*/ 


         if(x==1)                          /*break when HALT instruction is encountered*/ 
     break; 
} 
if(m==2)                                  /*to deal with branch instruction*/ 
{ branch (arr1); 
     }
if(m==3)                                       /*to deal with port instruction*/ 
{port(arr1);} 
if(m==4)                                       /*to check if output file has start address*/ 
{ 
 hex(arr1); 
} 
m=0;                                          /*reinitializing m*/ 
} 
fclose(fp); 
fclose(fp3);                                  /*closing input and output files*/ 
if((fp1=fopen("label_tab","r"))==0) 
{remove("label_tab"); 
fclose(fp1);} 
                       /*print the number of lines  in the program*/ 
printf("The total lines in the program are %d\n",lines); 
system("cat exe");                            /*displaying the output file*/ 
} 


int  search_lab(char s[15]) 
{  FILE *fp1,*fp,*fp5; 
     int i=1,k=0,j=0,a; 
     int t=0;



                                               29 
     char d[5]={'\0'},x[5]=".ORIG"; 
 while(k<5) 
 { if ((s[k]==x[k])&&((s[i]!='\0')||(s[i]!='\n'))) 
      { 
      k++; 
      } 
      else 
      break; 
 } 
     if(k==5)                                 /*check if string is .ORIG*/ 
{   m=4; 
     return 0; 
} 
k=0; 
     fp1=fopen("keywords","r+");             /*open the keywords file*/ 
     while(k<8) 
 {   if((s[k]=='\0')||(s[k]=='\n')) 
       s[k]='\0'; 
       k++; } 
       k=0; 
do 
 {     if((fscanf(fp1,"%s",d))==1)          /*fetch a word from the file*/ 
       {   } 
     else 
     break; 
 while(k<5) 
 { if (s[k]==d[k]) 
      { 
      k++; 
      } 
      else



                                               30 
      break; 
 } 
     if(k==5)                                 /*check if string is mnemonic*/ 
{  k=0; 
     fp=fopen("jump","r+");                  /*open the jump mnemonics file*/ 
     while(feof(fp)==0) 
{ 
     fscanf(fp,"%s",d); 
     if(strcmp(s,d)==0)                /*check if the string is branch mnemonic*/ 
{    p=addr_update(bytes); 
       bytes+=look_search(s);    /*fetch opcode for the instruction*/ 
       fclose(fp); 
       m=2; 
       return 0; 
} 
} 
     if((strcmp(s,"IN")==0)||(strcmp(s,"OUT")==0)) 
       /*check if the mnemonic is port related*/ 
{   p=addr_update(bytes); 
     bytes+=look_search(s);        /*fetch opcode for the instruction*/ 
      fclose(fp); 
      m=3; 
      return 0; 
} 
      return 1; 
      break; 
} 
     k=0; 
} while(1); 
fclose(fp1); 
fclose(fp);



                                                 31 
j=valid_lab(s); 
if(PASS==1) 
{ 
if(j!=1) 
{ 
fp1=fopen("label_tab","a+");          /*open labels table to enter labels and address*/ 


     fprintf(fp1,"%s %s",s,p); 
     a= ftell(fp1); 
     t++; 
while(a<=(t*15))                           /*print spaces for rest of 15 cursor positions*/ 
{  fprintf(fp1," "); 
 a++;} 
fclose(fp1); 
return 0; 
 }   } 
else 
return 0; 
} 




int look_search(char temp1[10]) 
{ 
 int i=0,j=0,k=0; 
 int bytes1=0; 
 char opcode[3]="AA",temp2[9]="A"; 
 FILE *fp; 
 fp=fopen("look_uptab","r+");               /*open lookup_table*/ 
while(feof(fp)==0) 
 { 
      while(k<10)



                                                 32 
          { 
           temp2[k]='\0'; 
               k++; 
           } 
     if((fscanf(fp,"%s",temp2))==1)           /*fetch a string from lookup_table*/ 
          { 
           } 
          else 
          break; 
i=0; 
while(i<9) 
{ if(temp1[i]=='\n') 
     {temp1[i]='\0'; 
      break; 
     } 
     i++; 
} 
     if((strcmp(temp1,temp2))==0)          /*comparing sent string with that fetched 
                                             from lookup_table*/ 
 { fscanf(fp,"%s%d",opcode,&bytes1);            /*fetch opcode and bytes*/ 
     if(PASS==2) 
 { fprintf(fp3,"%s %s",p,opcode);}         /*print opcode in output file*/ 
      break; 
     }
 }
fclose(fp);                                /*close the lookup_table*/ 
return bytes1; 
} 
char *addr_update(int bytes1) 
{ 
 int  a=0,x[4]={0},i,k=1,r=0,q=0;



                                               33 
 long int dec=0; 
 char *s="A"; 
     for(i=0;i<4;i++)                                  /*start reading the address*/ 
{ 
if((s[i]>='0') && (s[i]<='9'))                  /*check if the characters are numerals*/ 
{ 
a=s[i]; 
x[i]=a­48;                                               /*numeric value*/ 
} 
else if(s[i]=='A') 
x[i]=10; 
else if(s[i]=='B') 
x[i]=11; 
else if(s[i]=='C') 
x[i]=12; 
else if(s[i]=='D') 
x[i]=13; 
else if(s[i]=='E') 
x[i]=14; 
else 
x[i]=15; 
} 
dec=((x[0]*4096)+(x[1]*256)+(x[2]*16)+x[3]);   /*decimal value of address*/ 
dec=ADDR+bytes1;                           /*add bytes to decimal address*/ 
i=0; 
a=0; 
     do                                             /*converting decimal address back into hex*/ 
{                   q=(dec/16); 
                  r =(dec%16); 
                  x[i]=r; 
                  x[i+1]=q;



                                                        34 
                    i++; 
                    dec=q; 
} 
while(q>=16); 
for(i=0;i<=3;i++) 
       {     if((x[i]>=0)&&(x[i]<=9)) 
              { 
                      a=x[i]; 
                      s[3­i]=a+48;    } 
     if((x[i]>=10)&&(x[i]<=15)) 
     {   if(x[i]==10) 
           s[3­i]='A'; 
       else if(x[i]==11) 
       s[3­i]='B'; 
           else if(x[i]==12) 
       s[3­i]='C'; 
      else if(x[i]==13) 
       s[3­i]='D'; 
       else if(x[i]==14) 
       s[3­i]='E'; 
       else 
           s[3­i]='F'; 
      } 
             } 
 s[i]='\0'; 
return(s);                                           /*return  updated address*/ 
} 


int chg_data(char *s) 
{ 
char d[2]={'\0'},a1[2]={'\0'},a2[2]={'\0'},x[3]="HLT";



                                           35 
int i,n=0,v=2; 
for(i=0;i<10;i++)                                                /*loop to read the sent token*/ 
{ if(s[i]==',') 
{if((((s[i+1]>='0')&&(s[i+1]<='9'))||((s[i+1]>='A')&&(s[i+1]<='F')))&&(((s[i+2]>='0') 
&&(s[i+2]<='9'))||((s[i+2]>='A')&&(s[i+2]<='F')))&&(((s[i+3]>='0')&&(s[i+3]<='9')) 
||((s[i+3]>='A')&&(s[i+3]<='F'))))                               /*deal with the data instructions 
                                                                of type xxx REG,ADDR*/ 
{ 
a1[0]=s[i+3];   a1[1]=s[i+4];   a2[0]=s[i+1];   a2[1]=s[i+2]; 
s[i+1]='A';   s[i+2]='D';   s[i+3]='D';  s[i+4]='R';  s[i+5]='\0'; 
v=0; 
n=1; 
break; 
} 
else if((((s[i+1]>='A')&&(s[i+1]<='E'))||(s[i+1]=='H')||(s[i+1]=='L')||(s[i+1]=='M')) 
         &&((s[i+2]=='\0')||(s[i+2]=='H'))) 
        break; 
else 
if((((s[i+1]>='0')&&(s[i+1]<='9'))||((s[i+1]>='A')&&(s[i+1]<='F')))&&(((s[i+2]>='0') 
        &&(s[i+2]<='9'))||((s[i+2]>='A')&&(s[i+2]<='F')))) 
                                                                  /*deal with the address instructions 
                                                                 of type  xxx REG,DATA*/ 
{     d[0]=s[i+1];     d[1]=s[i+2]; 
     s[i+1]='D';    s[i+2]='A';  s[i+3]='T';   s[i+4]='A';  s[i+5]='\0'; 
     v=1; 
        break; 
} 
}  } 
if(((s[0]=='L')&&(s[1]=='D')&&(s[2]=='A')&&(s[3]!='X'))||((s[0]=='S')&&(s[1]=='T') 
&&(s[2]=='A')))                                                           /*deal with the address instructions 
                                                                   of type  xxx ADDR*/



                                                      36 
{ 
a1[0]=s[5];  a1[1]=s[6];  a2[0]=s[3];  a2[1]=s[4]; 
s[3]='A';  s[4]='D';   s[5]='D';  s[6]='R'; 
v=0; 
n=1; 
s[7]='\0'; 
} 
if(((s[0]=='L')&&(s[1]=='H')&&(s[2]=='L')&&(s[3]=='D'))||((s[0]=='S')&&(s[1]=='H') 
&&(s[2]=='L')&&(s[3]=='D'))||((s[0]=='C')&&(s[1]=='A')&&(s[2]=='L')&&(s[3]=='L'))) 
{ 
a1[0]=s[6];  a1[1]=s[7];  a2[0]=s[4]; a2[1]=s[5];               /*deal with the address instructions 
                                                                of type  xxx ADDR*/ 
s[4]='A';  s[5]='D';  s[6]='D';  s[7]='R'; 
v=0; 
n=1; 
s[8]='\0'; 
} 
if(n!=1) 
{ 
i=3; 
if((((s[i]>='0')&&(s[i]<='9'))||((s[i]>='A')&&(s[i]<='F')))&&(((s[i+1]>='0') 
&&(s[i+1]<='9'))||((s[i+1]>='A')&&(s[i+1]<='F'))))  /*deal with the address instructions 
                                                                   of type   xxx DATA*/ 
{    d[0]=s[i];  d[1]=s[i+1]; 
       s[i]='D';  s[i+1]='A';  s[i+2]='T';  s[i+3]='A';   s[i+4]='\0'; 
       v=1; 
}  }
 bytes+=look_search(s);                                  /*call look_search() function with 's' 
string*/ 
 if(PASS==2)




                                                   37 
{ if(v==0)                                    /*if it is address instruction then print 
address*/ 
 fprintf(fp3,",%s,%c%c\n",a1,a2[0],a2[1]); 
 else if(v==1)                                /*if it is address instruction then print 
address*/ 
 fprintf(fp3,",%c%c\n",d[0],d[1]); 
     else 
 fprintf(fp3,"\n"); 
} 
p=addr_update(bytes); 
if((strcmp(s,x))==0)                   /*check if the mnemonic is HALT*/ 
return 1; 
else 
return 0; 
} 


void port(char x[10]) 
{ 
     fprintf(fp3,",%s",x);            /*printing the value of port instructions*/ 
} 


void branch (char x[10]) 
{ 
int n=0,q=0,k=0; 
char t[10]={'\0'},e[10]={'\0'}; 
FILE *fpx; 
fpx=fopen("label_tab","r");           /*opening the labels file*/ 
while(feof(fpx)==0)                   /*start reading the labels file*/ 
 { 
      while(k<10) 
       {



                                           38 
           t[k]='\0'; 
               k++; 
           } 
     if((fscanf(fpx,"%s",t))==1)               /*reading a string from labels file*/ 
          { 
           } 
          else 
          break; 
     n=0; 
 while(n<10) 
{ if(x[n]=='\n') 
     {x[n]='\0'; 
      break; 
     } 
 n++; 
} 


 if((strcmp(x,t))==0)                        /*compare the label from file with sent label*/ 
               { 
               fscanf(fpx,"%s",e);          /*read the address of the label from the file*/ 
               fprintf(fp3,",%c%c,%c%c\n",e[2],e[3],e[0],e[1]); 
               break;                       /*print address of the label in output file*/ 
               } 
 }
fclose(fpx);                                /*close the labels file*/ 
} 


int  valid_lab(char a1[10]) 
{   int i=1; 
 if((strcmp(a1,".ORIG"))==0) 
                       return 0;           /*skip checking for validity if string is .ORIG*/



                                                    39 
 if(((a1[0]>='!')&&(a1[0]<='/')))    /*check for validity of labels*/ 
{  printf("2.invalid label\n"); 
              return 1; }                       /*return '1' if the label is invalid*/ 
 else if((a1[0]>=':')&&(a1[0]<='@')) 
{ printf("2.invalid label\n"); 
               return 1;} 
 else if((a1[0]>='0')&&(a1[0]<='9')) 
{ printf("2.invalid label\n"); 
               return 1;} 
 else if((a1[0]>='[')&&(a1[0]<='^')) 
{ printf("2.invalid label\n") 
         return 1;} 
  else if((a1[0]>='{')&&(a1[0]<='~')) 
         {printf("2.invalid label\n"); 
         return 1;} 
         else{ 
for(i=1;i<5;i++) 
  {if(((a1[i]>='!')&&(a1[i]<='/'))) 
    { 
         printf("3.invalid label\n"); 
         return 1; 
    } 
         else if((a1[i]>=':')&&(a1[i]<='@')) 
         { printf("3.invalid label\n"); 
         return 1;} 
else if((a1[i]>='[')&&(a1[i]<='^')) 
         { printf("3.invalid label\n"); 
         return 1;} 
else if((a1[i]>='{')&&(a1[i]<='~')) 
         { printf("3.invalid label\n"); 
         return 1;}



                                                      40 
      }   } 
      return 0;                                            /*return '0' if it is a valid label*/ 
} 


void hex(char s[10]) 
{ 
int  a,x[4]={0},i,k=1 ; 
long int dec=0; 
for(i=0;i<4;i++)                                           /*loop to read the input hex string*/ 
{ 
if((s[i]>='0') && (s[i]<='9'))                        /*check if the character is a numeral*/ 
{ 
a=s[i]; 
x[i]=a­48;                                            /*put numeric value of numeral into another array*/ 
} 
else if((s[i]=='a') || (s[i]=='A') )          /*check for valid characters in hexadecimal*/ 
x[i]=10; 
else if((s[i]=='b') || (s[i]=='B')) 
x[i]=11; 
else if((s[i]=='c') || (s[i]=='C')) 
x[i]=12; 
else if((s[i]=='d') || (s[i]=='D')) 
x[i]=13; 
else if((s[i]=='e') || (s[i]=='E')) 
x[i]=14; 
else if((s[i]=='f') || (s[i]=='F')) 
{x[i]=15;} 


else{ 
k=0; 
break;}



                                                     41 
} 
if(k==0) 
printf("invalid"); 
else 
{dec=x[0]*4096+x[1]*256+x[2]*16+x[3]; /*evaluate decimal value of hex number*/ 
 ADDR=dec; 
} 
} 
6.1 LOOKUP TABLE FOR THE ASSEMBLER: 
Filename: look_uptab 
Format:  mnemonic<data/address/operands> <opcode> <bytes> <instruction cycles> 


ACIDATA CE 2 7          ADCA 8F 1 4             ADCB 88 1 4        ADCC 89 1 4 
ADCD 8A 1 4             ADCE 8B 1 4         ADCH 8C 1 4            ADCL 8D 1 4 
ADCM 8E 1 7             ADDA 87 1 4             ADDB 80 1 4        ADDC 81 1 4 
ADDD 82 1 4             ADDE 83 1 4             ADDH 84 1 4          ADDL 85 1 4 
ADDM 86 1 7             ADIDATA C6 2 7          ANAA A7 1 4          ANAB A0 1 4 
ANAC A1 1 4             ANAD A2 1 4         ANAE A3 1 4            ANAH A4 1 4 
ANAL A5 1 4             ANAM A6 1 7             ANIDATA E6 2 7  CALL CD 3 18 
CC DC 3 18              CM FC 3 18              CMA 2F 1 4         CMC 3F 1 4 
CMPA BF 1 4             CMPB B8 1 4             CMPC B9 1 4        CMPD BA 1 4 
CMPE BB 1 4             CMPH BC 1 4         CMPL BD 1 4            CMPM BE 1 4 
CNC D4 3 9              CNZ C4 3 18         CP F4 3 18             CPE EC 3 18 
CPIDATA FE 2 7          CPO E4 3 18             CZ CC 3 18          DAA 27 1 4 
DADB 09 1 10            DADD 19 1 10            DADH 29 1 10        DADSP 39 1 10 
DCRA 3D 1 4             DCRB 05 1 4             DCRC 0D 1 4         DCRD 15 1 4 
DCRE 1D 1 4             DCRH 25 1 4             DCRL 2D 1 4        DCRM 35 1 10 
DCXB 0B 1 6             DCXD 1B 1 6             DCXH 2B 1 6         DCXSP 3B 1 6 
DI F3 1 4               EI FB 1 4               HLT 76 1 5          IN DB 2 10 
INRA 3C 1 4             INRB 04 1 4             INRC 0C 1 4         INRD 14 1 4




                                          42 
INRE 1C 1 4        INRH 24 1 4             INRL 2C 1 4       INRM 34 1 10 
INXB 03 1 6        INXD 13 1 6             INXSP 33 1 6      JC DA 3 10 
JM FA 3 10         JMP C3 3 10             JNC D2 3 10       JNZ C2 3 10 
JP F2 3 10         JPE EA 3 10             JPO E2 3 10        JZADDR 3A 3 13 
JZ CA 3 10         LDAADDR 3A 3 13  LDAXB 0A 1 7              LDAXD 1A 1 7 
LHLDADDR 2A 3 16  LXIB 01 3 10             LXID 11 3 10       LXIH 21 3 10 
LXISP 31 3 10      MOVA,A 7F 1 4           MOVA,B 78 1 4      MOVA,C 79 1 4 
MOVA,D 7A 1 4      MOVA,E 7B 1 4           MOVA,H 7C 1 4      MOVA,L 7D 1 4 
MOVA,M 7E 1 7      MOVB,A 47 1 4           MOVB,E 40 1 4       MOVB,C 41 1 4 
MOVB,D 42 1 4      MOVB,E 43 1 4           MOVB,H 44 1 4       MOVB,L 45 1 4 
MOVB,M 46 1 7      MOVC,A 4F 1 4           MOVC,B 48 1 4      MOCVC,C 49 1 4 
MOVC,D 4A 1 4      MOVC,E 4B 1 4           MOVC,H 4C 1 4      MOVC,L 4D 1 4 
MOVC,M 4E 1 7      MOVD,A 57 1 4           MOVD,B 50 1 4       MOVD,C 51 1 4 
MOVD,D 52 1 4      MOVD,E 53 1 4           MOVD,H 54 1 4       MOVD,L 55 1 4 
MOVD,M 56 1 7      MOVE,A 5F 1 4           MOVE,B 58 1 4       MOVE,C 59 1 4 
MOVE,D 5A 1 4      MOVE,E 5B 1 4           MOVE,H 5C 1 4       MOVE,L 5D 1 4 
MOVE,M 5E 1 7      MOVH,A 67 1 4           MOVH,B 60 1 4       MOVH,C 61 1 4 
MOVH,D 62 1 4      MOVH,E 63 1 4           MOVH,H 64 1 4       MOVH,L 65 1 4 
MOVH,M 66 1 7      MOVL,A 6F 1 4           MOVL,B 68 1 4       MOVL,C 69 1 4 
MOVL,D 6A 1 4      MOVL,E 6B 1 4           MOVL,H 6C 1 4       MOVL,L 6D 1 4 
MOVL,M 6E 1 7      MOVM,A 77 1 7           MOVM,B 70 1 7       MOVM,C 71 1 7 
MOVM,D 72 1 7      MOVM,E 73 1 7            MOVM,H 74 1 7      MOVM,L 75 1 7 
MVIA,DATA 3E 2 7  MVIB,DATA 06 2 7  MVIC,DATA 0E 2 7 MVID,DATA 16 2 7 
MVIE,DATA 1E 2 7   MVIH,DATA 26 2 7  MVIL,DATA 2E 2 7 MVIM,DATA 36 2 10 
NOP 00 1 4        ORAA B7 1 4              ORAB B0 1 4         ORAC B1 1 4 
ORAD B2 1 4       ORAE B3 1 4              ORAH B4 1 4         ORAL B5 1 4 
ORAM B6 1 7        ORIDATA F6 2 7          OUT D3 2 10         PCHL E9 1 6 
POPB C1 1 10       POPD C1 1 10            POPH E1 1 10        POPPSW F1 1 10 
PUSHB C5 1 12      PUSHD D5 1 12           PUSHH E5 1 12      PUSHPSW F5 1 12 
RAL 17 1 4         RAR 1F 1 4              RC D8 1 12          RET C89 1 10 
RIM 20 1 4         RLC 07 1 4              RM F8 1 12          RNC D0 1 12



                                     43 
RNZ C0 1 12             RP F0 1 12                RPE E8 1 12           RPO E0 1 12 
RRC 0F 1 4              RST0 C7 1 12              RST1 CF 1 12          RST2 D7 1 12 
RST3 DF 1 12            RST4 E7 1 12              RST5 EF 1 12          RST6 F7 1 12 
RST7 FF 1 12            RZ C8 1 12                SBBA 9F 1 4           SBBB 98 1 4 
SBBC 99 1 4             SBBD 9A 1 4               SBBE 9B 1 4           SBBH 9C 1 4 
SBBL 9D 1 4             SBBM 9E 1 7          SBIDATA DE 2 7          SHLDADDR 22 3 16 
SIM 30 1 4              SPHL F9 1 6               STAADDR 32 3 13        STAXB 02 1 7 
STAXD 12 1 717          STC 37 1 4                SUBA 97 1 4            SUBB 90 1 4 
SUBC 91 1 4             SUBD 92 1 4               SUBE 93 1 4            SUBH 94 1 4 
SUBL 95 1 4             SUBM 96 1 7               SUIDATA D6 2 7         XCHG EB 1 4 
XRAA AF 1 4             XRAB A8 1 4               XRAC A9 1 4               XRAD AA 1 4 
XRAE AB 1 4             XRAH AC 1 4               XRAL AD 1 4            XRIM AE 1 7 
XRIDATA EE 2 7          XTHL E3 1 16              INXH 23 1 6        LXIH,DATA 21 3 18 
LXID,DATA 11 3 18                           LXIB,DATA 01 3 10 
LXIH, ADDR 21 3 10                          LXIB, ADDR 01 3 10 
LXID, ADDR 11 3 10                          CALLADDR CD 3 18 


6.2 KEYWORDS TABLE: 
Filename: keywords 
The table contains all the mnemonics of 8085 instruction set architecture (ISA). 


ACI  ADC  ADD  ADI  ANA  ANI  CALL  CC  CM  CMA  CMC  CMP  CNC 
CP     CPE  CPI  CPO  CZ           DAA  DAD         DCR  DCX  DI       EI     HLT  IN 
INR    INX  JC       JM    JMP  JNC  JNZ  JP             JPE  JPO     JZ      LDA  LDAX 
LHLD LXI  MOV  MVI  NOP  ORA  ORI  OUT  PCHL POP  PUSH RAL  RAR 
RC     RET  RIM  RLC  RM           RNC  RNZ  RP          RPE  RPO  RRC  RST  RZ 
SBB  SBI       SHLD SIM  SPHL  STA  STAX STC  SUB  SUI  XCHG XRA  XRI 
XTHL




                                            44 
6.3 JUMP/LABEL INSTRUCTIONS TABLE: 
Filename:  jump 
The table contains the mnemonics of labels/jump related instructions. 
CC CM CNC CNZ CP CPE CPO CZ JC JM JMP JNC JNZ JP JPE JPO JZ 


6.4 SAMPLE ASSEMBLY CODE: 
An assembly language code for multiplication of two numbers (16 Bit numbers) is given 
as a sample code. 
Steps to run the sample code: 
   1.  Type the following assembly language code in a file and save it with the filename 
       ‘sample’ in the same directory as that of the assembler. 
Filename: sample 
           .ORIG 2000H 
            LHLD 2501H           ; get multiplicand in H­L pair 
            XCHG                 ; multiplicand in D­E pair 
            LDA    2503H         ; multiplier in accumulator 
            LXI     H, 0000      ; initial value of product=00 in H­L pair 
            MVI    C, 08         ; count=8 in register C 
LOOP         DAD   H           ; shift partial product left by 1 digit 
            RAL                ; rotate multiplier left one bit. Is multiplier’s bit=1? 
            JNC    AHEAD         ; No, go to AHEAD 
            DAD   D            ; product =product +multiplicand 
AHEAD      DCR   C             ; decrement count 
            JNZ     LOOP 
            SHLD 2504H         ; store result 
            HLT                ; stop 


   2.  Type the following commands 
       UNIX platform 
          $cc assembler.c <return> 
          $. /a.out sample output <return>



                                             45 
       WINDOWS platform 
           1. Open TC.exe 
           2. Open ‘assembler.c’ file 
           3. Compile and run the code 


OUTPUT: 
   A file with name ‘output’ is created as shown below and is displayed on the output 
screen. 


   2000       2A,01,25 
   2003       EB 
   2004       3A,03,25 
   2007       21,00,00 
   200A     0E, 08 
   200C     29 
   200D     17 
   200E      D2, 12, 20 
   2011       19 
   2012       0D 
   2013       C2,0C,20 
   2016       22,04,25 
   2019      76




                                          46 
REFERENCES: 
 Book references: 
 1.  Introduction to Computing Systems by 
    Yale N. Patel 
     Sanjay J.Patel 
 2.  Fundamentals of Microprocessors and Microcomputers by 
    B.Ram 
 3.  The C Programming Language by 
    Brian W. Kernighan 
    Dennis M. Ritchie 
 4.  e­Book on Assembly Language by 
    Christopher Morley




                                        47 
48

								
To top