Az assembler program fordításának lépései, az egyes fájlok magyarázata

1         A programnyelv felépítése

Az assembly nyelvet mikroprocesszorok programozására használják. A nyelv elemkészlete közvetlenül igazodik a processzor gépi kódú utasításkészletéhez (tehát ahhoz az elemkészlethez, melyet bináris formában a memóriából felolvasva a processzor értelmezni képes), a gyártó által definiált egyes gépi kódú utasításoknak rendre egy-egy un. mnemonik, assem 141e49b bly nyelvü utasítás felel meg. Az assembly nyelvekkel ellentétben a magas szintü programnyelvek, pl. Pascal utasításai - melyek egy-egy összetettebb, bonyolultabb feladatot valósítanak meg - csak sok gépi kódú utasítás egymás utáni végrehajtásával realizálhatóak. Az adott programnyelvben értelmezett utasítások átfordítását a processzor által értelmezett gépi kóddá a fordítóprogramok végzik. Magas szintü programnyelvek esetén ez bonyolult feladat, az assembly fordítók (un. assemblerek) viszont egyszerüen müködhetnek, mivel az egyes utasításoknak közvetlenül egy-egy gépi kód felel meg.

Az assembly nyelven való programozás elönye, hogy a memória szempontjából helytakarékos és igen gyorsan futó alkalmazásokat lehet készíteni, valamint a programozó teljes mértékben kézben tartja a processzor eröforrásait. Hátrányként jelentkezik, hogy az elkészült program igen sok utasítást tartalmazhat, nehezen átlátható lehet. Ezzel szemben a magas szintü nyelvekben könnyen átlátható, egyszerüen elkészíthetö programokat lehet írni, viszont az általános célú utasítások megvalósítása miatt a lefordított kód egy adott alkalmazáshoz nem lesz optimális méretü, és nem lesz optimális futási idejü.

Természetesen az egyes processzorokhoz (így a 8051-es családhoz is) kapható közvetlenül magas szintü nyelvet értelmezö fordító is, és a processzor a nehézkes assembly helyett programozható pl. C alapú nyelven. Ugyanakkor az egyes assembly fordítók különbözö komfort szolgáltatásokat kínálnak a felhasználónak, pl. lehetövé teszik makro blokkok definiálását, stb. Így egy assembly forrásállomány is két típusú utasítást tartalmazhat: olyan mnemonikokat, melyek közvetlenül megfeleltethetök gépi kódú utasításoknak és olyan elemeket, melyek a fordító (assembler) müködését vezérlik, és áttekinthetöbbé, egyszerübben kezelhetövé teszik az assembly programot (pl. EQU).

A 8051 assembly nyelv utasításai rendelkezhetnek 3 operandussal (pl. CJNE), 2 operandussal (pl. ORL), 1 operandussal (pl. CPL), illetve állhat a mnemonik önmagában, operandus nélkül (pl. RET).

2         A program fordítása után keletkezö fájlok, azok szerepe

a)     Az assembly nyelvü programot - csakúgy, mint pl. egy Pascal nyelvü programot - szöveges állományként kell megírni (ehhez bármilyen szövegszerkesztö használható). A legtöbb assembly fordító igényli, hogy a forrásprogram ASM kiterjesztésü állományban legyen eltárolva.

b)     A szöveges forrásállományt a fordítóprogram segítségével lefordítjuk. Különbözö fordítóprogramok különbözö kimeneteket generálnak. Például az ASM51.EXE program a lefordított kódot object állományba teszi (OBJ kiterjesztés), és fordítási segédinformációkat is szolgáltat (LST kiterjesztés).

c)     Amennyiben a tényleges kód nem egy forrásállomány fordítása során keletkezik (pl. csoportmunka esetén), az egyes kódokat (object állományokat) megfelelöen össze kell "dolgozni", össze kell szerkeszteni. Erre a célra szolgál pl. a LINK51.EXE program, amelyet akkor is érdemes használni, ha a gépi kódot egyetlen forrásállományból kapjuk, mivel a LINK51.EXE futásának járulékos terméke egy olyan szövegállomány (M51 kiterjesztéssel), amely az alkalmazott szimbólumokról (címkék, definiált nevek, stb.) közöl információt, és pl. a szimulációnál használható fel. A LINK51.EXE program egyébként tetszöleges számú bemenö (összeszerkesztendö) object állományból egy, már összeszerkesztett object állományt állít elö.

d)     Az OBJ kiterjesztésü állományt az OBJ2HEX.EXE programmal továbbfordítva HEX kiterjesztésü, hexa sztringeket tartalmazó állományt kapunk. A legtöbb EPROM égetö ezt a formátumot értelmezi.

3         A fordítás lépéseinek bemutatása egy példán keresztül

3.1        A program két BCD kódban megadott számot ad össze úgy, hogy az eredmény is BCD kódban keletkezzen. Az ASM állomány: (BCD.ASM)

;BCD összeadó

;a p1 alsó 4 bitje az 1. szám, a felsö 4 bitje a 2. BCD kódú szám

;p3 kimeneten jelenik meg az eredmény BCD kódban

;készítette Kövári Botond, 1999

kezd:

call beolvas ;szubrutinok hívása

call osszead

call kiir

jmp kezd ;ugrás az elejére

beolvas:

mov a, p1 ;akkumulátorba kerül az egész p1 port

mov 100,a ;100-as címre másolom az akk.-t

anl 100,#00001111b ;az 1. számot kapom meg a 100-as címen,

;hiszen mintegy letakartam a felsö 4 bitet

mov r5, 100 ;1. szám az r5-be került

anl a, #11110000b ;akk.-ban a 2. számot kapom meg,

;hiszen most az alsó 4 bitet takartam le

swap a ;akk. alsó-felsö 4 bitje helyet cserél,

;így kapom meg a tényleges 2. számot

mov r6, a ;r6-ba másolom a 2. számot

ret ;föprogramba visszatér

osszead:

mov a, r5 ;az 1. számot az akk.-ba másolom

add a, r6 ;a két számot összeadom, a hamis összeg

;megjelenik az akk.-ban

mov c, ac ;ha van hexa átvitel (alsó 4 bitröl a felsöre),

;akkor azt a carry-be másolom

jc korrigal ;ha van átvitel, mindenkeppen korrigálni kell

mov c, acc.1 ;akk. 1. bitjét másolom a carry-be (Z2)

anl c, acc.3 ;a carry-ben megjelenik a Z2*Z8 (hisz acc.3=Z8)

mov 110,c ;110 címre teszem a Z2*Z8-at

mov c, acc.2 ;Z4 a carry-be kerül

anl c, acc.3 ;carry-ben megjelenik a Z4*Z8

orl c, 110 ;carry-ben lesz a Z4*Z8+Z2*Z8

jc korrigal ;ha ez 1, korrigálni kell

ret

korrigal:

add a, #0110b ;korrigálás:

;a hamis összeghez konstans hatot adok

ret ;föprogramhoz tér vissza

kiir:

mov p3, a ;az eredmény a p3 porton jelenik meg

ret

end ;fordítónak szóló utasítás

3.2        Az ebböl létrejövö listaállomány (LST):

Vastag betüvel a magyarázat, ez nem keletkezik a fordítás során!

Feger + Reith  Assembler - Copyright (c) 1991 Ashling Microsystems Ltd. Version 1.0.0 02-20-:0 PAGE 1

SourceFile = BCD.ASM  Forrásfájl neve

LOC OBJ LINE SOURCE

1 ;BCD összeadó

2 ;a p1 alsó 4 bitje az 1. szám, a felsö 4 bitje a 2. BCD kódú szám

3 ;p3 kimeneten jelenik meg az eredmény BCD kódban

4 ;készítette Kövári Botond, 1999

5

6 kezd:

0000 12000B 7 call beolvas ;szubrutinok hívása

0000 memóriacímen helyezkedik el az elsö utasítás, aminek a kódja 12000B. Ez a következöképpen értelmezendö: a call utasítás kódja 12, a "beolvas" változó pedig a 000B. Ezt lehet látni a fájl végén szereplö szimbólumtáblából is. A call utasítás elfoglal 3 bájtot, így a következö utasítás a 0003 bájton foglal helyet.

A kód után lévö 7 szám egyszerüen azt jelenti, hogy hányadik sor volt ez az eredeti ASM szöveges állományban.

0003 120019 8 call osszead

Szintén a 12 kódú call utasítás, operandusa a 0019 címen lévö "osszead" változó.

0006 120031 9 call kiir

0009 80F5 10 jmp kezd ;ugrás az elejére

11 beolvas:

Látható, hogy a beolvas szubrutin valóban a 000B címen kezdödik.

000B E590 12 mov a, p1 ;akkumulátorba kerül az egész p1 port

000D F564 13 mov 100,a ;100-as címre másolom az akk.-t

000F 53640F         14 anl 100,#00001111b ;az 1. számot kapom meg a 100-as címen,

15 ;hiszen mintegy letakartam a felsö 4 bitet

0012 AD64 16 mov r5, 100 ;1. szám az r5-be került

0014 54F0 17 anl a, #11110000b ;akk.-ban a 2. számot kapom meg,

18 ;hiszen most az alsó 4 bitet takartam le

0016 C4             19 swap a ;akk. alsó-felsö 4 bitje helyet cserél,

20 ;így kapom meg a tényleges 2. számot

0017 FE             21 mov r6, a ;r6-ba másolom a 2. számot

0018 22             22 ret ;föprogramba visszatér

23 osszead:

0019 ED             24 mov a, r5 ;az 1. számot az akk.-ba másolom

001A 2E             25 add a, r6 ;a két számot összeadom, a hamis összeg

26 ;megjelenik az akk.-ban

001B A2D6 27 mov c, ac ;ha van hexa átvitel (alsó 4 bitröl a felsöre),

28 ;akkor azt a carry-be másolom

001D 400F 29 jc korrigal ;ha van átvitel, mindenkeppen korrigálni kell

001F A2E1        30 mov c, acc.1 ;akk. 1. bitjét másolom a carry-be (Z2)

0021 82E3 31 anl c, acc.3 ;a carry-ben megjelenik a Z2*Z8 (hisz acc.3=Z8)

0023 926E 32 mov 110,c ;110 címre teszem a Z2*Z8-at

0025 A2E2 33 mov c, acc.2 ;Z4 a carry-be kerül

0027 82E3 34 anl c, acc.3 ;carry-ben megjelenik a Z4*Z8

0029 726E 35 orl c, 110 ;carry-ben lesz a Z4*Z8+Z2*Z8

002B 4001 36 jc korrigal ;ha ez 1, korrigálni kell

002D 22             37 ret

38

39 korrigal:

002E 2406 40 add a, #0110b ;korrigálás:

41 ;a hamis összeghez konstans hatot adok

0030 22             42 ret ;föprogramhoz tér vissza

43 kiir:

0031 F5B0  44 mov p3, a ;az eredmény a p3 porton jelenik meg

0033 22             45 ret

46 end ;fordítónak szol

Feger + Reith  Assembler - Copyright (c) 1991 Ashling Microsystems Ltd. Version 1.0.0 02-20-:0 PAGE 2

Most a szimbólumok elhelyezkedése

SYMBOL TABLE LISTING

N A M E T Y P E V A L U E A T T R I B U T E S

AC ..............................B ADDR 00D0H.6 A

ACC .............................D ADDR 00E0H A

BEOLVAS .........................C ADDR 000BH A

Azaz a "beolvas" szubrutin a 000B hexa címen kezdödik

KEZD ............................C ADDR 0000H A

KIIR ............................C ADDR 0031H A

KORRIGAL ........................C ADDR 002EH A

OSSZEAD .........................C ADDR 0019H A

P1 ..............................D ADDR 0090H A

P3 ..............................D ADDR 00B0H A

Assembly of BCD.ASM complete.

46 Lines assembled

A program összesen 46 sorból állt.

Register bank(s) used: 0, Target machine(s): 8051/8031

Csak a 0, regisztertömböt használtuk (vagy azt sem). A program a 8051/8031-es processzortípus számára került lefordításra.

No Errors detected

Nem volt hiba. Ez azért érdekes, mert a fordító a hibás programot is lefordítja, csak a fordítás során a hibás sort egyszerüen kihagyja, és ebben az LST állományban megjelöli azt.

3.3        A lefordított HEX állomány:

:1000000012000B12001912003180F5E590F56453CF

:10001000640FAD6454F0C4FE22ED2EA2D6400FA2B0

:10002000E182E3926EA2E282E3726E400122240634

:0400300022F5B022E3

:00000001FF

Ezek már csak az elöbbi LST állományban is szereplö gépi kódok.