CS 2734 Computer Organization II

• Macro - names a piece of text. The macro name is used in place of the text and cpp replaces it. For example, macro_defs.h contains the macro definitions.

  (FYI: You might want to look in a standard C book about macros.)

• The process of creating an excecutable module can be summarized as follows:

  • Preprocess (cpp) - expand macros (#define) and process #include.

    Note: there is a continuing confusion about #include - this only causes the preprocessor to copy prototypes of functions, it does not actually include the code for the functions. (Do an example with math.h.)

  • Compile or assemble (cc) translates source code into object code. The process produces object modules. Each object module has its own address space.

  • Link the object modules to produce an executable (ld):
    • The address spaces of the separate modules must be merged.
    • External references (such as calls to functions that are defined in other modules) must be resolved:
      • Construct a table of object modules and their lengths.
      • Assign a starting address for each module.
      • Adds the starting address (relocation constant) to all memory addresses.
      • Finds instructions that reference other procedures and inserts the address of the procedure.

• The object modules contain more than source code:
  • ID
  • Entry point table - offsets of symbols in this object module referenced by other modules
  • External reference table - symbols used in this module that are defined in other modules
  • Machine instructions
  • Relocation dictionary - offsets of instructions that have to be relocated.
  • End
  Think about what instructions would cause entries in this table for Sparc. (Note: Sun uses a format called ELF = Executable and Linking Format that has become somewhat of a standard.)

• Static vs Dynamic linking Static linking means linking library functions at compile time to producing an executable. The disadvantages of static linking are:
  • Takes up a lot of room on disk.
  • Everybody is using the same standard libraries.

  Dynamic linking means that the executable doesn't actually contain the library code, but rather library calls are translated into instructions that jump to a linkage table. The entry causes a trap -- allowing the operating system to figure out where the library routine is and to replace that entry with the actual address. Next time the function is called, it doesn't cause a trap. This also allows library code to be shared.

• Discuss Laboratory 7 briefly.

Revision Date: 2/26/97 at 2:45pm