**Asembla komputillingvo** estas skribosistemo por la maŝina lingvo, kiun uzas konkreta komputila arkitekturo, legebla de homoj. Maŝina lingvo, nura sinsekvo de bitoj, estas legebligita anstataŭigante la nombrajn valorojn per vico da ordonsimboloj kaj valoroj (tial en Esperanto oni ankaŭ uzas la nomon **simbola maŝinkodo**).

Malkiel en altnivelaj lingvoj ebliĝas 1-al-1-traduko de asembla kodo kaj maŝinkodo, do komputiloj povas traduki en ambaŭ direktoj sen perdi informojn. **Asemblilo** transformas asemblan kodon en la maŝinan; la transformon en la kontraŭa direkto plenumas **malasemblilo**. Plej ofte vera programado estas farita en asembla lingvo uzante pli altnivelajn kapablojn de la lingvo (minimume nomojn, ofte eĉ makroojn), la 1-al-1-rilato perdiĝas.

Ĉiu procesora arkitekturo havas sian propran maŝinan lingvon, kaj tial propran asemblan lingvon. Ĉi tiuj lingvoj malsamas pro la nombro kaj speco de operacioj kiujn ili disponigas. Ili ankaŭ povas havi malsamajn grandecojn kaj nombrojn de reĝistroj, kaj malsamajn manierojn prezenti datumtipojn en memoro. Kvankam ĉiuj ĝeneralcelaj komputiloj kapablas fari escence la samajn aferojn, la manieroj malsamas.

Aldone, pluraj aroj da mnemonikaj simboloj aŭ pluraj sintaksoj povas ekzisti por unu sama sortimento da komandoj. En tiaj okazoj, la plej populara kutime estas tiu uzata en la dokumentaro de la fabrikanto.

Maŝinaj komandoj
----------------

Similaj bazaj operacioj estas uzeblaj en preskaŭ ĉiuj komandaroj.

* kopii / movi
	+ kopii datumon el reĝistro al alia reĝistro
	+ kopii datumon el memora loko al reĝistro aŭ inverse
* komputi
	+ aldoni, subtrahi, (parte eĉ multipliki aŭ dividi) valorojn en du reĝistroj, metante la rezulton en reĝistron
	+ perbite kombini du reĝistrajn valorojn per logika "kaj" aŭ logika "aŭ" aŭ logika "malinkluziva aŭ"
* kompari kaj utiligi kondiĉojn
* regi fluon de programo
	+ salti al alia loko en la programo (kutime komandoj estas traktataj sinsekve)
	+ salti al alia loko, sed konservi la pozicion de la sekva komando kiel revenlokon
	+ reiri al la lasta revenloko
	+ kondiĉe salti

Konkretaj komandaroj ofte havas unuopajn aŭ malmultajn komandojn por oftaj komplikaj operacioj (por kiuj normale necesus multaj unuopaj komandoj), ekzemple:

* movi grandajn memorblokojn
* alta aritmetiko (sinuso, kosinuso, kvadrata radiko, ktp.)
* alta logiko (CRC32 aŭ eĉ kriptografio)
* apliki unu operacion (ekzemple aldonadon) al aro de valoroj

La nomoj de la komandoj varias laŭ la asembla lingvo por diversaj procesoroj. Ankaŭ por unu sama procesoro povas ekzisti pluraj malsimilaj variantoj de asembla lingvo. Tamen iuj nomoj de komandoj ofte samas en diversaj asemblaj lingvoj.

Kelkaj ĉefaj maŝinkomandoj de x86
---------------------------------

Ekzemploj validas por procesoroj Intel **x86** kaj similaj.

|  |  |
| --- | --- |
| Komando | Signifo |
| **nop** | komando, kiu nenion faras |
| **jmp** | saltokomando |
| **mov** | kopiado |
| **cmp** | komparo |
| **and** | laŭbita logika KAJ |
| **sub** | subtraho |
| **dec** | dekremento je 1 |
| **inc** | alkremento je 1 |
| **add** | adicio |
| **mul** | multipliko |
| **div** | divido |
| **xor** | laŭbita disaŭo |
| **or** | laŭbita logika AŬ |
| **not** | laŭbita logika NE |
| **ret** | reveno el subprogramo |

La komando *mov* havas du argumentojn kaj estas skribata en la formo `mov a, b`. La direkto de kopiado de la datumoj dependas de la konkreta varianto de asembla lingvo. Povas esti aŭ de *a* al *b* aŭ inverse.

Kalkulaj komandoj kutime havas du argumentojn. Ekzemple adicio aldonas unu el la argumentoj al la alia. Same kiel pri kopiado: kien estas skribota la rezulto dependas de la konkreta varianto de asembla lingvo. Do `add a, b` povas signifi, ke la valoro *a+b* estas konservita en *a* aŭ en *b*.

Ordonoj de asembla lingvo
-------------------------

Aldone al kodoj por maŝinaj komandoj, asemblaj lingvoj havas kromajn ordonojn por asembli datumblokojn kaj doni adreslokojn al komandoj aŭ kodo.

Ili kutime havas simplan simbolan kapablon por difini valorojn kiel simbolajn esprimojn, kiuj estas evaluitaj je asembla tempo, ebligante verki kodon kiu estas pli facile legi kaj kompreni.

Ili ankaŭ kutime havas makroan lingvon por plifaciligi la kreon de komplikaj pecoj de kodo aŭ datumoj.

Uzo de asembla lingvo
---------------------

Estas iom da polemiko pri la utileco de asembla lingvo. En multaj okazoj, modernaj tradukiloj povas transformi fontan programon el altnivela lingvo en maŝinan kodon funkciantan preskaŭ same rapide kiel mane verkita kodo en asembla lingvo. Sed en la frua epoko asembla lingvo estis pli-malpli devo por kreado de utilaj programoj, tradukiloj de altnivelaj lingvoj aŭ ne ekzistis aŭ ties rezulta kodo estis nepraktike larĝa kaj ruliĝis tro longe.

Tamen, kelkajn komputojn ankaŭ hodiaŭ eblas plirapidigi per asemblilo, kaj kelkaj malaltnivelaĵoj estas pli facile fareblaj en asembla lingvo. Sistemdependaj taskoj faritaj de operaciumoj simple ne povas esti esprimitaj en altnivelaj lingvoj. Multaj tradukiloj transformas kodon de altnivelaj lingvoj en asemblan lingvon antaŭ ol plene traduki, do la asembla kodo povas esti vidita por sencimigaj kaj optimumigaj celoj.

Eksteraj ligiloj
----------------

* Kategorio Asembla lingvo en la Vikimedia Komunejo (Multrimedaj datumoj)

* 
* 
* (angla)


|  |  |
| --- | --- |
| Bibliotekoj | * PeEnEo: 9143
* GND: 4003255-3
* LCCN: sh85008765
* BNF: 11961749m
* NKC: ph318939
 |