mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1259 lines
53 KiB
1259 lines
53 KiB
/*
|
|
* TITLE
|
|
* newent.c
|
|
* Pete Stewart
|
|
* (C) Copyright Microsoft Corp 1984-1989
|
|
* 1 October 1984
|
|
*
|
|
* DESCRIPTION
|
|
* This file contains routines for the DOS 4.0 linker
|
|
* that manage per-segment entry point information.
|
|
*
|
|
* It also contains routines that manage per-segment
|
|
* relocation information.
|
|
*
|
|
* Modifications:
|
|
*
|
|
* 09-Feb-1989 RB Fix Insert().
|
|
*/
|
|
|
|
#include <minlit.h> /* Basic type definitions */
|
|
#include <bndtrn.h> /* Constants and compound types */
|
|
#include <bndrel.h> /* Types and constants */
|
|
#include <lnkio.h> /* I/O definitions */
|
|
#include <newexe.h> /* DOS & 286 .EXE format data structures */
|
|
#if EXE386
|
|
#include <exe386.h> /* 386 .EXE format data structures */
|
|
#endif
|
|
#include <lnkmsg.h> /* Error messages */
|
|
#include <extern.h> /* External declarations */
|
|
#include <impexp.h>
|
|
|
|
#define hashra(ra) (WORD) ((ra) % HEPLEN)
|
|
/* Function to hash offset */
|
|
#if NOT EXE386
|
|
#define hashrlc(r) (((NR_SEGNO(*r) << NR_STYPE(*r)) + NR_ENTRY(*r)) & HASH_SIZE - 1)
|
|
/* Hash relocation item */
|
|
#define EOC ((RATYPE) 0xFFFF)
|
|
/* End-of-chain marker */
|
|
#endif
|
|
|
|
#define IsInSet(x) ((pOrdinalSet[(x) >> 3] & BitMask[(x) & 0x07]) != 0)
|
|
#define NotInSet(x) ((pOrdinalSet[(x) >> 3] & BitMask[(x) & 0x07]) == 0)
|
|
#define SetBit(x) (pOrdinalSet[(x) >> 3] |= BitMask[(x) & 0x07])
|
|
#define MaxIndex 8192
|
|
#define ET_END 0xffff
|
|
|
|
/*
|
|
* FUNCTION PROTOTYPES
|
|
*/
|
|
|
|
|
|
LOCAL void NEAR NewBundle(unsigned short type);
|
|
LOCAL WORD NEAR MatchRlc(RLCPTR rlcp0,
|
|
RLCPTR rlcp1);
|
|
#if NOT QCLINK
|
|
LOCAL void NEAR NewEntry(unsigned short sa,
|
|
RATYPE ra,
|
|
unsigned char flags,
|
|
unsigned short hi,
|
|
unsigned short ord);
|
|
LOCAL void SavExp1(APROPNAMEPTR apropexp,
|
|
RBTYPE rhte,
|
|
RBTYPE rprop,
|
|
WORD fNewHte);
|
|
LOCAL void SavExp2(APROPNAMEPTR apropexp,
|
|
RBTYPE rhte,
|
|
RBTYPE rprop,
|
|
WORD fNewHte);
|
|
LOCAL WORD NEAR BuildList(WORD NewOrd, RBTYPE NewProp);
|
|
LOCAL WORD NEAR FindFreeRange(void);
|
|
LOCAL WORD NEAR Insert(RBTYPE NewProp);
|
|
#endif
|
|
|
|
|
|
/*
|
|
* LOCAL DATA
|
|
*/
|
|
|
|
#if NOT QCLINK
|
|
#pragma pack(1)
|
|
|
|
typedef struct _BUNDLE
|
|
{
|
|
BYTE count;
|
|
BYTE type;
|
|
}
|
|
BUNDLE;
|
|
|
|
#pragma pack()
|
|
|
|
LOCAL WORD ceCurBnd; /* No. of entries in current bundle */
|
|
LOCAL WORD offCurBnd; /* Offset of current bundle header */
|
|
LOCAL WORD tyCurBnd; /* Type of current bundle */
|
|
|
|
LOCAL WORD ordMac; /* Highest entry ordinal number */
|
|
LOCAL BYTE *pOrdinalSet;
|
|
#if EXE386
|
|
LOCAL APROPEXPPTR pExport; /* Pointer to export property cell */
|
|
#endif
|
|
LOCAL struct {
|
|
WORD ord; /* Current available ordinal */
|
|
WORD count; /* Number of free ordinals in range */
|
|
}
|
|
FreeRange;
|
|
|
|
LOCAL BYTE BitMask[] = { /* Bit mask used in set operations */
|
|
0x01,
|
|
0x02,
|
|
0x04,
|
|
0x08,
|
|
0x10,
|
|
0x20,
|
|
0x40,
|
|
0x80 };
|
|
|
|
LOCAL WORD MinOrd = 0; /* Min ordinal number see so far */
|
|
LOCAL WORD MaxOrd = 0; /* Max ordinal number see so far */
|
|
RBTYPE pMinOrd = NULL; /* Pointer to property cell with MinOrd */
|
|
LOCAL RBTYPE pMaxOrd = NULL; /* Pointer to property cell with MaxOrd */
|
|
LOCAL RBTYPE pStart;
|
|
|
|
#ifndef UNPOOLED_RELOCS
|
|
LOCAL void * pPoolRlc; /* memory pool for relocations */
|
|
#endif
|
|
|
|
|
|
|
|
#if NOT EXE386
|
|
LOCAL void NEAR NewBundle(type) /* Make a new bundle */
|
|
WORD type; /* Type of new bundle */
|
|
{
|
|
BUNDLE FAR *pBnd; /* Ptr to start of bundle or entry */
|
|
BUNDLE bnd;
|
|
|
|
if (EntryTable.byteMac != 0)
|
|
{
|
|
// If there is a previous bundle patch the count filed
|
|
|
|
pBnd = (BUNDLE FAR *) &(EntryTable.rgByte[offCurBnd]);
|
|
pBnd->count = (BYTE) ceCurBnd;
|
|
}
|
|
|
|
bnd.count = 0;
|
|
bnd.type = (BYTE) type;
|
|
offCurBnd = AddEntry((BYTE *) &bnd, sizeof(BUNDLE));
|
|
ceCurBnd = 0;
|
|
tyCurBnd = type;
|
|
|
|
if (type == ET_END)
|
|
EntryTable.byteMac--;
|
|
}
|
|
#endif
|
|
|
|
|
|
/****************************************************************
|
|
* *
|
|
* NAME: NewEntry *
|
|
* *
|
|
* DESCRIPTION: *
|
|
* *
|
|
* This function makes an entry in the Entry Table for a *
|
|
* given file segment number, offset, and flag set. It also *
|
|
* makes an entry in the entry address hash table on the *
|
|
* given hash chain for the new entry point. N.B.: this *
|
|
* function assumes the static variable ordMac is set to the *
|
|
* desired ordinal value for the entry being added. *
|
|
* *
|
|
* ARGUMENTS: *
|
|
* *
|
|
* SATYPE sa File segment number *
|
|
* RATYPE ra Offset *
|
|
* FTYPE flags Entry point flags *
|
|
* WORD hi Hash table index *
|
|
* WORD ord New ordinal *
|
|
* *
|
|
* RETURNS: *
|
|
* *
|
|
* WORD Offset in Entry Table *
|
|
* *
|
|
* SIDE EFFECTS: *
|
|
* *
|
|
* Maintains a hash table hashing file segment/offset pairs *
|
|
* to entry table offsets. Builds in virtual memory the *
|
|
* Entry Table. Updates the following variables: *
|
|
* *
|
|
* WORD offCurBnd Offset of start of current *
|
|
* bundle of entries. *
|
|
* WORD ceCurBnd Count of entries in cur- *
|
|
* rent bundle. *
|
|
* WORD tyCurBnd Type of current bundle. *
|
|
* WORD cbEntTab Size of Entry Table in *
|
|
* bytes. *
|
|
* *
|
|
* NOTE: THIS FUNCTION CALLS THE VIRTUAL MEMORY MANAGER. *
|
|
* *
|
|
****************************************************************/
|
|
|
|
LOCAL void NEAR NewEntry(sa,ra,flags,hi,ord)
|
|
SATYPE sa; /* File segment number */
|
|
RATYPE ra; /* Segment offset */
|
|
FTYPE flags; /* Entry point flags */
|
|
WORD hi; /* Hash table index */
|
|
WORD ord; /* New ordinal */
|
|
{
|
|
EPTYPE FAR *ep; /* Entry point node */
|
|
#if NOT EXE386
|
|
WORD tyEntry; /* Entry type */
|
|
WORD cbEntry; /* Length of entry in bytes */
|
|
BYTE entry[6]; /* The entry itself - NE version */
|
|
#endif
|
|
#if EXE386
|
|
static WORD prevEntryOrd; // Previous export ordinal
|
|
DWORD eatEntry; /* The entry itself - LE version */
|
|
#endif
|
|
|
|
#if NOT EXE386
|
|
if(sa == SANIL) /* If absolute symbol */
|
|
tyEntry = BNDABS; /* use fake segment # */
|
|
else if (TargetOs == NE_OS2)
|
|
tyEntry = NonConfIOPL(mpsaflags[sa]) ? BNDMOV: sa;
|
|
else
|
|
tyEntry = (mpsaflags[sa] & NSMOVE)? BNDMOV: sa;
|
|
/* Get the entry type */
|
|
/* If not library, or realmode and not solo data, clear local data bit. */
|
|
if(!(vFlags & NENOTP) || (!(vFlags & NEPROT) && !(vFlags & NESOLO)))
|
|
flags &= ~2;
|
|
entry[0] = (BYTE) flags; /* Set the entry flags */
|
|
if(tyEntry == BNDMOV /* If entry is in movable segment */
|
|
#if O68K
|
|
&& iMacType == MAC_NONE
|
|
#endif
|
|
)
|
|
{
|
|
++cMovableEntries; /* Increment movable entries count */
|
|
cbEntry = 6; /* Entry is six bytes long */
|
|
entry[1] = 0xCD; /* INT... */
|
|
entry[2] = 0x3F; /* ...3FH */
|
|
entry[3] = (BYTE) sa; /* File segment number */
|
|
entry[4] = (BYTE) ra; /* Lo-byte of offset */
|
|
entry[5] = (BYTE)(ra >> BYTELN);/* Hi-byte of offset */
|
|
}
|
|
else /* Else if fixed entry */
|
|
{
|
|
cbEntry = 3; /* Entry is three bytes long */
|
|
entry[1] = (BYTE) ra; /* Lo-byte of offset */
|
|
entry[2] = (BYTE)(ra >> BYTELN);/* Hi-byte of offset */
|
|
}
|
|
#endif
|
|
|
|
#if EXE386
|
|
/*
|
|
* This function creates one entry in the Export Address Table.
|
|
* The EAT table is stored in linker's VM in area AREAEAT. The
|
|
* global variable cbEntTab always points to free space in the
|
|
* AREAEAT.
|
|
*/
|
|
|
|
|
|
eatEntry = 0L;
|
|
if ((prevEntryOrd != 0) && (ord > prevEntryOrd + 1))
|
|
{
|
|
// Write unused entries in the Export Address Table
|
|
|
|
for (; prevEntryOrd < ord - 1; prevEntryOrd++)
|
|
{
|
|
if (cbEntTab + sizeof(DWORD) > MEGABYTE)
|
|
Fatal(ER_eatovf, MEGABYTE);
|
|
vmmove(sizeof(DWORD), &eatEntry, (long)(AREAEAT + cbEntTab), TRUE);
|
|
cbEntTab += sizeof(DWORD);
|
|
}
|
|
}
|
|
prevEntryOrd = ord;
|
|
|
|
// FLAT address
|
|
|
|
eatEntry = mpsaBase[sa] + ra;
|
|
|
|
/* Check for Entry Table overflow */
|
|
|
|
if (cbEntTab + sizeof(DWORD) > MEGABYTE)
|
|
Fatal(ER_eatovf, MEGABYTE);
|
|
#endif
|
|
|
|
/* Insert the new entry */
|
|
|
|
#if NOT EXE386
|
|
if (tyCurBnd != tyEntry || ceCurBnd == BNDMAX)
|
|
NewBundle(tyEntry); /* Make a new bundle if needed */
|
|
|
|
++ceCurBnd; /* Increment counter */
|
|
#endif
|
|
|
|
/* Save entry in virtual memory */
|
|
|
|
#if EXE386
|
|
vmmove(sizeof(DWORD), &eatEntry, (long)(AREAEAT + cbEntTab), TRUE);
|
|
#else
|
|
AddEntry(entry, cbEntry);
|
|
#endif
|
|
ep = (EPTYPE FAR *) GetMem(sizeof(EPTYPE));
|
|
ep->ep_next = htsaraep[hi]; /* Link old chain to new node */
|
|
ep->ep_sa = sa; /* Save the file segment number */
|
|
ep->ep_ra = ra; /* Save offset */
|
|
ep->ep_ord = ord; /* Save Entry Table ordinal */
|
|
htsaraep[hi] = ep; /* Make new node head of chain */
|
|
}
|
|
|
|
/****************************************************************
|
|
* *
|
|
* NAME: MpSaRaEto *
|
|
* *
|
|
* DESCRIPTION: *
|
|
* *
|
|
* This function returns an Entry Table ordinal given a *
|
|
* file segment number (sa) for a segment and an offset in *
|
|
* that segment. *
|
|
* *
|
|
* ARGUMENTS: *
|
|
* *
|
|
* SATYPE sa File segment number *
|
|
* RATYPE ra Offset *
|
|
* *
|
|
* RETURNS: *
|
|
* *
|
|
* WORD Entry Table ordinal *
|
|
* *
|
|
* SIDE EFFECTS: *
|
|
* *
|
|
* Calls NewEntry(). Increments ordMac. *
|
|
* *
|
|
* NOTE: THIS FUNCTION CALLS THE VIRTUAL MEMORY MANAGER. *
|
|
* *
|
|
****************************************************************/
|
|
|
|
WORD NEAR MpSaRaEto(sa,ra)
|
|
SATYPE sa; /* File segment number */
|
|
RATYPE ra; /* Segment offset */
|
|
{
|
|
WORD hi; /* Hash table index */
|
|
EPTYPE FAR *ep; /* Entry point node */
|
|
|
|
hi = hashra(ra); /* Hash the offset */
|
|
for (ep = htsaraep[hi]; ep != NULL; ep = ep->ep_next)
|
|
{ /* Loop through hash chain */
|
|
if (ep->ep_sa == sa && ep->ep_ra == ra)
|
|
return(ep->ep_ord);
|
|
/* If match found, return number */
|
|
}
|
|
|
|
// At this point, we know a new entry must be created.
|
|
|
|
NewEntry(sa, ra, 0, hi, ++ordMac); /* Add a new entry */
|
|
return(ordMac); /* Return Entry Table ordinal */
|
|
}
|
|
|
|
|
|
/****************************************************************
|
|
* *
|
|
* NAME: BuildList *
|
|
* *
|
|
* DESCRIPTION: *
|
|
* *
|
|
* This function links the property cells of exports with *
|
|
* preassigned ordinals into list. Global pointers pMinOrd *
|
|
* and pMaxOrd points to the begin and end of this list. The *
|
|
* preassigned ordinals are stored in the set pointed by the *
|
|
* global pointer pOrdinalSet. *
|
|
* *
|
|
* ARGUMENTS: *
|
|
* *
|
|
* WORD NewOrd New preassigned ordinal *
|
|
* RBTYPE NewProp Addr of property cell *
|
|
* *
|
|
* RETURNS: *
|
|
* *
|
|
* TRUE if ordinal seen for the first time, otherwise FALSE. *
|
|
* *
|
|
* SIDE EFFECTS: *
|
|
* *
|
|
* Changes pMinOrd and pMaxOrd pointers, sets bits in ordinal *
|
|
* set and sets MinOrd, MaxOrd seen so far. *
|
|
* *
|
|
****************************************************************/
|
|
|
|
|
|
LOCAL WORD NEAR BuildList(WORD NewOrd, RBTYPE NewProp)
|
|
|
|
{
|
|
RBTYPE pTemp; /* Temporary pointer to property cell */
|
|
APROPEXPPTR pExpCurr; /* Export record pointer */
|
|
APROPEXPPTR pExpPrev; /* Export record pointer */
|
|
|
|
|
|
if (!MinOrd && !MaxOrd)
|
|
{ /* First time call */
|
|
MinOrd = MaxOrd = NewOrd;
|
|
pMinOrd = pMaxOrd = NewProp;
|
|
SetBit(NewOrd);
|
|
return TRUE;
|
|
}
|
|
|
|
if (IsInSet(NewOrd))
|
|
return FALSE; /* Ordinal all ready used */
|
|
|
|
SetBit(NewOrd); /* Set bit in ordinal set */
|
|
|
|
if (NewOrd > MaxOrd)
|
|
{ /* Add new at the list end */
|
|
pExpCurr = (APROPEXPPTR ) FetchSym(pMaxOrd,TRUE);
|
|
pExpCurr->ax_NextOrd = NewProp;
|
|
MARKVP();
|
|
pMaxOrd = NewProp;
|
|
MaxOrd = NewOrd;
|
|
pExpCurr = (APROPEXPPTR ) FetchSym(NewProp,TRUE);
|
|
pExpCurr->ax_NextOrd = NULL;
|
|
MARKVP();
|
|
}
|
|
else if (NewOrd < MinOrd)
|
|
{ /* Add new at list begin */
|
|
pExpCurr = (APROPEXPPTR ) FetchSym(NewProp,TRUE);
|
|
pExpCurr->ax_NextOrd = pMinOrd;
|
|
MARKVP();
|
|
pMinOrd = NewProp;
|
|
MinOrd = NewOrd;
|
|
}
|
|
else
|
|
{ /* Add new in the middle of list */
|
|
pTemp = pMinOrd;
|
|
do
|
|
{
|
|
pExpPrev = (APROPEXPPTR ) FetchSym(pTemp,TRUE);
|
|
pExpCurr = (APROPEXPPTR ) FetchSym(pExpPrev->ax_NextOrd,TRUE);
|
|
if (NewOrd < pExpCurr->ax_ord)
|
|
{
|
|
pTemp = pExpPrev->ax_NextOrd;
|
|
pExpPrev->ax_NextOrd = NewProp;
|
|
MARKVP();
|
|
pExpCurr = (APROPEXPPTR ) FetchSym(NewProp,TRUE);
|
|
pExpCurr->ax_NextOrd = pTemp;
|
|
MARKVP();
|
|
break;
|
|
}
|
|
pTemp = pExpPrev->ax_NextOrd;
|
|
} while (pTemp);
|
|
}
|
|
if(NewOrd > ordMac) ordMac = NewOrd; /* Remember largest ordinal */
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
/****************************************************************
|
|
* *
|
|
* NAME: FindFreeRange *
|
|
* *
|
|
* DESCRIPTION: *
|
|
* *
|
|
* This function finds in the ordinal set first available *
|
|
* free range of ordinals. *
|
|
* *
|
|
* ARGUMENTS: *
|
|
* *
|
|
* Nothing. *
|
|
* *
|
|
* RETURNS: *
|
|
* *
|
|
* TRUE if free range found, otherwise FALSE. *
|
|
* *
|
|
* SIDE EFFECTS: *
|
|
* *
|
|
* Changes FreeRange descriptor by setting first free ordinal *
|
|
* and the lenght of range. *
|
|
* *
|
|
****************************************************************/
|
|
|
|
|
|
|
|
LOCAL WORD NEAR FindFreeRange(void)
|
|
|
|
{
|
|
int ByteIndex;
|
|
int BitIndex;
|
|
|
|
|
|
ByteIndex = FreeRange.ord >> 3;
|
|
BitIndex = FreeRange.ord & 0x07;
|
|
|
|
while ((pOrdinalSet[ByteIndex] & BitMask[BitIndex]) &&
|
|
ByteIndex < MaxIndex)
|
|
{ /* Skip all used ordinals */
|
|
FreeRange.ord++;
|
|
BitIndex = (BitIndex + 1) & 0x07;
|
|
if (!BitIndex)
|
|
ByteIndex++;
|
|
}
|
|
|
|
if (ByteIndex < MaxIndex)
|
|
{
|
|
if (FreeRange.ord > MaxOrd)
|
|
{
|
|
FreeRange.count = 0xffff - MaxOrd;
|
|
return TRUE;
|
|
}
|
|
|
|
do
|
|
{ /* Count all unused ordinals */
|
|
FreeRange.count++;
|
|
BitIndex = (BitIndex + 1) & 0x07;
|
|
if (!BitIndex)
|
|
ByteIndex++;
|
|
} while (!(pOrdinalSet[ByteIndex] & BitMask[BitIndex]) &&
|
|
ByteIndex < MaxIndex);
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
|
|
/****************************************************************
|
|
* *
|
|
* NAME: Insert *
|
|
* *
|
|
* DESCRIPTION: *
|
|
* *
|
|
* This function inserts into the exports list new property *
|
|
* cell without preassigned ordinal. It assigns new ordinal. *
|
|
* *
|
|
* ARGUMENTS: *
|
|
* *
|
|
* RBTYPE NewProp New property cell to insert *
|
|
* *
|
|
* RETURNS: *
|
|
* *
|
|
* New assigned ordinal. *
|
|
* *
|
|
* SIDE EFFECTS: *
|
|
* *
|
|
* Changes FreeRange descriptor and MaxOrd assigned so far. *
|
|
* *
|
|
****************************************************************/
|
|
|
|
|
|
|
|
LOCAL WORD NEAR Insert(RBTYPE NewProp)
|
|
|
|
{
|
|
APROPEXPPTR pExpCurr; /* Export record pointer */
|
|
APROPEXPPTR pExpPrev; /* Export record pointer */
|
|
WORD NewOrd;
|
|
RBTYPE pTemp, rbPrev, rbCur;
|
|
/*
|
|
* On entry, pStart points to the place in the export list where
|
|
* NewProp should be inserted. If NULL, the list is empty.
|
|
*/
|
|
if (!FreeRange.count)
|
|
{
|
|
/* No more space left in current free range; find the next one. */
|
|
if (!FindFreeRange())
|
|
Fatal(ER_expmax);
|
|
/*
|
|
* Update pStart (the insertion point) by walking down the list and
|
|
* finding the first element whose ordinal is greater than the new
|
|
* ordinal, or the end of the list if none is found.
|
|
*/
|
|
rbPrev = RHTENIL;
|
|
for (rbCur = pStart; rbCur != RHTENIL; rbCur = pExpCurr->ax_NextOrd)
|
|
{
|
|
pExpCurr = (APROPEXPPTR) FetchSym(rbCur, FALSE);
|
|
if (pExpCurr->ax_ord > FreeRange.ord)
|
|
break;
|
|
rbPrev = rbCur;
|
|
}
|
|
/* Set pStart to the insertion point. */
|
|
pStart = rbPrev;
|
|
}
|
|
|
|
/* Insert new property cell */
|
|
|
|
NewOrd = FreeRange.ord++;
|
|
FreeRange.count--;
|
|
SetBit(NewOrd);
|
|
pExpCurr = (APROPEXPPTR ) FetchSym(NewProp,TRUE);
|
|
pExpCurr->ax_ord = NewOrd;
|
|
MARKVP();
|
|
if (pStart != NULL)
|
|
{
|
|
// We're not inserting at head of list. Append new cell to previous
|
|
// cell.
|
|
pExpPrev = (APROPEXPPTR ) FetchSym(pStart,TRUE);
|
|
pTemp = pExpPrev->ax_NextOrd;
|
|
pExpPrev->ax_NextOrd = NewProp;
|
|
MARKVP();
|
|
}
|
|
else
|
|
{
|
|
// We're inserting at head of list. Set head list pointer to new
|
|
// cell.
|
|
pTemp = pMinOrd;
|
|
pMinOrd = NewProp;
|
|
}
|
|
/*
|
|
* Set the next pointer to the following element in the list.
|
|
*/
|
|
pExpCurr = (APROPEXPPTR ) FetchSym(NewProp,TRUE);
|
|
pExpCurr->ax_NextOrd = pTemp;
|
|
MARKVP();
|
|
/*
|
|
* Update MaxOrd and pStart.
|
|
*/
|
|
if (NewOrd > MaxOrd)
|
|
MaxOrd++;
|
|
pStart = NewProp;
|
|
return NewOrd;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/****************************************************************
|
|
* *
|
|
* NAME: SavExp1 *
|
|
* *
|
|
* DESCRIPTION: *
|
|
* *
|
|
* This function places the virtual addresses of property *
|
|
* cells for exports with preassigned ordinals into a table *
|
|
* which will later be used to create the first part of the *
|
|
* entry table. It also verifies the validity of the ex- *
|
|
* ports. *
|
|
* *
|
|
* ARGUMENTS: *
|
|
* *
|
|
* APROPEXPPTR apropexp Export record pointer *
|
|
* RBTYPE rhte Addr of hash table entry *
|
|
* RBTYPE rprop Address of export record *
|
|
* FTYPE fNewHte New hash table entry flag *
|
|
* *
|
|
* RETURNS: *
|
|
* *
|
|
* Nothing. *
|
|
* *
|
|
* SIDE EFFECTS: *
|
|
* *
|
|
* Entries are made in a table on the stack to which the *
|
|
* local static variable prb points. The global variable *
|
|
* ordMac is set to the highest ordinal value found. Pro- *
|
|
* perty cells for exports are updated to contain the file *
|
|
* segment number and offset of the entry point. *
|
|
* *
|
|
* NOTE: THIS FUNCTION CALLS THE VIRTUAL MEMORY MANAGER. *
|
|
* *
|
|
****************************************************************/
|
|
|
|
LOCAL void SavExp1(APROPNAMEPTR apropexp,
|
|
RBTYPE rhte,
|
|
RBTYPE rprop,
|
|
WORD fNewHte)
|
|
{
|
|
AHTEPTR ahte; /* Pointer to hash table entry */
|
|
LOCAL APROPNAMEPTR apropnam; /* Public definition record pointer */
|
|
LOCAL APROPPTR aprop; /* temp. pointer */
|
|
WORD ord; /* Entry ordinal */
|
|
SATYPE sa; /* File segment number */
|
|
RATYPE ra; /* Offset in segment */
|
|
WORD fStartSeen=0; /* Have we seen the start of the list */
|
|
APROPEXPPTR pExport;
|
|
char *p;
|
|
|
|
ASSERT(fNewHte); /* Only once per customer */
|
|
pExport = (APROPEXPPTR ) apropexp;
|
|
if((ord = pExport->ax_ord) >= EXPMAX)
|
|
{ /* If ordinal too big */
|
|
pExport->ax_ord = 0; /* Treat as unspecified */
|
|
ord = 0;
|
|
MARKVP(); /* Page has changed */
|
|
/* Issue error message */
|
|
ahte = (AHTEPTR ) FetchSym(rhte,FALSE);
|
|
OutError(ER_ordmax,1 + GetFarSb(ahte->cch));
|
|
}
|
|
apropnam = (APROPNAMEPTR ) FetchSym(pExport->ax_symdef,FALSE);
|
|
/* Fetch the public symbol def. */
|
|
|
|
|
|
for (aprop = (APROPPTR) apropnam; aprop->a_attr != ATTRPNM;)
|
|
{
|
|
|
|
if(aprop->a_attr == ATTRALIAS) /* If an alias */
|
|
{
|
|
aprop = (APROPPTR) FetchSym(
|
|
((APROPALIASPTR)aprop)->al_sym, FALSE );
|
|
if (aprop->a_attr == ATTRPNM) /* The substitute is a public-OK */
|
|
break;
|
|
}
|
|
|
|
aprop = (APROPPTR) FetchSym (aprop->a_next, FALSE);
|
|
if (aprop->a_next == NULL && aprop->a_attr == ATTRNIL) /* Beginning of list */
|
|
{
|
|
aprop = (APROPPTR) FetchSym ( ((AHTEPTR)aprop)->rprop, FALSE);
|
|
fStartSeen ++;
|
|
}
|
|
|
|
if ((aprop != (APROPPTR) apropnam) && (fStartSeen<2))
|
|
continue; /* Find an ALIAS or the starting point */
|
|
|
|
/* Issue error message */
|
|
if(SbCompare(GetPropName(FetchSym(rhte,FALSE)), GetPropName(FetchSym(pExport->ax_symdef,FALSE)), 0))
|
|
{
|
|
/* skip the (alias %s) part */
|
|
OutError(ER_expund,1 + GetPropName(FetchSym(rhte,FALSE)), " ");
|
|
}
|
|
else
|
|
{
|
|
if(p = GetMem(SBLEN + 20))
|
|
sprintf(p, " (alias %s) ", 1 + GetPropName(FetchSym(pExport->ax_symdef,FALSE)));
|
|
OutError(ER_expund,1 + GetPropName(FetchSym(rhte,FALSE)),p);
|
|
if(p) FreeMem(p);
|
|
}
|
|
/* Flag export as undefined */
|
|
pExport = (APROPEXPPTR ) FetchSym(rprop,TRUE);
|
|
pExport->ax_symdef = RHTENIL;
|
|
return;
|
|
}
|
|
|
|
apropnam = (APROPNAMEPTR) aprop;
|
|
sa = mpsegsa[mpgsnseg[apropnam->an_gsn]];
|
|
/* Get the file segment number */
|
|
ra = apropnam->an_ra; /* Get the offset in the segment */
|
|
#if NOT EXE386
|
|
if(apropnam->an_flags & FIMPORT) /* If public is an import */
|
|
{
|
|
/* Issue error message */
|
|
OutError(ER_expimp,1 + GetPropName(FetchSym(rhte,FALSE)),
|
|
1 + GetPropName(FetchSym(pExport->ax_symdef,FALSE)));
|
|
/* Flag export as undefined */
|
|
pExport = (APROPEXPPTR ) FetchSym(rprop,TRUE);
|
|
pExport->ax_symdef = RHTENIL;
|
|
return;
|
|
}
|
|
if (!IsIOPL(mpsaflags[sa])) /* If not I/O privileg segment */
|
|
pExport->ax_flags &= 0x07; /* force parameter words to 0 */
|
|
#endif
|
|
pExport = (APROPEXPPTR ) FetchSym(rprop,TRUE);
|
|
/* Fetch the export property cell */
|
|
pExport->ax_sa = sa; /* Set the file segment number */
|
|
pExport->ax_ra = ra; /* Set the offset in the segment */
|
|
MARKVP();
|
|
if(ord == 0) return; /* Skip unspecified ordinals for now */
|
|
if(!BuildList(ord, rprop)) /* If ordinal conflict found */
|
|
{
|
|
/*
|
|
* Issue error message for ordinal conflict
|
|
*/
|
|
OutError(ER_ordmul,ord,1 + GetPropName(FetchSym(rhte,FALSE)));
|
|
return;
|
|
}
|
|
}
|
|
|
|
/****************************************************************
|
|
* *
|
|
* NAME: SavExp2 *
|
|
* *
|
|
* DESCRIPTION: *
|
|
* *
|
|
* This function enters those exports without preassigned *
|
|
* ordinal numbers into the table to which prb refers. It *
|
|
* also builds the resident and non-resident name tables. *
|
|
* *
|
|
* ARGUMENTS: *
|
|
* *
|
|
* APROPEXPPTR apropexp Export record pointer *
|
|
* RBTYPE rhte Addr of hash table entry *
|
|
* RBTYPE rprop Address of export record *
|
|
* FTYPE fNewHte New hash table entry flag *
|
|
* *
|
|
* RETURNS: *
|
|
* *
|
|
* Nothing. *
|
|
* *
|
|
* SIDE EFFECTS: *
|
|
* *
|
|
* Entries are made in a table in virtual memory. A global *
|
|
* variable is set to contain the highest ordinal value seen. *
|
|
* *
|
|
* NOTE: THIS FUNCTION CALLS THE VIRTUAL MEMORY MANAGER. *
|
|
* *
|
|
****************************************************************/
|
|
|
|
LOCAL void SavExp2(APROPNAMEPTR apropexp,
|
|
RBTYPE rhte,
|
|
RBTYPE rprop,
|
|
WORD fNewHte)
|
|
{
|
|
AHTEPTR ahte; /* Pointer to hash table entry */
|
|
APROPNAMEPTR apropnam; /* Public definition record pointer */
|
|
WORD ord; /* Ordinal number */
|
|
WORD cb; /* # of bytes in name table entry */
|
|
SATYPE sa; /* File segment number */
|
|
FTYPE fResNam; /* True if name is resident */
|
|
FTYPE fNoName; /* True if discard name */
|
|
APROPEXPPTR pExport;
|
|
SBTYPE sbName;
|
|
|
|
|
|
pExport = (APROPEXPPTR ) apropexp;
|
|
if (pExport->ax_symdef == RHTENIL) return;
|
|
/* Skip undefined exports */
|
|
apropnam = (APROPNAMEPTR ) FetchSym(pExport->ax_symdef,FALSE);
|
|
/* Fetch the public symbol def. */
|
|
sa = mpsegsa[mpgsnseg[apropnam->an_gsn]];
|
|
/* Get the file segment number */
|
|
#if NOT EXE386
|
|
if (!IsIOPL(mpsaflags[sa])) /* If not I/O privileg segment */
|
|
pExport->ax_flags &= 0x07; /* force parameter words to 0 */
|
|
#endif
|
|
if ((ord = pExport->ax_ord) == 0) /* If unassigned export found */
|
|
{
|
|
ord = Insert(rprop); /* Add new export to the list */
|
|
fResNam = (FTYPE) TRUE; /* Name is resident */
|
|
}
|
|
else
|
|
fResNam = (FTYPE) ((pExport->ax_nameflags & RES_NAME) != 0);
|
|
/* Else set resident name flag */
|
|
fNoName = (FTYPE) ((pExport->ax_nameflags & NO_NAME) != 0);
|
|
ahte = (AHTEPTR ) FetchSym(rhte,FALSE);
|
|
/* Get external name */
|
|
cb = B2W(ahte->cch[0]) + 1; /* Number of bytes incl. length byte */
|
|
#if EXE386
|
|
/*
|
|
* For linear-executable build the Export Name Pointers Table and
|
|
* Export Name Table. For linear-executable all exported names
|
|
* are put in one Exported Name Table; there is no distiction
|
|
* between resident and non-resident tables. We still support
|
|
* the NONAME keyword by removing the exported name
|
|
* from the Export Name Table.
|
|
*/
|
|
|
|
if (!fNoName)
|
|
{
|
|
if (cb > sizeof(sbName) - sizeof(BYTE))
|
|
cb = sizeof(sbName) - sizeof(BYTE);
|
|
memcpy(sbName, GetFarSb(ahte->cch), cb + 1);
|
|
/* Copy the name to local buffer */
|
|
if (fIgnoreCase)
|
|
SbUcase(sbName); /* Make upper case if ignoring case */
|
|
|
|
// Store the pointer to the name; for now it is an offset from
|
|
// the begin of Export Name Table (be sure that name doesn't
|
|
// cross VM page boundary). Later when the size of the
|
|
// Export Directory Table plus the size of Export Address Table
|
|
// becomes known we update the entries in the Export Name Pointer
|
|
// Table to become a relative virtual address from the Export
|
|
// Directory Table.
|
|
|
|
if ((cbExpName & (PAGLEN - 1)) + cb > PAGLEN)
|
|
cbExpName = (cbExpName + PAGLEN - 1) & ~(PAGLEN - 1);
|
|
|
|
vmmove(sizeof(DWORD), &cbExpName, AREANAMEPTR + cbNamePtr, TRUE);
|
|
cbNamePtr += sizeof(DWORD);
|
|
if (cbNamePtr > NAMEPTRSIZE)
|
|
Fatal(ER_nameptrovf, NAMEPTRSIZE);
|
|
|
|
// Store exported name
|
|
|
|
vmmove(cb, &sbName[1], AREAEXPNAME + cbExpName, TRUE);
|
|
cbExpName += cb;
|
|
if (cbExpName > EXPNAMESIZE)
|
|
Fatal(ER_expnameovf, EXPNAMESIZE);
|
|
}
|
|
#else
|
|
/* Add exported name to segmented-executable name tables */
|
|
|
|
if (fResNam || !fNoName)
|
|
{
|
|
if (cb > sizeof(sbName) - sizeof(BYTE))
|
|
cb = sizeof(sbName) - sizeof(BYTE);
|
|
memcpy(sbName, GetFarSb(ahte->cch), cb + 1);
|
|
/* Copy the name to local buffer */
|
|
if (fIgnoreCase
|
|
#if NOT OUT_EXP
|
|
|| TargetOs == NE_WINDOWS
|
|
#endif
|
|
)
|
|
SbUcase(sbName); /* Make upper case if ignoring case */
|
|
|
|
AddName(fResNam ? &ResidentName : &NonResidentName,
|
|
sbName, ord);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
#pragma check_stack(on)
|
|
|
|
void NEAR InitEntTab()
|
|
{
|
|
BYTE OrdinalSet[MaxIndex];
|
|
/* Ordinal numbers set */
|
|
#if NOT EXE386
|
|
APROPEXPPTR exp; /* Pointer to export property cell */
|
|
#endif
|
|
WORD i; /* Index */
|
|
|
|
tyCurBnd = 0xFFFF; /* Won't match any legal types */
|
|
ceCurBnd = 0; /* No entries yet */
|
|
offCurBnd = 0; /* First bundle at beginning */
|
|
ordMac = 0; /* Assume no exported entries */
|
|
pOrdinalSet = OrdinalSet; /* Set global pointer */
|
|
memset(OrdinalSet,0,MaxIndex*sizeof(BYTE));
|
|
/* Initialize set to empty */
|
|
EnSyms(SavExp1,ATTREXP); /* Enumerate exports with ordinals */
|
|
FreeRange.ord = 1; /* Initialize free range of ordinals */
|
|
FreeRange.count = 0;
|
|
pStart = pMinOrd;
|
|
EnSyms(SavExp2,ATTREXP); /* Enumerate exports without ordinals */
|
|
if (MaxOrd > ordMac)
|
|
ordMac = MaxOrd;
|
|
pStart = pMinOrd;
|
|
for(i = 1; i <= ordMac && pStart != NULL; ++i)
|
|
{ /* Loop to start Entry Table */
|
|
#if EXE386
|
|
pExport = (APROPEXPPTR ) FetchSym(pStart,FALSE);
|
|
/* Fetch symbol from virtual memory */
|
|
pStart = pExport->ax_NextOrd; /* Go down on list */
|
|
NewEntry(pExport->ax_sa, pExport->ax_ra, pExport->ax_flags,
|
|
hashra(pExport->ax_ra), pExport->ax_ord);
|
|
#else
|
|
if(NotInSet(i)) /* If a hole found */
|
|
{
|
|
if (tyCurBnd != BNDNIL || ceCurBnd == BNDMAX)
|
|
NewBundle(BNDNIL);
|
|
/* Make a new bundle if needed */
|
|
++ceCurBnd; /* Increment counter */
|
|
continue; /* Next iteration */
|
|
}
|
|
exp = (APROPEXPPTR ) FetchSym(pStart,FALSE);
|
|
/* Fetch symbol from virtual memory */
|
|
pStart = exp->ax_NextOrd; /* Go down on list */
|
|
NewEntry(exp->ax_sa,exp->ax_ra,exp->ax_flags,hashra(exp->ax_ra),i);
|
|
#endif
|
|
/* Create Entry Table entry */
|
|
}
|
|
#if EXE386
|
|
SortPtrTable();
|
|
pExport = NULL;
|
|
#endif
|
|
}
|
|
|
|
#pragma check_stack(off)
|
|
|
|
|
|
#if NOT EXE386
|
|
|
|
/****************************************************************
|
|
* *
|
|
* NAME: OutEntTab *
|
|
* *
|
|
* DESCRIPTION: *
|
|
* *
|
|
* This function writes the Entry Table to the executable *
|
|
* file. First it writes an empty bundle to mark the end of *
|
|
* the table. *
|
|
* *
|
|
* ARGUMENTS: *
|
|
* *
|
|
* None *
|
|
* *
|
|
* RETURNS: *
|
|
* *
|
|
* Nothing. *
|
|
* *
|
|
* SIDE EFFECTS: *
|
|
* *
|
|
* A table is written to the file specified by the global *
|
|
* file pointer, bsRunfile. This function calls OutVm(), *
|
|
* which CALLS THE VIRTUAL MEMORY MANAGER. *
|
|
* *
|
|
****************************************************************/
|
|
|
|
void NEAR OutEntTab()
|
|
{
|
|
NewBundle(ET_END); /* Append an empty bundle */
|
|
WriteByteArray(&EntryTable); /* Write the table */
|
|
}
|
|
#endif
|
|
|
|
#endif /* NOT QCLINK */
|
|
|
|
#if NOT EXE386
|
|
|
|
|
|
/****************************************************************
|
|
* *
|
|
* NAME: MatchRlc *
|
|
* *
|
|
* DESCRIPTION: *
|
|
* *
|
|
* This function compares two relocation records and returns *
|
|
* TRUE if they match. Two records are said to match if they *
|
|
* agree on the fixup type and the target specification. The *
|
|
* location being fixed up does not have to match. *
|
|
* *
|
|
* ARGUMENTS: *
|
|
* *
|
|
* struct new_rlc *rlcp0 Ptr to relocation record *
|
|
* struct new_rlc *rlcp1 Ptr to relocation record *
|
|
* *
|
|
* RETURNS: *
|
|
* *
|
|
* FTYPE *
|
|
* *
|
|
* SIDE EFFECTS: *
|
|
* *
|
|
* None. *
|
|
* *
|
|
****************************************************************/
|
|
|
|
LOCAL WORD NEAR MatchRlc(rlcp0,rlcp1)
|
|
RLCPTR rlcp0; /* Ptr to struct new_rlc record */
|
|
RLCPTR rlcp1; /* Ptr to struct new_rlc record */
|
|
{
|
|
|
|
if(NR_STYPE(*rlcp0) != NR_STYPE(*rlcp1) ||
|
|
NR_FLAGS(*rlcp0) != NR_FLAGS(*rlcp1)) return(FALSE);
|
|
/* Check flags and type */
|
|
if((NR_FLAGS(*rlcp0) & NRRTYP) == NRRINT)
|
|
{ /* If internal reference */
|
|
return((NR_SEGNO(*rlcp0) == NR_SEGNO(*rlcp1)) &&
|
|
(NR_ENTRY(*rlcp0) == NR_ENTRY(*rlcp1)));
|
|
/* Check internal references */
|
|
}
|
|
return((NR_MOD(*rlcp0) == NR_MOD(*rlcp1)) &&
|
|
(NR_PROC(*rlcp0) == NR_PROC(*rlcp1)));
|
|
/* Check imports */
|
|
}
|
|
|
|
|
|
|
|
/****************************************************************
|
|
* *
|
|
* NAME: SaveFixup *
|
|
* *
|
|
* DESCRIPTION: *
|
|
* *
|
|
* This function saves a fixup record for emission later. In *
|
|
* addition, if the fixup is not additive, it builds chains. *
|
|
* *
|
|
* ARGUMENTS: *
|
|
* *
|
|
* SATYPE saLoc Segment of location to fix *
|
|
* relocation *rlcp Ptr to relocation record *
|
|
* *
|
|
* RETURNS: *
|
|
* *
|
|
* RATYPE *
|
|
* Returns the previous head of the fixup chain so that it *
|
|
* can be stuffed into the location being fixed up. If the *
|
|
* fixup is additive, however, it always returns EOC. *
|
|
* *
|
|
****************************************************************/
|
|
|
|
RATYPE NEAR SaveFixup(SATYPE saLoc, RLCPTR rlcp)
|
|
{
|
|
WORD hi; // Hash index
|
|
RLCHASH FAR *pHt; // Hash table
|
|
RLCBUCKET FAR *pBucket; // Relocation bucket
|
|
WORD fi; // fixup bucket index
|
|
RLCPTR pRlc; // Pointer to relocation record
|
|
WORD tmp;
|
|
RATYPE ra;
|
|
void FAR *pTmp;
|
|
|
|
#ifndef UNPOOLED_RELOCS
|
|
if (pPoolRlc == NULL)
|
|
pPoolRlc = PInit();
|
|
#endif
|
|
|
|
if (mpsaRlc[saLoc] == NULL)
|
|
{
|
|
// Allocate hash vector for physical segment saLoc
|
|
|
|
#ifndef UNPOOLED_RELOCS
|
|
mpsaRlc[saLoc] = (RLCHASH FAR *) PAlloc(pPoolRlc, sizeof(RLCHASH));
|
|
#else
|
|
mpsaRlc[saLoc] = (RLCHASH FAR *) GetMem(sizeof(RLCHASH));
|
|
#endif
|
|
}
|
|
pHt = mpsaRlc[saLoc];
|
|
tmp = hashrlc(rlcp);
|
|
hi = (WORD) tmp;
|
|
pBucket = pHt->hash[hi];
|
|
|
|
#if FALSE
|
|
if (saLoc == 2 && hi == 8)
|
|
{
|
|
fprintf(stdout, "Storing fixup for segment: %d\r\n", saLoc);
|
|
fprintf(stdout, " Source offset: %x; type: %x\r\n", NR_SOFF(*rlcp), NR_STYPE(*rlcp));
|
|
fprintf(stdout, " Hash index: %d\r\n", hi);
|
|
}
|
|
#endif
|
|
if (pBucket && !(NR_FLAGS(*rlcp) & NRADD))
|
|
{
|
|
// For non-additive fixups search the bucket for
|
|
// matching relocation records
|
|
|
|
for(fi = 0; fi < pBucket->count; fi++)
|
|
{
|
|
pRlc = &(pBucket->rgRlc[fi]);
|
|
if (MatchRlc(pRlc, rlcp))
|
|
{
|
|
// Relocation records match - chain them
|
|
|
|
ra = (WORD) NR_SOFF(*pRlc);
|
|
// Save previous head of chain
|
|
NR_SOFF(*pRlc) = NR_SOFF(*rlcp);
|
|
// Insert new head of chain
|
|
#if FALSE
|
|
if (saLoc == 2 && hi == 8)
|
|
fprintf(stdout, " Match found with fixup @%x\r\n", ra);
|
|
#endif
|
|
return(ra); // Return previous head of chain
|
|
}
|
|
}
|
|
}
|
|
|
|
// At this point, we know we have to add a new entry
|
|
// to the bucket we are examining.
|
|
|
|
pHt->count++; // Increment count of fixups per segment
|
|
|
|
#if FALSE
|
|
if (saLoc == 2 && hi == 8)
|
|
fprintf(stdout, " New entry; Count: %d\r\n", pHt->count);
|
|
#endif
|
|
// Check space in the bucket
|
|
|
|
if (pBucket == NULL)
|
|
{
|
|
// Allocate new fixup bucket
|
|
|
|
#ifndef UNPOOLED_RELOCS
|
|
pBucket = (RLCBUCKET FAR *) PAlloc(pPoolRlc, sizeof(RLCBUCKET));
|
|
pBucket->rgRlc = (RLCPTR) PAlloc(pPoolRlc, BUCKET_DEF * sizeof(RELOCATION));
|
|
#else
|
|
pBucket = (RLCBUCKET FAR *) GetMem(sizeof(RLCBUCKET));
|
|
pBucket->rgRlc = (RLCPTR) GetMem(BUCKET_DEF * sizeof(RELOCATION));
|
|
#endif
|
|
pBucket->countMax = BUCKET_DEF;
|
|
pHt->hash[hi] = pBucket;
|
|
}
|
|
else if (pBucket->count >= pBucket->countMax)
|
|
{
|
|
// Realloc fixup bucket
|
|
|
|
#ifndef UNPOOLED_RELOCS
|
|
// REVIEW: for now we just throw away the old memory, we'll free
|
|
// REVIEW: it later, we do this infrequently anyways...
|
|
|
|
pTmp = PAlloc(pPoolRlc, (pBucket->countMax << 1) * sizeof(RELOCATION));
|
|
FMEMCPY(pTmp, pBucket->rgRlc, pBucket->countMax * sizeof(RELOCATION));
|
|
// FFREE(pBucket->rgRlc); NOT MUCH MEMORY WASTED HERE
|
|
#else
|
|
pTmp = GetMem((pBucket->countMax << 1) * sizeof(RELOCATION));
|
|
FMEMCPY(pTmp, pBucket->rgRlc, pBucket->countMax * sizeof(RELOCATION));
|
|
FFREE(pBucket->rgRlc);
|
|
#endif
|
|
pBucket->rgRlc = pTmp;
|
|
pBucket->countMax <<= 1;
|
|
}
|
|
|
|
// Add new relocation record at the end of bucket
|
|
|
|
NR_RES(*rlcp) = '\0'; // Zero the reserved field
|
|
pBucket->rgRlc[pBucket->count] = *rlcp;
|
|
++pBucket->count; // Increment count of fixups
|
|
return(EOC); // Return end-of-chain marker
|
|
}
|
|
|
|
/****************************************************************
|
|
* *
|
|
* NAME: OutFixTab *
|
|
* *
|
|
* DESCRIPTION: *
|
|
* *
|
|
* This fuction writes the load-time relocation (fixup) table *
|
|
* for a given file segment to the execuatble file. *
|
|
* *
|
|
* ARGUMENTS: *
|
|
* *
|
|
* SATYPE sa File segment number *
|
|
* *
|
|
* RETURNS: *
|
|
* *
|
|
* Nothing. *
|
|
* *
|
|
* SIDE EFFECTS: *
|
|
* *
|
|
* A table is written to the file specified by the global *
|
|
* file pointer, bsRunfile. *
|
|
* *
|
|
****************************************************************/
|
|
|
|
void NEAR OutFixTab(SATYPE sa)
|
|
{
|
|
WORD hi; // Hash table index
|
|
RLCHASH FAR *pHt;
|
|
RLCBUCKET FAR *pBucket;
|
|
|
|
|
|
|
|
pHt = mpsaRlc[sa];
|
|
WriteExe(&(pHt->count), CBWORD); // Write the number of relocations
|
|
for (hi = 0; hi < HASH_SIZE; hi++)
|
|
{
|
|
pBucket = pHt->hash[hi];
|
|
if (pBucket != NULL)
|
|
{
|
|
WriteExe(pBucket->rgRlc, pBucket->count * sizeof(RELOCATION));
|
|
#ifdef UNPOOLED_RELOCS
|
|
FFREE(pBucket->rgRlc);
|
|
#endif
|
|
}
|
|
}
|
|
#ifdef UNPOOLED_RELOCS
|
|
FFREE(pHt);
|
|
#endif
|
|
}
|
|
|
|
/****************************************************************
|
|
* *
|
|
* NAME: ReleaseRlcMemory *
|
|
* *
|
|
* DESCRIPTION: *
|
|
* *
|
|
* This function releases the pool(s) of memory that held the *
|
|
* segment relocations *
|
|
* *
|
|
* RETURNS: *
|
|
* *
|
|
* Nothing. *
|
|
* *
|
|
* SIDE EFFECTS: *
|
|
* *
|
|
* pPoolRlc is set to NULL so that we will fail if we should *
|
|
* ever try to allocate more relocations after this point *
|
|
* *
|
|
****************************************************************/
|
|
|
|
void NEAR ReleaseRlcMemory()
|
|
{
|
|
#ifndef UNPOOLED_RELOCS
|
|
// free all the memory associated with the saved relocation
|
|
if (pPoolRlc) {
|
|
PFree(pPoolRlc);
|
|
pPoolRlc = NULL;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
#endif /* NOT EXE386 */
|