Register to reply

Confusions about Position Independent Code

by Marmoteer
Tags: addressing, libraries, memory, offset table
Share this thread:
Marmoteer
#1
Feb13-13, 10:38 PM
P: 8
Hello! I was reading this excellent article about position independent code and it's implementation for shared libraries. I'm still confused about one part though. My current understanding is that the offset between the code section and data section is known at compile time. Since this offset never changes, variable references can be reassigned as the position of the currently executing instruction address plus the known offset to the data section. This is where I get confused. The author states that the variable is indirectly addressed via the Global Offset table which resides in the beginning of the DS. The addresses in the GOT are assigned at runtime. What I'm wondering is that if the data section's address is known relative to the current instruction why not just add the offset to the variable instead of going through the Global Offset Table?

To summarize if the GOT address is known relative to the code section and its offset is encoded into each variable/function reference why not just encode the relative variable address instead?

Is it that the the data section is scrambled for some reason and the GOT has the only consistent address? (0x0 I believe in the DS)

Anyway I hope my question isn't too confusing and thanks for the help.
Here's the article referred to in my question - http://eli.thegreenplace.net/2011/11...red-libraries/

Some relevant information:
Relocations - http://en.wikipedia.org/wiki/Relocation_(computing)
Data Segment - http://en.wikipedia.org/wiki/Data_segment
Position Independent Code - http://www.gentoo.org/proj/en/hardened/pic-guide.xml
Phys.Org News Partner Science news on Phys.org
Wildfires and other burns play bigger role in climate change, professor finds
SR Labs research to expose BadUSB next week in Vegas
New study advances 'DNA revolution,' tells butterflies' evolutionary history
rcgldr
#2
Feb14-13, 12:11 AM
HW Helper
P: 7,054
This depends on the addressing modes supported by the processor. On a Motorola 68000 series processor, all memory reference instructions can be PC (program counter) relative, so position independent code just needs to use those PC relative addressing modes. On an Intel X86 processor, only the branch and call instructions are PC relative, the memory reference instructions use other registers as the base and/or index registers, so some scheme needs to be used in order to make X86 code (and data) position independent.

For windows, shared libraries are implemented as dynamic linked libraries instead of using position independent code methods. The code is shared between running processes, but usually each process has it's own copy of the dynamic linked library data. There can also be shared data with a dynamic link library. I'm not sure on the details on how the private and shared data virtual adress spaces are setup. Wiki article:

http://en.wikipedia.org/wiki/Dynamic-link_library

MSDN article:

http://msdn.microsoft.com/en-us/library/ms682594
Marmoteer
#3
Feb15-13, 12:40 PM
P: 8
Right, on Windows relocations are performed to keep the code position independent. I'm pretty sure I understand the mechanism of position independent code on x86 (using instruction relative addressing) I'm just confused why (for linux) the GOT is accessed and used to address the data indirectly when it is in the same section as the data itself. I hope that makes sense.

harborsparrow
#4
Mar6-13, 07:25 PM
PF Gold
harborsparrow's Avatar
P: 347
Confusions about Position Independent Code

The loader gets involved when shared libraries are concerned. When a process is first created for an executable file, all calls to shared libraries are replaced with stubs which actually call "the linking loader". The first time this code executes, the linking loader finds where the shared library ACTUALLY is at that moment and patches in the address of the shared library (and also records, by some means, that this code is using that library so the library can't be "unloaded" too early). For subsequent calls, the code jumps directly to the library without the loader being involved.
harborsparrow
#5
Mar6-13, 07:25 PM
PF Gold
harborsparrow's Avatar
P: 347
Sorry--the above is for "dynamically linked libraries" (DLL's on Windows, or dynamic libraries on Linux or UNIX).
harborsparrow
#6
Mar6-13, 07:26 PM
PF Gold
harborsparrow's Avatar
P: 347
Static libraries on Linux actually copy the library routines right into the executable file, which is bad is lots of ways--thus the invention of dynamic linking.


Register to reply

Related Discussions
Matlab code for time-independent schrodinger equation Quantum Physics 0
Why do we treat velocity and position as independent in a lagrangian Classical Physics 3
C++ Independent Study for Research Position Advice Academic Guidance 12
Musical instrument confusions. General Physics 25
Some confusions Programming & Computer Science 0