Assembly nyelvek előadás vázlat(Halász Gábor)
Országok listája
HungaryDebreceni EgyetemInformatikai KarProgramtervező informatikusAssembly NyelvekJegyzetekAssembly nyelvek előadás vázlat(Halász Gábor)
2009.03.26 20:38:26
Az alábbi szöveg egy formázás és képek nélküli előnézete a dokumentumnak. A tökéletes megjelenítéshez jelentkezz be, majd töltsd le a dokumentumot.
Assembly nyelvek
07/11/05 16:40:11
(vázlat az el adásokhoz)
· Bevezetés: Irodalom, HLA, gépi kód, CPU, regiszterek, alapvet utasítások · Memória elérés: címzésmódok, mutatók, memória szervezés · Adatábrázolás: típusok, gépi kód, számrendszerek, el jeles egészek · programszerkezeti elemek: if, ciklusok, eljárások, paraméter átadási módok, lokális változók · Alacsony szint kontroll szerkezetek JMP oda; Jcc címke; LOOP(címke); call elj; ret(n); · Utasításkészlet: Adatmozgatás és veremm veletek Aritmetika és BCD korrekciók Sztingm veletek, HLA-sztring szerkezete Logikai és léptet m veletek Megszakítások, kivételek, I/O, (LOCK, ESC, WAIT) (FPU, MMX)
,,Hello World!" program
Program HelloWorld; #include("stdlib.hhf") begin HelloWorld; stdout.put("Hello World!",nl); end HelloWorld; Program hw; // Sok-sok megjegyzés #incule("stdlib.hhf") begin hw; stdout.put // ,,szabad" szintaxis ( "Hello" // stringek automatikus összef zése " World!" nl // nl == new line ); end hw; // Fordítás, futtatás: hla hw; hw
Neumann architektúrájú számítógépek
(Az Intel 80x86 CPU családja is ebbe a körbe tartozik)
· F részei:
CPU Memória I/O eszközök
· Kapcsolat közöttük: Rendszerbuszok
Cím busz (32 bit) Adat busz (32 bit) Kontroll busz
Az Intel 80x86 CPU
regiszterei
· Általános célú regiszterek · Speciális regiszterek alkalmazások számára hozzáférhet · Flag regiszter (F, EF) · (Utasítás számláló (IP, EIP)) operációs rendszer számára fenntartott · szegmens regiszterek CS: Kód SS: Verem DS: Adat ES, FS, GS: Extra adat
Az Intel 80x86 CPU általános regiszterei
· 8 bites regiszeterek AL, AH, BL, BH, CL, CH, DL, DH · 16 bites regiszterek AX, BX, CX, DX, SI, DI, BP, SP · 32 bites regiszterek EAX, EBX, ECX, EDX, ESI, EDI, EBP, ESP · Átfedés van közöttük: AX=EAX%65535=256*AH+AL , BX, CX, DX SI=ESI%65535 , DI, BP, SP · ,,jelentés" a név mögött: AX=Accumulator, BX=Base register, CX=Counter_register, DX=Data_register, SI=Source_Index, DI=Destination_Index BP=Base_Pointer, SP=Stack_Pointer (NE HASZNÁLD!) AL=Accumulator Low, AH=Accumulator High, stb... EAX=Extended Accumulator, stb...
A flag regiszter
Egyedi ,,zászlók" - logikai változók gy jteménye · Állapot jelz k bit-0: CF Carry átvitel bit-2: PF Parity párosság bit-4: AF - Auxiliary carry közbens átvitel bit-6: ZF Zero zéró bit-7: SF Sign el jel bit-B: OF Overflow Túlcsordulás · Vezérl bitek bit-8: TF Trace nyomkövet bit-9: IF Interrupt enable Megszakítás engedélyezés bit-A: DF Direction Irány jelz ----ODIT.SZ-A-P-C
Alapvet utasítások
MOV(mit, hová);// hová=mit · mit: regiszter, memória, konstans · hová: regiszter, memória · mit és hová azonos méret (8, 16 vagy 32 bit) · Flag regiszter változatlan ADD(mit, mihez);// mihez=mihez+mit · mit: regiszter, memória, konstans · mihez: regiszter, memória · mit és mihez azonos méret (8, 16 vagy 32 bit) · Állapotjelz k állítódnak SUB(mit, mib l);// mib l=mib l-mit · mit: regiszter, memória, konstans · mib l: regiszter, memória · mit és mib l azonos méret (8, 16 vagy 32 bit) · Állapotjelz k állítódnak INTMUL(forrás,cél); INTMUL(konstans,forrás,cél) · forrás: regiszter, memória, konstans · cél: regiszter · forrás és cél azonos méret (16 vagy 32 bit) · Állapotjelz k állítódnak (CF=OF; többi határozatlan)
Alapvet könyvtári függvények, adat deklarációk
program plST; // Azonosítók: [_a-zA-Z][_a-zA-Z0-9]* #include("stdlib.hhf); static a:int32:=-7; b:int32; begin plST; stdout.put("a értéke: ",a,nl); // Írás a ,,képerny re" stdout.put("írj be egy számot:"); stdin.get(b); // Olvasás a ,,billenyt zetr l" stdout.put("A beírt szám: ",b,nl); end plST; //,,static" //,,a:", ,,b:" //,,int32" //,,:=-7" : : : : adat deklarációs rész megkezdése Változók nevének megadása (,,neutrális") típus - 32 bites el jeles egész szám kezd érték megadása -- nem kötelez
Egyszer minta program
program Demo; #include("stdlib.hhf"); STATIC a:int32:=5; b:int32; c:int32; begin Demo; stdout.put("Az 'a' változó értéke: ",a,nl); stdout.put("Irj be egy számot:"); stdin.get(b); mov(b,eax);add(a,eax);if(@S) then neg(eax); endif; mov(eax,c); stdout.put(a,"+",b," absolut értéke: ",c,nl); end Demo;
Általános memória használat
......: ......: ......: ......: ......: 16 MB: 16 MB: 128 KB: storage szekció --static szekció ----(@nostorage) read-only szekció --- (align(4) ) rendszer konstansok program kód --- byte 3,7,9;(pseudo halom (default méret) verem (default méret) (VAR szekció) Operációs rendszer
opcode)
Alignment:1-2-4-8-16, ,,nagy objektumok": 8-16 align(x);
Adatábrázolás, adattípusok
· bit, nible, byte · Assembly alaptípusok byte, word, dword, qword, tbyte, lword ----------- valahol itt kezd dik a harmadik e.a.---· memória elérés (align) · Utasítások - címzésmódok · ,,Magas szint " adattípusok Egész számok (int32, uns8) · bináris <=> BCD (Binary Coded Decimal) · pozitív <=> el jeles Valós számok (real32, real64, real80) Karakterek, karakterfüzérek (char, string) Mutatók - memória címek (pointer) Tömbök (tomb:int16[3,2];tomb2:byte:=[5,8,4,9];)
A gépi kód
(ADD utasítás egyik formája)
%000000_d_w %mm_reg_r/m [DISP vagy disp] %000000 -> ADD ; d -> melyik a forrás ; w -> méret mm -> mod (0-1-2: memória, 3 regiszter) regiszter: 8 bit: AL,CL,DL,BL,AH,CH,DH,CH 16 bit: AX,CX,DX,BX,SP,BP,SI,DI r/m, ha memória: DISP+ BX+SI,BX+DI,BP+SI,BP+DI,SI,DI,BP,BX Kivétel: Ha mm=0 és r/m=6 ==> (BP helyett) DISP (Van még konstans hozzáadása, ill. speciális esetek.) %100000_s_w %mm_000_r/m [DISP vagy disp] data (data) s -> adat el jelkiterjesztése %0000010_w data (data) ADD(kons,AL); ADD(kons,AX); SIB byte (Skála Index Bázis) mod: 00-nincs 01-8bites 02-32bites eltolas 03-regiszter mod<11 és r/m=4--> SIB bájt: %sk_ind_baz mod=00 és r/m=5 16-bites eltolas REGS: eax, ecx, edx, ebx, esp, ebp, esi, edi Prefixek: utasítás, cím méret, operandus méret, szegmens Az EIP regiszter
Címzésmódok
1: konstans, azonnali 2: regiszter Memória címzések: 3: direkt, közvetlen 4: regiszter indirekt 5: bázis relatív 5: indexelt 7: bázisrelatív indexelt
(operandusok megadási módjai)
,,Magas szint " adattípusok
· Pozitív egészek (uns8, uns16, uns32, uns64, uns128) 0 ... 2^(n)-1 · El jeles egészek ábrázolása (LSB és MSB) el jelbit (80 bites BCD számok) -2^(n-1)+1 ... +2^(n-1)-1 eltolással EE=PE-konst. (valós számok karakterisztikája) -konst. ... 2^(n)-1-konst. egyes komplemens -2^(n-1)+1 ... +2^(n-1)-1 kettes komplemens (int8, int16, int32, int64, int128) -2^(n-1) ... +2^(n-1)-1 int=uns-MSB*2^n · Valós számok (real32, real64, real80)
érték=(-1)^(S)*2^(karakterisztika)*(1+mantissza) (IEEE szabvány) real32: 1+ 8+23 10^38 6-7 jegy real64: 1+11+52 10^308 15-16 jegy real80: 1+15+64 10^4800 19-20 jegy
· Mutatók (pointer) · Karakterek, karakter füzérek (char, string)
· Összetett típusok (tömbök, recordok, uniók)
Adatmozgató utasítások
· · · · · · ·
(Minden flag változatlan)
MOV(forrás,cél); //Nincs (m,m), (sr,sr), (k,sr) MOVSX(forrás,cél_reg);MOVZX(forrás,cél_reg) XCHG(m/r,m/r); // azonos méret, NINCS m,m XLAT; // MOV([EBX+AL],AL) LEA(mem,cél_reg32);// "=" MOV(&mem,cél_reg32) LAHF; SAHF; // Load, Save az AH szempontjából .. LDS(mem48,reg32);LES(mem48,reg32);
VEREM m veletek
· PUSH(forrás);//mem, reg, 16/32 bit PUSHW(forrás); // mem16, reg16, konst ESP-=2 PUSHD(forrás); // mem32, reg32, konst ESP-=4 · POP(forrás); //mem, reg, 16/32 bit · PUSHF; PUSHFD; · POPF; POPFD; · PUSHA; PUSHAD; · POPA; POPAD;
Aritmetikai utasítások
· · · · ADD(forrás,cél);SUB(forrás,cél); ADC(forrás,cél);SBB(forrás,cél); INC(m/r); DEC(m/r);NEG(m/r); CMP(cél,forrás);
Feltételes ugrások CMP után · J... címke; pozitív mennyiségek hasonlítása után JA, JB, JE, JAE, JBE, JNA, JNB, JNE, JNAE, JNBE el jeles mennyiségek hasonlítása után JG, JL, JE, JGE, JLE, JNG, JNL, JNE, JNGE, JNLE
· INTMUL(forrás,cél);intmul(kons,forrás,cél);
· MUL(forrás);IMUL(forrás); · DIV(osztó);IDIV(osztó);//kivétel
Programszerkezeti elemek
· Elágazások if(feltétel) utasítások {{elseif utasítások} else utasítások} endif · felt: @z, @ae, a
, !=, =, ==, {!}boolean_var, reg {not} in low..Hi · Ciklusok while(felt) do ut... endwhile for(ut;felt;utasítás) do ut... endfor repeat ut... until(felt) forever ut.... endfor · break; breakif(felt); · continue; continueif(felt); begin nev; ut...; end nev; · exit nev; exitif(felt) nev;
logikai utasítások
· · · · · NOT(cél); // Minden flag változatlan OR(forrás, cél); AND(forrás,cél); XOR(forrás,cél); TEST(forrás,cél); // TEST(al,al); TEST(8,AH);
· forrás: mem/reg/konst · cél: mem/reg · cél és forrás azonos méret / 8-16-32 bit nem lehet mindkett memória cím · OF=CF=0 · AF határozatlan · PF, ZF, SF értelemszer en
Forgatások, léptetések
· · · · · · · · · · SHL(sz,cél);//SHR, SAR ROL(sz,cél);//ROR, RCL, RCR SHLD(sz,forrás,cél);// SHL(sz,cél:forrás); SHRD(sz,reg,mem/reg);// SHR(sz,forrás:cél); Csak a cél változik meg sz: konstans vagy CL cél és forrás azonos méret forrás csak regiszter lehet, csak 16-32 bites lehet Csak CF és OF változik meg a forgatásoknál AF határozatlan a léptetéseknél
Közvetlen bitelérések
· Flag regiszter bitjei CLC, CLD, CLI, STC, STD, STI, CMC · BT(hányadik, miben); // Bit Test CF-et állítja · BTC, BTR, BTS; // BT and Complement, Reset, Set · miben: mem/reg16/reg32 · hányadik reg/konst: 0--15/31 regiszter méret 255 ha hányadik konstans limit nélkül, ha hányadik reg és miben mem ha reg, akkor azonos méret mibennel · BSF(miben,hova);// legalacsonyabb helyiérték 1-es bit sorszáma mibenben --> hova / ha ZF=0 · BSR(miben,hova);// legmagasabb helyiérték 1-es bit sorszáma mibenben --> hova miben és hova azonos méret (16/32 bit) hova: regiszter
Eljárások,
paraméter átadás
· Procedure elj_nev(formális_paraméter_lista);@opciók; lokális deklarációk begin elj_nev; utasítások end elj_nev; · Eljárás Hívása: nev(aktuális_paraméter_lista); · Paraméter átadás módja · VAL, VAR, RESULT, VALRES, .... helye · verem, regiszter · Regiszterek meg rése · lokális deklarációk láthatóság élettartam · exit elj_nev;exitif(felt) elj_nev;
CPU Állapot (regiszterek)meg rzése
Program nem_mukodik; #include("stdlib.hhf") procedure tiz_szokoz;begin tiz_szokoz;mov(10,ecx); repeat stdout.put(' ');dec(ecx);until(@z); end tiz_szokoz; begin nem_mukodik; mov(20,ecx); repeat tiz_szokoz();stdout.put("*",nl);dec(ecx); until(@z); end nem_mukodik; // Javítás: // valaki (hívó/hívott) menti ECX-et
Lokális változók
program demo;#include(,,stdlib.hhf") static i:uns32:=10;j:uns32:=20; Procedure elso;var i:int32;j:uns32;begin eslo; mov(10,j);for(mov(0,i);i<10;inc(i))do stdout.put(,,i,j=",i," ,,,j,nl);dec(j);endfor; end elso; procedure masodik;var i:int32;begin masodik; mov(10,j);for(mov(0,i);i<10;inc(i))do stdout.put(,,i,j=",i," ,,,j,nl);dec(j);endfor; end masodik; begin demo; elso(); masodik(); stdout.put(,,i=",i," j=",j,nl); end demo;
Paraméter átadás
· VAL: Procedure demo_val(N:uns32); demo_val(10);//konstans demo_val(eax);//32 bites regiszter demo_val(uns32_valtozo);// nem fog demo_val(dword_valtozo);// megváltozni · VAR: Procedure demo_var(VAR N:uns32); demo_var(uns32_valtozo);// "meg fog" demo_var(dword_valtozo);// változni közvetlenül a címét kapjuk meg · RESULT: Procedure demo_result(RESULT N:uns32); demo_var(uns32_valtozo);// "meg fog" demo_var(dword_valtozo);// változni lokális másolatot kapunk, kezd érték nélkül · VALRES: Procedure demo_valres(VALRES N:uns32); demo_var(uns32_valtozo);// "meg fog" demo_var(dword_valtozo);// változni lokális másolatot kapunk, kezd értékkel
Függvények,
visszatérési érték
· FÜGGVÉNYEK: Olyan eljárások, melyek ,,f feladata", hogy egy konkrét ,,függvényértéket" meghatározzanak -kiszámoljanak-, és azt ,,visszadják" a hívónak. · Kompozit utasítások · A ,,@returns" opció · procedure betu_e(c:char);@returns(,,eax"); .... mov(betu_e(al),ebx); if(betu_e(chr)) then ... endif; · betu_e(chr); if(eax) then ... endif;
Eljárások opciói
· @forward; @noframe; @nodisplay; @noalignstack; @external; @use reg32; @cdecl; @stdcall; @pascal · Paraméterátadás helye: regiszter verem kód · Aktivációs Rekord · CALL és RET utasítások · @external;#include();// ,,nagy" programok, · @external csak a globális szinten csak eljárás, static, readonly, storage static c:char;@external(,,var_c"); · Lokális változók ,,igazítása" var [4:1]// var {[max{:min}]}{:=start}
procedure AddandZero( var p1_ref: uns32; var p2_ref:uns32 );@nodisplay;@noframe; var p1: uns32; p2: uns32; begin AddandZero; push( ebp ); sub( _vars_, esp ); // Note: _vars_ is "8" in this example. push( eax ); mov( p1_ref, eax ); mov( [eax], eax ); mov( eax, p1 ); mov( p2_ref, eax ); mov( [eax], eax ); mov( eax, p2 ); pop( eax ); // Actual procedure body begins here: mov( p2, eax ); add( eax, p1 ); mov( 0, p2 ); // Clean up code associated with the procedure?s return: push( eax ); push( ebx ); mov( p1_ref, ebx ); mov( p1, eax ); mov( eax, [ebx] ); mov( p2_ref, ebx ); mov( p2, eax ); mov( eax, [ebx] ); pop( ebx ); pop( eax ); ret( 8 ); end AddandZero;//----------------------------------------------
procedure uhoh( valres i:int32; valres j:int32 ); @nodisplay; begin uhoh; mov( 4, i ); mov( i, eax ); add( j, eax ); stdout.put( "i+j=", (type int32 eax), nl ); end uhoh; ... var k: int32; ... mov( 5, k ); uhoh( k, k ); ... procedure DisplayAndClear( val i:int32 ); @nodisplay; @noframe; begin DisplayAndClear; push( ebp ); // NOFRAME, so we have to do this manually. mov( esp, ebp ); stdout.put( "I = ", i, nl ); mov( 0, i ); pop( ebp ); ret(); // Note that we don?t clean up the parameters. end DisplayAndClear; ... push( m ); call DisplayAndClear; pop( m ); stdout.put( "m = ", m, nl );
Display:
procedure dummy(a:int64;b:int64); var aa:int16;//[ebp-10]; procedure dm(a:int8;b:int16); var x:int8;//[ebp-13] y:int16;//[ebp-15] begin dm;//push(ebp);push([ebp-4]);push([ebp-8]); //lea([esp+8],ebp);push(ebp);sub(4,esp); //and($FFFF_FFFC,esp); mov(y,ax); add(x,al); end dm; //mov(ebp,esp);pop(ebp);ret(8); var bb:int8;//[epb-11] begin dummy;//push(ebp);push([ebp-4]);lea([esp+4],ebp); //push(ebp);sub(4,esp);and($FFFF_FFFC,esp); mov(aa,ax); add(bb,al); end dummy;//mov(ebp,esp);pop(ebp);ret(16);
Sztringkezel utasítások
Adatmozgató utasítások · LODSB; LODSW; LODSD; // ESI // direction flag · STOSB; STOSW; STOSD; // EDI · MOVSB; MOVSW; MOVSD; // ESI, EDI hasonlító utasítások · SCASB; SCASW; SCASD; // AL-[EDI] · CMPSB; CMPSW; SMPSD; // [ESI]-EDI] Ismétl prefixek · REP.MOZGATO · REPE.HASONLITO · REPNE.HASONLITO // ECX
HLA sztringjei
· [max-hossz; hossz; maga asztring; lezáró 0; üres] · str.strRec.length, str.strRec.MaxStrLen · stralloc; mov(eax,str_var); .... ; strfree(str_var); · stdin.gets(str_var); std_in.a_gets(); mov(eax,str_var2);
Hasonló témájú dokumentumok
- 2008-11-28 21:19:19
- 2009-01-11 13:50:54
- 2009-10-29 18:39:33
- 2008-01-24 00:43:39
- 2010-09-06 14:11:14
- 2009-10-29 19:05:00
- 2009-10-29 18:37:57
A mások által feltöltött dokumentumokat értékelheted. Ha úgy ítéled meg, hogy a vizsgára való felkészülés szempontjából hasznos volt egy dokumentum, akkor adj rá sokcsillagos értékelést.
Ha hibákat tartalmaz, vagy egyéb probléma van vele, akkor keveset.
A dokumentumok sorrendje az értékelések alapján adódik. Ami fentebb van a listában, azt hasznosabbnak ítélték társaid. Az új dokumentumok pedig (értékelések hiányában) szintén a lista tetején kezdenek.
Hozzászólások
Ha észrevételed van egy dokumentummal kapcsolatban (például hibát találtál benne), akkor a Hozzászólások részben jelezheted. Az olyan jellegű kérdéseket mint pl.: A 2. feladat 4. sorából milyen átalakítással jutottunk az 5. sorban szereplő képlethez? - szintén ide érdemes írni
Egy tipp az oldalhoz! - Add hozzá azokat a tantárgyakat a saját tárgyakhoz, melyeket aktuálisan hallgatsz a félév során. Így megkapod mások üzeneteit akik tantárggyal kapcsolatban írnak, illetve Te magad is írhatsz ezzel kapcsolatban. Írhatsz naptári bejegyzést, kitöltheted a tantárgyi adatlapját és egy tárgy lapján látod azokat a hallgatókat akik szintén felvették ebben a félévben a tárgyat.
Egy felsőoktatási közösségi oldal amely segít kapcsolatot tartani a hallgatók között, így segítséget nyújt a sikeres tanulmányokhoz...
