ASSEMBLY PROGRAMOZÁS TANTÁRGYHOZ SZÜKSÉGES ELŐISMERETEK ISMÉTLÉSE Dr. Varga Imre Debreceni Egyetem Informatikai Rendszerek és Hálózatok Tanszék 2019. augusztus 31.
A C programozási nyelv alapos ismerete és az algoritmizálás képessége nélkülözhetetlen a tárgy sikeres teljesítéséhez. Ezek felelevenítése nem feladata ennek a diasornak. Önálló felkészülés elvárt. A C programozási nyelv
Számábrázolás, adattípusok Fixpontos számábrázolás Lebegőpontos számábrázolás Főbb adattípusok
Adatok Információtároláshoz különböző adattípusok A számítógépen minden adat végül bitsorozat numerikus infó szöveg kép kódolás hang videó számok bitsorozat dekódolás adatbázis programok
Csak két számjegy: 0 és 1 Bináris számok Jelentőség: 2 állapot (igen/nem, van/nincs, stb.) Konverzió 69,375 10 = 1000101,011 2 69 2 34 1 17 0 8 1 4 0 2 0 1 0 0 1 2 375 0 750 1 500 1 000 64 32 16 8 4 2 1 1/2 1/4 1/8 2 6 2 5 2 4 2 3 2 2 2 1 2 0 2-1 2-2 2-3 1 0 0 0 1 0 1 0 1 1
Hexadecimális számok 16 számjegy: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F Szoros kapcsolat a binárissal, de rövidebb alak Jelölés: 1FA 16, 0x1FA, $1FA, 0FAh Konverzió 1*256 15*16 10*1 =506 10 16 2 16 1 16 0 1 F A 0 0 0 1 1 1 1 1 1 0 1 0 2 11 2 10 2 9 2 8 2 7 2 6 2 5 2 4 2 3 2 2 2 1 2 0 2048 1024 512 256 128 64 32 16 8 4 2 1 =506 10 0x1FA = 0b 1 1111 1010 = 506
Adategységek Bit (binary digit): két állapot (0, 1) Nibble (fél bájt): 4 bit Bájt : 8 bit Szó: 16 bit Dupla szó: 32 bit Négyszeres szó: 64 bit Adatszervezés 18.446.744.073.709.551.616 4.294.967.296 65.536 256 16 2
Egész értékek reprezentálása Fixpontos számábrázolás Előjel nélküli eset (csak természetes szám) ábrázolandó szám kettes számrendszerben adott számú biten Példa (1 bájt esetén) 41 10 101001 2 N biten ábrázolható legkisebb szám: 0 legnagyobb szám: 2 N -1 0 0 1 0 1 0 0 1 unsigned int, unsigned short, unsigned char
Előjeles eset Fixpontos számábrázolás Nem negatív érték esetén: előjel nélküli logika Negatív érték esetén: kettes komplemens Abszolút érték bitjeinek invertálása (egyes komplemens) A kapott érték növelése 1-gyel Példa (1 bájt esetén) -41 10-101001 2 N biten ábrázolható legkisebb szám: -(2 N-1 ) Legnagyobb szám: 2 N-1-1 1 int, short, long, char 1 0 1 0 1 1 1 meghatározza az előjelet
Két féle hibalehetőség Aritmetikai túlcsordulás Előjel nélkül: több bit lenne szükséges (carry) 4,295E+09 4G 01011010 90 2,147E+09 2G +11110001 +241 0-2,15E+09-2G 101001011 75 331 >255 0 2,147E+09 4,295E+09 6,442E+09 8,59E+09 1,074E+10 1,288E+10 1,503E+10 1,718E+10 Előjeles: nem várt előjelváltás (overflow) 4,295E+09 4G 01011010 90 2,147E+09 2G +01110001 +113 0-2,15E+09-2G 11001011-53 203 > 127 0 2,147E+09 4,295E+09 6,442E+09 8,59E+09 1,074E+10 1,288E+10 1,503E+10 1,718E+10
Kiterjesztés Néha szükség van egy adatot a korábbinál több biten ábrázolni úgy, hogy az értéke ne változzon Nulla kiterjesztés: kitöltés nullával unsigned short x=5; unsigned long y=x; Rövid előjel nélküli értékből hosszú előjelnélküli 8 bit: 01101001 16 bit: 0000000001101001 8 bit: 11010010 16 bit: 0000000011010010 Előjel tartó kiterjesztés: kitöltés előjel bittel Rövid előjeles értékből hosszú előjeles 8 bit: 01101001 16 bit: 0000000001101001 8 bit: 11010010 16 bit: 1111111111010010 short int q=-17; long int z=q;
Bájtsorrend Több bájtos adatok esetén a bájtok sorrendje Little-endian: (gazdagép bájtsorrend) Legkisebb helyi értékű bájt (LSB) elől Big-endian: (hálózati bájtsorrend) Legnagyobb helyi értékű bájt (MSB) elől Példa: 523124044 = 0b11111001011100011110101001100 = 0x1F2E3D4C Little-endian: Big-endian: 25 32 17 24 9 16 1 8 0x4C 0x3D 0x2E 0x1F 0x1F 0x2E 0x3D 0x4C 1 8 9 16 17 24 25 32
Lebegő pontos számábrázolás Valós számok ábrázolása (float, double) Alapja a normalizálás: 123,45 = 1,2345 10 2 Minden (2 számrendszerbeli) szám felírható így: (-1) S M A K ahol a mantissza (M) 1.H alakú, azaz 1 2 M < 10 2 karakterisztika (K) pozitív és negatív is lehet Nem tároljuk: alap (A=2), rejtett bit, K előjele E=K+B adott számú biten nem negatív (B: nulla pont) Tárolandó: S, H, E
Lebegő pontos szabvány IEEE 754/1985 szabvány (ISO/IEC/IEEE 60559:2011) Előjel Pozitív: 0; Negatív: 1 Formátumok Egyszeres pontosság Dupla pontosság Kiterjesztett pontosság méret S hossz E hossz H hossz 32 bit 1 bit 8 bit 23 bit 127 64 bit 1 bit 11 bit 52 bit 1023 80 bit 1 bit 15 bit 63(+1) bit 16383 B
Lebegő pontos számábrázolás Példa: -13.8125 egyszeres pontossággal -13.8125 10 = -1101.1101 2 = -1 1 1.1011101 2 3 Előjel: S = 1 Karakterisztika: K = 3 10 = 11 2 Mantissza: M = 1.1011101 Hasznos bitek: H = 10111010000000000000000 Eltolt karakterisztika: E = 3 10 +127 10 = 10000010 2 1 1 0 0 0 0 0 1 0 1 0 1 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 S E H
Kerekítési hiba Ok: hasznos bitek tárolás véges számú biten Túl sok hasznos bit esetén kerekítés szükséges Ha az utolsó tárolható hasznos bit után 0 áll, akkor a további biteket levágjuk Különben felfelé kerekítünk Kerekítési hiba: nem pontos ábrázolás Példa: 0.3 ábrázolása egyszeres pontossággal hasznos bitek: 00110011001100110011001100110 tárolt bitek: 00110011001100110011010 0.3 0.300000011920929
Kerekítési hiba Valós számok: folytonos halmaz, végtelen sok elemmel Lebegőpontos számok: diszkrét halmaz, véges sok elemmel Például: 1.0000000000; 1.0000001192; 1.0000002384; 1.0000003576 Az ábrázolható számok sűrűsége nem állandó A tárolt értékek csak néhány számjegyig pontosak
Speciális lebegőpontos értékek +0 és -0 előjel bit 0 (+) vagy 1 (-), minden más bit 0 Pl.: 0.0/-1.0, -1.0*0.0 ±végtelen (Inf) karakterisztika csupa 1, mantissza csupa 0 Pl.: 1.0/0.0, inf+1.0, túl nagy érték nem szám (NaN) karakterisztika csupa 1, mantissza nem csupa 0 Pl.: 0.0/0.0, inf-inf, 0.0*inf, NaN+1.0 denormalizált szám (subnormal) karakterisztika csupa 0, mantissza nem csupa 0
Számolás lebegő pontos számokkal Összeadás: fixpontostól nagyon eltérő módszer Példa: 7,5 + 0,625 7,5 = 01000000 11110000 00000000 00000000 0,625 = 00111111 00100000 00000000 00000000 3 10000001 > 01111110 11110000 + 10100 100000100 1+10000001 = 10000010 01000001 000000100 00000000 00000000 (-1) 0 * 1,000001 *10 11 = 8,125
Példa: bitsorozat értelmezés Mit jelenthet az alábbi big-endian bitsorozat? 11101001 10110000 10100101 01000110 32 bites előjeles egész: -374 299 322 32 bites előjel nélküli egész: 3 920 667 974 16 bites előjeles egészek: -5 712; -23 226 16 bites előjel nélküli egészek: 59 824; 42 310 lebegőpontos: -26693928249241673000000000.0 Latin 1 szöveg: é F Latin 2 szöveg: é ĽF Unicode szöveg UTF8 kódolással: 鰥 F Pakolt BCD:?9?0?546 (érvénytelen) vagy +9-0+546
A processzor felépítése és működése CPU Regiszterek Fetch-execute ciklus
A számítógép alapvető felépítése Processzor Memória Input-Output interfész Buszrendszer Perifériák Perifériák Processzor Memória I/O interfész Buszrendszer
Központi Feldolgozó Egység Central Processing Unit (CPU) Részei: Vezérlő egység (CU) Aritmetikai és logikai egység (ALU) Processzor Címző egység (AU) és Busz illesztő egység (BIU) Regiszterek Belső buszrendszer Belső gyorsítótár Egyéb (pl. órajel generátor) Végrehajtó egység (EU)
Regiszterek Kis méretű (flip-flop-szerű) tároló áramkör Mérete általában a busz szélességével egyenlő Általában 8-512 bit tárolására alkalmas Gyors hozzáférésű (elérési idő < 1ns) Darabszámát a processzor határozza meg (10-100) Gyakran regisztertömböket alkot Van nevűk (néha átnevezhetőek) 3 kategória: Rendszer-, általános célú- és speciális célú regiszter
Aritmetikai és logikai egység Számítási műveleteket végez Tartalmaz: fixpontos összeadót, komplemens képzőt, léptető regisztereket, bitenkénti logikai művelet végző, stb. áramköröket A operandus B operandus utasítás ALU állapot eredmény
Vezérlő egység Az IR-ben lévő érték alapján irányítja, szabályozza a többi egység (pl. ALU) működését Fontos regiszterei: IR, PC, SR A vezérlés történhet Huzalozott logikával (közvetlenül) Minden utasításhoz létrehozott bonyolult digitális elektronika segítségével Mikroprogramozott (közvetett) módon Minden műveleti kód elindít egy apró (ROM-ban tárolt) mikroprogramot
Címző egység Addressing Unit (AU), Address Generation Unit (AGU) Az utasítások sokféle címzési mód segítségével határozhatják meg hol található az operandus Az AU az operandus címét állítja elő és helyezi el az MAR-ban Az utasításban található címet képezi le fizikai memóriacímre Tárolóvédelmi hibák felismerése Kapcsolat: BIU
Egy művelet sorozat ismételgetése Fetch-execute ciklus Órajel szinkronizált CU vezényel A CPU működése Végtelen, monoton, gépies ismétlés során Adatmozgatás Műveletvégzés Fontos a regiszterek (PC, IR, SR, ACC, MAR, MDR, stb.) tartalma és annak változása
Fetch-Execute ciklus 1. Utasítás beolvasása A PC-ben található érték megmondja, hol található a memóriában a következő utasítás. Ezt be kell olvasni az IR-be. 2. Dekódolás A beolvasott műveleti kódot értelmezni kell. Milyen művelet? Milyen adatokon? Eredmény hová kerül? Utasításkészlet architektúra (ISA) definiálja Lehet huzalozott vagy mikroprogramozott
Fetch-Execute ciklus 3. Operandus beolvasása Az operandus címének meghatározása és onnan beolvasása a megfelelő regiszterbe 4. Művelet végrehajtása például az ALU által, az eredmény egy átmenti regiszterbe kerül 5. Eredmény tárolás regiszterbe vagy memóriacímre 6. Következő utasítás címének meghatározása
Memória hierarchia Regiszter L1 cache L2 cache L3 cache Memória Lemez Harmadlagos tár s ms s ns EB TB GB MB kb B Elérési idő Tároló kapacitás
Intel x86-64 architektúra Processzor felépítés Regiszterkészlet Memóriakezelés
Kezdetek Az Intel 1976-78 között fejlesztette ki az új Intel 8086 névre hallgató processzorát Később ezt fokozatosan tovább fejlesztették Intel 80186 (1982) Intel 80286 (1982) Intel 80386 (1986) Intel 80486 (1989) Visszafelé kompatibilitás Ma a processzorcsaládra x86 néven hivatkozunk Az AMD 64-bites kiterjesztésére x86-64 néven hivatkozunk (1999)
Memória szegmentáció A memória logikai részekre van osztva Kód szegmens Adat szegmens Verem szegmens A címzést külön regiszterek segítik (CS, DS, SS, ES) Címzés: szegmens kezdőcím + eltolás Memóriakezelés Valós-, védett-, virtuális-, hosszú mód
Valós mód Memória szegmentáció 8086-ban csak ez van 20 bites címbusz (1MB) Szegmens méret 64kB (16 bit) Minden memóriacím elérhető korlátozás nélkül Ilyen módban indul a processzor Lineáris cím = szegmenscím*16 + eltolás Lineáris cím = fizikai cím + Szegmens kezdőcím (16 bit) Eltolási cím (16 bit) Lineáris kezdőcím (20 bit)
Védett mód Memória szegmentáció 80386 vezeti be Korlátozott memóriahozzáférés Címtér 32 bites (4GB) Virtuális memória támogatás Lineáris cím (32) = szegmenscím (32) + offset (16/32) Lineáris cím lapozás fizikai cím Virtuális mód (látszólagos valós mód 80386-tól) Hosszú mód (64 bites, nincs szegmentálás)
X86-64 regiszterkészlet RAX RBX RCX RDX RSP RBP RSI RDI 63 EAX AX R8D R8W AH AL R8 R8B R9 R10 R11 ESP SP R12 SPL R13 R14 R15 EIP RIP IP 31 15 7 0 RFLAGS CS DS SS 63 31 15 7 0 ES FS GS
Főbb regiszterek RAX X86-64 regiszterkészlet Elsődleges munka regiszter (akkumulátor), szorzás, osztás RBX Munka regiszter, bázis mutató RCX Munka regiszter, (ciklus)számláló RDX Munka regiszter, input/output, szorzás, osztás
Főbb regiszterek RSP (verem mutató) X86-64 regiszterkészlet Verem tetején lévő elemet címzi (SS regiszterrel) RBP (bázis mutató) Lokális változókhoz, paraméterekhez (SS regiszterrel) RSI (forrás index regiszter) Sztring műveletek forrás indexe (DS regiszterrel) RDI (cél index regiszter) Sztring műveletek cél indexe (ES regiszterrel)
Szegmens regiszterek CS X86-64 regiszterkészlet Kód szegmens kezdőcíme, IP ebben címzi az utasítást DS Adat szegmens kezdőcíme (statikus változók) SS Verem szegmens kezdőcíme, ESP és EBP használja ES, FS, GS Extra adat szegmens, RDI alap szegmense az ES
X86-64 regiszterkészlet EFLAGS regiszter Állapot bitek Vezérlő bitek Rendszer bitek 31 30 29 28 27 26 25 24 0 0 0 0 0 0 0 0 23 22 21 20 19 18 17 16 0 0 ID VIP VIF AC VM RF 15 14 13 12 11 10 9 8 0 NT IOPL OF DF IF TF 7 6 5 4 3 2 1 0 SF ZF 0 AF 0 PF 1 CF
Utasítás számláló RIP (Instruction pointer) X86-64 regiszterkészlet CS regiszter révén a kód szegmensben található utasításokat címzi Minden fetch-execute ciklus során inkrementálódik az adott utasítás hosszával (kivéve vezérlésátadás) Egyéb regiszterek Vannak további működést segítő regiszterek IR, MAR, MDR, stb. Programozó elől rejtettek
x87 regiszterkészlet Lebegőpontos egység (matematikai társprocesszor) 8 darab 64 (80) bites regiszter (ST(0)-ST(7)) Veremszerű működés Dupla pontosságú lebegőpontos reprezentáció Regiszterenként 2 további bit 00 érvényes, 01 nulla, 10 speciális (Inf, NaN), 11 üres Saját állapot regiszterek (pl. OE, UE, ZE, TOS, B, DE) és vezérlő regiszterek (pl. RC, PC) +MMX, SSE, AVX kiterjesztések nagy regiszterei
Portra leképezett I/O (PMIO) 16 bites I/O címek (0h-FFFFh) Külön utasítások (in, ins, out, outs, stb.) Egy eszközhöz több port is tartozhat Adat, Utasítás, Állapot I/O porton elérhető fontosabb eszközök: Input-Output DMA vezérlő, programozható megszakítás kezelő (8259A), időzítő (8254), billentyűzet (8042), valós idejű óra, matematikai társprocesszor, PATA vezérlő, stb. Linux: /proc/ioports
Megjelenési év 2008 64 bites regiszterek (x86-64) Példa: Intel Core i7 Mikroarchitektúra: Nehalem, Sandy Bridge, Ivy Bridge, Haswell, Broadwell, 45-14nm technológia (780-1400 millió tranzisztor) 2-8 mag LGA aljzat (1000-2000 kontaktus) DMA, Virtuális Memória kezelés, integrált FPU, L3 cache, integrált GPU, elágazásbecslés, VT-x, AVX-512, (HT), integrált NorthBridge
Assembly nyelv Utasítás készlet Címzési módok Gépi kód
Alacsony absztrakciós szint Programozói szabadság Feladatra optimalizálható kód Nagyobb program teljesítmény Hardverismeret szükség Nehezebben átlátható kód PC, mikrokontroller Magasszintű programnyelvek Assembly programozás Gépi kód
Utasítás szerkezet 4 címes utasítás Műveleti kód 3 címes utasítás Műveleti kód 1. Operandus cím 1. Operandus cím 2. Operandus cím 2. Operandus cím Eredmény cím Eredmény cím Következő utasítás cím 2 címes utasítás Műveleti kód 1. Operandus + eredmény cím 2. Operandus cím 1 címes utasítás Műveleti kód 2. Operandus cím
Program és utasítás felépítés Forrás fájl utasítás_1 utasítás_2 utasítás_3 utasítás_4 utasítás_5 Címke Művelet Operandus(ok) Megjegyzés.L1: mov ax, 0 # zero into ax Címke Azonosító, általában kettősponttal zárul Művelet Operandus(ok) Megjegyzés Az elvégzendő művelet mnemonic-ja Adat(ok) vagy adat(ok)ra hivatkozás(ok) Sor végéig a fordító figyelmen kívül hagyja
Utasításkészlet architektúra ISA (Instruction Set Architecture) A számítógép programozáshoz kötődő részletei Bitszélesség (buszok és regiszterek) Regiszter készlet Gépi utasítások Címzési módok Memória architektúra Megszakítás kezelés
Adatmozgató utasítások (Egész) aritmetikai utasítások Bitenkénti logikai utasítások Bitléptető utasítások Vezérlésátadó utasítások Sztringkezelő utasítások BCD és valós aritmetikai utasítások Fordítási direktívák Egyéb utasítások Utasítás típusok
Utasítás típusok Adatmozgató utasítások Regiszter-regiszter (mov, xchg) Regiszter-memória (mov) Regiszter-I/O port (in, out) Regiszter-verem (push, pop) Kiterjesztés (bitszélesség fontos) (cbw, cwd) Státusz bit állítás (sti, cli)
Utasítás típusok Aritmetikai utasítások Összeadás (átvitel nélkül/átvitellel) (add, adc) Kivonás (átvitel nélkül/átvitellel) (sub, sbb) Inkrementálás, dekrementálás (inc, dec) Kettes komplemens (neg) Előjeles/előjel nélküli szorzás (imul, mul) Előjeles/előjel nélküli osztás (idiv, div) Összehasonlítás (cmp)
Bitenkénti logikai utasítások ÉS művelet (and) VAGY művelet (or) KIZÁRÓ VAGY művelet (xor) Egyes komplemens (not) Bit tesztelés (test) Utasítás típusok
Utasítás típusok Bitléptető utasítások Logikai/előjel nélküli balra léptetés (shl) Logikai/előjel nélküli jobbra léptetés (shr) Aritmetikai/előjeles balra léptetés (sal=shl) Aritmetikai/előjeles jobbra léptetés (sar) Jobbra/balra forgatás (ror, rol) Jobbra/balra forgatás carry-n keresztül (rcr, rcl)
Vezérlésátadó utasítások Feltétel nélküli ugrás (jmp) Utasítás típusok Feltételes ugrás (ja, jae, jb, jbe, je, jne, jc, jo, ) Ciklusszervező (loop, loopz, loopnz, ) Hívó utasítás (call) Szubrutinból visszatérés (ret) Szoftveres megszakítás kérés (int) Megszakítás-kezelőből visszatérés (iret) Példa:.L1: sub eax, 1 jnz.l1 mov eax, 9 mov ebx, eax
Utasítás típusok Stringkezelő (bájtsorozat kezelő) utasítások Sztring mozgató (movs, movsb, movsw) Sztring összehasonlító (cmps) Keresés sztringben (scas) Egyéb utasítások Koprocesszor vezérlő (wait, esc) Rendszervezérlő (hlt) Üres utasítás (nop)
Utasítás típusok Fordítási direktívák: gépi kód nincs mögöttük, a fordítás menetét befolyásolják Szegmens definiálás (.segment, ends) Egyszerűsített szegmensdefiníció (stack,.data) Helyfoglalás (.byte,.4byte,.long) Helyettesítő szimbólum létrehozás (equ)
Adat vagy utasítás hogyan érhető el. Rejtett (implicit, implied) Közvetlen adat megadás (immediate) Közvetlen cím (direct, absolute) Regiszteres cím (register direct) Közvetett cím (indirekt) Regiszter indirekt Indexelt cím Bázis relatív cím Címzési módok
Címzési módok Rejtett címzés Nincs igazi cím megadás Pl. ha nincs operandus 500 501 502 503 Op.kód1 Op.kód2
Címzési módok Közvetlen adat megadás Műveleti kód után közvetlenül található adat Ez lesz az operandus Konstans 500 501 502 503 Op.kód Adat
Címzési módok Regiszteres címzés A műveleti kód hivatkozik egy regiszterre A regiszterben található az operandus értéke 500 501 502 503 Op.kód regiszter Adat
Címzési módok Közvetlen cím Műveleti kód után található egy memóriacím Itt helyezkedik el az operandus 500 730 501 Op.kód 731 Adat 502 731 732 503 733
Címzési módok Közvetett cím A műveleti kód után található egy cím Ezen a címen található az operandus igazi címe 500 730 943 501 Op.kód 731 945 944 502 731 732 945 Adat 503 733 946
Regiszter indirekt Címzési módok A műveleti kód hivatkozik egy regiszterre A regiszterben található címen helyezkedik el az operandus regiszter 500 731 730 501 Op.kód 731 Adat 502 732 503 733
Indexelt Címzési módok A műveleti kód után található egy cím, ehhez hozzáadva az index regiszterben található értéket megkapjuk az operandus memóriacímét index reg. 500 31 730 501 Op.kód 731 Adat 502 700 732 503 733
Bázis relatív Címzési módok A műveleti kód után található egy eltolási érték, ehhez hozzáadva a bázis regiszterben található kezdőcímet megkapjuk az operandus címét bázis reg. 500 720 730 501 Op.kód 731 Adat 502 11 732 503 733
Assembly szintaxis Intel szintaxis.intel_syntax noprefix.globl main main: push ebp mov ebp, esp sub esp, 16 mov DWORD PTR [ebp-16], 2 mov DWORD PTR [ebp-12], 3 cmp DWORD PTR [ebp-16], 4 jne.l2 mov eax, DWORD PTR [ebp-12] mov DWORD PTR [ebp-8], eax jmp.l3.l2: mov DWORD PTR [ebp-8], 4.L3: mov eax, DWORD PTR [ebp-8] add esp, 16 pop ebp ret AT&T szintaxis.att_syntax noprefix.globl main main: pushl %ebp movl %esp, %ebp subl $16, %esp movl $2, -16(%ebp) movl $3, -12(%ebp) cmpl $4, -16(%ebp) jne.l2 movl -12(%ebp), %eax movl %eax, -8(%ebp) jmp.l3.l2: movl $4, -8(%ebp).L3: movl -8(%ebp), %eax addl $16, %esp popl %ebp ret
Operandusok Regiszter (8, 16, 32 bites) Konstans (8, 16, 32 bites) Memória tartalom Memória cím és méret kényszerítés mov al, BYTE PTR [ebx] mov ax, WORD PTR [ebx] mov eax, DWORD PTR [ebx] Operandusok
Címzési módok Regiszteres Közvetlen adat Közvetlen cím Közvetett regiszteres Regiszter relatív Bázisos indexelt Bázis+index relatív Skálázott Szegmens előtag mov ax, bx mov ax, 7Fh mov ax, [1234] mov ax, [bx] mov ax, [bx + 100h] mov ax, [bx + si] mov ax, [bp + di + 123] mov ax, [si * 4 +10h] mov ax, [es:bx]
Címzési módok Effektív cím (EA) megadás alakjainak összegzése CS: SS: DS: ES: FS: GS: egyiksem Szegmens szelektor EAX EBX ECX EDX ESI EDI EBP ESP egyiksem EAX EBX ECX EDX + ESI EDI EBP egyiksem 1 2 4 8 egyiksem Bázis Index Skálázó faktor Példa: mov EAX, [DS:EBP+EDI*4+10h] vagy ugyanaz más írásmódban: mov EAX, DS:10h[EBP][EDI*4] + eltolás semmi Eltolás
Last In First Out tároló A verem Tetejének a memóriacímét a verem mutató regiszter (SP) tárolja Push és Pop művelet A verem mérete korlátos Veremhez gyakran hozzá kell férni Általában gyorsítótárazott (cache) Adat kivétele nem fizikai törlés Külön memóriaszegmensben van
Hívó szabályai Alprogram hívási konvenció Paraméterek fordított sorrendben a rendszerverembe helyezése Néha adott sorrendben regiszterekbe: edi, esi, edx, Lebegő pontos paraméterek a SSE regiszterekbe (eax-be a float paraméterek száma) Alprogram hívás (visszatérési cím a verembe kerül, programszámláló átáll az alprogram kezdőcímére) Visszatérés után veremből paraméterek kivétele Visszatérési érték az eax regiszterben van Számítógép architektúrák 73
Alprogram hívási konvenció Hívott szabályai Bázis pointer verembe mentés Verem mutató mentése bázis pointerbe Helyfoglalás lokális változóknak a veremben Használandó regiszterek mentése a verembe Visszatérési érték az eax regiszterbe tétele Mentett regiszterek és verem visszaállítás Visszatérés (a veremben lévő címre) Számítógép architektúrák 74
Inline assembly C-ben A C nyelv és az assembly asm( movl $10, %eax ); C forráskód fordítás assembly-re gcc-vel gcc -S -masm=intel prog.c Kimenet: prog.s Assembly forráskód fordítás gcc-vel gcc prog.s Kimenet: a.out
A félév során használt utasítások.2byte,.4byte,.bss,.byte,.comm,.data,.globl,.intel_syntax noprefix,.section,.string,.text,.zero, add, addsd, and, call, cbw, cdq, cdqe, cmp, cwd, dec, div, idiv, imul, inc, ja, jae, jb, jbe, jc, je, jg, jge, jl, jle, jmp, jnc, jne, jnz, jz, lea, leave, loop, mov, movabs, movsd, movsx, movzx, mul, mulsd, neg, nop, not, or, pop, push, ret, rol, ror, sal, sar, seta, setb, setbe, setc, sete, setea, setg, setge, setl, setle, setnc, setne, setnz, setz, shl, shr, sub, test, xchg, xor Részletes leírás elérhető itt: https://www.felixcloutier.com/x86/
Gépi kód Az egyetlen nyelv, amit a processzor megért Bináris formátum Processzoronként változó lehet Példa: assembly: gépi kód: SUB EAX, EBX # eax = eax-ebx 0x29 0xD8 0 0 1 0 1 0 0 1 1 1 0 1 1 0 0 0 OpKód d s MOD REG R/M SUB művelet REG mező a forrás 32 bites regiszter Regiszteres címzés Forrás: EBX Cél: EAX
Gépi kód példa C nyelvű kód y=5; z=6; x=z+y*7; Assembly kód mov DWORD PTR [ebp-12], 5 mov DWORD PTR [ebp-8], 6 mov ebx, DWORD PTR [ebp-12] mov eax, ebx sal eax, 3 sub eax, ebx add eax, DWORD PTR [ebp-8] mov DWORD PTR [ebp-16], eax Gépi kód c7 45 f4 05 00 00 00 c7 45 f8 06 00 00 00 8b 5d f4 89 d8 c1 e0 03 29 d8 03 45 f8 89 45 f0
Ajánlott irodalom Varga Imre: Számítógép architektúrák (diasor), 2019 Andrew S. Tanenbaum: Számítógép architektúrák, Panem, 2006 Joseph Cavanagh: X86 Assembly Language and C Fundamentals, CRC Press, 2013 Richard Blum: Professional Assemby Language, Wiley, 2005 Nicholas Charter: Computer architecture, McGraw-Hill, 2001 R. E. Bryant, D. R. O Hallaron: Computer Systems A programmer s perspective, Pearson, 2016 Ray Seyfarth: Introduction to 64 bit assembly programming for Linux and OS X, Amazon, 2013 Clive Maxfield: Bebop to the Boolean boogie, Newnes, 2003
Köszönöm a figyelmet! Sikeres felkészülést!