Linking Modules and Creating EXE File

This is the last phase of program compilation – linking all modules and creating the executable file for program. Turbo Pascal first marks all symbol table blocks for variables, typed constants, procedures and code blocks as unused, then it iterates through all modules and marks used blocks starting from the main program, after that it calculates code offsets, variable offsets, resolves references, and finally, it writes code to either overlay file or to the executable file.

Procedure Link;
Var SavedHeapPtr1: Word;
    SavedHeapPtr2: Word;
    UnitCodeSize: Word;
    NumberOfUnprocessedUnitsForReferences: Word;

begin
  UnitPtrRec.Ofs := 0;
  If not (LinkBufferOnDisk in LinkerOptions) then
    begin
      UnitPtrRec.Seg := LastLoadedUsedUnit;
      Repeat
        LoadUnitFileSymbolTables (stCode, stTypedConstantsReferences);
        UnitPtr^.UnitPathAndNameOffset := 0;
        UnitPtrRec.Seg := UnitPtr^.PreviousUnitSegment;
      until UnitPtrRec.Seg = 0;
    end;
  MarkProcCodeConstVarBlocksAsUnused;
  PUnitHeader (Ptr (LastLoadedUsedUnit, 0))^.OverlayedUnitCodeSize := 0;
  PUnitHeader (Ptr (SystemUnitSegment, 0))^.OverlayedUnitCodeSize := 0;
  Repeat
    UnitPtrRec.Seg := LastLoadedUsedUnit;
    NumberOfUnprocessedUnitsForReferences := 0;
    Repeat
      If UnitPtr^.NumberOfUnprocessedBlocksForReferences <> 0 then
        begin
          SavedHeapPtr1 := HeapPtrRec.Seg;
          LoadUnitFileSymbolTables (stCodeReferences, stTypedConstantsReferences);
          MarkUsedBlocksInUnit;
          HeapPtrRec.Seg := SavedHeapPtr1;
          Inc (NumberOfUnprocessedUnitsForReferences);
        end;
      UnitPtrRec.Seg := UnitPtr^.PreviousUnitSegment;
    until UnitPtrRec.Seg = 0;
  until NumberOfUnprocessedUnitsForReferences = 0;
  CurrentCodeSegment := 0;
  OverlayHeapSize := 0;
  CurrentRelocationItemOffset := RelocationTableOffset;
  CalculateCodeBlockOffsetsAndTotalCodeSize;
  DataSegment := CurrentCodeSegment;
  CalculateVariableOffsetsAndTotalDataSize;
  CalculateFirstFreeSegment;
  If not (cmoCreateExeFile in CompilerModeOptions) then
    begin
      UnitPtrRec.Seg := LastLoadedUsedUnit;
      HeapPtrRec.Seg := UnitPtr^.SymbolTableSegment [stCode];
      Exit;
    end;
  SavedHeapPtr1 := HeapPtrRec.Seg;
  CreateExeFile;
  If OverlayHeapSize <> 0 then
    begin
      FindFilePath (StrCopy (@Identifier, CurrentFileName), Dir_Forced or Dir_EXE_TPU or Ext_Forced or Ext_OVR);
      CreateFile (OverlayFile, @Identifier);
      OutputFileHandle := FileRec (OverlayFile).Handle;
      Seek (OverlayFile, 8);
    end;
  OverlayCodeList := 0;
  OverlayHeader.OverlaySize.Long := 8;
  ExeHeaderBuffer.Ofs := RelocationTableOffset;
  UnitPtrRec.Seg := LastLoadedUsedUnit;
  Repeat
    SavedHeapPtr2 := HeapPtrRec.Seg;
    LoadUnitFileSymbolTables (stCode, stTypedConstantsReferences);
    With  UnitPtr^ do
      begin
        UnitCodeSize := CodeSize;
        If UnitCodeSize < OverlayedUnitCodeSize then UnitCodeSize := OverlayedUnitCodeSize;
      end;
    CurrentUnitCodeSegment := HeapPtrRec.Seg;
    Inc (HeapPtrRec.Seg, (UnitCodeSize + $000F) shr 4);
    If HeapPtrRec.Seg > HeapEndRec.Seg then Error (OutOfMemory);
    ResolveReferences (stCodeBlocks, UnitPtr^.SymbolTableSegment [stCode], UnitPtr^.SymbolTableSegment [stCodeReferences]);
    JoinUsedSymbolTables (stCodeBlocks, UnitPtr^.SymbolTableSegment [stCode], CurrentUnitCodeSegment);
    If UnitPtr^.OverlayedUnitCodeSize <> 0 then
      begin
        BlockWrite (OverlayFile, Ptr (CurrentUnitCodeSegment, 0)^, UnitPtr^.OverlayedUnitCodeSize);
        CreateSegmentReferencesTableForOverlayedUnit;
        BlockWrite (OverlayFile, Ptr (CurrentUnitCodeSegment, 0)^, UnitPtr^.NumberOfSegmentReferencesInProgramCodeBlocks * 2);
        CreateProcedureOffsetsTableForOverlayedUnit;
      end else WriteRelocationItems (stCodeBlocks, UnitPtr^.SymbolTableSegment [stCodeReferences], UnitPtr^.CodeSegment);
    FillChar (Ptr (CurrentUnitCodeSegment, UnitPtr^.CodeSize)^, 16 - UnitPtr^.CodeSize and $000F, 0);
    BlockWrite (ExeFile, Ptr (CurrentUnitCodeSegment, 0)^, (UnitPtr^.CodeSize + $000F) and $FFF0);
    ResolveReferences (stTypedConstantsBlocks, UnitPtr^.SymbolTableSegment [stTypedConstants],
                                             UnitPtr^.SymbolTableSegment [stTypedConstantsReferences]);
    JoinUsedSymbolTables (stTypedConstantsBlocks, UnitPtr^.SymbolTableSegment [stTypedConstants], TypedConstantsPointer.Seg);
    WriteRelocationItems (stTypedConstantsBlocks, UnitPtr^.SymbolTableSegment [stTypedConstantsReferences], DataSegment);
    HeapPtrRec.Seg := SavedHeapPtr2;
    UnitPtrRec.Seg := UnitPtr^.PreviousUnitSegment;
  until UnitPtrRec.Seg = 0;
  WriteTypedConstantsAndExeHeader;
  If OverlayHeapSize <> 0 then
    begin
      Seek (OverlayFile, 0);
      Dec (OverlayHeader.OverlaySize.Long, 8);
      BlockWrite (OverlayFile, OverlayHeader, 9);
      Close (OverlayFile);
    end;
  HeapPtrRec.Seg := SavedHeapPtr1;
  UnitPtrRec.Seg := LastLoadedUsedUnit;
  HeapPtrRec.Seg := UnitPtr^.SymbolTableSegment [stCode];
  If DebugInformationInExe in LinkerOptions then
    begin
      Seek (ExeFile, ExeFileSize);
      SavedHeapPtr1 := HeapPtrRec.Seg;
      AddDebugInfoToExeFile;
      HeapPtrRec.Seg := SavedHeapPtr1;
    end;
  ExeFileHandle := 0;
  Close (ExeFile);
  If LinkerOptions * [MapFileWithSegments, MapFileWithPublics] <> [] then
    begin
      SavedHeapPtr1 := HeapPtrRec.Seg;
      CreateMapFile;
      HeapPtrRec.Seg := SavedHeapPtr1;
    end;
end;

This procedure writes relocation items (pointers to segment references) for all used blocks in a unit.

Procedure WriteRelocationItems (Block: TSymbolTable; Seg1, Seg2: Word);
Var CodeConstVarBlockRecord: PCodeConstVarBlockRecord;
    CodeConstVarBlockRecordPtrRec: PtrRec absolute CodeConstVarBlockRecord;
    ReferencesBlockRecord: PReferencesBlockRecord;
    ReferencesBlockRecordPtrRec: PtrRec absolute ReferencesBlockRecord;

  Procedure WriteRelocationItemsForBlock;
  Var EndOffset: Word;
  begin
    EndOffset := ReferencesBlockRecordPtrRec.Ofs + CodeConstVarBlockRecord^.ReferencesSize;
    While ReferencesBlockRecordPtrRec.Ofs <> EndOffset do
      begin
        If rfSegment in ReferencesBlockRecord^.Flags then
          begin
            With RelocationTable^ do
              begin
                Offset := ReferencesBlockRecord^.PositionOfReference + CodeConstVarBlockRecord^.Offset;
                If rfOffset in ReferencesBlockRecord^.Flags then Inc (Offset, 2);
                Segment := Seg2;
              end;
            Inc (RelocationTable);
          end;
        Inc (ReferencesBlockRecord);
      end;
  end;

begin
  ReferenceRecordsSegment := Seg1;
  CodeConstVarBlockRecord := Ptr (UnitPtrRec.Seg, UnitPtr^.BlockOffset [Block]);
  ReferencesBlockRecord := Ptr (ReferenceRecordsSegment, 0);
  While CodeConstVarBlockRecordPtrRec.Ofs <> UnitPtr^.BlockOffset [Succ (Block)] do
    begin
      If CodeConstVarBlockRecord^.Offset <> $FFFF then WriteRelocationItemsForBlock else
        Inc (ReferencesBlockRecordPtrRec.Ofs, CodeConstVarBlockRecord^.ReferencesSize);
      Inc (CodeConstVarBlockRecord);
    end;
end;

This procedure creates table of offsets to each segment reference in a unit.

Procedure CreateSegmentReferencesTableForOverlayedUnit;
Var ProgramCodeBlock: PCodeConstVarBlockRecord;
    ProgramCodeBlockPtrRec: PtrRec absolute ProgramCodeBlock;
    ReferencesBlockRecord: PReferencesBlockRecord;
    ReferencesBlockRecordPtrRec: PtrRec absolute ReferencesBlockRecord;
    SegmentReferencesTable: PWord;

  Procedure CreateSegmentReferencesTableForOneCodeBlock;
  Var EndOffset, OffsetOfReference: Word;
  begin
    EndOffset := ReferencesBlockRecordPtrRec.Ofs + ProgramCodeBlock^.ReferencesSize;
    While ReferencesBlockRecordPtrRec.Ofs <> EndOffset do
      begin
        If rfSegment in ReferencesBlockRecord^.Flags then
          begin
            OffsetOfReference := ReferencesBlockRecord^.PositionOfReference + ProgramCodeBlock^.Offset;
            If rfOffset in ReferencesBlockRecord^.Flags then Inc (OffsetOfReference, 2);
            SegmentReferencesTable^ := OffsetOfReference;
            Inc (SegmentReferencesTable);
          end;
        Inc (ReferencesBlockRecordPtrRec.Ofs, 8);
      end;
  end;

begin
  ReferenceRecordsSegment := UnitPtr^.SymbolTableSegment [stCodeReferences];
  ReferencesBlockRecord := Ptr (ReferenceRecordsSegment, 0);
  SegmentReferencesTable := Ptr (CurrentUnitCodeSegment, 0);
  ProgramCodeBlock := Ptr (UnitPtrRec.Seg, UnitPtr^.BlockOffset [stCodeBlocks]);
  While ProgramCodeBlockPtrRec.Ofs <> UnitPtr^.BlockOffset [Succ (stCodeBlocks)] do
    begin
      If ProgramCodeBlock^.Offset <> $FFFF then
        CreateSegmentReferencesTableForOneCodeBlock else
          Inc (ReferencesBlockRecordPtrRec.Ofs, ProgramCodeBlock^.ReferencesSize);
      Inc (ProgramCodeBlock);
    end;
end;

This procedure creates table of offsets to procedures in an overlayed unit.

Procedure CreateProcedureOffsetsTableForOverlayedUnit;
Var TempPtr: PWord;
    ProceduresBlockRecord: PProceduresBlockRecord;
    ProceduresBlockRecordPtrRec: PtrRec absolute ProceduresBlockRecord;
    N: Byte;
begin
  TempPtr := Ptr (CurrentUnitCodeSegment, 0);
  TempPtr^ := $3FCD;
  Inc (TempPtr);
  TempPtr^ := 0;
  Inc (TempPtr);
  TempPtr^ := OverlayHeader.OverlaySize.WordL;
  Inc (TempPtr);
  TempPtr^ := OverlayHeader.OverlaySize.WordH;
  Inc (TempPtr);
  TempPtr^ := UnitPtr^.OverlayedUnitCodeSize;
  Inc (TempPtr);
  TempPtr^ := UnitPtr^.NumberOfSegmentReferencesInProgramCodeBlocks * 2;
  Inc (TempPtr);
  TempPtr^ := (UnitPtr^.CodeSize - $20) div 5;
  Inc (TempPtr);
  TempPtr^ := OverlayCodeList;
  Inc (TempPtr);
  For N := 1 to 8 do
    begin
      TempPtr^ := 0;
      Inc (TempPtr);
    end;
  ProceduresBlockRecord := Ptr (UnitPtrRec.Seg, UnitPtr^.BlockOffset [stProcedures]);
  Repeat
    If ProceduresBlockRecord^.OverlayedProcedureOffset <> 0 then
      begin
        TempPtr^ := $3FCD;
        Inc (TempPtr);
        TempPtr^ := ProceduresBlockRecord^.SizeOfConstants + PProgramCodeBlockRecord (Ptr (UnitPtrRec.Seg,
                       UnitPtr^.BlockOffset [stCodeBlocks] + ProceduresBlockRecord^.ProgramCodeBlockRecordOffset))^.Offset;
        Inc (TempPtr);
        Byte (TempPtr^) := 0;
        Inc (PChar (TempPtr));
      end;
    Inc (ProceduresBlockRecord);
  until ProceduresBlockRecordPtrRec.Ofs = UnitPtr^.BlockOffset [Succ (stProcedures)];
  Inc (OverlayHeader.OverlaySize.Long, UnitPtr^.OverlayedUnitCodeSize);
  Inc (OverlayHeader.OverlaySize.Long, UnitPtr^.NumberOfSegmentReferencesInProgramCodeBlocks * 2);
  OverlayCodeList := UnitPtr^.CodeSegment;
end;