Computer Architecture and System Programming Laboratory

Slides:



Advertisements
Similar presentations
Passing by-value vs. by-reference in ARM by value C code equivalent assembly code int a;.section since a is not assigned an a:.skip initial.
Advertisements

Macro Processor.
C Programming and Assembly Language Janakiraman V – NITK Surathkal 2 nd August 2014.
Practical Session 3. The Stack The stack is an area in memory that its purpose is to provide a space for temporary storage of addresses and data items.
NASM Preprocessor. NASM preprocessor  NASM contains a powerful macro processor, which supports conditional assembly, multi-level file inclusion, two.
Accessing parameters from the stack and calling functions.
Practical Session 3. The Stack The stack is an area in memory that its purpose is to provide a space for temporary storage of addresses and data items.
Chapter 12: High-Level Language Interface. Chapter Overview Introduction Inline Assembly Code C calls assembly procedures Assembly calls C procedures.
NASM Preprocessor. NASM preprocessor  NASM contains a powerful macro processor, which supports conditional assembly, multi-level file inclusion, two.
Position Independent Code self sufficiency of combining program.
NASM Preprocessor. NASM preprocessor  NASM contains a powerful macro processor, which supports conditional assembly, multi-level file inclusion, two.
CS2422 Assembly Language & System Programming October 31, 2006.
Practical Session 8 Computer Architecture and Assembly Language.
1 Chapter 4 Macro Processors Professor Gwan-Hwan Hwang Dept. Computer Science and Information Engineering National Taiwan Normal University 9/17/2009.
Macro & Function. Function consumes more time When a function is called, the copy of the arguments are passed to the parameters in the function. After.
Windows Programming Lecture 05. Preprocessor Preprocessor Directives Preprocessor directives are instructions for compiler.
Computer Architecture and Operating Systems CS 3230 :Assembly Section Lecture 7 Department of Computer Science and Software Engineering University of Wisconsin-Platteville.
Practical Session 4. Labels Definition - advanced label: (pseudo) instruction operands ; comment valid characters in labels are: letters, numbers, _,
Machine Independent Macro Processor Features Concatenation of Macro Parameters Generation of Unique Labels Conditional Macro Expansion Keyword Macro.
NASM Preprocessor. NASM preprocessor  NASM contains a powerful macro processor, which supports conditional assembly, multi-level file inclusion, two.
ICS312 Set 14 MACROS. Macros The program structure is similar to that for procedures. As for procedure names, macro names represent a group of instructions.
Assembly Language for x86 Processors 7th Edition Chapter 13: High-Level Language Interface (c) Pearson Education, All rights reserved. You may modify.
CT215: Assembly Language Programming Chapter 10: Macros (c) Pearson Education, All rights reserved. You may modify and copy this slide show for your.
Assembly Language. Symbol Table Variables.DATA var DW 0 sum DD 0 array TIMES 10 DW 0 message DB ’ Welcome ’,0 char1 DB ? Symbol Table Name Offset var.
Introduction to Assembly II Abed Asi Extended System Programming Laboratory (ESPL) CS BGU Fall 2013/2014.
Assembly 07. Outline Boxes within Boxes Procedure Definition call, ret Saving / Restoring Registers Argument(s) Return Value(s) Global vs. Local Data.
Assembly 08. Outline Local Labels Jump Lengths External Libraries Macros 1.
Introduction to Assembly II Abed Asi Extended System Programming Laboratory (ESPL) CS BGU Fall 2014/2015.
CSC 221 Computer Organization and Assembly Language Lecture 16: Procedures.
Practical Session 8. Position Independent Code- self sufficiency of combining program Position Independent Code (PIC) program has everything it needs.
Preocedures A closer look at procedures. Outline Procedures Procedure call mechanism Passing parameters Local variable storage C-Style procedures Recursion.
Assembly Language Addressing Modes. Introduction CISC processors usually supports more addressing modes than RISC processors. –RISC processors use the.
ICS51 Introductory Computer Organization Accessing parameters from the stack and calling functions.
Practical Session 6 Computer Architecture and Assembly Language.
Macro Processor Design Options Recursive Macro Expansion General-Purpose Macro Processors Macro Processing within Language Translators.
Practical Session 3.
Practical Session 5.
Computer Architecture and Assembly Language
Functions.
Assembly Language Lab 9.
Computer Architecture and Assembly Language
Computer Architecture and Assembly Language
Homework Reading Labs PAL, pp
143A: Principles of Operating Systems Lecture 4: Calling conventions
Additional Assembly Programming Concepts
Computer Architecture and Assembly Language
Microprocessor Architecture
High-Level Language Interface
MACRO Processors CSCI/CMPE 3334 David Egle.
Computer Architecture and Assembly Language
Passing by-value vs. by-reference in ARM
Stack Frames and Advanced Procedures
Assembly Language Programming II: C Compiler Calling Sequences
Computer Architecture and Assembly Language
Machine-Level Representation of Programs III
Practical Session 4.
EECE.3170 Microprocessor Systems Design I
EECE.3170 Microprocessor Systems Design I
Miscellaneous C++ Topics
X86 Assembly Review.
Computer Architecture and System Programming Laboratory
Computer Architecture and System Programming Laboratory
Computer Organization and Assembly Language
ICS51 Introductory Computer Organization
Computer Architecture and System Programming Laboratory
Computer Architecture and Assembly Language
Computer Architecture and System Programming Laboratory
Computer Architecture and System Programming Laboratory
Computer Architecture and System Programming Laboratory
Computer Architecture and System Programming Laboratory
Presentation transcript:

Computer Architecture and System Programming Laboratory TA Session 6 Macro

NASM Preprocessor - Macro - definition Macro is a set of statements given a symbolic name Macro is invoked, not called. A copy of macro is inserted directly into the program After being defined, NASM preprocessor will substitute (expand) those statements whenever it finds the symbolic name macro definition Source code myMacro . Expanded code . macro name macro body (statements) NASM preprocessor macro-expander macro usage Note: we cover only part of NASM macro processor features. Read more here

Single-line macros %define (%idefine for case insensitive) - a macro resolved at the time that it is invoked Example: %define ctrl 0x1F & %define param(a, b) ((a)+(a)*(b)) mov byte [param(2,ebx)], ctrl 'D' expanded by NASM preprocessor mov byte [((2)+(2)*(ebx))], 0x1F & 'D' %xdefine - a macro resolved at the time that it is defined 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 2 %xdefine isTrue 2 val2: db isFalse ; val2 = ? val2: db isFalse; val2=?

Single-line macros %define (%idefine for case insensitive) - a macro resolved at the time that it is invoked Example: %define ctrl 0x1F & %define param(a, b) ((a)+(a)*(b)) mov byte [param(2,ebx)], ctrl 'D' expanded by NASM preprocessor mov byte [((2)+(2)*(ebx))], 0x1F & 'D' %xdefine - a macro resolved at the time that it is defined Example: %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 2 %xdefine isTrue 2 val2: db isFalse ; val2 = 2 val2: db isFalse; val2=1 use the current value of ‘isTrue’ use ‘isTrue’ value to at the time that ‘isFalse’ was defined %undef – undefines defined single-line macro

%define foo (x) 1+x %define foo (x, y) 1+x*y Single-line macros 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 %define foo 1+ebx A macro with no parameters prohibits the definition of the same name as a macro with parameters, and vice versa.

Multiple-line macros %macro (%imacro for case insensitive) <name, numOfParams> … %endmacro macro parameters is referred to as %1, %2, %3, ... Example: %macro startFunc 1 push ebp mov ebp, esp sub esp, %1 %endmacro my_func: startFunc 12 … gets single parameter first macro parameter my_func: push ebp mov ebp, esp sub esp,12 NASM preprocessor %unmacro – undefines defined single-line macro

this is overload of push instruction Multiple-line macros 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. %macro DefineByte 2 %2: db %1 %endmacro DefineByte {“Hello”,10,0}, msg msg: db “Hello”,10, 0 NASM preprocessor Multi-line macros can be overloaded by defining the same macro name several times with different amounts of parameters. (Also macros with no parameters.) %macro push 2 push %1 push %2 %endmacro this is overload of push instruction push ebx push ebx push eax, ecx ; this is original push instruction ; this is a macro invocation NASM preprocessor push eax push ecx

Multiple-line macros Error: infinite loop ! 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. %macro DefineByte 2 %2: db %1 %endmacro DefineByte {“Hello”,10,0}, msg msg: db “Hello”,10, 0 Note: NASM preprocessor Multi-line macros can be overloaded by defining the same macro name several times with different amounts of parameters. (Also macros with no parameters.) Note: if define macro ‘push’ with one parameter, the original ‘push’ instruction would be overloaded. But… There is a macro-expander 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. %macro push 1 push %1 %endmacro push eax NASM preprocessor Error: infinite loop !

Multiple-line macros with internal labels %macro addEAX10 0 ; if ZF == 0, add 10 to EAX jnz skip add eax, 10 skip: %endmacro … jnz skip add eax, 10 skip: same label cannot be defined several times in the code … addEAX10

Multiple-line macros with internal labels %macro addEAX10 0 ; if ZF == 0, add 10 to EAX jnz %%skip add eax, 10 %%skip: %endmacro Use –e option to get a source code with all your macros expanded. > nasm -e sample.s For every ‘addEAX10’ invocation, macro-expander creates a unique label to substitute for  %%skip, where the number part of the label changes with every macro invocation. … jnz ..@1.skip add eax, 10 ..@1.skip : jnz ..@2.skip ..@2.skip : jnz ..@3.skip ..@3.skip : … addEAX10 macro-label is not local, but also is not global label. Ignore it when detect local labels scope

Macro with default 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] mov eax, %1 mov ebx, %2 %endmacro foo 42 %macro foo 1-3 mov eax, %1 mov ebx, %2 %endmacro foo 42 mov eax, 42 mov ebx, we will get compile-time error could be called with between one (min) and three (max) 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] Note: 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 with greedy parameters If invoke macro with more parameters than it expects, all the spare parameters get lumped into the last defined one. section .text in RAM Example: let’s implement C standard library function int puts(const char * str) some code … mov ebx, 1 mov edx, … mov ecx, … 0x0A ‘s’ ‘i’ ‘r’ ‘P’ myPuts “Print this“, ”and this”, 10 %macro myPuts 1+ jmp %% skip %%str: db %1 %%skip: mov ecx, %%str mov edx, %%skip - %%str mov ebx, 1 mov eax, 4 int 0x80 %endmacro %macro myPuts 1+ mov ecx, ? mov edx, ? mov ebx, 1 ; stdout mov eax, 4 int 0x80 %endmacro skip 1+ means that if this macro gets more than one parameter, all the rest parameters would be attached to the first parameter str

Macro with greedy parameters If invoke macro with more parameters than it expects, all the spare parameters get lumped into the last defined one. Example: let’s implement C standard library function int puts(const char * str) Note: same section may be reopened in your code as many times as you wish. Assembler would gather all the pieces of the same section into a single section. myPuts “Print this“, ”and this”, 10 %macro myPuts 1+ section .data %%str: db %1 %%len: equ $- %%str section .text mov ecx, %%str mov edx, %%len mov ebx, 1 mov eax, 4 int 0x80 %endmacro %macro myPuts 1+ mov ecx, ? mov edx, ? mov ebx, 1 ; stdout mov eax, 4 int 0x80 %endmacro

Advanced example of macro usage This macro invokes the PUSH instruction on each of its arguments in turn, from left to right. It begins by pushing its first argument, %1, then invokes %rotate to move all the arguments one place to the left, so that the original second argument is now available as %1. Repeating this procedure as many times as there were arguments (achieved by supplying %0 as the argument to %rep) causes each argument in turn to be pushed. Note also the use of * as the maximum parameter count, indicating that there is no upper limit on the number of parameters you may supply to the multipush macro. %macro multipush 1-* %rep %0 push %1 %rotate 1 %endrep %endmacro It would be convenient, when using this macro, to have a POP equivalent, which didn't require the arguments to be given in reverse order. Ideally, you would write the multipush macro call, then cut-and-paste the line to where the pop needed to be done, and change the name of the called macro to multipop, and the macro would take care of popping the registers in the opposite order from the one in which they were pushed. This macro begins by rotating its arguments one place to the right, so that the original last argument appears as %1. This is then popped, and the arguments are rotated right again, so the second-to-last argument becomes %1. Thus the arguments are iterated through in reverse order. %macro multipop 1-* %rep %0 %rotate -1 pop %1 %endrep %endmacro Read more here