nasmdoc8.htm

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

<h3><a name="section-8.2">8.2 Writing NetBSD/FreeBSD/OpenBSD and Linux/ELF Shared Libraries</a></h3>
<p><code><nobr>ELF</nobr></code> replaced the older
<code><nobr>a.out</nobr></code> object file format under Linux because it
contains support for position-independent code (PIC), which makes writing
shared libraries much easier. NASM supports the
<code><nobr>ELF</nobr></code> position-independent code features, so you
can write Linux <code><nobr>ELF</nobr></code> shared libraries in NASM.
<p>NetBSD, and its close cousins FreeBSD and OpenBSD, take a different
approach by hacking PIC support into the <code><nobr>a.out</nobr></code>
format. NASM supports this as the <code><nobr>aoutb</nobr></code> output
format, so you can write BSD shared libraries in NASM too.
<p>The operating system loads a PIC shared library by memory-mapping the
library file at an arbitrarily chosen point in the address space of the
running process. The contents of the library's code section must therefore
not depend on where it is loaded in memory.
<p>Therefore, you cannot get at your variables by writing code like this:
<p><pre>
        mov     eax,[myvar]             ; WRONG
</pre>
<p>Instead, the linker provides an area of memory called the <em>global
offset table</em>, or GOT; the GOT is situated at a constant distance from
your library's code, so if you can find out where your library is loaded
(which is typically done using a <code><nobr>CALL</nobr></code> and
<code><nobr>POP</nobr></code> combination), you can obtain the address of
the GOT, and you can then load the addresses of your variables out of
linker-generated entries in the GOT.
<p>The <em>data</em> section of a PIC shared library does not have these
restrictions: since the data section is writable, it has to be copied into
memory anyway rather than just paged in from the library file, so as long
as it's being copied it can be relocated too. So you can put ordinary types
of relocation in the data section without too much worry (but see
<a href="#section-8.2.4">section 8.2.4</a> for a caveat).
<h4><a name="section-8.2.1">8.2.1 Obtaining the Address of the GOT</a></h4>
<p>Each code module in your shared library should define the GOT as an
external symbol:
<p><pre>
extern  _GLOBAL_OFFSET_TABLE_   ; in ELF 
extern  __GLOBAL_OFFSET_TABLE_  ; in BSD a.out
</pre>
<p>At the beginning of any function in your shared library which plans to
access your data or BSS sections, you must first calculate the address of
the GOT. This is typically done by writing the function in this form:
<p><pre>
func:   push    ebp 
        mov     ebp,esp 
        push    ebx 
        call    .get_GOT 
.get_GOT: 
        pop     ebx 
        add     ebx,_GLOBAL_OFFSET_TABLE_+$$-.get_GOT wrt ..gotpc 

        ; the function body comes here 

        mov     ebx,[ebp-4] 
        mov     esp,ebp 
        pop     ebp 
        ret
</pre>
<p>(For BSD, again, the symbol
<code><nobr>_GLOBAL_OFFSET_TABLE</nobr></code> requires a second leading
underscore.)
<p>The first two lines of this function are simply the standard C prologue
to set up a stack frame, and the last three lines are standard C function
epilogue. The third line, and the fourth to last line, save and restore the
<code><nobr>EBX</nobr></code> register, because PIC shared libraries use
this register to store the address of the GOT.
<p>The interesting bit is the <code><nobr>CALL</nobr></code> instruction
and the following two lines. The <code><nobr>CALL</nobr></code> and
<code><nobr>POP</nobr></code> combination obtains the address of the label
<code><nobr>.get_GOT</nobr></code>, without having to know in advance where
the program was loaded (since the <code><nobr>CALL</nobr></code>
instruction is encoded relative to the current position). The
<code><nobr>ADD</nobr></code> instruction makes use of one of the special
PIC relocation types: GOTPC relocation. With the
<code><nobr>WRT ..gotpc</nobr></code> qualifier specified, the symbol
referenced (here <code><nobr>_GLOBAL_OFFSET_TABLE_</nobr></code>, the
special symbol assigned to the GOT) is given as an offset from the
beginning of the section. (Actually, <code><nobr>ELF</nobr></code> encodes
it as the offset from the operand field of the
<code><nobr>ADD</nobr></code> instruction, but NASM simplifies this
deliberately, so you do things the same way for both
<code><nobr>ELF</nobr></code> and <code><nobr>BSD</nobr></code>.) So the
instruction then <em>adds</em> the beginning of the section, to get the
real address of the GOT, and subtracts the value of
<code><nobr>.get_GOT</nobr></code> which it knows is in
<code><nobr>EBX</nobr></code>. Therefore, by the time that instruction has
finished, <code><nobr>EBX</nobr></code> contains the address of the GOT.
<p>If you didn't follow that, don't worry: it's never necessary to obtain
the address of the GOT by any other means, so you can put those three
instructions into a macro and safely ignore them:
<p><pre>
%macro  get_GOT 0 

        call    %%getgot 
  %%getgot: 
        pop     ebx 
        add     ebx,_GLOBAL_OFFSET_TABLE_+$$-%%getgot wrt ..gotpc 

%endmacro
</pre>
<h4><a name="section-8.2.2">8.2.2 Finding Your Local Data Items</a></h4>
<p>Having got the GOT, you can then use it to obtain the addresses of your
data items. Most variables will reside in the sections you have declared;
they can be accessed using the <code><nobr>..gotoff</nobr></code> special
<code><nobr>WRT</nobr></code> type. The way this works is like this:
<p><pre>
        lea     eax,[ebx+myvar wrt ..gotoff]
</pre>
<p>The expression <code><nobr>myvar wrt ..gotoff</nobr></code> is
calculated, when the shared library is linked, to be the offset to the
local variable <code><nobr>myvar</nobr></code> from the beginning of the
GOT. Therefore, adding it to <code><nobr>EBX</nobr></code> as above will
place the real address of <code><nobr>myvar</nobr></code> in
<code><nobr>EAX</nobr></code>.
<p>If you declare variables as <code><nobr>GLOBAL</nobr></code> without
specifying a size for them, they are shared between code modules in the
library, but do not get exported from the library to the program that
loaded it. They will still be in your ordinary data and BSS sections, so
you can access them in the same way as local variables, using the above
<code><nobr>..gotoff</nobr></code> mechanism.
<p>Note that due to a peculiarity of the way BSD
<code><nobr>a.out</nobr></code> format handles this relocation type, there
must be at least one non-local symbol in the same section as the address
you're trying to access.
<h4><a name="section-8.2.3">8.2.3 Finding External and Common Data Items</a></h4>
<p>If your library needs to get at an external variable (external to the
<em>library</em>, not just to one of the modules within it), you must use
the <code><nobr>..got</nobr></code> type to get at it. The
<code><nobr>..got</nobr></code> type, instead of giving you the offset from
the GOT base to the variable, gives you the offset from the GOT base to a
GOT <em>entry</em> containing the address of the variable. The linker will
set up this GOT entry when it builds the library, and the dynamic linker
will place the correct address in it at load time. So to obtain the address
of an external variable <code><nobr>extvar</nobr></code> in
<code><nobr>EAX</nobr></code>, you would code
<p><pre>
        mov     eax,[ebx+extvar wrt ..got]
</pre>
<p>This loads the address of <code><nobr>extvar</nobr></code> out of an
entry in the GOT. The linker, when it builds the shared library, collects
together every relocation of type <code><nobr>..got</nobr></code>, and
builds the GOT so as to ensure it has every necessary entry present.
<p>Common variables must also be accessed in this way.
<h4><a name="section-8.2.4">8.2.4 Exporting Symbols to the Library User</a></h4>
<p>If you want to export symbols to the user of the library, you have to
declare whether they are functions or data, and if they are data, you have
to give the size of the data item. This is because the dynamic linker has
to build procedure linkage table entries for any exported functions, and
also moves exported data items away from the library's data section in
which they were declared.
<p>So to export a function to users of the library, you must use
<p><pre>
global  func:function           ; declare it as a function 

func:   push    ebp 

        ; etc.
</pre>
<p>And to export a data item such as an array, you would have to code
<p><pre>
global  array:data array.end-array      ; give the size too 

array:  resd    128 
.end:
</pre>
<p>Be careful: If you export a variable to the library user, by declaring
it as <code><nobr>GLOBAL</nobr></code> and supplying a size, the variable
will end up living in the data section of the main program, rather than in
your library's data section, where you declared it. So you will have to
access your own global variable with the <code><nobr>..got</nobr></code>
mechanism rather than <code><nobr>..gotoff</nobr></code>, as if it were
external (which, effectively, it has become).
<p>Equally, if you need to store the address of an exported global in one
of your data sections, you can't do it by means of the standard sort of
code:
<p><pre>
dataptr:        dd      global_data_item        ; WRONG
</pre>
<p>NASM will interpret this code as an ordinary relocation, in which
<code><nobr>global_data_item</nobr></code> is merely an offset from the
beginning of the <code><nobr>.data</nobr></code> section (or whatever); so
this reference will end up pointing at your data section instead of at the
exported global which resides elsewhere.
<p>Instead of the above code, then, you must write
<p><pre>
dataptr:        dd      global_data_item wrt ..sym
</pre>
<p>which makes use of the special <code><nobr>WRT</nobr></code> type
<code><nobr>..sym</nobr></code> to instruct NASM to search the symbol table
for a particular symbol at that address, rather than just relocating by
section base.
<p>Either method will work for functions: referring to one of your
functions by means of
<p><pre>
funcptr:        dd      my_function
</pre>
<p>will give the user the address of the code you wrote, whereas
<p><pre>
funcptr:        dd      my_function wrt .sym
</pre>
<p>will give the address of the procedure linkage table for the function,
which is where the calling program will <em>believe</em> the function
lives. Either address is a valid way to call the function.
<h4><a name="section-8.2.5">8.2.5 Calling Procedures Outside the Library</a></h4>
<p>Calling procedures outside your shared library has to be done by means
of a <em>procedure linkage table</em>, or PLT. The PLT is placed at a known
offset from where the library is loaded, so the library code can make calls
to the PLT in a position-independent way. Within the PLT there is code to
jump to offsets contained in the GOT, so function calls to other shared
libraries or to routines in the main program can be transparently passed
off to their real destinations.
<p>To call an external routine, you must use another special PIC relocation
type, <code><nobr>WRT ..plt</nobr></code>. This is much easier than the
GOT-based ones: you simply replace calls such as
<code><nobr>CALL printf</nobr></code> with the PLT-relative version
<code><nobr>CALL printf WRT ..plt</nobr></code>.
<h4><a name="section-8.2.6">8.2.6 Generating the Library File</a></h4>
<p>Having written some code modules and assembled them to
<code><nobr>.o</nobr></code> files, you then generate your shared library
with a command such as
<p><pre>
ld -shared -o library.so module1.o module2.o       # for ELF 
ld -Bshareable -o library.so module1.o module2.o   # for BSD
</pre>
<p>For ELF, if your shared library is going to reside in system directories
such as <code><nobr>/usr/lib</nobr></code> or
<code><nobr>/lib</nobr></code>, it is usually worth using the
<code><nobr>-soname</nobr></code> flag to the linker, to store the final
library file name, with a version number, into the library:
<p><pre>
ld -shared -soname library.so.1 -o library.so.1.2 *.o
</pre>
<p>You would then copy <code><nobr>library.so.1.2</nobr></code> into the
library directory, and create <code><nobr>library.so.1</nobr></code> as a
symbolic link to it.
<p align=center><a href="nasmdoc9.html">Next Chapter</a> |
<a href="nasmdoc7.html">Previous Chapter</a> |
<a href="nasmdoc0.html">Contents</a> |
<a href="nasmdoci.html">Index</a>
</body></html>