Mr Register

Register hos mikroprocessorn 8086 (286,386,486 samt även 8088)

Ett register fungerar ungefär som en variabel i C eller något annat högnivåspråk fast mycket snabbare. Det finns fyra stycken allmänna register Ax, Bx, Cx och Dx som är inblandade i de flesta instruktioner som utförs i ett program. Registren består av ett word (16 bitar) vardera. Man kan dela in registren i två delar (en byte (8 bitar) vardera), den vänstra (mest signifikanta) kallas den höga byten och den högra (minst signifikanta) kallas den låga byten. Till exempel kallas den låga byten hos Ax för Al och den höga byten hos Ax kallas Ah. På samma sätt kan man komma åt den låga resp höga byten hos Bx, Cx och Dx som Bl,Bh; Cl,Ch och Dl,Dh.

Faktaruta 1
*************************
* Allmänna register	*
*			*
* Bit 15-8 7-0		*
* Ax	Ah, Al		*
* Bx	Ah, Al		*
* Cx	Ah, Al		*
* Dx	Ah, Al		*
*************************

MOV är den vanligaste assembler instruktionen. Den flyttar data till en destinationen från en källa.
Exempel: mov Ax, 5 ;flyttar talet 5 till Ax.
Kom ihåg att destinationen alltid står först sedan ett kommatecken och sist källan (source på engelska). Man kan bara skriva en instruktion per rad, instruktionen avslutas med return, semikolon betyder kommentar. I vissa högnivåspråk kan man skriva assemblerinstruktioner direkt i koden. Om man gör det är det inte säkert att semikolon fungerar som kommentar. I Borland C måste man använda borlands kommentartecken istället för semikolon.

Exempel på inline assembler i C:
	asm	mov	Ax, 5	// flyttar talet 5 till Ax, asm betyder att nu
				//kommer en assembler instruktion.

Nästa exempel är ett fullt körbart exempel som använder instruktionen ADD. ADD adderar två register och placerar resultatet i det första.

;Exempel på körbart program som adderar två tal och placerar resultatet i variabeln resultat

.model small
.Data				; segment för data

TAL1		DW	5	; deklarera variabler
TAL2		DW	7	; deklarera tal2 som ett word med startvärde 7
RESULTAT	DW	?	;resultat word som vi inte vet värdet av än

.Code				; segment för kod

Start:	mov	Ax, TAL1	;kopierar tal1 till ax (talet 5 alltså)
	add	Ax, TAL2	;adderar tal2 (7) till Ax (5) och placerar
				;resultatet (12) i Ax
	mov	RESULTAT,Ax	;kopierar Ax (12) till variabeln resultat

END	Start			;talar om för assemblatorn att programmet slutar här och att det börjar vid start

första raden talar om vilken typ programmet skall vara av, small är den minsta modellen men fungerar för alla program som jag tänker gå igenom (det går t ex att ställa in borland c's kompilator för vilken modell man vill ha och det är precis samma namn där Huge är den största). Den andra raden talar om att nu kommer variabeldeklarationer precis som man gör överst i ett c eller pascal program. DW betyder declare word, man kan även skriva DB som betyder declare byte. .Code betyder att nu börjar själva koden. Mellan .Code och END är programmet, vanligtvis litet längre men strukturen på assemblerprogrammen ser ut på det här sättet. Ett program innehåller alltid minst två segment. Först datasegmentet som innehåller variabler och arrayer och sen kodsegmentet som innehåller själva programmet.

Nu kommer samma program i inline assembler i c:

// addera två tal med hjälp av inline assembler

void main(void)
{
int	tal1 = 5,tal2 = 7,resultat;
asm{
	mov	Ax,tal1		// kopiera tal1 till Ax OBS att tal1
				// måste vara int (16 bitar)
	add	Ax,tal2
	mov	resultat,Ax
}
} // slut på main

Detta program gör exakt samma sak som resultat = tal1 + tal2; skulle ha gjort fast litet snabbare. Det är dock inte vid vanlig addition man gör de största tidsvinsterna med assembler utan vid olika slags grafik hantering. Bara att använda register istället för minnesvariabler går upp till 100 ggr fortare. Observera att man istället för Ax kunnat använda enbart Al eller Ah (eller vilket som helst av de andra allmänna registren) eftersom talen var mindre än 256.

Faktaruta 2

*****************************************
* Uppbyggnad av ett assemblerprogram	*
*					*
* .model Small	;Storlek		*
* .Data		;Datasegment		*
* . . .					*
* . . .		;Variabeldeklarationer	*
* . . .					*
* .Code		;Kodsegment		*
* Start:				*
* . . .		;Huvudprogram		*
* . . .					*
* . . .					*
* END Start	;Slut			*
*****************************************

Segmentregister

Innan vi tittar mer på registren behöver vi veta litet grand om segment. Förr i tiden användes ett 16- bitarsregister för att peka ut en minnescell vilket gör att antalet unika adresser endast var 65536 stycken. För att kunna nå en hel megabyte (1024 K) måste man använda sig av något som kallas minnessegmentering vilket ger en adress på 20 bitar. Minnet är uppdelat i segment som kan vara max 64 K vardera. För att kunna nå en viss adress måste man först ange vilket segment man tänker använda i ett speciellt segmentregister och sedan använda vanlig 16-bitars adressering inom det segmentet. Det finns fyra segmentregister utav vilka vi kommer att använda två:DS och ES. DS pekar ut datasegmentet som innehåller variabler och arrayer, ES är extra segmentregister som man brukar använda till att peka ut t ex början av bildskärmen. När man skriver t ex mov Ax, TAL1, där TAL1 är en variabel, så antas automatiskt att det är ds som pekar ut segmentet som TAL1 finns i. Man kan även använda segmentöverskridning och nå data från ett annat segment genom att skriva t ex mov Ax, ES:[Bx]. Denna instruktion kopierar innehållet i adressen som pekas ut av es + bx till Ax. Den fysiska adressen beräknas genom att ta innehållet i segmentregistret * 16 + index (det som står efter kolonet). Om es t ex innehåller 64 och bx innehåller 5 så blir adressen som pekas ut av ES:Bx = 64*16 + 5 = 1029 och mov Ax, ES:[Bx] kopierar alltså innehållet i minnesadress 1029 till Ax. Det finns även ett kodsegment register, CS som pekar ut kodsegmentet, men det sköts om automatiskt så det behöver man inte bry sig om som programmerare. Sedan finns även ett stacksegmentregister, SS som pekar ut början av stacken.

Indexregister

Det finns två indexregister, Si och Di. Dessa brukar användas till att peka på strängar med data i minnet och kallas därför också strängindexregister. Med sträng menas inte nödvändigtvis en textsträng, det kan också vara en sträng med färger till en palett eller en sträng med bitinformation i ett bitplan. Si är förkortning för SourceIndex (källindex) och Di betyder DestinationsIndex. Man brukar använda Si (källindex) tillsammans med Ds (datasegmentet) och di (destinationsindex) tillsammans med Es (extra segment). Bland annat används dessa kombinationer tillsammans med instruktionerna MOVS (movestring), LODS (loadstring) och STOS (storestring) som flyttar strängar med data inom minnet och mellan minnet och register Ax (Se listan med instruktioner längre ned).

Faktaruta 3

*****************************************************************
* Alla registren						*
*								*
* Bit 15-8 7-0							*
* Ax	Ah, Al							*
* Bx	Ah, Al			Allmänna register		*
* Cx	Ah, Al							*
* Dx	Ah, Al							*
*								*
* Bit  15-0							*
* 	Si			Indexregister			*
* 	Di							*
*								*
* 	Sp			Stackpekare			*
* 	Bp							*
*								*
* 	Cs							*
* 	Ds			Segmentregister			*
* 	Ss							*
* 	Es							*
*								*
* 	ip			Instruktionspekare		*
* 	Flags			Flaggregister			*
*****************************************************************

Cs:ip innehåller adressen till nästa instruktion som ska utföras (behöver vi inte bry oss om). Flags innehåller information om senast utförda beräkning eller jämförelse (om noll eller spill osv), används bl a vid villkorliga hopp.

REGISTERS PERSONLIGHET

Alla de fyra allmänna registren klarar av att lagra tal mellan 0 och 65535, de kan laddas från minnet (mov Dx, TAL1), de kan skriva i minnet (mov resultat, Ax) och de kan användas i aritmetiska och logiska operationer ( ADD Ax,Bx), (AND Cx, 1). Det finns dock vissa saker som endast ett register klarar av eller är specialicerat på, vilket ger registren en viss personlighet.

AX - registret

Kallas också ackumulatorn. Ax - registret är alltid inblandat vid multiplikation och division och är även snabbast på vissa andra operationer.

Exempel:
	mov	Ax,10	;laddar Ax med 10
	mov	Bx,5	;laddar Bx med 5
	mul	Bx	;multiplicerar Bx med Ax, resultatet (50) placeras i Ax

De 16 lägsta bitarna placeras i Ax och de 16 högsta bitarna placeras i DX. Om resultatet är mindre än 65536 hamnar alltså alla signifikanta bitar i Ax (alla bitar som betyder något).

BX - registret

kan användas för att peka ut minnesceller i minnet

CX - registret

Cx - registret används bl a som loopräknare

Exempel:

	mov	Cx, 50	;flytta antalet ggr något ska göras till Cx
enloop:	...		;enloop är en sk label som markerar en
			;position i minnet
	...		;namnet på labeln byts ut av assembleraren
			;mot en minnesadress
	...
	loop	enloop	;minskar cx med ett och hoppar tillbaka till labeln
			;som anges efter loop
			;om cx är skilt från noll

Loop-instruktionen motsvarar en for-sats i c eller pascal och använder alltid Cx som loopräknare. Vad som skall göras i loopen bestäms naturligtvis av programmeraren.

DX-registret

används bland annat vid multiplikation (se Ax) och division (se lista över instruktioner).

SI - registret

(källindex)
Si (SourceIndex) kan användas precis som de allmänna registren men Si andvänds speciellt till att peka på data i minnet.

Exempel:
.Data
	.
	.
Palett	DB	0,1, 2, 3, 4, 5 . . .
.Code
	.
	.
	.
	mov	Si, OFFSET Palett	;laddar si med
					;offseten till arrayen palett
	lodsb				;laddar Ax med innehållet i
	.				;adressen DS:SI
	.				;som är första byten i arrayen palett

OFFSET Palett ger skillnaden (offseten) mellan adressen till Palett och Ds (datasegmentet). Instruktionen lodsb kopierar en byte från adressen som ds:si pekar på, till Ax. Dessutom räknas si upp ett steg så att om man gör lodsb igen, laddas andra byten i Palett till Ax. Lodsw laddar två byte (ett word) på samma sätt fast räknar upp Si med två steg.

DI - registret

Di (DestinationsIndex) används precis som Si fast pekar på destinationen istället för källan.

Exempel:
	mov	Ax, 0B800H	;adressen till skärmen i textmod
				;H betyder hexadecimalt
	mov	Es,Ax		;ladda es med adressen till bildminnet
	mov	Di, 0		;första byten på skärmen
				;(längst upp till vänster)
	mov	Ah, 'A'		;bokstaven stora A ska skrivas
	mov	Al, 7+ 4*16	;vit (färg 7) text på röd (färg 4) bakgrund
	stosw			;skriv ut tecknet och färgattributet
				;till skärmen

Instruktionen stosw kopierar ett word från Ax till adressen som es:di pekar på. Dessutom räknas di upp två steg så att om man gör stosw igen, skrivs samma tecken och attribut ut på nästa position på skärmen. (se Avsnittet Bildskärmen i Textmod för mera information om adresser, färger osv). Stosb gör samma sak som stosw fast flyttar bara en byte och räknar bara upp di ett steg.