Chapter 0: Interlude on Linkers

Originally called a linkage editor by IBM.

A linker is an example of a utility program included with an operating system distribution. Like a compiler, the linker is not part of the operating system per se, i.e. it does not run in supervisor mode. Unlike a compiler it is OS dependent (what object/load file format is used) and is not (normally) language dependent.

0.1: What does a Linker Do?

Link of course.

When the compiler and assembler have finished processing a module, they produce an object module that is almost runnable. There are two remaining tasks to be accomplished for the object module to be runnable. Both are involved with linking (that word, again) together multiple object modules. The tasks are relocating relative addresses and resolving external references.

0.1.1: Relocating Relative Addresses

• Each module is (mistakenly) treated as if it will be loaded at location zero.
• For example, the machine instruction
  jump 100
  is used to indicate a jump to location 100 of the current module.
• To convert this relative address to an absolute address, the linker adds the base address of the module to the relative address. The base address is the address at which this module will be loaded.
• Example: Module A is to be loaded starting at location 2300 and contains the instruction
  jump 120
  The linker changes this instruction to
  jump 2420
• How does the linker know that Module M5 is to be loaded starting at location 2300?
• It processes the modules one at a time. The first module is to be loaded at location zero. So relocating is trivial (adding zero). We say that the relocation constant is zero.
• After processing the first module, the linker knows its length (say that length is L1).
• Hence the next module is to be loaded starting at L1, i.e., the relocation constant is L1.
• In general the linker keeps the sum of the lengths of all the modules it has already processed; this sum is the relocation constant for the next module.

0.1.2: Resolving External Reverences

• If a C (or Java, or Pascal) program contains a function call
  f(x)
  to a function f() that is compiled separately, the resulting object module must contain some kind of jump to the beginning of f.
• But this is impossible!
• When the C program is compiled. the compiler and assembler do not know the location of f() so there is no way they can supply the starting address.
• Instead a dummy address is supplied and a notation made that this address needs to be filled in with the location of f(). This is called a use of f.
• The object module containing the definition of f() contains a notation that f is being defined and gives the relative address of the definitiion, which the linker can convert to an absolute address

The output of a linker is called a load module because it is now ready to be loaded and run.

To see how a linker works lets consider the following example, which is the first dataset from lab #1. The description in lab1 is more detailed.

The target machine is word addressable and has a memory of 250 words, each consisting of 4 decimal digits. The first (leftmost) digit is the opcode and the remaining three digits form an address.

Each object module contains three parts, a definition list, the program text itself, and a use list. Each definition is a pair (sym, loc). Each use is a pair (sym, loc). The address in loc points to the next use or is 888 to end the chain.

The program text consists of a count N followed by N pairs (type, word), where word is a 4-digit instruction described above and type is a single character indicating if the address in the word is Immediate, Absolute, Relative, or External.

Input set #1

1 xy 2
5 R 1004  I 5678  E 2777  R 8002  E 7002
1 z 4
0
6 R 8001  E 1777  E 1001  E 3002  R 1002  A 1010
1 z 3
0
2 R 5001  E 4777
1 z 1
1 z 2
3 A 8000  E 1777  E 2001
1 xy 2

The first pass simply produces the symbol table giving the values for xy and z (2 and 15 respectively). The second pass does the real work (using the values in the symbol table).

(Unofficial) Remark: It is faster (less I/O) to do a one pass approach, but is harder since you need ``fix-up code'' whenever a use occurs in a module that precedes the module with the definition.

            Symbol Table
                xy=2
                z=15

               Memory Map
 +0
 0:       R 1004      1004+0 = 1004
 1:       I 5678               5678
 2: xy:   E 2777 ->z           2015
 3:       R 8002      8002+0 = 8002
 4: ->z   E 7002               7015
 +5    
 0        R 8001      8001+5 = 8006
 1        E 1777 ->z           1015
 2        E 1001 ->z           1015
 3 ->z    E 3002               3015
 4        R 1002      1002+5 = 1007
 5        A 1010               1010
 +11    
 0        R 5001      5001+11= 5012
 1 ->z    E 4777               4015
 +13    
 0        A 8000               8000
 1        E 1777 ->xy          1002
 2 z:->xy E 2001               2002

The linker on unix is mistakenly called ld (for loader), which is unfortunate since it links but does not load.

Lab #1: Implement a linker. The specific assignment is detailed on the sheet handed out in in class and is due 27 September. The content of the handout is available on the web as well (see the class home page).

End of Interlude on Linkers