{"id":589,"date":"2026-09-24T18:47:48","date_gmt":"2026-09-24T18:47:48","guid":{"rendered":"https:\/\/d-mashina.net\/?p=589"},"modified":"2026-09-24T18:47:48","modified_gmt":"2026-09-24T18:47:48","slug":"nazaj-k-osnovam-nasm-linux-in-asembler","status":"publish","type":"post","link":"https:\/\/d-mashina.net\/index.php\/2026\/09\/24\/nazaj-k-osnovam-nasm-linux-in-asembler\/","title":{"rendered":"Nazaj k osnovam: NASM, Linux in asembler"},"content":{"rendered":"

Z asemblerjem sem se prvi\u010d sre\u010dal \u017ee na fakulteti. Takrat svet ra\u010dunalni\u0161tva ni bil videti tako kot danes. Delali smo na ra\u010dunalnikih DEC VAX<\/strong>, kjer je bil pogled na procesor, registre in pomnilnik precej bolj neposreden kot pri dana\u0161njem razvoju programske opreme.<\/p>\n

Od takrat je minilo kar nekaj \u010dasa. Vmes so pri\u0161li Linux, stre\u017eniki, virtualizacija, kontejnerji, Kubernetes in ne\u0161teto programskih jezikov ter orodij, ki razvijalca ali sistemskega administratorja precej oddaljijo od samega procesorja.<\/p>\n

Pred kratkim pa sem se ponovno lotil asemblerja. Tokrat na precej bolj doma\u010dem okolju: Intel x86-64 in Linux<\/strong>, z uporabo assemblerja NASM<\/strong>.<\/p>\n

In presenetljivo \u2014 \u0161e vedno je zabavno.<\/p>\n

Zakaj sploh asembler?<\/h3>\n

Danes skoraj nih\u010de ne pi\u0161e celotnih aplikacij v asemblerju. Za ve\u010dino stvari imamo C, C++, Rust, Go, Python in celo vrsto drugih jezikov.<\/p>\n

Toda asembler ima \u0161e vedno posebno vrednost.<\/p>\n

Ko pi\u0161emo program v Pythonu, na primer:<\/p>\n

print(\"Hello world\")<\/code><\/pre>\n
se med na\u0161o vrstico kode in procesorjem zgodi ogromno stvari.<\/p>\n
Pri asemblerju smo precej bli\u017eje procesorju. Ukvarjamo se neposredno z:<\/p>\n
    \n
  • registri,<\/li>\n
  • pomnilnikom,<\/li>\n
  • skladom,<\/li>\n
  • naslovi,<\/li>\n
  • procesorskimi ukazi,<\/li>\n
  • sistemskimi klici operacijskega sistema.<\/li>\n<\/ul>\n
    Prav zaradi tega je asembler odli\u010den na\u010din za razumevanje, kaj ra\u010dunalnik dejansko po\u010dne pod pokrovom<\/strong>.<\/p>\n
    NASM<\/h3>\n
    Za eksperimentiranje sem uporabil NASM \u2013 Netwide Assembler<\/strong>.<\/p>\n
    Na Debianu oziroma Ubuntuju ga namestimo zelo preprosto:<\/p>\n
    sudo apt install nasm<\/code><\/pre>\n
    Na distribucijah iz dru\u017eine Red Hat oziroma Oracle Linux:<\/p>\n
    sudo dnf install nasm<\/code><\/pre>\n
    NASM uporablja Intelovo sintakso, ki mi je tudi osebno nekoliko bolj pregledna od AT&T sintakse, ki jo pogosto sre\u010damo pri GNU assemblerju.<\/p>\n
    Prvi program<\/h3>\n
    Klasi\u010dnega Hello World<\/code> se seveda ne da presko\u010diti.<\/p>\n
    Datoteka hello.asm<\/code>:<\/p>\n
    section .data\r\n    message db \"Hello from assembler!\", 10\r\n    message_len equ $ - message\r\n\r\nsection .text\r\n    global _start\r\n\r\n_start:\r\n\r\n    mov rax, 1\r\n    mov rdi, 1\r\n    mov rsi, message\r\n    mov rdx, message_len\r\n    syscall\r\n\r\n    mov rax, 60\r\n    xor rdi, rdi\r\n    syscall<\/code><\/pre>\n
    Program prevedemo z NASM:<\/p>\n
    nasm -f elf64 hello.asm -o hello.o<\/code><\/pre>\n
    Nato ga pove\u017eemo:<\/p>\n
    ld hello.o -o hello<\/code><\/pre>\n
    in po\u017eenemo:<\/p>\n
    .\/hello<\/code><\/pre>\n
    Rezultat:<\/p>\n
    Hello from assembler!<\/code><\/pre>\n
    Na prvi pogled je za nekaj, kar bi v Pythonu napisali v eni sami vrstici, potrebnega absurdno veliko dela.<\/p>\n
    Toda prav v tem je \u010dar.<\/p>\n
    Kaj se pravzaprav dogaja?<\/h3>\n
    Na 64-bitnem Linuxu se za sistemske klice uporabljajo registri procesorja.<\/p>\n
    Pri:<\/p>\n
    mov rax, 1<\/code><\/pre>\n
    v register RAX<\/code> zapi\u0161emo \u0161tevilko sistemskega klica write<\/code>.<\/p>\n
    Nato pripravimo argumente:<\/p>\n
    mov rdi, 1<\/code><\/pre>\n
    RDI<\/code> vsebuje file descriptor. Vrednost 1<\/code> pomeni standardni izhod oziroma stdout<\/code>.<\/p>\n
    mov rsi, message<\/code><\/pre>\n
    RSI<\/code> ka\u017ee na naslov podatkov, ki jih \u017eelimo izpisati.<\/p>\n
    mov rdx, message_len<\/code><\/pre>\n
    RDX<\/code> vsebuje dol\u017eino podatkov.<\/p>\n
    Ko izvedemo:<\/p>\n
    syscall<\/code><\/pre>\n
    procesor preda izvajanje jedru Linuxa.<\/p>\n
    Jedro nato izvede sistemski klic write()<\/code>.<\/p>\n
    \u010ce bi isto stvar napisali v jeziku C, bi bila videti pribli\u017eno tako:<\/p>\n
    write(1, message, message_len);<\/code><\/pre>\n
    Asembler nam tako poka\u017ee precej neposredno povezavo med uporabni\u0161kim programom in Linux jedrom.<\/p>\n
    Registri<\/h3>\n
    Pri x86-64 hitro ponovno naletimo na stare znance:<\/p>\n
    RAX\r\nRBX\r\nRCX\r\nRDX\r\nRSI\r\nRDI\r\nRSP\r\nRBP<\/code><\/pre>\n
    poleg njih pa \u0161e:<\/p>\n
    R8\r\nR9\r\nR10\r\nR11\r\nR12\r\nR13\r\nR14\r\nR15<\/code><\/pre>\n
    Registri so izjemno hiter pomnilnik neposredno v procesorju.<\/p>\n
    \u010ce prihajamo iz vi\u0161jenivojskih programskih jezikov, kjer ves \u010das delamo s spremenljivkami, objekti in strukturami, je delo z nekaj registri sprva skoraj nenavadno omejujo\u010de.<\/p>\n
    Toda kmalu za\u010dne\u0161 druga\u010de gledati na program.<\/p>\n
    Namesto:<\/p>\n
    Kaj naj naredi ta funkcija?<\/p><\/blockquote>\n
    za\u010dne\u0161 razmi\u0161ljati:<\/p>\n
    Kateri podatek je trenutno v katerem registru?<\/p><\/blockquote>\n
    In to je precej druga\u010den pogled na ra\u010dunalni\u0161tvo.<\/p>\n
    Linux je za tak\u0161ne poskuse idealno okolje<\/h3>\n
    Ena od stvari, ki mi je pri Linuxu vedno v\u0161e\u010d, je, da ti sistema ne skriva.<\/p>\n
    Program lahko po\u017eenemo skozi:<\/p>\n
    strace .\/hello<\/code><\/pre>\n
    in vidimo sistemske klice:<\/p>\n
    write(1, \"Hello from assembler!\\n\", 22) = 22\r\nexit(0)<\/code><\/pre>\n
    To je pravzaprav natanko tisto, kar smo napisali v asemblerju.<\/p>\n
    Program lahko odpremo tudi z:<\/p>\n
    objdump -d hello<\/code><\/pre>\n
    ali:<\/p>\n
    readelf -a hello<\/code><\/pre>\n
    in pogledamo, kako je sestavljena ELF datoteka.<\/p>\n
    Za \u0161e globlji pogled pa lahko uporabimo debugger:<\/p>\n
    gdb .\/hello<\/code><\/pre>\n
    ter izvajamo program ukaz za ukazom in opazujemo registre.<\/p>\n
    Na primer:<\/p>\n
    info registers<\/code><\/pre>\n
    Nenadoma stvari, ki jih obi\u010dajno jemljemo za samoumevne, postanejo zelo konkretne.<\/p>\n
    Od DEC VAX do x86-64<\/h3>\n
    Ko sem se prvi\u010d u\u010dil asemblerja na sistemih DEC VAX<\/strong>, je bila ra\u010dunalni\u0161ka arhitektura precej druga\u010dna.<\/p>\n
    VAX je predstavljal filozofijo procesorjev CISC \u2013 Complex Instruction Set Computer. Procesor je imel zelo bogat nabor ukazov, nekateri ukazi pa so lahko izvajali precej kompleksne operacije.<\/p>\n
    Dana\u0161nji x86-64 je zgodovinsko prav tako CISC arhitektura, \u010deprav sodobni Intelovi in AMD-jevi procesorji interno delujejo bistveno bolj kompleksno. Ukaze x86 procesor praviloma razbije v preprostej\u0161e mikrooperacije, ki jih nato izvaja moderno procesorsko jedro.<\/p>\n
    Kljub desetletjem razvoja pa osnovna ideja ostaja enaka.<\/p>\n
    Imamo podatke.<\/p>\n
    Imamo registre.<\/p>\n
    Imamo pomnilnik.<\/p>\n
    In imamo ukaze, ki podatke premikajo ter nad njimi izvajajo operacije.<\/p>\n
    MOV je kralj<\/h3>\n
    Pri ponovnem u\u010denju asemblerja hitro dobi\u0161 ob\u010dutek, da polovico programa sestavljajo ukazi:<\/p>\n
    mov<\/code><\/pre>\n
    Premakni nekaj v register.<\/p>\n
    Premakni nekaj iz registra.<\/p>\n
    Premakni naslov.<\/p>\n
    Pripravi argument.<\/p>\n
    Shrani rezultat.<\/p>\n
    Seveda obstajajo \u0161e:<\/p>\n
    add\r\nsub\r\ninc\r\ndec\r\ncmp\r\njmp\r\ncall\r\nret\r\npush\r\npop<\/code><\/pre>\n
    in \u0161e ogromno drugih ukazov.<\/p>\n
    Toda presenetljivo veliko dela je preprosto premikanje podatkov na pravo mesto.<\/p>\n
    Kaj ti asembler da danes?<\/h3>\n
    Verjetno ne bom naslednje spletne aplikacije napisal v NASM-u.<\/p>\n
    Tudi ve\u010dine administratorskih orodij zagotovo ne.<\/p>\n
    Toda nekaj ur dela z asemblerjem zelo hitro osve\u017ei razumevanje \u0161tevilnih stvari, ki jih pri vsakodnevnem delu z Linuxom sre\u010dujemo ves \u010das:<\/p>\n
      \n
    • kako delujejo procesi,<\/li>\n
    • kaj so sistemski klici,<\/li>\n
    • kako program komunicira z jedrom,<\/li>\n
    • kaj pravzaprav pomeni stack,<\/li>\n
    • kako delujejo funkcijski klici,<\/li>\n
    • zakaj obstaja ABI,<\/li>\n
    • kako se argumenti prena\u0161ajo med funkcijami,<\/li>\n
    • kaj se zgodi pri segfaultu,<\/li>\n
    • kako debugger vidi program,<\/li>\n
    • kaj pravzaprav vsebuje izvr\u0161na ELF datoteka.<\/li>\n<\/ul>\n
      \u0160e posebej zanimivo je potem pogledati kodo, ki jo generira compiler iz programa v C.<\/p>\n
      Na primer:<\/p>\n
      gcc -S test.c<\/code><\/pre>\n
      Kar naenkrat assembler ni ve\u010d neka skrivnostna plast nekje globoko pod programom.<\/p>\n
      Postane nekaj, kar lahko prebere\u0161.<\/p>\n
      Zaklju\u010dek<\/h3>\n
      Moje ponovno sre\u010danje z asemblerjem po vseh teh letih je bilo precej nostalgi\u010dno.<\/p>\n
      Od DEC VAX ra\u010dunalnikov na fakulteti<\/strong> do dana\u0161njega x86-64 Linuxa z NASM-om<\/strong> se je spremenilo skoraj vse.<\/p>\n
      Procesorji so neprimerno hitrej\u0161i.<\/p>\n
      Operacijski sistemi so kompleksnej\u0161i.<\/p>\n
      Programski jeziki imajo ve\u010d plasti abstrakcije.<\/p>\n
      Ra\u010dunalniki imajo danes gigabajte pomnilnika tam, kjer smo neko\u010d \u0161teli kilobajte in megabajte.<\/p>\n
      Toda nekje globoko spodaj \u0161e vedno obstaja zelo preprost svet.<\/p>\n
      Registri.<\/p>\n
      Naslovi.<\/p>\n
      Pomnilnik.<\/p>\n
      Ukazi.<\/p>\n
      In procesor, ki jih enega za drugim izvaja.<\/p>\n
      V\u010dasih je prav prijetno odstraniti vse moderne plasti abstrakcije in se za nekaj \u010dasa vrniti tja.<\/p>\n
      \u010cisto do \u017eeleza.<\/strong><\/p>\n","protected":false},"excerpt":{"rendered":"
      Z asemblerjem sem se prvi\u010d sre\u010dal \u017ee na fakulteti. Takrat svet ra\u010dunalni\u0161tva ni bil videti tako kot danes. Delali smo na ra\u010dunalnikih DEC VAX, kjer je bil pogled […]<\/p>\n","protected":false},"author":1,"featured_media":590,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[10,125],"tags":[],"class_list":["post-589","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-linux","category-unix"],"_links":{"self":[{"href":"https:\/\/d-mashina.net\/index.php\/wp-json\/wp\/v2\/posts\/589","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/d-mashina.net\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/d-mashina.net\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/d-mashina.net\/index.php\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/d-mashina.net\/index.php\/wp-json\/wp\/v2\/comments?post=589"}],"version-history":[{"count":1,"href":"https:\/\/d-mashina.net\/index.php\/wp-json\/wp\/v2\/posts\/589\/revisions"}],"predecessor-version":[{"id":591,"href":"https:\/\/d-mashina.net\/index.php\/wp-json\/wp\/v2\/posts\/589\/revisions\/591"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/d-mashina.net\/index.php\/wp-json\/wp\/v2\/media\/590"}],"wp:attachment":[{"href":"https:\/\/d-mashina.net\/index.php\/wp-json\/wp\/v2\/media?parent=589"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/d-mashina.net\/index.php\/wp-json\/wp\/v2\/categories?post=589"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/d-mashina.net\/index.php\/wp-json\/wp\/v2\/tags?post=589"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}