Förord

Nu ska jag ta ett par ord om globala variabler i assembly, vare sig vi talar om initierade eller onitierade sådana. Detta är den sista artikeln tills jag har funnit något annat intressant ämne inom assembly att skriva om.

Innehåll

  » Initierade variabler
  » Oinitierade variabler

Initierade variabler

Vi ska ta oss en närmare titt på globala initierade variabler, som oftast placeras i sektionen för initierad data som heter ".data". Du kan där placera allt från s k "byte arrays", strängar, strukturer till tal (hel- och decimaltal).

För att deklarera något så följer man nedanstående syntax.

variabelnamn datatyp värde

I praktiken ser det ut så här...

min_variabel dd 0 ; skapa en global variabel av typen DWORD med namnet "min_variabel" som är initierad med värdet 0
dd är det intressanta här. dd står för declare dword och talar om för assemblern att variabeln är av datatypen DWORD, alltså en datatyp för tal som tar upp 4 bytes i minnet.

Här följer en lista på de olika förkortningarna för datatyper.

• db - kort för declare byte ("deklarera byte"), deklarerar en byte.
• dw - kort för declare word ("deklarera ord"), deklarerar ett 16-bitars tal av storleken 2 bytes.
• dd - kort för declare dword ("deklarera dubbelord"), deklarerar ett 32-bitars tal av storleken 4 bytes.
• dq - kort för declare qword ("deklarera fyrdubbelord"), deklarerar ett (1) 64-bitars tal av storleken 8 bytes.
• df - kort för declare fword ("deklarera långtord"), deklarerar ett 32-bitars tal som används som en pekare av storleken 6 bytes.
• dt - kort för declare tbyte ("deklarera ten byte"), deklarerar en 10-bytes variabel för binära och decimala tal (BCD).

; Exempel: skapa globala variabler i sektionen för initierad data
.data

byt0 db 128
byt1 db ’A’
num0 dw 1111
num1 dd 11111111
num2 dd 1000.100
num3 dq 10000000000000000000010
num4 dq 100000000000000000000000.100000

Oinitierade variabler

Globala oinitierade variabler skapas på nästan samma sätt som initierade globala variabler. De placeras i en sektion som heter ”.data?” i assembly, och i stället för att specifiera ett värde bakom ex. dd så använder du ett frågetecken. Se exemplet nedan.

; Exempel: skapa globala variabler i sektionen för oinitierad data
.data? ; sektion namnet (notera frågetecknet i slutet)

; diverse oinitierade variabler för tal
num0 dw ?
num1 dd ?
num2 dd ?
num3 dq ?
num4 dq ?

; oinitierad variabel som kan hålla 1 byte
byte_id db ?

; oinitierad buffert som kan hålla 260 bytes
buffer db 260 dup(?)
Att deklarera globala variabler är ganska enkelt att lära sig. Ett litet tips: deklarera oinitierade globala variabler så ofta du kan då de till skillnad från initierade variabler inte tar upp plats i den binära programfilen. Lägg till följande kodrad i ”Hello World”-exemplet (i data-sektionen) i den 3:e artikeln och se hur programfilens storlek har ökat från 2.50 KB till 6.50 KB, och öppna även programfilen i Anteckningar eller någon hex-redigerare för att se datan.

buffer db 4096 dup(’A’) ; 4 KB av bokstaven A
Det var allt! Har ni några frågor, kommentarer eller synpunkter så får ni gärna framföra de. Det må dyka upp fler assembly artiklar i framtiden, men för tillfället har jag inga planer liggandes på bordet. Den som lever får se!;)

Nedan är ett exempel på hur man använder variabler, både initierade och oinitierade.

.486 ; 32-bitars CPU
.model flat,stdcall ; 32-bitars minnesmodell
option casemap:none ; Verbalkänslig

include \masm32\include\windows.inc
include \masm32\include\kernel32.inc
include \masm32\include\user32.inc

includelib \masm32\lib\user32.lib
includelib \masm32\lib\kernel32.lib

; sektionen för oinitierade variabler
.data?

buf db 255 dup(?) ; en buffert som kan hålla 255 bytes
num0 dw ?
num1 dd ?

; sektionen för initierade variabler
.data

chars db 70h,65h,6ch,6ch,65h,73h,6fh,66h,74h,0h ; en array av bytes med hextal vars ASCII-koder sammansatt blir "pellesoft"...
;chars db "pellesoft",0 ; ...ger samma resultat

syntax db "Text: %s",0dh,0ah,"Kort tal: %hd",0dh,0ah,"Långt tal: %d",0 ; wsprintf() syntax
msgtitle db "Variabler",0

.code

start:

mov num0,25000 ; flytta 25000 till den oinitierade WORD:en
mov num1,10101010 ; flytta 10101010 till den oinitierade DWORD:en
mov eax,num1
add ax,num0 ; addera num0 med num1 (notera att vi använder AX eftersom num0 är ett 16-bitars nummer)
mov num1,eax

invoke wsprintf,addr buf,addr syntax,addr chars,dword ptr [num0],num1 ; formattera texten
invoke MessageBox,0,addr buf,addr msgtitle,MB_OK ; visa ett meddelande med den resulterande texten
invoke ExitProcess,0

end start
Du finner hela ovanstående källkod samt dess programfil här.

2 Kommentarer

1. 
   Simon Dahlbacka
   

   1 jan 2007

   ..bra initiativ, borde sätta mej ned och labba lite :) En fråga dock, om oinitierade variabler är så bra, så hur använder man dem efter att man deklarerat dom?

2. 
   Sebastian Andersson
   

   2 jan 2007

   Tackar. Du använder oinitierade variabler på precis samma sätt som initierade variabler, de enda skillnaderna är som sagt att initierade variabler tar upp plats i programfilen och att oinitierade variabler kan vara osäkra om man inte vad de håller när man använder de, men det har aldrig riktigt varit något problem för mig. Jag ska uppdatera artikeln med ett exempel.;)

Skriv en kommentar på artikeln

Ditt betyg på artikeln

UtmärktLäsvärdIntressantMindre braDålig

Kommentar: