Laboratorium AK –ATT asembler (Debian LINUX)  

 Janusz Biernat,  

pa dziernik 2007 

1 

(Debian LINUX) – komendy 

 

!

"

(nakładka na #

), 

przenoszenie z „notepad” do 

 (Win XP): zaznacz (Ctrl-A, Ctrl-C, … Shift-Ins) 

$

↑

%

↓

&

$

'

&

$'

'

(

((

$

&

Kompilacja (as), konsolidacja (ld) i uruchamianie programu 

(

)

)

*

)

+ , $

*

)

)

(

)

$

-./0/*

'

'&

1

+ , $

11 2

3

&

'

&

11 2

3

&

'

&

11 2

3

&

'

&

11 2

3

&

'

&

(

)

*

*

)

)

(

$

opcja uruchomienia z poziomu kompilatora C++ (etykieta startowa:

 

4

 

– jak w C a nie 

4

)  

(

(

)

*

5 , $

*

)

)%

' '

56

)%

'

78

'

9

'

: ; <==

&

'

>(

tworzenie pliku wsadowego: asemblacja-ł

czenie

  

!

&

'

' '

*

)

'$

&

(

)

) *

)

'$

&

&

(

)

)

$3

& *

$3

& *

$3

& *

$3

& *

'

'

'

&

$3

$

'

&

$

&

'

,

&

?

6

&

'

7

6

$ &

@'

A

! !

B

&

' 5 , $

!

)C

$3

*

$3

*

$3

*

$3

*

@

! '

B

'

'$

&

)

A

)

A

)

A

)

A

&

&6

&

&

&6

$3

&

A

@

B

Laboratorium AK –ATT asembler (Debian LINUX)  

 Janusz Biernat,  

pa dziernik 2007 

2 

Struktura programu w j zyku asemblera ATT (linux-asm  dla x86/Pentium) 

Zapis stałych i znaków specjalnych 

 7 : "">D:E

>D:E

$

3

7

'

7: ;

&

7:A(D

(D

$

A 

"

7: :E:E

:E:E

$

,&

 

"

7:!(FEG =HI(<

(FEG =H AE:

<

$

!

 

 

znaki specjalne  (\ =”escape” – nast

pny znak specjalny) – konwencja UNIX / LINUX 

J

!

/C KK

,

JALL

LL

/C KK

: ; H / ;M

J:

'

J

N

J:A:/

J:E<

J

O/P

J:A:H

J:EE

J

J:A:>

J:E:

J!

MM

!

!

J:A:

J:EG

J

Q

'

J:A:L

J:E=

J;

&

) JJ

J

JB

B

) R' S/N

@

B

S/N

)

S/N T

S/N

)

)

A

U

&

3

'5

S/N

' 7

Dyrektywy organizacyjne 

 )

"

/ I

&

6

'

&

/ I

 )

" )

A

'

'

'

&

6

)

N/PIN

3

)

&

)

4

V4

6

4

4

)

! W!'

&

!'

&

3

&

)

&

)

!

!'

&

)

&

 )

" )

'

&

 )

" )

'!

&

)==%XE  E"

) R' P-M4CKYI

'

'

,

'

EX :::)

)

/LLQ

P-M4CKYI

'&

'&

P-M4CKYI

& ,

3

)

'!

'

&6

' /LLQ

)

'

MKNI

!

&

3

'

')

Rezerwacja bufora w pami



ci (w sekcji danych) 

* )

BZ J B

$ 9 '

,

/C KK

A * )

T

A * )

@J B

.ascii “STRNG” zamienia ka



dy znak ła



cucha (“STRNG”) na bajt kodu ASCII 

*

&

&

'

@

B

)

#

E #

< ;

&

&

& ,

6

)

#

E #

< ;

&

&

G(

&

$,

6

4

T) (

&

&

' @7B

Laboratorium AK –ATT asembler (Debian LINUX)  

 Janusz Biernat,  

pa dziernik 2007 

3 

*

&

'!

3

@

B

)

 num [, fill] 

num – rozmiar w bajtach, fill – opcja: warto



 wypełnienia (domy

lnie 0), 

*)

 

równowa



na dyrektywa:  )

num [, fill] 

)

)

V)

&

&

)

!

)DF%DH  E"

)

Zmienna i jej adres 

# ?

A

@

B

&

'

# ?

A

7

& @

B

&

'

Funkcje standardowe – syscall (linux-asm  dla x86/Pentium)  

!'

&

?

A

* ?

A

?

A

?

A

@ A

A

A

A

B

6

9

'

I[KO T E

!'

&

'

TE

 

#

7 '

?

A"

?

A

'

@

7B

?

>

5

,

#

7I[KO

?

A

'

!'

&

TE

?

A

7:A>:

,

$

!'

&

@

B

!'

&

@

,

&

V

B

COLK

T :

&

'

?

A

QI/L T F

!'

&

&

TF

)

)

'!

&

P-M\Q*

;

&

&

'!

&

P-M4CKYI T)( P-M\Q

)

)

A

'5

!'

&

QI/L

;

#

7P-M4CKYI

?

A

'!

&

7P-M4CKYI

?

A

#

7P-M\Q

?

A

'!

7P-M\Q

?

A

#

7COLK

?

A

&

?

A

COLK T:

#

7QI/L

?

A

!'

&

?

A

TF

7:A>:

@

B

!'

&

@

&

V

B

COL\-O T E

&

?

A

.QKOI T G

!'

&

&

TG

)

)

A

'5

!'

&

.QKOI

;

#

7P-M4CKYI

?

A

'!

&

7P-M4CKYI

?

A

#

7P-M\Q

?

A

'!

7P-M\Q

?

A

#

7COL\-O

?

A

&

?

A

COL\-OTE

#

7.QKOI

?

A

!'

&

?

A

TG

7:A>:

Laboratorium AK –ATT asembler (Debian LINUX)  

 Janusz Biernat,  

pa dziernik 2007 

4 

Najwa niejsze funkcje systemu Linux

O

(E) K

N

'A C

 E"

%eax 

nazwa 

%ebx  

%ecx  

%edx  

Uwagi 

1  exit  

status (int)  

 

 

Zako

czenie programu 

3  read   numer pliku

1) 

adres bufora  

rozmiar bufora  

Odczytuje plik do wskazanego bufora. 

4  write   numer pliku

1) 

adres bufora  

rozmiar bufora  

Zapisuje z bufora do danego pliku. 

5  open   nazwa pliku

2)

  

lista opcji

3)

  

kod zezwole

 

(lub 0666) 

Otwiera plik o podanej nazwie. Zwraca 
numer pliku (w %eax) lub kod bł



du. 

6  close   numer pliku

1) 

 

 

Zamyka plik o danym numerze. 

12  chdir   nazwa katalogu

4)

    

 

Przeł



cza do wskazanego katalogu. 

19  lseek   numer pliku

1) 

tryb wska



nika    

Pozycjonuje wska



nik w pliku. Tryb 

offsetu: 0 – absolutny, 1 – wzgl



dny. 

20  getpid    

 

 

Identyfikator ID bie



cego procesu. 

39  mkdir   nazwa katalogu

4)

   kod zezwole

 

 

Tworzy katalog, zakładaj



c 



e katalogi 

nadrz



dne (

cie



ka) ju



 istniej



. 

40  rmdir   nazwa katalogu

4)

    

 

Usuwa katalog. 

41  dup  

numer pliku

1) 

 

 

Zwraca nowy numer u



ywanego pliku. 

42  pipe   pipe array  

 

 

Tworzy 2 numery pliku, wymuszaj



c 

odczyt do drugiego podczas zapisu do 
pierwszego. 

%ebx 

jest wska



nikiem 

dwóch słów zawieraj



cych te numery. 

45  brk  

adres pułapki 

 

 

Ustanawia pułapk



 (system break) 

(ostatni adres sekcji danych). Je

li 

%ebx

=0, zwraca bie



cy adres pułapki 

1)

 nadawany przez LINUX deskryptor (numer) pliku (file descriptor),    

2)

 pierwsze litery nazwy pliku 

3)

 opcje dost



pu – odczyt / zapis / odczyt i zapis,    

4)

 pierwsze litery nazwy katalogu 

 

Koncepcja pliku w systemie UNIX / LINUX – obsługa plików z poziomu asemblera 

Pliki UNIX /LINUX, niezale



nie od rodzaju i sposobu wytworzenia, s

 dost

pne jako ła



cuch bajtów. 

Dost

p  do  pliku  rozpoczyna  jego  otwarcie  przez  podanie  nazwy.  Wtedy  system  operacyjny  podaje 

(tymczasowy)  numer,  zwany  deskryptorem  pliku  (file  descriptor),  u



ywany  jako  odsyłacz  do  pliku 

podczas jego u



ycia. Po zapisie lub odczycie plik nale



y zamkn



, co uniewa



nia deskryptor.  

 

1. Podaj do systemu Linux nazw

 pliku i 



dany tryb otwarcia (odczyt, zapis, odczyt i zapis, utwórz go 

je



li nie istnieje, itd.). Wykonuje to funkcja 

open

 (

%eax

 = 5), która pobiera nazw

 pliku, kod trybu 

oraz zbiór zezwole



 (permissions set) jako parametry. Adres pierwszego znaku nazwy pliku powinien 

by



 w 

%ebx

. W 

%ecx

 nale



y wpisa



 kod trybu u



ycia (0 dla plików, które b

d

 tylko odczytywane, 

03101 dla plików, które b

d

 zapisywane (! zero wiod

ce jest konieczne). Zbiór zezwole



 ma by



 

wpisany do 

%edx

. Je



li nie znasz kodów zezwole



 UNIX / LINUX, wpisz kod 0666 (! zero wiod

ce 

jest konieczne – patrz [1: 

rozdział 10, sekcja Truth, Falsehood, and Binary Numbers]

. 

2. LINUX zwróci w 

%eax

 deskryptor pliku (file descriptor), który jest odsyłaczem do tego pliku.  

3. Teraz mo



na wykona



 funkcje read (

%eax

 = 3), write (

%eax

 = 4), wpisuj

c deskryptor pliku do 

%ebx

, adres bufora danych do 

%ecx

, rozmiar bufora do 

%edx

. Funkcja (

read / write) 

zwróci (w 

%eax)

 liczb

 znaków przeczytanych z pliku, albo kod bł

du (error code), który jest liczb

 ujemn

.  

4. Po zako



czeniu operacji plik nale



y zamkn



 za pomoc

 funkcji 

close

 (

%eax

 = 6), której jedynym 

parametrem jest deskryptor pliku (w 

%ebx

). Deskryptor jest odt

d uniewa



niony. 

 

Na  stronie 

http://www.lxhp.in-berlin.de/lhpsyscal.html

  zamieszczono  prawie  kompletn

  list

  funkcji 

systemu  wraz  z  dodatkowymi  informacjami.  Wi

cej informacji mo



na te



 uzyska



 z manuala, pisz

c: 

man  2  SYSCALLNAME

, co zwróci informacje o funkcjach systemowych z cz



ci 2 UNIX manual. S

 

tam jednak



e odwołania do wywoła



 funkcji z poziomu jezyka C.  

Laboratorium AK –ATT asembler (Debian LINUX)  

 Janusz Biernat,  

pa dziernik 2007 

5 

Informacje  o  Linux-owej  implementacji  funkcji:  Linux  Kernel  2.4  Internals  (section  on  how  system 
calls are implemented) na stronie 

http://www.faqs.org/docs/kernel_2_4/lki-2.html#ss2.11

 . 

Kod ASCII, który zawiera tylko znaki alfabetu łaci



skiego (angielskiego), jest wypierany przez 

standard Unicode. UTF-8 jest cz



ciowo kompatybilny z ASCII (zgodno





 dla znaków angielskich, 

rozszerzenia wielobajtowe dla innych. UTF-32 wymaga zawsze 4 bajtów na znak. Windows® u



ywa 

UTF-16, który jest kodem o zmiennej długo



ci (co najmniej 2 bajty na znak), nie jest wi

c zgodny z 

ASCII (znaki angielskie poprzedza bajt zerowy). Dobrym podr

cznikiem Unicode jest: Joe Spolsky, 

"The Absolute Minimum Every Software Developer Absolutely, Positively Must Know About Unicode 
and Character Sets (No Excuses!)" (

http://www.joelonsoftware.com/articles/Unicode.html

.)  

 

Odwzorowanie programu, danych i stosu w pami

ci [1] 

Ka



da sekcja jest ładowana do osobnego obszaru w pami

ci (pocz

tek bloku: adres 0x BFFF FFFF).  

 

Zmienne 



rodowiskowe (environment variables) 

 

0x BFFF FFFF  

… 

 

 

Arg 2 

 

 

Arg 1 

 

 

Nazwa programu (program name) 

 

 

Liczba argumentów (# of arguments) 

%esp 

 

Pami



 dost



pna dla programu (Unmapped memory)   

 

Kod i dane programu (Program Code and Data) 

break 

0x 0804 8000 

 

Kody instrukcji (

.section .text

) s

 ładowane pocz

wszy od adresu 0x08048000, kody danych 

(

.section .data

) bezpo



rednio po nich, a nast

pnie bufor dynamiczny (

.section .bss

). Ostatni 

bajt nie mo



e by



 wy



ej ni



 w lokacji 0xBFFFFFFF. W tym miejscu Linux zaczyna tworzy



 swój stos, 

który jest rozbudowywany w kierunku adresów rosn

cych, a



 do swej kolejnej sekcji.  

 

Pomi

dzy nimi jest olbrzymi obszar wolny. Pocz

tkowo na dnie stosu (the bottom of the stack), 

którego adres jest najwy



szy (the top address of memory) jest umieszczone tzw. słowo zerowe 

(wszystkie bity s

 zerami). Po nim nast

puje zako



czona zerem (the null-terminated) nazwa programu 

w kodzie ASCII, a po niej zmienne 



rodowiskowe programu (program’s environment variables). Dalej 

umieszczone s

 argumenty wywołania (command-line arguments), czyli parametry (warto



ci) wpisane 

do linii polecenia podczas wywołania programu. Na przykład, gdy uruchamiamy 

as

, podajemy jako 

argumenty: 

as

, 

sourcefile.s

, 

-o

 i 

objectfile.o

. Po nich nast

puj

 u



ywane argumenty, które s

 

umieszczoane na pocz

tku bloku stosu wskazanego przez wska



nik stosu (stack pointer) 

%esp

. Kolejne 

operacje na stosie zmieniaj

 ten wska



nik – składowanie zmniejsza 

%esp

.  

 

Obszar danych programu rozpoczyna si

 na dnie pami

ci (the bottom of memory) i jest budowany 

wzwy



 (kolejne lokacje maj

 coraz wy



sze adresy). Stos rozpoczyna si

 na szczycie pami

ci (the top 

of memory) i jest rozbudowywany w dół (w kierunku adresów malej

cych) po ka



dym składowaniu 

instrukcj

 

push

. Obszar pomi

dzy stosem a obszarem danych jest z zasady niedost

pny z poziomu 

programu. Próba dost

pu (u



ycie adresu z tego obszaru) ko



czy si

 sygnalizacj

 bł

du , zwykle jako 

"segmentation fault". To samo zdarzy si

 podczas próby zaadresowania obszaru poni



ej adresu  

0x08048000. Ten najni



szy dost

pny adres jest nazywany system break (albo [current] break). 

Dost

p do obszaru zakazanego, z ograniczeniami wynikaj

cymi ze struktury systemu operacyjnego) 

mo



na uzyska



 za pomoc

 komunikatu przekazanego funkcjom j

dra (kernel) systemu operacyjnego. 

 

UWAGA: podobne, ale nie równowa



ne działanie (pushl i popl s

 nierozdzielne wobec przerwania) 

Instrukcja 

pushl %eax 

nie jest równowa



na 

movl %eax, (%esp); subl $4, %esp

, a instrukcja  

popl %eax 

nie jest równowa



na  

movl (%esp), %eax; addl $4, %esp. 

Laboratorium AK –ATT asembler (Debian LINUX)  

 Janusz Biernat,  

pa dziernik 2007 

6 

U ycie debuggera gdb (linux-asm  dla x86/Pentium)  

B

B

!

'

'

((

(

)

)

&

((

)

(

)

$

(

)

&

)

'

5

)%

)%

' '

'

6

'

&3

&

 

" A

'

'$

&

' A

A

T

V

V

4!'

&

A

'$

&

' A

A

;

'$

&

' A

;

'

A

;

'$

&

' A

;

'

'

,

'$

&

'

 ' "

' '

$

'

'

;

(

&

'&

3

&

3

'

* @C

;B

@2

#

CK0K O

K

'

)B

 

"

.

*

4

'

&

&3

  A "

!'

&

&

&

'

& 1

! 

"

&

&

%

!

7

&

?

7

1

!

!

*

3

A

,

!

A%

!

&

3

&

,$ $

$

' $

!

!

&

5 &

5

T

'

&

TE

T

5

6

%

!

7

&

5

&

'$

%

,

3

'

$ 9 '

/C KK

!  "

!

&

*

&

3

!  "

!

&

&

!  "

!

&

'

'$

 

"

'

 

"

9

'

'

 

]

R'

&

'

'

Laboratorium AK –ATT asembler (Debian LINUX)  

 Janusz Biernat,  

pa dziernik 2007 

7 

U ycie edytora vi / vim [3] 

#

#

#

#

 nazwa pliku   lub  

#

#

#

#

   

(

mcedit

 – nakładka na 

#

#

#

#

), 

#

#

#

#

 – wersja rozszerzona 

#

#

#

#

 

tryby pracy: 

(1) edycja tekstu (tryb edycji) 

(2) przyjmowanie polece

 z klawiatury (tryb komend) – tryb startowy 

(3) edycja własnego wiersza polece

 

 

vi [Enter] 

→

 (2) [a] (doł



cz) / [i] (wstaw) / [o] (wstaw powy



ej) /… 

→

 (1) … … (1) [Esc] 

→

 (2)   

(2) [Esc] 

→

 „beep” 

→

 (2) – bez efektu, sygnał d



wi



kowy bł



dnej sekwencji 

(po kilku [Esc] zawsze przej



cie do (2) i wtedy trzeba albo do (1) albo do (3)0 

(2) [:] / [/] / [?]

→

 (3) – przej



cie do edycji wiersza polece

 

(3) [Esc] [Enter] 

→

 (2) – powrót do trybu wprowadzania polece

  

(3) :q!, [enter] = quit  (zako

cz i wró



 do systemu) 

(3) :wq!, [enter] = write and quit  (zapisz zmiany, zako

cz i wró



 do systemu) 

 

Tryb polece



 – manewrowanie kursorem 

[l] – 

→

1

 (1 znak w prawo, tak



e [space])  

[h] – 

←

1

 (1 znak w lewo, tak



e [backspace]) 

[j] /  – 

↓

1

 (1 linia w dół) /  

[k] – 

↑

1

 (1 linia w gór



) 

[-] – 

←←↑

1

 (pocz



tek wiersza, linia w gór



)  

[+] – 

←←↓

1

 (pocz



tek wiersza, linia w dół = 

↵

↵↵

↵

 ) 

[0] – 

←←

 (pocz



tek wiersza)  

[$] – 

→→

 (koniec wiersza) 

[w] – pocz



tek kolejnego słowa  

[b] – najbli



szy pocz



tek słowa  

 [Ctrl+f] / [Ctrl+d] – ekran / pół ekranu w dół 

[Ctrl+b] / [Ctrl+u] – ekran / pół ekranu w gór



 

#[G] – pocz



tek wiersza o numerze #;   1[G] – pocz



tek pliku,   [G] – koniec pliku 

[H] – pocz



tek bie

 

cego ekranu  

[F1] – ekran pomocy; wyj



cie:   :q 

Edycja polece



 

:r plik – wstaw (czytaj) plik 

/wzorzec – szukaj wzorca w dół (w prawo) 

?wzorzec  – szukaj wzorca w gór



 (w lewo) 

:q! – quit bezwarunkowo, bez zapisu zmian 

:q – quit warunkowo, po zapisie zmian 

:w plik – write, zapisz do pliku 

:wq – write & quit, zapisz do aktualnego pliku i zako

cz  (tak



e :x) 

:help – wezwanie pomocy; wyj



cie z help przez :q 

Laboratorium AK –ATT asembler (Debian LINUX)  

 Janusz Biernat,  

pa dziernik 2007 

8 

Edycja tekstu 

[i] – insert, wstaw przed kursorem  

[a] – append, wstaw za kursorem  

[I] –  wstaw od pocz



tku wiersza 

[A] –  wstaw na ko

cu wiersza 

[x] – usu

 znak na pozycji kursora (extract)  

[X] – usu

 znak na pozycji przed kursorem 

[d..] – delete, usu

 … 

 

[dd] – usu

 cały wiersz 

 

[d0] – usu

 od pocz



tku wiersza do kursora 

 

[d$] – usu

 od kursora do ko

ca wiersza (tak



e [D] 

 

[dw] – usu

 słowo wskazane przez kursor 

[r] – replace, nadpisz znak na pozycji kursora 

[R] – Replace, nadpisz tekst od pozycji kursora 

[y..] – copy, kopiuj … 

 

[yy] – kopiuj aktualny wiersz do bufora 

 

[y0] – kopiuj od pocz



tku wiersza do kursora 

 

[y$] – kopiuj od kursora do ko

ca wiersza 

 

[yw] – kopiuj słowo wskazane przez kursor 

[c..] – change, zamie

 … 

 

[cc] – zamie

 aktualny wiersz (tak



e [ddI]) 

 

[c0] – zamie

 od pocz



tku wiersza do kursora (tak



e [d0i]) 

 

[c$] – zamie

 od kursora do ko

ca wiersza (tak



e [d$i]) 

 

[cw] – zamie

 słowo wskazane przez kursor (tak



e [dwi]) 

[J] – join, poł



cz wiersze (usu

 znak NewLine)… 

 

[dd] – usu

 cały wiersz 

[o] / [O] –  wstaw wiersz poni



ej / powy



ej 

[p] – paste, wstaw zawarto





 bufora za kursorem lub do kolejnego wiersza 

[P] – Paste, wstaw zawarto





 bufora przed kursorem lub do poprzedniego wiersza 

[u] – undo, anuluj 

[”] – odwołanie do konkretnego bufora 

[n] / [N] – powtórz ostatnie wyszukiwanie w tym samym / przeciwnym kierunku 

ZZ -  ??? co to jest?, chyba quit  

Laboratorium AK –ATT asembler (Debian LINUX)  

 Janusz Biernat,  

pa dziernik 2007 

9 

Przykładowe programy 

Szukanie maksimum [1] 

2-Q2\CI* O

!

A

'

'

!

!

)

?

( Z

A

!

A

?

A ( N

! '

?

A (

'

O

!

'

*

4

(

) / :

'

)

)

4

*

O

)

F XD FG <<< G= D= =G FG GG FF << EE XX :

)

)

A

)

4

4

*

#

7:

?

#

:

A

#

4

?

G

?

A

!

!

#

?

A

?

A

!

?

A

4

*

7:

?

A

!

^#

&

4 A

?

A

#

'

#

4

?

G

?

A

?

A

?

A

#

'

&

4

&'

!

^

#

?

A

?

A

#

#

'

&

4

&'

4 A

*

?

A

'

!

A

A

'

'

#

7E

?

A

E

A

7:A>:

Kompilacja i konsolidacja (Now, assemble and link it with these commands): 

A

' )

(

A

' )

A

' )

(

A

'

Uruchomienie i sprawdzenie statusu (Now run it, and check it’s status). 

)%

A

'

)% (

56

78

Laboratorium AK –ATT asembler (Debian LINUX)  

 Janusz Biernat,  

pa dziernik 2007 

10 

Funkcja silnia (ang. factorial) i liczenie kombinacji  - bez rekurencji 

arg = 5 

# argument silni 

.text 
.globl _start 
_start: 
movl $arg, %eax 
 
factorial: 
pushl %ebp  

#standard function stuff - we have to 

 

#restore %ebp to its prior state before 

 

#returning, so we have to push it 

movl %esp, %ebp  

#This is because we don’t want to modify 

 

#the stack pointer, so we use %ebp. 

movl 8(%ebp), %eax  

#This moves the first argument to %eax 

 

#4(%ebp) holds the return address, and 

 

#8(%ebp) holds the first parameter 

cmpl $1, %eax  

# koniec rekurencji, gdy argument=1 

 

#If the number is 1, that is our base 

 

#case, and we simply return (1 is 

 

#already in %eax as the return value) 

je end_factorial 
decl %eax  

#otherwise, decrease the value 

 
pushl %eax  

#push it for our call to factorial 

call factorial  

#call factorial 

 
movl 8(%ebp), %ebx  

#%eax has the return value, so we 

 

#reload our parameter into %ebx 

mull %ebx, %eax  

# multiply that by the result of the last 

 

# call to factorial (in %eax) 

 

#the answer is stored in %eax, which is good 

 

# since that’s where return values go. 

 
end_factorial: 
movl %ebp, %esp  

#standard function return stuff - we 

popl %ebp  

#have to restore %ebp and %esp to where 

 

#they were before the function started 

ret  

#return to the function (this pops the 

 

#return value, too) 

 
movl %eax, %ebx  

# wynik jako status (w %bl) 

movl $1, %eax  

# funkcja „exit”  

int $0x80 
 
 

Laboratorium AK –ATT asembler (Debian LINUX)  

 Janusz Biernat,  

pa dziernik 2007 

11 

Funkcja rekurencyjna (silnia , ang. factorial) 

arg = 5 

# argument silni 

.text 
.globl _start 
.globl factorial  

#zb dne, gdy funkcja nie jest eksportowana 

_start: 
movl $arg, %eax 
 
pushl %eax  

# argument na stos 

call factorial  

# wywołanie funkcji factorial, wynik w %eax 

nxt_adr:

 

addl $4, %esp  

# „oczyszczenie” stosu – zdj cie argumentu 

 

# 

Scrubs the parameter that was pushed on the stack

 

movl %eax, %ebx  

# wynik jako status (w %bl) 

movl $1, %eax  

# funkcja „exit”  

int $0x80 
 
 

# definicja funkcji 

.type factorial,@function 
factorial: 
pushl %ebp  

#standard function stuff - we have to 

 

#restore %ebp to its prior state before 

 

#returning, so we have to push it 

movl %esp, %ebp  

#This is because we don’t want to modify 

 

#the stack pointer, so we use %ebp. 

movl 8(%ebp), %eax  

#This moves the first argument to %eax 

 

#4(%ebp) holds the return address, and 

 

#8(%ebp) holds the first parameter 

cmpl $1, %eax  

# koniec rekurencji, gdy argument=1 

 

#If the number is 1, that is our base 

 

#case, and we simply return (1 is 

 

#already in %eax as the return value) 

je end_factorial 
decl %eax  

#otherwise, decrease the value 

 
pushl %eax  

#push it for our call to factorial 

call factorial  

#call factorial 

 
movl 8(%ebp), %ebx  

#%eax has the return value, so we 

 

#reload our parameter into %ebx 

mull %ebx, %eax  

# multiply that by the result of the last 

 

# call to factorial (in %eax) 

 

#the answer is stored in %eax, which is good 

 

# since that’s where return values go. 

 
end_factorial: 
movl %ebp, %esp  

#standard function return stuff - we 

popl %ebp  

#have to restore %ebp and %esp to where 

 

#they were before the function started 

ret  

#return to the function (this pops the 

 

#return value, too) 

 

Laboratorium AK –ATT asembler (Debian LINUX)  

 Janusz Biernat,  

pa dziernik 2007 

12 

Obliczanie kombinacji (przerobiona silnia) 

.text 
.globl _start 
.globl factorial  

#zb dne, gdy funkcja nie jest eksportowana 

_start: 
movl $argn, %eax 

# argn = argument n – liczba elementów 

movl $1, %ecx 

# liczenie od 1 do argk (liczba wybieranych) 

 
pushl %eax  

# argument n na stos 

(malej

cy do n-k+1)

 

pushl %ecx  

# argument 1 na stos (rosn

cy a



 do k) 

call 

combination

  

# wywołanie funkcji 

combination

, wynik w %eax 

nxt_adr:

 

addl $4, %esp  

# „oczyszczenie” stosu – zdj cie argumentu 

 

# 

Scrubs the parameter that was pushed on the stack

 

movl %eax, %ebx  

# wynik jako status (w %bl) 

movl $1, %eax  

# funkcja „exit”  

int $0x80 
 
.type 

combination

,@function   # definicja funkcji 

factorial: 
pushl %ebp  

#standard function stuff - we have to 

 

#restore %ebp to its prior state before 

 

#returning, so we have to push it 

movl %esp, %ebp  

#This is because we don’t want to modify 

 

#the stack pointer, so we use %ebp. 

movl 8(%ebp), %eax  

#This moves the first argument to %eax 

 

#4(%ebp) holds the return address, and 

 

#8(%ebp) holds the first parameter 

cmpl $argk, %ecx  

# koniec rekurencji, gdy argument2 =argk 

 

#If the number is 1, that is our base 

 

#case, and we simply return (1 is 

 

#already in %eax as the return value) 

je end_combine 

# je



li %ecx=argk, b dzie ostatnie dzielenie  

decl %eax  

#otherwise, decrease the value 

incl %ecx  

# increase the value of denominator 

 
pushl %eax  

#push it for our call to factorial 

pushl %ecx  

#push it for our call to factorial 

call 

combination

  

 

movl 8(%ebp), %ecx  

#%ecx has the return value,  

movl 12(%ebp), %ebx   #reload into %ebx since %eax has the return value 

mull %ebx, %eax  

# multiply that by the result of the last 

divl %ecx, %eax

 

# call to factorial (in %eax) 

 

#the answer is stored in %eax, which is good 

 

# since that’s where return values go. 

end_combine

: 

movl %ebp, %esp  

#standard function return stuff - we 

popl %ebp  

#have to restore %ebp and %esp to where 

 

#they were before the function started 

ret  

#return to the function and pop the return value,  

 

Laboratorium AK –ATT asembler (Debian LINUX)  

 Janusz Biernat,  

pa dziernik 2007 

13 

Funkcja rekurencyjna – zagnie d anie (budowa stosu) 

 

stos 

 

  komentarz 

pushl %eax 

 

 

  # argument (eax) na stos 

 

%eax 

esp:=esp-4 

  # 

 

 

„old” 

esp 

  # 

 

 

 

 

  # 

 

call factorial 

nxt_adr  esp:=esp-4 

  # wywołanie, zło

enie adresu 

 

nxt_adr: 

%eax 

esp 

  # 

 

(addl $4, %esp, …)  

„old” 

 

  # 

 

 

 

 

  # 

 

 

 

 

  # 

 

factorial: 

 

 

  # 

 

pushl %ebp  

%ebp 

esp':=esp-4 

  # 

 

 

nxt_adr 

(=esp'+4)    # 

 

 

%eax 

(=esp'+8)    # 

 

 

„old” 

 

  # 

 

movl %esp, %ebp  

 

ebp':=esp’    # 

 

movl 8(%ebp), %eax  

 

eax:=[esp’+8]    # zło

ony argument (eax) 

 

 

 

 

  # ze stosu do eax

 

cmpl $1, %eax  

 

 

  # 

 

je end_factorial 

 

 

  # je



li eax=1, koniec rekurencji

 

 

 

 

  # 

 

decl %eax  

 

 

  # zmniejszanie eax

 

pushl %eax  

 

 

  # kolejny poziom rekurencji

 

call factorial  

%ebp’ 

esp":=esp’-4 

 

 

pushl %ebp 

nx_ad 

(=esp”+4)    # zmniejszony argument na stos

 

 

%eax 

(=esp”+8)    # wywołanie, zło

enie adresu

 

 

%ebp 

esp' 

  # 

 

 

nxt_adr 

esp (=esp'+4)    # 

 

 

%eax 

(=esp'+8)    # 

 

 

„old” 

 

  # 

 

movl %esp, %ebp  

 

ebp":=esp”    # 

 

movl 8(%ebp), %eax  

 

eax:=[esp”+8]    # zło

ony argument (eax) 

 

 

 

 

  # ze stosu do eax

 

cmpl $1, %eax  

 

 

  # 

 

je end_factorial 

 

 

  # je



li eax=1, koniec rekurencji

 

 

 

 

  # 

 

 

 

 

 

 

decl %eax  

 

 

  # zmniejszanie eax

 

pushl %eax  

%ebp” 

esp*:=esp”-4 

  # kolejny poziom rekurencji

 

call factorial  

nx_ad 

(=esp”+4)    # 

 

pushl %ebp 

%eax” 

(=esp”+8)    # (eax = 1)

 

 

%ebp’ 

esp":=esp’-4 

  # 

 

 

nx_ad 

(=esp”+4)    # 

 

 

%eax’ 

(=esp”+8)    # (eax = 2)

 

 

%ebp 

esp' 

  # 

 

 

nxt_adr 

esp (=esp'+4)    # 

 

 

%eax 

(=esp'+8)    # (eax = 3)

 

 

„old” 

    # 

 

movl %esp, %ebp  

 

ebp:=esp*    # 

 

movl 8(%ebp), %eax 

 

eax:=[esp*+8]    # 

 

 

 

 

  # 

 

cmpl $1, %eax  

 

 

  # eax=1

 

je end_factorial 

 

 

  # skocz, bo eax = 1

 

 

 

 

  # sekwencja powrotów

 

 

Laboratorium AK –ATT asembler (Debian LINUX)  

 Janusz Biernat,  

pa dziernik 2007 

14 

Funkcja rekurencyjna – powroty (zwalnianie stosu) 

nx_ad: 

%ebp” 

esp* 

  # omini te

 

movl 8(%ebp), %ebx  

nx_ad 

 

  # omini te

 

 

%eax” 

[ebp+8]

→

 ebx 

  # omini te

 

mull %ebx, %eax  

%ebp’ 

 

  # omini te

 

 

nx_ad 

 

  # 

 

 

%eax’ 

 

  # 

 

 

%ebp 

 

  # 

 

 

nxt_adr   

  # 

 

 

%eax 

 

  # wyj



cie z zagnie

d

enia

 

 

„old” 

 

  # 

 

end_factorial: 

 

(ebp = esp*) 

  # 

 

movl %ebp, %esp 

 

 

  # 

 

 

%eax” 

 

  # 

 

popl %ebp  

%ebp’ 

esp” 

  # 

 

ret  

nx_ad 

 

  # 

 

 

%eax’ 

[ebp+8]

→

 ebx 

  # 

 

 

%ebp 

 

  # 

 

 

nxt_adr   

  # 

 

 

%eax 

 

  # 

 

nx_ad: 

„old” 

 

  # kolejne argumenty ze stosu

 

movl 8(%ebp), %ebx  

 

 

  # kolejny mno

nik

 

mull %ebx, %eax  

 

 

  # wymnó

 przez poprzedni iloczyn

 

 

 

 

  # 

 

end_factorial: 

 

 

  # 

 

movl %ebp, %esp  

 

 

  # 

 

popl %ebp  

%eax” 

 

  # 

 

 

%ebp 

esp' 

  # 

 

ret  

nxt_adr   

  # 

 

 

%eax 

[ebp+8]

→

 ebx 

  # 

 

 

„old” 

 

  # 

 

nx_ad: 

 

 

  # 

 

movl 8(%ebp), %ebx  

 

 

  # kolejny mno

nik

 

mull %ebx, %eax  

 

 

  # wymnó

 przez poprzedni iloczyn

 

 

 

 

  # 

 

end_factorial: 

 

 

  # 

 

movl %ebp, %esp  

 

 

  # 

 

popl %ebp  

 

 

  # 

 

 

%eax 

esp 

  # 

 

ret  

„old” 

 

  # 

 

 

 

 

  # 

 

nxt_adr: 

 

 

  # 

 

(addl $4, %esp, …)  

„old” 

esp 

  # przywrócony  

 

 

 

  # stan pocz

tkowy stosu 

 

 

 

   

 

Literatura 

[1]  Programming from the Ground Up . (www….) 

[2]  J. Biernat, Architektura komputerów, Oficyna Wyd. PWr, Wrocław, 2005 (wyd. IV)  

[3]  L. Madeja, 



wiczenia z systemu Linux, MIKOM, 1999 (rozdz. 4). 

[4]  D. Elsner, J. Fenlason & friends, Using as. The GNU assembler, Free Software Foundation Inc., 

1994, (www….)