Practical Session 6

NASM Preprocessor

• NASM contains a powerful macro processor, which supports • conditional assembly• multi-level file inclusion• two forms of macro (single-line and multi-line) *• a `context stack' mechanism for extra macro power

• Preprocessor directives all begin with a % sign

* We are going to cover only this subsection of NASM macro processor. Use http://www.nasm.us/doc/nasmdoc4.html link to read more.

Macro - definition• Macro is a set of statements given a symbolic name

• Macro is invoked, not called. A copy of the macro is inserted directly into the program

• After being defined, NASM will substitute (expand) those statements whenever it finds the symbolic name

Source codemyMacro

.myMacro

.myMacro

.

Expanded code

.

.

.

NASM preprocessor

macro definition macro name

macro body (statements)

macro usage

Single-line macros• %define – defines single-line macro

• a macro is expanded only when it is called

Example:%define ctrl 0x1F & %define param(a, b) ((a)+(a)*(b))

mov byte [param(2,ebx)], ctrl 'D' expands to by NASM preprocessor

mov byte [(2)+(2)*(ebx)], 0x1F & 'D'

Example:

%define a(x) 1+b(x)%define b(x) 2*x expands to mov ax,1+2*8 mov ax, a(8) by NASM preprocessor

Single-line macros (cont)

• We can overload single-line macros. The preprocessor will be able to handle both types of macro call, by counting the parameters you pass.

%define foo(x) 1+x %define foo(x, y) 1+x*y

• Macros defined with %define are case sensitive. We use %idefine to define all the case variants of a macro at once.

• There is a mechanism which detects when a macro call has occurred as a result of a previous expansion of the same macro, to guard against circular references and infinite loops.

%define foo 1+ ebx

A macro with no parameters prohibits the definition of the same name as a macro with parameters, and vice versa.

Single-line macros (cont)

Example:%define isTrue 1 %xdefine isTrue 1 %define isFalse isTrue %xdefine isFalse isTrue %define isTrue 0 %xdefine isTrue 0 val1: db isFalse ; val1 = ? val1: db isFalse ; val1=?%define isTrue 1 %xdefine isTrue 1 val2: db isFalse ; val2 = ? val2: db isFalse; val2=?

• %define - a macro resolved at the time that it is called (used)

• %xdefine - a macro resolved at the time that it is defined

Single-line macros (cont)• In the left case, when ‘isFalse’ macro uses %define, so it is expanded only

when it is called. As ‘isFalse’ expands to ‘isTrue’, the expansion will be the current value of ‘isTrue’. The first time it is called that is 0, and the second time it is 1.

• In the right case, each time that ‘isFalse’ is called, it expands to 1, as that is what the macro ‘isTrue’ expanded to at the time that ‘isFalse’ was defined.

%define isTrue 1 %xdefine isTrue 1 %define isFalse isTrue %xdefine isFalse isTrue %define isTrue 0 %xdefine isTrue 0 val1: db isFalse ; val1 = 0 val1: db isFalse ; val1=1%define isTrue 1 %xdefine isTrue 1 val2: db isFalse ; val2 = 1 val2: db isFalse; val2=1

Single-line macros (cont)• %undef – undefines defined single-line macro

Example:

%define foo(x) 1+x %undef foo mov ax, foo(3) ; would not be expanded since

; after %undef the macro foo is no longer defined

Multiple-line macros• Works with %macro … %endmacro mechanism

• Macro parameters would be referred to as %1, %2, %3 and so on

Example:

%macro foo 1 push ebp mov ebp, esp sub esp, %1 %endmacro

my_func: foo 12 my_func: push ebp

mov ebp, esp sub esp,12

first parameter of the macro

this macro gets one parameter

NASM preprocessor

Multiple-line macros (cont)• Multi-line macros are case-sensitive, unless we define them

using the alternative directive %imacro.

• If we need to pass a comma as part of a parameter to a multi-line macro, we can do that by enclosing the entire parameter in braces.

Example: %macro foo 2

%2: db %1 %endmacro

foo 'a', letter_a letter_a: db 'a' foo 'ab', string_ab string_ab: db 'ab' foo {13,10}, crlf crlf: db 13,10

NASM preprocessor

Multiple-line macros (cont)• Multi-line macros can be overloaded by defining the same macro

name several times with different amounts of parameters. (This time, no exception is made for macros with no parameters.)

• Reserved words can also be overloaded:

Example:%macro push 2

push %1push %2

%endmacro

push ebx ; this line is not a macro call push eax, ecx ; but this one is a macro call

Note: if define macro ‘push’ with one parameter, the original ‘push’ instruction would be overloaded.

Multiple-line macros – labelsDefining a macro with an internal label:

%macro retz 0 jnz %%skip ret %%skip:%endmacro

In every ‘retz’ invocation, the preprocessor creates some unique label of the form: [email protected] to substitute for the label %%skip, where the number 2345 changes with every macro call.

If a label begins with the special prefix ..@, then it doesn’t interfere with the local label mechanism.

label1: ; a non-local label..@ 2345.skip : ; this is a macro label.local: ; this is really label1.local

Default Macro Parameters

We supply a minimum and maximum number of parameters for a macro of this type; the minimum number of parameters are required in the macro call, and we provide defaults for the optional ones.

Example:

%macro foo 1-3 eax, [ebx+2]

• could be called with between one and three parameters• %1 would always be taken from the macro call (minimal number of parameters)• %2, if not specified by the macro call, would default to eax• %3, if not specified by the macro call, would default to [ebx+2]

We may omit parameter defaults from the macro definition, in which case the parameter default is taken to be blank. This can be useful for macros which can take a variable number of parameters, since the %0 token allows us to determine how many parameters were really passed to the macro call.

%macro name min - max <default parameters list>

Greedy Macro ParametersIf invoke the macro with more parameters than it expects, all the spare parameters get lumped into the last defined one.

%macro macroName numOfParams +

The mark %numOfParams will be replaced with numOfParams’s parameter and whatever follows it.

Example:%macro writefile 2+ jmp %%endstr %%str: db %2 %%endstr: mov dx, %%str mov cx, %%endstr - %%str mov bx, %1 mov ah, 0x40 int 0x21%endmacro

writefile [fileHandle],"hello, world",13,10

Macro ExpansionUse –e option to get a source code with all your macros expanded.

> nasm -e sample.s

Jump table• Jump table is

– a graceful way to implement “switch - case” mechanism– used to select a function to be evoked

• We will construct a array of the jump addresses.• For each number will jump to the corresponding entry in the

jump table.switch ( letter ) { case 'A': upper ++; case ‘a': lower ++; default : total ++;}

main.cextern void jumper(int);int main (int argc , char* argv){

jumper (0);jumper (1);jumper (2);return 0;

}

Jump table - example

jumper(i) should be implemented as follows:

printf (“num = %d”, i);switch (i) { case ‘0': printf (“Got the number 0”); case ‘1': printf (“Got the number 1”); default : printf (“Out of bound”);}

Output:

num = 0Got the number 0num = 1Got the number 1num = 2Out of bound

section .datajt: dd label_1

dd label_2

str0: db "Got the number 0",10,0str1: db "Got the number 1",10,0str2: db "Out of bound",10,0str3: db "num = %d",10,0

section .textglobal jumperextern printf

jumper:push ebpmov ebp, esppushamov ebx, dword [ebp+8]push ebxpush str3call printf ; print numadd esp, 8cmp ebx,0 ; check if num is in boundsjb out_ofcmp ebx , 1ja out_ofshl ebx,2 ; num = num * 4jmp dword [ebx + jt] ; jump according to address

; in table

label_1: push str0call printfadd esp, 4jmp end

label_2: push str1call printfadd esp, 4jmp end

out_of: push str2call printfadd esp, 4jmp end

end: popapop ebpret

Jump table - example

to b

e ab

le to

jum

p in

a ta

ble

of d

wor

ds

printf (“num = %d”, i);switch (i) { case ‘0': printf (“Got the number 0”); case ‘1': printf (“Got the number 1”); default : printf (“Out of bound”);}

למבחן חזרה שאלות

1שאלה : הבאות ההגדרות נתונות

x: dw 1y: db 2z: db 3

את להכפיל -x,y,zיש . 2ב אחת פקודה באמצעותשאין להניח overflowניתן

1שאלה : הבאות ההגדרות נתונות

x: dw 1y: db 2z: db 3

את להכפיל -x,y,zיש . 2ב אחת פקודה באמצעותשאין להניח overflowניתן

- תשובה: ב המילה כל את :2נכפול

shl dword [x], 1

2שאלה , ארגומנטים ללא לפונקציה קריאה לממש עלינו

ברגיסטר נמצאת את. eaxשכתובתה לסמן ישש .לאהקוד נכון זאת יבצע

a) push next_apush eaxretnext_a:

b) push eaxpush eaxret

c) push next_ajmp eaxnext_a:

d) call eax

3שאלה הערך -eaxברגיסטר לרשום. 1נמצא 5יש

לכך שונותפקודות תגרום מהן אחת שכלהערך eaxשברגיסטר .1יהיה

3שאלה הערך -eaxברגיסטר לרשום. 1נמצא 5יש

לכך שונותפקודות תגרום מהן אחת שכלהערך eaxשברגיסטר .1יהיה

תשובה

mov eax, 1add eax, 2neg eaxshr eax, 31and eax, 1

4שאלה הגדרת :macroנתונה , בזכרון נתונים וכן הבאה

%macro print 3pushamov eax, 4 ; writemov ebx, %1 ; file descriptormov ecx, %2 ; addressmov edx, %3 ; byte countint 0x80popa

%endmacrosection .rodataFile: dd 1MJ: db “Beat it”, 10, 0

: התוכנית של נכונה לא לפעולה יגרום במקרו הבאים מהשימושים איזהa) mov ebx, MJ

print 1, ebx, 9b) print 1, MJ, 9c) print dword [File], MJ, 9d) mov edx, 9

print 1, MJ, edx

5שאלה : הבא הקוד קטע את לממש עלינוint a, b, x;x = blah(a,&b)

נכון ? זאת שיבצע הקוד קטע מהוa) push a c) push dword b push b push dword [a] call blah call blah add esp, 8 add esp, 8 mov [x], eax mov [x], eax

b) push dword [b] d) push dword [b] push dword a push dword a call blah call blah add esp, 8 add esp, 8 mov [x], eax pop dword [x]

6שאלה Gloat: shl ebx, 2

jmp [ebx+Tab] Tab: dd F4

dd F3dd F2dd F1

F1: add ebx, 4F2: add ebx, 4F3: add ebx, 4F4: shr ebx, 2

ret

הפונקציה תחזיר - 0בין ebxעבור ) ebxברגיסטר Gloatמה ( ?3ל

( 0א( ( 2בחזקת ebxב ( ebxבחזקת 2ג 2כפול ebxד

6שאלה Gloat: shl ebx, 2

jmp [ebx+Tab] Tab: dd F4

dd F3dd F2dd F1

F1: add ebx, 4F2: add ebx, 4F3: add ebx, 4F4: shr ebx, 2

ret

הפונקציה תחזיר - 0בין ebxעבור ) ebxברגיסטר Gloatמה ( ?3ל

( 0א( ( 2בחזקת ebxב 2כפול ebxד( ebxבחזקת 2ג

7שאלה • , - ערך את שמכפיל פעמי רב לשימוש קוד לכתוב : 2מוצעות. 3פי eaxברצוננו אפשרויות

במקרו לפונקציה tripleשימוש קריאה : Tripleאו• %macro triple 0

mov ebx, eaxadd eax, eaxadd eax, ebx

%endmacro• Triple: mov ebx, eax

add eax, eax add eax, ebx

ret- ל( ריצה בזמן .2א ביצוע זמן אותו האפשרויות

- ב( השימוש .macroב , לקוד זיכרון יותר דורש אבל יותר מהיר. , לקוד( זיכרון יותר דורש אבל יותר מהיר בפונקציה השימוש ג

הפונקציה( , Tripleד מהמחסנית משתנים מוציאה לא היא כי לעבוד יכולה לא

Practical Session 6

Documents

Transcript of Practical Session 6