nasmdoc4.htm

nasm手册 大家可以看看 对要写汇编程序的帮助很大

<p><pre>
myfunc: push    ebp 
        mov     ebp,esp 
        sub     esp,12
</pre>
<p>The number <code><nobr>1</nobr></code> after the macro name in the
<code><nobr>%macro</nobr></code> line defines the number of parameters the
macro <code><nobr>prologue</nobr></code> expects to receive. The use of
<code><nobr>%1</nobr></code> inside the macro definition refers to the
first parameter to the macro call. With a macro taking more than one
parameter, subsequent parameters would be referred to as
<code><nobr>%2</nobr></code>, <code><nobr>%3</nobr></code> and so on.
<p>Multi-line macros, like single-line macros, are case-sensitive, unless
you define them using the alternative directive
<code><nobr>%imacro</nobr></code>.
<p>If you need to pass a comma as <em>part</em> of a parameter to a
multi-line macro, you can do that by enclosing the entire parameter in
braces. So you could code things like
<p><pre>
%macro  silly 2 

    %2: db      %1 

%endmacro 

        silly 'a', letter_a             ; letter_a:  db 'a' 
        silly 'ab', string_ab           ; string_ab: db 'ab' 
        silly {13,10}, crlf             ; crlf:      db 13,10
</pre>
<h4><a name="section-4.3.1">4.3.1 Overloading Multi-Line Macros</a></h4>
<p>As with single-line macros, multi-line macros can be overloaded by
defining the same macro name several times with different numbers of
parameters. This time, no exception is made for macros with no parameters
at all. So you could define
<p><pre>
%macro  prologue 0 

        push    ebp 
        mov     ebp,esp 

%endmacro
</pre>
<p>to define an alternative form of the function prologue which allocates
no local stack space.
<p>Sometimes, however, you might want to `overload' a machine instruction;
for example, you might want to define
<p><pre>
%macro  push 2 

        push    %1 
        push    %2 

%endmacro
</pre>
<p>so that you could code
<p><pre>
        push    ebx             ; this line is not a macro call 
        push    eax,ecx         ; but this one is
</pre>
<p>Ordinarily, NASM will give a warning for the first of the above two
lines, since <code><nobr>push</nobr></code> is now defined to be a macro,
and is being invoked with a number of parameters for which no definition
has been given. The correct code will still be generated, but the assembler
will give a warning. This warning can be disabled by the use of the
<code><nobr>-w-macro-params</nobr></code> command-line option (see
<a href="nasmdoc2.html#section-2.1.18">section 2.1.18</a>).
<h4><a name="section-4.3.2">4.3.2 Macro-Local Labels</a></h4>
<p>NASM allows you to define labels within a multi-line macro definition in
such a way as to make them local to the macro call: so calling the same
macro multiple times will use a different label each time. You do this by
prefixing <code><nobr>%%</nobr></code> to the label name. So you can invent
an instruction which executes a <code><nobr>RET</nobr></code> if the
<code><nobr>Z</nobr></code> flag is set by doing this:
<p><pre>
%macro  retz 0 

        jnz     %%skip 
        ret 
    %%skip: 

%endmacro
</pre>
<p>You can call this macro as many times as you want, and every time you
call it NASM will make up a different `real' name to substitute for the
label <code><nobr>%%skip</nobr></code>. The names NASM invents are of the
form <code><nobr>[e-mail]</nobr></code>, where the number 2345 changes
with every macro call. The <code><nobr>..@</nobr></code> prefix prevents
macro-local labels from interfering with the local label mechanism, as
described in <a href="nasmdoc3.html#section-3.9">section 3.9</a>. You
should avoid defining your own labels in this form (the
<code><nobr>..@</nobr></code> prefix, then a number, then another period)
in case they interfere with macro-local labels.
<h4><a name="section-4.3.3">4.3.3 Greedy Macro Parameters</a></h4>
<p>Occasionally it is useful to define a macro which lumps its entire
command line into one parameter definition, possibly after extracting one
or two smaller parameters from the front. An example might be a macro to
write a text string to a file in MS-DOS, where you might want to be able to
write
<p><pre>
        writefile [filehandle],"hello, world",13,10
</pre>
<p>NASM allows you to define the last parameter of a macro to be
<em>greedy</em>, meaning that if you invoke the macro with more parameters
than it expects, all the spare parameters get lumped into the last defined
one along with the separating commas. So if you code:
<p><pre>
%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
</pre>
<p>then the example call to <code><nobr>writefile</nobr></code> above will
work as expected: the text before the first comma,
<code><nobr>[filehandle]</nobr></code>, is used as the first macro
parameter and expanded when <code><nobr>%1</nobr></code> is referred to,
and all the subsequent text is lumped into <code><nobr>%2</nobr></code> and
placed after the <code><nobr>db</nobr></code>.
<p>The greedy nature of the macro is indicated to NASM by the use of the
<code><nobr>+</nobr></code> sign after the parameter count on the
<code><nobr>%macro</nobr></code> line.
<p>If you define a greedy macro, you are effectively telling NASM how it
should expand the macro given <em>any</em> number of parameters from the
actual number specified up to infinity; in this case, for example, NASM now
knows what to do when it sees a call to <code><nobr>writefile</nobr></code>
with 2, 3, 4 or more parameters. NASM will take this into account when
overloading macros, and will not allow you to define another form of
<code><nobr>writefile</nobr></code> taking 4 parameters (for example).
<p>Of course, the above macro could have been implemented as a non-greedy
macro, in which case the call to it would have had to look like
<p><pre>
          writefile [filehandle], {"hello, world",13,10}
</pre>
<p>NASM provides both mechanisms for putting commas in macro parameters,
and you choose which one you prefer for each macro definition.
<p>See <a href="nasmdoc5.html#section-5.2.1">section 5.2.1</a> for a better
way to write the above macro.
<h4><a name="section-4.3.4">4.3.4 Default Macro Parameters</a></h4>
<p>NASM also allows you to define a multi-line macro with a <em>range</em>
of allowable parameter counts. If you do this, you can specify defaults for
omitted parameters. So, for example:
<p><pre>
%macro  die 0-1 "Painful program death has occurred." 

        writefile 2,%1 
        mov     ax,0x4c01 
        int     0x21 

%endmacro
</pre>
<p>This macro (which makes use of the <code><nobr>writefile</nobr></code>
macro defined in <a href="#section-4.3.3">section 4.3.3</a>) can be called
with an explicit error message, which it will display on the error output
stream before exiting, or it can be called with no parameters, in which
case it will use the default error message supplied in the macro
definition.
<p>In general, you supply a minimum and maximum number of parameters for a
macro of this type; the minimum number of parameters are then required in
the macro call, and then you provide defaults for the optional ones. So if
a macro definition began with the line
<p><pre>
%macro foobar 1-3 eax,[ebx+2]
</pre>
<p>then it could be called with between one and three parameters, and
<code><nobr>%1</nobr></code> would always be taken from the macro call.
<code><nobr>%2</nobr></code>, if not specified by the macro call, would
default to <code><nobr>eax</nobr></code>, and <code><nobr>%3</nobr></code>
if not specified would default to <code><nobr>[ebx+2]</nobr></code>.
<p>You 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
<code><nobr>%0</nobr></code> token (see <a href="#section-4.3.5">section
4.3.5</a>) allows you to determine how many parameters were really passed
to the macro call.
<p>This defaulting mechanism can be combined with the greedy-parameter
mechanism; so the <code><nobr>die</nobr></code> macro above could be made
more powerful, and more useful, by changing the first line of the
definition to
<p><pre>
%macro die 0-1+ "Painful program death has occurred.",13,10
</pre>
<p>The maximum parameter count can be infinite, denoted by
<code><nobr>*</nobr></code>. In this case, of course, it is impossible to
provide a <em>full</em> set of default parameters. Examples of this usage
are shown in <a href="#section-4.3.6">section 4.3.6</a>.
<h4><a name="section-4.3.5">4.3.5 <code><nobr>%0</nobr></code>: Macro Parameter Counter</a></h4>
<p>For a macro which can take a variable number of parameters, the
parameter reference <code><nobr>%0</nobr></code> will return a numeric
constant giving the number of parameters passed to the macro. This can be
used as an argument to <code><nobr>%rep</nobr></code> (see
<a href="#section-4.5">section 4.5</a>) in order to iterate through all the
parameters of a macro. Examples are given in
<a href="#section-4.3.6">section 4.3.6</a>.
<h4><a name="section-4.3.6">4.3.6 <code><nobr>%rotate</nobr></code>: Rotating Macro Parameters</a></h4>
<p>Unix shell programmers will be familiar with the
<code><nobr>shift</nobr></code> shell command, which allows the arguments
passed to a shell script (referenced as <code><nobr>$1</nobr></code>,
<code><nobr>$2</nobr></code> and so on) to be moved left by one place, so
that the argument previously referenced as <code><nobr>$2</nobr></code>
becomes available as <code><nobr>$1</nobr></code>, and the argument
previously referenced as <code><nobr>$1</nobr></code> is no longer
available at all.
<p>NASM provides a similar mechanism, in the form of
<code><nobr>%rotate</nobr></code>. As its name suggests, it differs from
the Unix <code><nobr>shift</nobr></code> in that no parameters are lost:
parameters rotated off the left end of the argument list reappear on the
right, and vice versa.
<p><code><nobr>%rotate</nobr></code> is invoked with a single numeric
argument (which may be an expression). The macro parameters are rotated to
the left by that many places. If the argument to
<code><nobr>%rotate</nobr></code> is negative, the macro parameters are
rotated to the right.
<p>So a pair of macros to save and restore a set of registers might work as
follows:
<p><pre>
%macro  multipush 1-* 

  %rep  %0 
        push    %1 
  %rotate 1 
  %endrep 

%endmacro
</pre>
<p>This macro invokes the <code><nobr>PUSH</nobr></code> instruction on
each of its arguments in turn, from left to right. It begins by pushing its
first argument, <code><nobr>%1</nobr></code>, then invokes
<code><nobr>%rotate</nobr></code> to move all the arguments one place to
the left, so that the original second argument is now available as
<code><nobr>%1</nobr></code>. Repeating this procedure as many times as
there were arguments (achieved by supplying <code><nobr>%0</nobr></code> as
the argument to <code><nobr>%rep</nobr></code>) causes each argument in
turn to be pushed.
<p>Note also the use of <code><nobr>*</nobr></code> as the maximum
parameter count, indicating that there is no upper limit on the number of
parameters you may supply to the <code><nobr>multipush</nobr></code> macro.
<p>It would be convenient, when using this macro, to have a
<code><nobr>POP</nobr></code> equivalent, which <em>didn't</em> require the
arguments to be given in reverse order. Ideally, you would write the
<code><nobr>multipush</nobr></code> 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 <code><nobr>multipop</nobr></code>, and the macro would take care of
popping the registers in the opposite order from the one in which they were
pushed.
<p>This can be done by the following definition:
<p><pre>
%macro  multipop 1-* 

  %rep %0 
  %rotate -1 
        pop     %1 
  %endrep 

%endmacro
</pre>
<p>This macro begins by rotating its arguments one place to the
<em>right</em>, so that the original <em>last</em> argument appears as
<code><nobr>%1</nobr></code>. This is then popped, and the arguments are
rotated right again, so the second-to-last argument becomes
<code><nobr>%1</nobr></code>. Thus the arguments are iterated through in
reverse order.
<h4><a name="section-4.3.7">4.3.7 Concatenating Macro Parameters</a></h4>
<p>NASM can concatenate macro parameters on to other text surrounding them.
This allows you to declare a family of symbols, for example, in a macro
definition. If, for example, you wanted to generate a table of key codes
along with offsets into the table, you could code something like
<p><pre>
%macro keytab_entry 2 

    keypos%1    equ     $-keytab 
                db      %2 

%endmacro 

keytab: 
          keytab_entry F1,128+1 
          keytab_entry F2,128+2 
          keytab_entry Return,13
</pre>
<p>which would expand to
<p><pre>