archive
/
windows-nt-4.0
mirror of https://github.com/lianthony/NT4.0
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Windows NT 4.0 source code leak
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.
2 Commits
1 Branch
0 Tags
184 MiB
 
 
 
 
 
 
Tree: b4a8d373d8
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'b4a8d373d8'
${ noResults }
windows-nt-4.0/private/sdktools/vctools/link/coff/incr.cpp

6139 lines
133 KiB
Raw Blame History

/***********************************************************************
* Microsoft (R) 32-Bit Incremental Linker
*
* Copyright (C) Microsoft Corp 1992-1996. All rights reserved.
*
* File: incr.cpp
*
* File Comments:
*
* ilink routines that didn't find a place elsewhere.
*
***********************************************************************/
#include "link.h"
// statics
static PLIB plibModObjs; // linker defined lib for the modified cmdline objs
static LPEXT lpextWeak = {CPEXT_WEAK, 0, 0, 0}; // list that has the weak/lazy externs
static PLPEXT plpextWeak = &lpextWeak; // list that has the weak/lazy externs
static LPEXT lpextMultDef = {CPEXT_MULT, 0, 0, 0}; // list that will hold potential
static PLPEXT plpextMultDef = &lpextMultDef; // multiply defined syms.
static PLEXT plextMovedData; // list of data externs that have moved
static WORD cmods; // count of MODs in project
static DWORD cReloc; // count of relocs
static PGRP pgrpIdata$4;
static PGRP pgrpIdata$5;
static PGRP pgrpIdata$6;
// globals
struct ILINK_INFO
{
const void *pvJumpEntry;
size_t cbJumpEntry;
WORD address_offset;
BYTE bPad;
};
static const ILINK_INFO *ilink_info;
static const BYTE I386JmpTblEntry[] = { // jmp rel32
0xE9,
0x00, 0x00, 0x00, 0x00
};
static const ILINK_INFO I386_ilink = {
I386JmpTblEntry,
sizeof(I386JmpTblEntry),
1,
X86_INT3
};
static const BYTE MPPCJmpTblEntry[] = { // for MacPPC
0x00, 0x00, 0x00, 0x00
};
static const ILINK_INFO MPPC_ilink = {
MPPCJmpTblEntry,
sizeof(MPPCJmpTblEntry),
0,
0 // 0xFF
};
static const DWORD MIPSJmpTblEntry[] = {
0x03e04025, /* or t0,ra,zero */
0x04110001, /* bgezal zero,0xc */
0x00000000, /* nop */
0x8fe90014, /* lw t1,20(ra) */
0x013f4821, /* addu t1,t1,ra */
0x25290018, /* addiu t1,t1,24 */
0x01200008, /* jr t1 */
0x0100f825, /* or ra,t0,zero */
0xdeadbeef, /* ld t5,-16657(s5) */
};
static const ILINK_INFO MIPS_ilink = {
MIPSJmpTblEntry,
sizeof(MIPSJmpTblEntry),
sizeof(MIPSJmpTblEntry)-4,
0xff
};
static const DWORD ALPHAJmpTblEntry[] = {
0xc0000000, // br $0, zero Pick up PC value
0x20600014, // lda 20($3), zero
0xa0a3fffc, // ldl $5, -4($3)
0x40a30003, // addl $5, $3, $3
0x68030000, // jmp zero, $3
0x00000000 // halt (maintain 16 byte align and puke if execute)
};
static const ILINK_INFO ALPHA_ilink = {
ALPHAJmpTblEntry,
sizeof(ALPHAJmpTblEntry),
sizeof(ALPHAJmpTblEntry)-4,
0xff
};
size_t cbJumpEntry;
PLMOD plmodNewModsFromLibSrch; // list of mods added as a result of lib search.
// reloc counting function
void CountBaseRelocsPMOD(PMOD, DWORD *);
// weak extern prototypes
void AssignWeakDefinition(PEXTERNAL, PEXTERNAL, PST);
// calc ptrs prototypes
void FindSlotForPCON(PCON);
// export function prototypes
BOOL FExpFileChanged(PEXPINFO);
// library inclusion
BOOL CheckForUnrefLibMods(PIMAGE);
void CheckForMultDefns(PIMAGE, PLPEXT);
#ifdef ILINKLOG
DWORD dwBegin;
void
IlinkLog (
UINT FullLinkErr
)
{
DWORD cb;
char McName[32];
char rgchOut[1024];
char szFname[_MAX_FNAME + _MAX_EXT];
char szExt[_MAX_EXT];
char rgchLogFilename[] = "\\\\fabrice2\\public\\linker\\ilink.log";
HANDLE hFile;
const int cRetry = 1;
int i;
// user requested no logging
if (!fIlinkLog) {
return;
}
if (!fINCR) {
// non-incremental link
if (FullLinkErr == -1) {
strcpy(rgchOut, "RLINK ");
} else {
strcpy(rgchOut, "RFAIL ");
}
} else if (fIncrDbFile) {
// Incremental link
if (errInc == errNone) {
strcpy(rgchOut, "ILINK ");
} else {
strcpy(rgchOut, "IFAIL ");
}
} else {
// Full link
if (FullLinkErr == -1) {
strcpy(rgchOut, "FLINK ");
} else {
strcpy(rgchOut, "FFAIL ");
}
}
// Name of machine
cb = 32;
if (!GetComputerName(McName, &cb)) {
strcpy(McName, "UNKNOWN");
}
sprintf(szFname, "%-10s", McName); // for better formatting
strcat(rgchOut, szFname);
strcat(rgchOut, " ");
// put in linker version
strcat(rgchOut, " ");
strcat(rgchOut, VERSION_STR);
strcat(rgchOut, " ");
// time for the link
sprintf(McName, "%08ld ", (DWORD)(GetTickCount() - dwBegin));
strcat(rgchOut, McName);
// name of target
if (OutFilename) {
_splitpath(OutFilename, NULL, NULL, szFname, szExt);
strcat(rgchOut, "\"");
strcat(rgchOut, szFname);
strcat(rgchOut, szExt);
strcat(rgchOut, "\" ");
} else {
strcat(rgchOut, " NOOUTPUTFILE ");
}
// report target platform
char *szPlatform;
switch (wMachine) {
case IMAGE_FILE_MACHINE_I386 :
szPlatform = " IX86 ";
break;
case IMAGE_FILE_MACHINE_R3000 :
case IMAGE_FILE_MACHINE_R4000 :
case IMAGE_FILE_MACHINE_R10000 :
szPlatform = " MIPS ";
break;
case IMAGE_FILE_MACHINE_ALPHA :
szPlatform = " ALFA ";
break;
case IMAGE_FILE_MACHINE_POWERPC :
szPlatform = " PWPC ";
break;
case IMAGE_FILE_MACHINE_M68K :
szPlatform = " M68K ";
break;
case IMAGE_FILE_MACHINE_MPPC_601 :
szPlatform = " MPPC ";
break;
default :
szPlatform = " UNKN ";
break;
}
strcat(rgchOut, szPlatform);
// put out the host platform
if (IsOSWin95()) {
strcat(rgchOut, " WIN95 ");
} else {
strcat(rgchOut, " WINNT ");
}
// put out the date
time_t ltime;
_tzset();
time((time_t *)&ltime);
char *szTime = ctime(&ltime);
if (szTime != NULL) {
szTime[strlen(szTime) - 1] = '\0';
strcat(rgchOut, szTime);
} else {
strcat(rgchOut, "notime");
}
strcat(rgchOut, " ");
if (fIncrDbFile) {
// Incremental link
switch (errInc) {
case errNone:
break;
case errOutOfDiskSpace:
strcat(rgchOut, "OUT_OF_DISKSPACE");
break;
case errOutOfMemory:
strcat(rgchOut, "OUT_OF_MEMORY");
break;
case errFpo:
strcat(rgchOut, "FPO_PAD_OVERFLOW");
break;
case errTypes:
strcat(rgchOut, "ERROR_TYPES");
break;
case errDataMoved:
strcat(rgchOut, "DATA_MOVED");
break;
case errCalcPtrs:
strcat(rgchOut, "PAD_OVERFLOW");
break;
case errUndefinedSyms:
strcat(rgchOut, "UNDEFINED_SYMS");
break;
case errWeakExtern:
strcat(rgchOut, "WEAK_EXTERN");
break;
case errCommonSym:
strcat(rgchOut, "NEW_BSS_SYM");
break;
case errAbsolute:
strcat(rgchOut, "ABSOLUTE_SYM");
break;
case errJmpTblOverflow:
strcat(rgchOut, "JMP_TBL_OVERFLOW");
break;
case errDirectives:
strcat(rgchOut, "DIRECTIVS_CHNG");
break;
case errBaseReloc:
strcat(rgchOut, "BASERELOC_PAD_OVERFLOW");
break;
case errFileAdded:
strcat(rgchOut, "NEW_FILE_ADDED");
break;
case errFileDeleted:
strcat(rgchOut, "FILE_DELETED_OR_RENAMED");
break;
case errLibChanged:
strcat(rgchOut, "LIB_CHANGED");
break;
case errTooManyChanges:
strcat(rgchOut, "TOO_MANY_CHANGES");
break;
case errExports:
strcat(rgchOut, "EXPORTS_CHANGED");
break;
case errLibRefSetChanged:
strcat(rgchOut, "LIB_REFSET_CHANGED");
break;
case errMultDefFound:
strcat(rgchOut, "MULTIPLE_DEFN_FOUND");
break;
case errComdat:
strcat(rgchOut, "COMDAT_SEL_FAILED");
break;
case errNoChanges:
strcat(rgchOut, "NO_CHANGES");
break;
default:
strcat(rgchOut, "UNKNOWN");
}
} else {
// Full link
if (FullLinkErr != -1) {
sprintf(McName, "error %04u", FullLinkErr);
strcat(rgchOut, McName);
}
}
strcat(rgchOut, "\r\n");
for (i = 0; i < cRetry; i++) {
hFile = CreateFile(rgchLogFilename,
GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ,
NULL,
OPEN_ALWAYS,
FILE_ATTRIBUTE_NORMAL,
NULL);
if (hFile != INVALID_HANDLE_VALUE) {
break;
}
// Sleep(100); // sleep for 0.1s and retry
}
// tried our best to log an entry.
if (i == cRetry) {
return;
}
assert(hFile != INVALID_HANDLE_VALUE);
// Seek to end of file
SetFilePointer(hFile, 0, NULL, FILE_END);
// Write
WriteFile(hFile, rgchOut, strlen(rgchOut), &cb, NULL);
// Close the file.
CloseHandle(hFile);
}
#endif // ILINKLOG
BOOL
FArgOnList (
PNAME_LIST pnl,
PARGUMENT_LIST parg
)
/*++
Routine Description:
Searches for the arg on the list. Marks the list entries as processed.
Arguments:
pnl - list to search
parg - arg to look for.
Return Value:
TRUE if found else FALSE
--*/
{
WORD i;
PARGUMENT_LIST pal;
assert(parg);
// walk the list
for (i = 0, pal = pnl->First;
i < pnl->Count;
i++, pal = pal->Next) {
// skip already processed entries
if (pal->Flags & ARG_Processed) {
continue;
}
if (!strcmp(pal->OriginalName, parg->OriginalName)) {
pal->Flags |= ARG_Processed;
return 1;
}
}
// not found
return 0;
}
void
AddArgToListOnHeap (
PNAME_LIST pnl,
PARGUMENT_LIST parg
)
/*++
Routine Description:
Adds the arg to the name list on private heap.
Arguments:
pnl - ptr to name list on private heap
parg - arg to add
Return Value:
None.
--*/
{
PARGUMENT_LIST pal;
assert(parg);
// alloc space
pal = (PARGUMENT_LIST) Malloc(sizeof(ARGUMENT_LIST));
// fill in fields
pal->OriginalName = Strdup(parg->OriginalName);
if (parg->ModifiedName) {
pal->ModifiedName = Strdup(parg->ModifiedName);
} else {
pal->ModifiedName = NULL;
}
pal->Next = NULL;
// attach it to list
if (!pnl->First) {
pnl->First = pal;
} else {
pnl->Last->Next = pal;
}
// update count
pnl->Count++;
// update last member
pnl->Last = pal;
// done
return;
}
void
AddExtToList(
PLPEXT plpext,
BOOL fTempList,
PEXTERNAL pext
)
/*++
Routine Description:
Adds the extern to the specified list.
Arguments:
plpext - pointer to list of externs
fTempList - list is a temporary list
pext - external sym to add.
Return Value:
None.
--*/
{
EXTERNAL **rgpext;
if ((plpext->pextChunkCur == NULL) || (plpext->cpextCur >= plpext->cpextMax)) {
// allocate a chunk
size_t cb = sizeof(EXTCHUNK) + plpext->cpextMax * sizeof(PEXTERNAL);
EXTCHUNK *pextChunk = fTempList ? (EXTCHUNK *) PvAlloc(cb):
(EXTCHUNK *) Malloc(cb);
// update state
pextChunk->pextChunkNext = plpext->pextChunkCur;
plpext->pextChunkCur = pextChunk;
plpext->cpextCur = 0;
}
rgpext = RgPext(plpext->pextChunkCur);
rgpext[plpext->cpextCur++] = pext;
plpext->cpextTotal++;
}
void
DelExtFromList(
PLPEXT plpext,
PEXTERNAL pext
)
/*++
Routine Description:
Removes the extern from the specified list.
Arguments:
plpext - pointer to list of externs
pext - external sym to add.
Return Value:
None.
--*/
{
EXTCHUNK *pextChunk;
WORD cpextMax;
for (pextChunk = plpext->pextChunkCur, cpextMax = plpext->cpextCur;
pextChunk != NULL;
pextChunk = pextChunk->pextChunkNext, cpextMax = plpext->cpextMax) {
EXTERNAL **rgpext;
WORD ipext;
rgpext = RgPext(pextChunk);
for (ipext = 0; ipext < cpextMax; ipext++) {
if (rgpext[ipext] == pext) {
rgpext[ipext] = NULL;
plpext->cpextTotal--;
return;
}
}
}
}
BOOL
IsExtListEmpty (
PLPEXT plpext
)
/*++
Routine Description:
Checks to see if the specified list is empty.
Arguments:
plpext - pointer to list of externs
Return Value:
TRUE if list is empty.
--*/
{
return(!plpext->cpextTotal);
}
//
// Enumerator of all externs in list
//
INIT_ENM(ExtList, EXT_LIST, (ENM_EXT_LIST *penm, PLPEXT plpext)) {
if (plpext) {
penm->lpext = (*plpext);
} else {
penm->lpext.pextChunkCur = NULL;
}
penm->ipext = 0;
}
NEXT_ENM(ExtList, EXT_LIST) {
if (penm->lpext.pextChunkCur == NULL) {
return(FALSE);
}
{
EXTERNAL **rgpext = RgPext(penm->lpext.pextChunkCur);
penm->pext = rgpext[penm->ipext++];
}
if (penm->ipext == penm->lpext.cpextCur) {
penm->lpext.pextChunkCur = penm->lpext.pextChunkCur->pextChunkNext;
penm->lpext.cpextCur = penm->lpext.cpextMax;
penm->ipext = 0;
}
return(TRUE);
}
END_ENM(ExtList, EXT_LIST) {
}
DONE_ENM
void
AddExtToModRefList (
PMOD pmod,
PEXTERNAL pext
)
/*++
Routine Description:
Adds the extern to the specified MODs reference list.
Arguments:
pmod - pointer to MOD
pext - external sym to add.
Return Value:
None.
--*/
{
if (!(pext->Flags & EXTERN_NO_REFS)) {
AddExtToList(pmod->plpextRef, FALSE, pext);
}
}
void
RemoveAllRefsToPext (
PEXTERNAL pext
)
/*++
Routine Description:
Removes all references made to this extern. This is done to
enable checking for correct library module inclusion
Arguments:
pext - external sym whose references need to be removed
Return Value:
None.
--*/
{
ENM_MOD_EXT enmModExt;
if (!pext->pmodOnly) {
return;
}
// walk the list of referencing MODs kept at each sym
InitEnmModExt(&enmModExt, pext);
while (FNextEnmModExt(&enmModExt)) {
if (!enmModExt.pmod) {
continue; // for ilink we remove references
}
DelExtFromList(enmModExt.pmod->plpextRef, pext);
}
}
BOOL
RemoveExtFromDefList (
PMOD pmod,
PEXTERNAL pext
)
/*++
Routine Description:
Removes extern from defined list of MOD if present.
Arguments:
pmod - ptr to MOD.
pext - external sym which needs to be removed from DEF list
Return Value:
TRUE if we did find pext in the list & removed it
--*/
{
PEXTERNAL *ppextPrev, pextCur;
pextCur = pmod->pextFirstDefined;
ppextPrev = &pmod->pextFirstDefined;
while (pextCur) {
if (pextCur == pext) {
(*ppextPrev) = pextCur->pextNextDefined; // remove pext from chain
pextCur->pextNextDefined = NULL; // set next field to NULL for pext just removed
return(TRUE);
}
ppextPrev = &pextCur->pextNextDefined;
pextCur = pextCur->pextNextDefined;
}
return(FALSE);
}
void
RemovePrevDefn (
PEXTERNAL pext
)
/*++
Routine Description:
All externs defined by a MOD are chained together. Need to remove
it from that chain.
For COMMON syms this is difficult since pext->pcon->pmodBack is
a "linker defined module". .
Arguments:
pext - external sym whose references need to be removed
Return Value:
None.
--*/
{
ENM_MOD_EXT enmModExt;
assert(pext->Flags & EXTERN_COMMON);
if (fIncrDbFile) {
assert(PmodPCON(pext->pcon) == pmodLinkerDefined);
}
assert(pext->pmodsFirst);
// walk the list of referencing MODs kept at each sym
// one of these MODs has defined the COMMON (eeewww!!!)
InitEnmModExt(&enmModExt, pext);
while (FNextEnmModExt(&enmModExt)) {
if (!enmModExt.pmod) {
continue; // for ilink we remove references
}
if (RemoveExtFromDefList(enmModExt.pmod, pext)) {
return; // found the definition
}
}
}
void
ProcessUndefinedExternals(
PIMAGE pimage
)
/*++
Routine Description:
Makes a pass over the undefined externals to see if they are really undefined.
REVIEW: Need to make a pass over this again w/ regard to weak externs since
we are doing lib searches now.
Arguments:
pimage - pointer to image
Return Value:
None.
--*/
{
PEXTERNAL pext;
ENM_UNDEF_EXT enmUndefExt;
PST pst = pimage->pst;
// First pass thru symbols checks for cases which may cause a full
// link. This way we avoid giving any warnings & later decide to do
// a full link after all.
InitEnmUndefExt(&enmUndefExt, pst);
while (FNextEnmUndefExt(&enmUndefExt)) {
pext = enmUndefExt.pext;
// symbol to be ignored
if ((pext->Flags & EXTERN_DEFINED) ||
(pext->Flags & EXTERN_IGNORE) )
continue;
// symbol no longer referenced by anybody
if (!FPextRef(pext)) {
SetDefinedExt(pext, TRUE, pst); // take it off undef list
pext->Flags = EXTERN_IGNORE;
pext->pcon = NULL; // clean
pext->ImageSymbol = NullSymbol; // clean
continue;
}
// if symbol undefined & marked relink then relink (for bss with multiple defn)
if (pext->Flags & EXTERN_RELINK) {
errInc = errCommonSym;
return;
}
// a COMDAT with a reference, dirty files didn't have defn but atleast one of the
// non-dirty files has a reference & may (or may not) have a defn
if (pext->Flags & EXTERN_COMDAT) {
errInc = errComdat;
return;
}
// undefined sym
#ifdef INSTRUMENT
{
char *szOutSymName;
szOutSymName = SzOutputSymbolName(SzNamePext(pext, pst), TRUE);
LogNoteEvent(Log, SZILINK, NULL, letypeEvent, "undefined sym: %s", szOutSymName);
if (szOutSymName != SzNamePext(pext, pst)) {
free(szOutSymName);
}
}
#endif // INSTRUMENT
errInc = errUndefinedSyms;
} // end while
}
BOOL
IsExpObj (
const char *szName
)
/*++
Routine Description:
Is the name specified an export object.
Arguments:
szName - name of file.
Return Value:
TRUE if export object else FALSE
--*/
{
char szDrive[_MAX_DRIVE];
char szDir[_MAX_DIR];
char szFname[_MAX_FNAME];
char szExt[_MAX_EXT];
char szExpFilename[_MAX_FNAME];
char szImplibFilename[_MAX_FNAME];
const char *szImplibT;
// generate possible import lib name (could be user specified)
if ((szImplibT = ImplibFilename) == NULL) {
_splitpath(OutFilename, szDrive, szDir, szFname, szExt);
_makepath(szImplibFilename, szDrive, szDir, szFname, ".lib");
szImplibT = szImplibFilename;
}
// Generate possible export filename
_splitpath(szImplibT, szDrive, szDir, szFname, NULL);
_makepath(szExpFilename, szDrive, szDir, szFname, ".exp");
// check to see if the names match
if (!_tcsicmp(szName, szExpFilename)) {
return 1;
}
return 0;
}
PARGUMENT_LIST
PargFindSz (
const char *szName,
PNAME_LIST ptrList
)
/*++
Routine Description:
Find the module in the given list
Arguments:
szName - name of file.
ptrList - list to search
Return Value:
pointer to argument or NULL
--*/
{
DWORD i;
PARGUMENT_LIST parg;
for (i = 0, parg = ptrList->First;
i < ptrList->Count;
i++, parg=parg->Next) {
// original name to handle resource files etc.
if (!_tcsicmp(szName, parg->OriginalName)) {
return parg;
}
}
return NULL;
}
BOOL
IsDirtyPMOD (
PMOD pmod
)
/*++
Routine Description:
Checks to see if this MOD if dirty.
Arguments:
pmod - ptr to a MOD.
Return Value:
TRUE if it is dirty.
--*/
{
// is it referenced by a modified file?
PARGUMENT_LIST parg = PargFindSz(SzOrigFilePMOD(pmod), &ModFileList);
return(parg != NULL);
}
void
AddToModList (
PARGUMENT_LIST parg,
WORD Flags
)
/*++
Routine Description:
Adds entry to modified list.
Arguments:
parg - pointer to entry to be added.
Flags - flags of entry
Return Value:
None.
--*/
{
PARGUMENT_LIST ptrList;
ptrList = (PARGUMENT_LIST) PvAlloc(sizeof(ARGUMENT_LIST));
// fill in fields
ptrList->OriginalName = parg->OriginalName;
ptrList->ModifiedName = parg->ModifiedName;
ptrList->TimeStamp = parg->TimeStamp;
ptrList->Flags = Flags;
ptrList->Next = NULL;
// If first member to be added.
if (!ModFileList.Last) {
ModFileList.Last = ptrList;
} else {
// Not first member, so add to the front.
ptrList->Next = ModFileList.First;
}
// Increment number of members in list.
++ModFileList.Count;
// Remember first member in list.
ModFileList.First = ptrList;
}
void
ProcessFileArg (
PARGUMENT_LIST parg,
WORD Flags,
DWORD TimeStamp,
DWORD HdrTimeStamp,
DWORD cbFile,
char *szOrigName,
BOOL fExpFileGen,
BOOL *pfLib,
BOOL *pfDel
)
/*++
Routine Description:
Adds entry to modified list.
Arguments:
parg - pointer to entry to be added if not NULL.
Flags - obj or lib
Timestamp - filssystem timestamp of obj or lib
HdrTimeStamp - timestamp in the hdr of obj file (ignored for obj in lib)
cbFile - size of object file (ignored for obj in lib)
szOrigName - original name of file (used for deleted files)
Return Value:
None.
--*/
{
ARGUMENT_LIST arg;
// found a matching name
if (parg) {
parg->Flags |= ARG_Processed;
// modified file
if (parg->TimeStamp != TimeStamp) {
if (Flags & ARG_Library) { // library modified
#ifdef INSTRUMENT
LogNoteEvent(Log, SZILINK, SZINIT, letypeEvent, "lib modified: %s", parg->OriginalName);
#endif // INSTRUMENT
*pfLib = 1;
} else { // object file modified
IMAGE_FILE_HEADER imFileHdr;
FileReadHandle = FileOpen(parg->ModifiedName, O_RDONLY | O_BINARY, 0);
ReadFileHeader(FileReadHandle, &imFileHdr);
assert(HdrTimeStamp);
assert(cbFile);
// file not really changed - touched for MR
if (imFileHdr.TimeDateStamp == HdrTimeStamp &&
FileLength(FileReadHandle) == (LONG) cbFile) {
FileClose(FileReadHandle, TRUE);
return;
}
FileClose(FileReadHandle, FALSE);
}
Flags |= ARG_Modified;
AddToModList(parg, Flags);
DBEXEC(DB_LISTMODFILES, DBPRINT("Modified File= %s\n",
parg->OriginalName));
DBEXEC(DB_LISTMODFILES, DBPRINT("\tOld TimeStamp= %s",
ctime((time_t *)&TimeStamp)));
DBEXEC(DB_LISTMODFILES, DBPRINT("\tNew TimeStamp= %s",
ctime((time_t *)&parg->TimeStamp)));
// unmodified file
} else {
DBEXEC(DB_LISTMODFILES, DBPRINT("Unchanged File= %s\n",parg->OriginalName));
}
// did not find matching name
} else {
// check to see if this is an export object
if (fExpFileGen && IsExpObj(szOrigName)) {
return;
}
*pfDel = 1;
arg.OriginalName = arg.ModifiedName = szOrigName;
Flags |= ARG_Deleted;
AddToModList(&arg, Flags);
#ifdef INSTRUMENT
LogNoteEvent(Log, SZILINK, SZINIT, letypeEvent, "file deleted: %s", szOrigName);
#endif // INSTRUMENT
DBEXEC(DB_LISTMODFILES, DBPRINT("Deleted File= %s\n",szOrigName));
}
}
void
InitModFileList (
PIMAGE pimage,
BOOL *pfLib,
BOOL *pfNew,
BOOL *pfDel
)
/*++
Routine Description:
Builds a list of files whose timestamp is newer than the
previous link.
Arguments:
pimage - image structure
pfLib - set to TRUE if LIB was modified
pfNew - set to TRUE if a NEW file was added
pfDel - Set to TRUE if an existing MOD was deleted
Return Value:
None.
--*/
{
PARGUMENT_LIST parg;
ARGUMENT_LIST arg;
DWORD i;
PLIB plib;
PMOD pmod;
ENM_MOD enm_mod;
ENM_LIB enm_lib;
*pfLib = 0;
*pfNew = 0;
*pfDel = 0;
// check out mods
InitEnmMod(&enm_mod, pimage->plibCmdLineObjs);
while (FNextEnmMod(&enm_mod)) {
pmod = enm_mod.pmod;
cmods++;
assert(pmod);
parg = PargFindSz(SzOrigFilePMOD(pmod), &FilenameArguments);
ProcessFileArg(parg,
ARG_Object,
pmod->TimeStamp,
pmod->HdrTimeStamp,
pmod->cbFile,
SzOrigFilePMOD(pmod),
pimage->ExpInfo.pmodGen != NULL,
pfLib,
pfDel);
}
EndEnmMod(&enm_mod);
// check out libs
InitEnmLib(&enm_lib, pimage->libs.plibHead);
while (FNextEnmLib(&enm_lib)) {
plib = enm_lib.plib;
assert(plib);
if (plib->flags & LIB_DontSearch) {
continue;
}
if (plib->flags & LIB_Default) {
struct _stat statfile;
char szFname[_MAX_FNAME];
char szExt[_MAX_EXT];
char szFilename[_MAX_FNAME + _MAX_EXT];
_splitpath(plib->szName, NULL, NULL, szFname, szExt);
strcpy(szFilename, szFname);
strcat(szFilename, szExt);
char *sz = SzSearchEnv("LIB", szFilename, LIB_EXT);
// lib names don't match
if (_tcsicmp(plib->szName, sz)) {
parg = NULL;
} else {
arg.OriginalName = arg.ModifiedName = sz;
if (_stat(arg.OriginalName, &statfile) == -1) {
Fatal(NULL, CANTOPENFILE, arg.OriginalName);
}
arg.TimeStamp = statfile.st_mtime;
parg = &arg;
}
} else {
parg = PargFindSz(plib->szName, &FilenameArguments);
}
ProcessFileArg(parg, ARG_Library, plib->TimeStamp,
0, 0, plib->szName, FALSE, pfLib, pfDel);
}
EndEnmLib(&enm_lib);
// check for new files
for (i = 0, parg = FilenameArguments.First;
i < FilenameArguments.Count;
i++, parg = parg->Next) {
RESN *pTempResn;
// already processed
if (parg->Flags & ARG_Processed) {
continue;
}
// check for repeated args
if (PmodFind(pimage->plibCmdLineObjs, parg->OriginalName, 0) ||
PlibFind(parg->OriginalName, pimage->libs.plibHead, FALSE)) {
continue;
}
parg->Flags |= ARG_Processed;
// check to see if it happens to be a PowerMac resource
if ((pTempResn = GetMacResourcePointer(parg->OriginalName, pimage)) != NULL) {
if (pTempResn->TimeStamp == parg->TimeStamp) {
continue;
} else {
PostNote(NULL, RESFILECHANGE, parg->OriginalName);
}
}
AddToModList(parg, ARG_NewFile);
*pfNew = 1;
DBEXEC(DB_LISTMODFILES, DBPRINT("New File= %s\n",parg->OriginalName));
#ifdef INSTRUMENT
LogNoteEvent(Log, SZILINK, SZINIT, letypeEvent, "new file: %s", parg->OriginalName);
#endif // INSTRUMENT
}
}
void
DoPass2PMOD (
IN PMOD pmod,
IN BOOL fDoDebug
)
/*++
Routine Description:
Mark the MOD for doing pass2 and for doing debug info if required.
CAVEAT: A MOD cannot change state from MOD_DoDebug to !MOD_DoDebug
or vice-versa during the same link.
Arguments:
pmod - ptr to MOD
fDoDebug - TRUE if debug info needs to be done during Pass2
Return Value:
None.
--*/
{
PLIB plib;
ENM_MOD enm_mod;
// already marked for doing pass2
if (FDoPass2PMOD(pmod)) {
return;
}
// mark for doing pass2
pmod->LnkFlags |= MOD_DoPass2;
if (fDoDebug) {
pmod->LnkFlags |= MOD_DoDebug;
}
// done if command line obj
if (!FIsLibPMOD(pmod)) {
return;
}
// mark MODs with the same name for Pass2 (DBI hack for import libs)
plib = pmod->plibBack;
// REVIEW: base reloc count is not accurate
InitEnmMod(&enm_mod, plib);
while (FNextEnmMod(&enm_mod)) {
if (!_tcsicmp(SzOrigFilePMOD(enm_mod.pmod),SzOrigFilePMOD(pmod))) {
enm_mod.pmod->LnkFlags |= MOD_DoPass2;
CountBaseRelocsPMOD(enm_mod.pmod, &cReloc);
if (fDoDebug) {
enm_mod.pmod->LnkFlags |= MOD_DoDebug;
}
}
}
EndEnmMod(&enm_mod);
}
void
DetermineTimeStamps (
VOID
)
/*++
Routine Description:
Determine timestamps of all files.
Arguments:
None.
Return Value:
None.
--*/
{
PARGUMENT_LIST argument;
DWORD i;
struct _stat statfile;
for (i = 0, argument = FilenameArguments.First;
i < FilenameArguments.Count;
argument = argument->Next, i++) {
// determine current timestamp of file
if (_stat(argument->OriginalName, &statfile) == -1) {
Fatal(NULL, CANTOPENFILE, argument->OriginalName);
}
argument->TimeStamp = statfile.st_mtime;
}
}
// assign the weak definition
void
AssignWeakDefinition (
PEXTERNAL pext,
PEXTERNAL pextWeakDefault,
PST pst
)
{
// define the weak/lazy external to its "default"
assert(pext);
assert(pextWeakDefault);
if ((pextWeakDefault->Flags & EXTERN_DEFINED)) {
PMOD pmod;
pext->ImageSymbol.Value =
pextWeakDefault->ImageSymbol.Value;
// + PsecPCON(pext->pextWeakDefault->pcon)->rva;
pext->ImageSymbol.SectionNumber =
pextWeakDefault->ImageSymbol.SectionNumber;
pext->ImageSymbol.Type =
pextWeakDefault->ImageSymbol.Type;
SetDefinedExt(pext, TRUE, pst);
pext->Flags |= (EXTERN_DEFINED|EXTERN_DIRTY);
pext->pcon = pextWeakDefault->pcon;
pext->FinalValue = pextWeakDefault->FinalValue;
// chain up extern to mod defining it
pmod = PmodPCON(pext->pcon);
assert(pmod);
if (pmod->pextFirstDefined) {
pext->pextNextDefined = pmod->pextFirstDefined;
}
pmod->pextFirstDefined = pext;
}
}
// All existing weak & lazy externs can be resolved. The 'lazy' because
// ilink assumes libs haven't changed and so there is no need to search
// the libs.
void
ResolveExistingWeakAndLazyExterns (
PIMAGE pimage
)
{
ENM_EXT_LIST enmExtList;
PST pst = pimage->pst;
// walk the list of existing weak/lazy externs
InitEnmExtList(&enmExtList, plpextWeak);
while (FNextEnmExtList(&enmExtList)) {
PEXTERNAL pext;
pext = enmExtList.pext;
// no longer referenced or marked as ignore
if (!FPextRef(pext) ||
(pext->Flags & EXTERN_IGNORE) )
continue;
// it is still weak/lazy
// if it is defined nothing to do (already been asigned to weak defn)
// else assign to weak defn
if (pext->Flags & (EXTERN_WEAK|EXTERN_LAZY)) {
PEXTERNAL pextWeakDefault;
if (pext->Flags & EXTERN_DEFINED) {
continue;
}
pextWeakDefault = PextWeakDefaultFind(pext);
AssignWeakDefinition(pext, pextWeakDefault, pst);
continue;
}
// weak/lazy has changed from weak definition to strong - punt
#ifdef INSTRUMENT
{
char *szOutSymName;
szOutSymName = SzOutputSymbolName(SzNamePext(pext, pst), TRUE);
LogNoteEvent(Log, SZILINK, NULL, letypeEvent, "weak/lazy extern (w 2 s): %s", szOutSymName);
if (szOutSymName != SzNamePext(pext, pst)) {
free(szOutSymName);
}
}
#endif // INSTRUMENT
errInc = errWeakExtern;
return;
} // end while
EndEnmExtList(&enmExtList);
}
// assign weak externs to their default definitions
// new weak/lazy are permitted on an ilink
// change in state from weak to strong or vice-versa isn't allowed
void
ResolveWeakExterns (
PIMAGE pimage,
DWORD Type
)
{
WEAK_EXTERN_LIST *pwel;
PST pst = pimage->pst;
// now walk the global list for any new weak/lazy externs
pwel = pwelHead;
for (; pwel; pwel = pwel->pwelNext) {
// look at ones of interest
if (!(pwel->pext->Flags & Type)) {
continue;
}
// skip ones already done in the prior pass
if (pwel->pext->Flags & EXTERN_DEFINED) {
continue;
}
// rest are ones which haven't been handled yet; new are ok
if (pwel->pext->Flags & EXTERN_NEWFUNC ||
pwel->pext->Flags & EXTERN_NEWDATA) {
AssignWeakDefinition(pwel->pext, pwel->pextWeakDefault, pst);
continue;
}
// weak and not new (=> a strong defn became a weak one)
errInc = errWeakExtern;
return;
}
}
void
RestoreWeakSymVals (
PIMAGE /* pimage */
)
/*++
Routine Description:
Restore weak sym values of externs that were modified just
before emit to map file.
Arguments:
pimage - ptr to image.
Return Value:
None.
--*/
{
WEAK_EXTERN_LIST *pwel;
for (pwel = pwelHead; pwel != NULL; pwel = pwel->pwelNext) {
if (pwel->pext->Flags & (EXTERN_WEAK | EXTERN_LAZY | EXTERN_ALIAS)) {
assert(pwel->pextWeakDefault);
pwel->pext->ImageSymbol.Value -=
PsecPCON(pwel->pextWeakDefault->pcon)->rva;
}
}
}
DWORD
CThunks (
PIMAGE pimage
)
/*++
Routine Description:
Returns count of thunks required.
Arguments:
pimage - ptr to image.
Return Value:
None.
--*/
{
PEXTERNAL pext;
DWORD cext = 0UL;
// walk the external symbol table
InitEnumerateExternals(pimage->pst);
while ((pext = PexternalEnumerateNext(pimage->pst)) != NULL) {
// ignore undefined externs
if (!(pext->Flags & EXTERN_DEFINED) || !pext->pcon || FIsLibPCON(pext->pcon)) {
continue;
}
// check to see if this is a function
if (ISFCN(pext->ImageSymbol.Type)) {
DBEXEC(DB_DUMPJMPTBL,
DBPRINT("sym=%s\n", SzNamePext(pext, pimage->pst)));
cext++;
}
}
TerminateEnumerateExternals(pimage->pst);
// done
return cext;
}
PCON
PconCreateJumpTable (
PIMAGE pimage
)
/*++
Routine Description:
Creates a dummy pcon for the jump table.
Arguments:
pimage - ptr to image.
Return Value:
None.
--*/
{
PCON pcon = NULL;
PSEC psecText;
PGRP pgrpBase;
// get count of functions
cextFCNs = CThunks(pimage);
if (cextFCNs == 0) {
return NULL;
}
// find .text section
psecText = PsecFind(NULL,
".text",
IMAGE_SCN_CNT_CODE | IMAGE_SCN_MEM_EXECUTE | IMAGE_SCN_MEM_READ,
&pimage->secs,
&pimage->ImgOptHdr);
assert(psecText);
pgrpBase = psecText->pgrpNext;
assert(pgrpBase);
assert(pgrpBase->pconNext);
// create a pcon
pcon = (PCON) Calloc(1, sizeof(CON));
switch (pimage->ImgFileHdr.Machine) {
case IMAGE_FILE_MACHINE_ALPHA :
ilink_info = &ALPHA_ilink;
cbJumpEntry = ilink_info->cbJumpEntry;
break;
case IMAGE_FILE_MACHINE_I386 :
ilink_info = &I386_ilink;
cbJumpEntry = ilink_info->cbJumpEntry;
break;
case IMAGE_FILE_MACHINE_R4000 :
case IMAGE_FILE_MACHINE_R10000 :
ilink_info = &MIPS_ilink;
cbJumpEntry = ilink_info->cbJumpEntry;
break;
case IMAGE_FILE_MACHINE_MPPC_601 :
ilink_info = &MPPC_ilink;
cbJumpEntry = ilink_info->cbJumpEntry;
break;
default:
assert(FALSE);
break;
}
// fill in structure
pcon->cbPad = __min(cextFCNs * CbJumpEntry(), USHRT_MAX);
pcon->cbRawData = cextFCNs * CbJumpEntry() + pcon->cbPad;
pcon->pgrpBack = pgrpBase;
pcon->pmodBack = pmodLinkerDefined;
pcon->pconNext = NULL;
pmodLinkerDefined->icon++;
// attach the pcon at the front of the list
pcon->pconNext = pgrpBase->pconNext;
pgrpBase->pconNext = pcon;
return(pcon);
}
void
BuildThunkMap (
PVOID pvThunkTable,
DWORD **prgThunkMapOff,
DWORD cThunk
)
/*++
Routine Description:
Builds the thunk map o be passed onto dbi.
Arguments:
pimage - ptr to image.
pvThunkTable - ptr to raw thunk table
prgThunkMapOff - ptr to array of file offsets of jmp destinations in
thunk table on return.
cThunk - count of thunks.
Return Value:
None.
--*/
{
BYTE *p;
DWORD i;
// Alloc space for the array of offsets
*prgThunkMapOff = (DWORD *) PvAlloc(cThunk * (sizeof(DWORD)));
// Fill the array with the offset values
p = (BYTE *) pvThunkTable;
if (fPowerMac) {
// The first entry in the Jump Table is not used
// for PowerMac. So get past it!
p += CbJumpEntry();
}
p += ilink_info->address_offset; // get past first opcode
for (i = 0; i < cThunk; i++) {
LONG offset = *(LONG UNALIGNED *) p;
if (fPowerMac) {
// If it is PowerMac, remove the opcode in the first 6 bits
SwapBytes(&offset, 4);
offset = (offset << 6) >> 6;
}
// Calculate file offset of jmp destination
(*prgThunkMapOff)[i] = pconJmpTbl->foRawDataDest +
((i+1) * CbJumpEntry()) + offset;
p += CbJumpEntry();
}
}
void
WriteJumpTable (
PIMAGE pimage,
PCON pconJmpTbl,
DWORD **prgThunkMapOff,
DWORD *pcThunk
)
/*++
Routine Description:
Builds the jump table & writes it out.
Arguments:
pimage - ptr to image.
pconJmpTbl - pcon to write out
prgThunkMap - ptr to array of addresses on return.
pcThunkAddr - on return has countof thunks.
Return Value:
None.
--*/
{
PVOID pvRaw = NULL;
DWORD cfuncs, i;
LONG offset;
BYTE *p;
PEXTERNAL pext;
// check for any thunks
if (!pconJmpTbl || !cextFCNs) {
return;
}
// allocate space for raw data
pvRaw = PvAllocZ(pconJmpTbl->cbRawData);
// hammer thunks into the space
switch (pimage->ImgFileHdr.Machine) {
case IMAGE_FILE_MACHINE_ALPHA:
ilink_info = &ALPHA_ilink;
cbJumpEntry = ilink_info->cbJumpEntry;
break;
case IMAGE_FILE_MACHINE_I386:
ilink_info = &I386_ilink;
cbJumpEntry = ilink_info->cbJumpEntry;
break;
case IMAGE_FILE_MACHINE_MPPC_601:
ilink_info = &MPPC_ilink;
cbJumpEntry = ilink_info->cbJumpEntry;
break;
case IMAGE_FILE_MACHINE_R4000:
case IMAGE_FILE_MACHINE_R10000:
ilink_info = &MIPS_ilink;
cbJumpEntry = ilink_info->cbJumpEntry;
break;
default:
assert(FALSE);
break;
}
cfuncs = cextFCNs;
p = (BYTE *) pvRaw;
for (i = 0; i < cfuncs; i++) {
memcpy(p, ilink_info->pvJumpEntry, ilink_info->cbJumpEntry);
p += ilink_info->cbJumpEntry;
}
p = (BYTE *) pvRaw + ilink_info->address_offset;
if (fPowerMac) {
// In PowerMac we never want to use the first entry
// because we rely on the offset being not zero
// for any of the function that goes thru jump table
p += CbJumpEntry();
// So the pad is decreased by that amount
pconJmpTbl->cbPad -= CbJumpEntry();
}
// Walk the external symbol table
InitEnumerateExternals(pimage->pst);
cfuncs = 0;
while ((pext = PexternalEnumerateNext(pimage->pst)) != NULL) {
if (!(pext->Flags & EXTERN_DEFINED) || !pext->pcon || FIsLibPCON(pext->pcon)) {
// Ignore undefined externs
continue;
}
// check to see if this is a function
if (ISFCN(pext->ImageSymbol.Type)) {
// Hammer in func addr
offset = (LONG)(pext->pcon->rva + pext->ImageSymbol.Value) -
(LONG)(pconJmpTbl->rva + (p - (BYTE *) pvRaw) +
(fPowerMac ? 0 : sizeof(LONG)) );
DBEXEC(DB_DUMPJMPTBL, DBPRINT("Offset= %.8lx, symval=%.8lx, pconrva=%.8lx, sym=%s\n",
offset, pext->ImageSymbol.Value,pext->pcon->rva,
SzNamePext(pext, pimage->pst)));
if (fPowerMac) {
if (!TEST32MBCODERANGE(offset)) {
// Bail out of linking because the offset is greater than 26 bits
Error(NULL, TOOFAR, SzNamePext(pext, pimage->pst));
} else {
offset = DwSwap(PPC_BRANCH | (offset & PPC_ADDR_MASK));
}
}
*(LONG UNALIGNED *) p = offset;
p += CbJumpEntry();
// store the offset in pconjmptbl for the symbol
pext->Offset =
p - (BYTE *) pvRaw - CbJumpEntry(); // offset is to addr
assert(pext->Offset);
cfuncs++;
}
}
TerminateEnumerateExternals(pimage->pst);
// Just checking
assert(cfuncs == cextFCNs);
if ((pimage->ImgFileHdr.Machine == IMAGE_FILE_MACHINE_R4000) &&
(pimage->Switch.Link.fPadMipsCode == TRUE)) {
DWORD cbAdjust;
if (!ComputeTextPad(pconJmpTbl->rva,
(DWORD *) pvRaw,
pconJmpTbl->cbRawData,
4096L,
&cbAdjust)) {
// Cannot adjust text, we're in big trouble
FatalPcon(pconJmpTbl, TEXTPADFAILED, cbAdjust, pconJmpTbl->rva);
}
assert(cbAdjust == 0);
}
// Pad the the remaining space with int3
p = (BYTE *) pvRaw + pconJmpTbl->cbRawData - pconJmpTbl->cbPad;
memset(p, ilink_info->bPad, pconJmpTbl->cbPad);
// Build the array of addr to which the thunks point to
if (pimage->Switch.Link.DebugInfo != None) {
*pcThunk = cfuncs;
BuildThunkMap(pvRaw, prgThunkMapOff, *pcThunk);
}
// Write out jump table
FileSeek(FileWriteHandle, pconJmpTbl->foRawDataDest, SEEK_SET);
FileWrite(FileWriteHandle, pvRaw, pconJmpTbl->cbRawData);
FileSeek(FileWriteHandle, 0, SEEK_SET);
DBEXEC(DB_DUMPJMPTBL, DBPRINT("cextFCNs= %.8lx, cfuncs= %.8lx\n", cextFCNs, cfuncs));
DBEXEC(DB_DUMPJMPTBL, DumpJmpTbl(pconJmpTbl, pvRaw));
FreePv(pvRaw);
}
void
UpdateJumpTable (
PIMAGE pimage,
DWORD **prgThunkMapOff,
DWORD *pcThunk
)
/*++
Routine Description:
Updates the existing jmp table with new addr of old
functions and adds entries for the new functions.
Is it faster to just write out the individual thunks?
Arguments:
pimage - ptr to image.
Return Value:
None.
--*/
{
PVOID pvRaw = NULL;
LONG offset;
BYTE *p;
PEXTERNAL pext;
BYTE *pvNew; // new thunks get written here
if (!pconJmpTbl) {
return;
}
// allocate space for raw data
pvRaw = PvAllocZ(pconJmpTbl->cbRawData);
// read in jump table
FileSeek(FileWriteHandle, pconJmpTbl->foRawDataDest, SEEK_SET);
FileRead(FileWriteHandle, pvRaw, pconJmpTbl->cbRawData);
DBEXEC(DB_DUMPJMPTBL, DBPRINT("\n---BEFORE---\n"));
DBEXEC(DB_DUMPJMPTBL, DumpJmpTbl(pconJmpTbl, pvRaw));
pvNew = (BYTE *) pvRaw + (pconJmpTbl->cbRawData - pconJmpTbl->cbPad);
// Walk the external symbol table
InitEnumerateExternals(pimage->pst);
while ((pext = PexternalEnumerateNext(pimage->pst)) != NULL) {
// consider only the dirty & new funcs
if (!(pext->Flags & EXTERN_DIRTY) && !(pext->Flags & EXTERN_NEWFUNC)) {
continue;
}
if (FIsLibPCON(pext->pcon)) {
// We ignore lib functions
continue;
}
// Check to see if this is a function
if (pext->Flags & EXTERN_NEWFUNC) {
assert(!pext->Offset);
pext->Flags &= ~(EXTERN_NEWFUNC);
// Check to see if we are about to run over jmp tbl space
if ((pvNew + ilink_info->cbJumpEntry) > (BYTE *) pvRaw + pconJmpTbl->cbRawData) {
TerminateEnumerateExternals(pimage->pst);
FreePv(pvRaw);
errInc = errJmpTblOverflow;
return;
}
if (fPowerMac) {
RESET_BIT (pext, sy_NEWSYMBOL);
}
// Hammer in thunk & new func addr
memcpy(pvNew, ilink_info->pvJumpEntry, ilink_info->cbJumpEntry);
pvNew += ilink_info->address_offset;
offset = (LONG)(pext->pcon->rva + pext->ImageSymbol.Value) -
(LONG)(pconJmpTbl->rva + (pvNew - (BYTE *) pvRaw) +
(fPowerMac ? 0 : sizeof(LONG)) );
if (fPowerMac) {
if (!TEST32MBCODERANGE(offset)) {
// Bail out of linking because the offset is greater than 26 bits
Error(NULL, TOOFAR, SzNamePext(pext, pimage->pst));
} else {
offset = DwSwap(PPC_BRANCH | (offset & PPC_ADDR_MASK));
}
}
*(LONG UNALIGNED *) pvNew = offset;
pvNew += 4;
// store the offset in pconjmptbl for the symbol
pext->Offset =
pvNew - (BYTE *) pvRaw - CbJumpEntry() + ilink_info->address_offset; // +N to go past opcode
// reduce the pad available
pconJmpTbl->cbPad -= CbJumpEntry();
} else {
// Old func whose addr has changed
assert(pext->Offset);
pext->Flags &= ~(EXTERN_DIRTY);
// Hammer in new address
p = (BYTE *) pvRaw + pext->Offset;
offset = (LONG)(pext->pcon->rva + pext->ImageSymbol.Value) -
(LONG)(pconJmpTbl->rva + (p - (BYTE *) pvRaw) +
(fPowerMac ? 0 : sizeof(LONG)) );
if (fPowerMac) {
if ( !TEST32MBCODERANGE(offset)) {
// Bail out of linking because the offset is greater than 26 bits
Error(NULL, TOOFAR, SzNamePext(pext, pimage->pst));
} else {
offset = (offset & PPC_ADDR_MASK) | PPC_BRANCH;
SwapBytes(&offset, 4);
}
}
*(LONG UNALIGNED *) p = offset;
}
}
TerminateEnumerateExternals(pimage->pst);
if ((pimage->ImgFileHdr.Machine == IMAGE_FILE_MACHINE_R4000) &&
(pimage->Switch.Link.fPadMipsCode == TRUE)) {
DWORD cbAdjust;
if (!ComputeTextPad(pconJmpTbl->rva,
(DWORD *) pvRaw,
pconJmpTbl->cbRawData,
4096L,
&cbAdjust)) {
// Cannot adjust text, we're in big trouble
FatalPcon(pconJmpTbl, TEXTPADFAILED, cbAdjust, pconJmpTbl->rva);
}
assert(cbAdjust == 0);
}
// Write out jump table
FileSeek(FileWriteHandle, pconJmpTbl->foRawDataDest, SEEK_SET);
FileWrite(FileWriteHandle, pvRaw, pconJmpTbl->cbRawData);
FileSeek(FileWriteHandle, 0, SEEK_SET);
// Build array of addr for disasm support
if (pimage->Switch.Link.DebugInfo != None) {
*pcThunk = ((BYTE *) pvNew - (BYTE *) pvRaw) / CbJumpEntry();
BuildThunkMap(pvRaw, prgThunkMapOff, *pcThunk);
}
DBEXEC(DB_DUMPJMPTBL, DBPRINT("\n---AFTER---\n"));
DBEXEC(DB_DUMPJMPTBL, DumpJmpTbl(pconJmpTbl, pvRaw));
FreePv(pvRaw);
}
PMOD
PmodFindPrevPMOD (
PMOD pmod
)
/*++
Routine Description:
Finds the mod before this.
Arguments:
pmod - pmod
Return Value:
PMOD prior to this or NULL
--*/
{
ENM_MOD enm_mod;
PMOD pmodP = NULL;
assert(pmod);
// walk the list of pmods
InitEnmMod(&enm_mod, pmod->plibBack);
while (FNextEnmMod(&enm_mod)) {
if (enm_mod.pmod == pmod) {
return pmodP;
}
pmodP = enm_mod.pmod;
}
EndEnmMod(&enm_mod);
return(NULL);
}
PCON
PconFindPrevPCON (
PCON pcon
)
/*++
Routine Description:
Finds the previous pcon.
Arguments:
pcon - pcon
Return Value:
None.
--*/
{
PGRP pgrp;
PCON pconP = NULL;
ENM_DST enm_dst;
assert(pcon);
// start at the top of the group
pgrp = pcon->pgrpBack;
InitEnmDst(&enm_dst, pgrp);
while (FNextEnmDst(&enm_dst)) {
if (enm_dst.pcon == pcon) {
return pconP;
}
pconP = enm_dst.pcon;
}
EndEnmDst(&enm_dst);
assert(0);
return(NULL);
}
PCON
PconFindOldPMOD (
PMOD pmodO,
PCON pconN
)
/*++
Routine Description:
Finds a matching PCON in the old mod
Arguments:
pmodO - old mod
pconN - con from new mod
Return Value:
Matching PCON in old mod or NULL
--*/
{
PCON pcon;
DWORD i;
if (!pmodO) {
return NULL;
}
assert(pmodO);
// walk the list of pcons
for (i = 0; i < pmodO->ccon; i++) {
pcon = RgconPMOD(pmodO) + i;
// seen already?
if (!pcon->foRawDataDest) {
continue;
}
// pcons match if they belong to same
// group & have same flags (turn off FIXED bit)
if (pcon->pgrpBack == pconN->pgrpBack &&
pcon->flags == pconN->flags) {
return(pcon);
}
}
// didn't find a match
return NULL;
}
void
ZeroPCONSpace (
PCON pcon
)
/*++
Routine Description:
Zeros out space occupied by a pcon in the output file.
Arguments:
pcon - pcon to be zeroed out.
Return Value:
None.
--*/
{
PVOID pvRawData;
assert(pcon);
// ignore PCONs that don't get written out to the output file.
if (pcon->flags & IMAGE_SCN_LNK_REMOVE ||
!pcon->cbRawData ||
FetchContent(pcon->flags) == IMAGE_SCN_CNT_UNINITIALIZED_DATA) {
return;
}
assert(pcon->foRawDataDest != 0);
// allocate a chunk for pcon and set to either int3 or zero
pvRawData = PvAlloc(pcon->cbRawData);
if (FetchContent(pcon->flags) == IMAGE_SCN_CNT_CODE) {
memset(pvRawData, ilink_info->bPad, pcon->cbRawData);
}
// zero out space in output file
FileSeek(FileWriteHandle, pcon->foRawDataDest, SEEK_SET);
FileWrite(FileWriteHandle, pvRawData, pcon->cbRawData);
FreePv(pvRawData);
}
void
FreePCONSpace(
PCON pconP,
PCON pconC,
PIMAGE pimage
)
/*++
Routine Description:
Frees up space. Makes it pad of the prior pcon.
Arguments:
pconP - previous pcon
pconC - pcon to be free'd (space) up
pimage - ptr to IMAGE
Return Value:
None.
--*/
{
assert(pconC);
if (!(fPowerMac && (PgrpPCON(pconC) == pgrpPdata))) {
// Pdata (C++ EH for PowerMac), do not zero out pcon
// because this is done in PDATAUpdate in ipdata.cpp
ZeroPCONSpace(pconC);
}
if (pconP) {
// A previous pcon exists
assert((pconP->flags & IMAGE_SCN_LNK_REMOVE) == 0);
pconP->cbRawData += pconC->cbRawData;
pconP->cbPad += (WORD) pconC->cbRawData;
pconP->pconNext = pconC->pconNext;
} else {
PCON pcon;
// This is the first pcon in the grp
// create a dummy PCON at the front of the group
// check to make sure that the first PCON in the image
// is pconC.
if (pconC != pconC->pgrpBack->pconNext) {
pcon = pconC->pgrpBack->pconNext;
while (pcon != pconC) {
assert(pcon->flags & IMAGE_SCN_LNK_REMOVE);
pcon = pcon->pconNext;
}
}
pcon = (PCON) Calloc(1, sizeof(CON));
pcon->pgrpBack = pconC->pgrpBack;
pcon->pmodBack = pmodLinkerDefined;
pmodLinkerDefined->icon++;
pcon->cbPad = pcon->cbRawData = pconC->cbRawData;
pcon->rva = pconC->rva;
pcon->foRawDataDest = pconC->foRawDataDest;
pcon->pconNext = pconC->pconNext; // unused cons bypassed - that's ok
pconC->pgrpBack->pconNext = pcon;
}
}
void
OverflowInPCON (
PCON pconN,
PCON pconO,
PIMAGE pimage
)
/*++
Routine Description:
Handles the case where a CON has overflowed its pad.
Arguments:
pconN - new pcon of the changed module
pconO - old pcon
pimage - ptr to IMAGE
Return Value:
None.
--*/
{
PCON pconP;
// Free up the space occupied currently by the pcon
pconP = PconFindPrevPCON(pconO);
while (pconP && ((pconP->flags & IMAGE_SCN_LNK_REMOVE) != 0)) {
pconP = PconFindPrevPCON(pconP);
}
FreePCONSpace(pconP, pconO, pimage);
// Find a slot for the new pcon
FindSlotForPCON(pconN);
// Mark pcon as seen
pconO->foRawDataDest = 0;
}
void
GrowPCON (
PCON pconN,
PCON pconO
)
/*++
Routine Description:
pcon has grown (incr/decr) to fit the current spot
Arguments:
pconN(ew) - pcon of the modified mod
pconO(ld) - pcon of the old mod
Return Value:
None.
--*/
{
PCON pconP;
// assign values
pconN->foRawDataDest = pconO->foRawDataDest;
pconN->rva = pconO->rva;
pconN->cbPad = (WORD) (pconO->cbRawData - pconN->cbRawData);
pconN->cbRawData += pconN->cbPad;
// find prev pcon and chain up the
// new pcon into the image map
pconP = PconFindPrevPCON(pconO);
if (pconP) {
pconP->pconNext = pconN;
} else {
pconN->pgrpBack->pconNext = pconN;
}
pconN->pconNext = pconO->pconNext;
// mark old pcon as seen.
pconO->foRawDataDest = 0;
}
void
FindSlotForPCON (
PCON pcon
)
/*++
Routine Description:
Moves pcon to the first available slot (alternative
strategies? best fit?)
Assumes that pcons are in proper rva order.
Arguments:
pcon - pcon that is to be moved
Return Value:
None.
--*/
{
PGRP pgrp;
PCON pconC;
BOOL fFound = 0;
DWORD rva, cbPad, cbRaw;
ENM_DST enm_dst;
assert(pcon);
assert(pcon->pgrpBack);
pgrp = pcon->pgrpBack;
// search within the group
InitEnmDst(&enm_dst, pgrp);
while (FNextEnmDst(&enm_dst)) {
pconC = enm_dst.pcon;
// skip unusable pcons
if (pconC->flags & IMAGE_SCN_LNK_REMOVE) {
continue;
}
// cannot use the pad of jmptbl pcon. It is committed space.
if (pconC == pconJmpTbl) {
continue;
}
if (fPowerMac) {
// cannot use the pad of PowerMacLoader, TOC Table,
// TOC descriptors, Glue Code pcons. They are all committed space.
if (pconC == pconPowerMacLoader || pconC == pconTocTable ||
pconC == pconTocDescriptors || pconC == pconGlueCode ||
pconC == pconMppcFuncTable) {
continue;
}
}
// do we have enough room for this pcon
if (pcon->cbRawData > pconC->cbPad ) {
continue;
}
// one more check to ensure padding requirements
cbRaw = pconC->cbRawData - pconC->cbPad; // raw data of existing PCON
rva = pconC->rva + cbRaw;
cbPad = RvaAlign(rva, pcon->flags) - rva; // pad for PCON being inserted
if (pcon->cbRawData + cbPad > pconC->cbPad) {
continue;
}
// found a slot
fFound = 1;
// assign values for PCON being inserted. Note that the pad
// calculated above becomes part of the existing PCON.
assert ((pconC->flags & IMAGE_SCN_LNK_REMOVE) == 0);
assert(pconC->rva != 0);
pcon->rva = pconC->rva + cbRaw + cbPad;
pcon->foRawDataDest = pconC->foRawDataDest + cbRaw + cbPad;
pcon->cbPad = (WORD)((DWORD)pconC->cbPad - (cbPad + pcon->cbRawData));
pcon->cbRawData += pcon->cbPad;
pcon->pconNext = pconC->pconNext;
// update values for existing CON
pconC->cbPad = (WORD)cbPad;
pconC->cbRawData = cbRaw + cbPad;
pconC->pconNext = pcon;
break;
}
EndEnmDst(&enm_dst);
// done
if (!fFound) {
#ifdef INSTRUMENT
LogNoteEvent(Log, SZILINK, SZCALCPTRS, letypeEvent, "failed to find a slot for pcon: %-8.8s",
pcon->pgrpBack->szName);
#endif // INSTRUMENT
errInc = errCalcPtrs;
}
}
void
FreePMOD (
PIMAGE pimage,
PMOD pmodO
)
/*++
Routine Description:
Frees up space.
Arguments:
pmodO - old mod
Return Value:
None.
--*/
{
DWORD i;
PCON pconP, pcon;
// free up space occupied by unseen pcons
for (i = 0; i < pmodO->ccon; i++) {
pcon = RgconPMOD(pmodO) + i;
// Seen already?
if (!pcon->foRawDataDest) {
continue;
}
pconP = PconFindPrevPCON(pcon);
while (pconP && ((pconP->flags & IMAGE_SCN_LNK_REMOVE) != 0)) {
pconP = PconFindPrevPCON(pconP);
}
FreePCONSpace(pconP, pcon, pimage);
if (fPowerMac && (PgrpPCON(pcon) == pgrpPdata)) {
// Pdata (C++ EH for PowerMac), do not delete base relocs
continue;
}
// zap any base relocs
if (fPowerMac) {
CHAR szBuffer[12];
// Code is pure in PowerMac and so there won't be any
// relocations in .text and .drectve sections
if (!(pcon->flags & IMAGE_SCN_CNT_CODE ||
pcon->flags & IMAGE_SCN_LNK_INFO)) {
AddArgumentToList(&ZappedBaseRelocList,
SzDup(_itoa(pcon->rva, szBuffer, 10)),
SzDup(_itoa(pcon->cbRawData - pcon->cbPad, szBuffer, 10)) );
}
} else {
// Intel, MIPS, and others
DeleteBaseRelocs(&pimage->bri,
pcon->rva,
pcon->cbRawData - pcon->cbPad);
}
}
// Free up memory occupied by PMOD (LATER)
}
void
AllocSpaceForImportPCON (
PCON pcon
)
/*++
Routine Description:
Allocates space for this .idata PCON.
Arguments:
pcon - ptr to a .idata pcon
Return Value:
None.
--*/
{
ENM_DST enm_dst;
PPCON ppcon;
if (!pgrpIdata$4) {
pgrpIdata$4 = PgrpFind(psecImportDescriptor, ".idata$4");
pgrpIdata$5 = PgrpFind(psecImportDescriptor, ".idata$5");
pgrpIdata$6 = PgrpFind(psecImportDescriptor, ".idata$6");
if (!pgrpIdata$4 || !pgrpIdata$5 || !pgrpIdata$6) {
#ifdef INSTRUMENT
LogNoteEvent(Log, SZILINK, SZCALCPTRS, letypeEvent, "failed to find a slot for pcon: %-8.8s",
pcon->pgrpBack->szName);
#endif // INSTRUMENT
errInc = errCalcPtrs;
return;
}
} // end if
assert(pgrpIdata$5);
assert(pgrpIdata$6);
if (pcon->pgrpBack != pgrpIdata$4 &&
pcon->pgrpBack != pgrpIdata$5 &&
pcon->pgrpBack != pgrpIdata$6) {
// PCON belongs to groups other than .idata${4,5,6}
errInc = errCalcPtrs;
return;
}
// for .idata$6 pcon is inserted like any other pcon
if (pcon->pgrpBack == pgrpIdata$6) {
FindSlotForPCON(pcon);
return;
}
// for .idata$5, .idata$4 pcons inserted in proper
// place (same DLL) and order (before NULL entry)
InitEnmDst(&enm_dst, pcon->pgrpBack);
ppcon = &pcon->pgrpBack->pconNext;
while (FNextEnmDst(&enm_dst)) {
if (strcmp(SzObjNamePCON(enm_dst.pcon), SzObjNamePCON(pcon)) ||
enm_dst.pcon->cbPad < pcon->cbRawData) {
ppcon = &enm_dst.pcon->pconNext;
continue;
}
// fill in fields for new CON
pcon->rva = enm_dst.pcon->rva;
pcon->foRawDataDest = enm_dst.pcon->foRawDataDest;
pcon->pconNext = enm_dst.pcon;
// update existing pcon fields
enm_dst.pcon->foRawDataDest += pcon->cbRawData;
enm_dst.pcon->rva += pcon->cbRawData;
enm_dst.pcon->cbRawData -= pcon->cbRawData;
enm_dst.pcon->cbPad -= pcon->cbRawData;
// update previous con's next ptr
(*ppcon) = pcon;
EndEnmDst(&enm_dst);
return;
}
EndEnmDst(&enm_dst);
errInc = errCalcPtrs;
}
void
CalcPtrsPMOD (
PMOD pmodN,
PMOD pmodO,
PIMAGE pimage
)
/*++
Routine Description:
Calculates new addresses for all the changed CONs.
If it is not possible to assign an address, function
returns after setting the appropriate error value in errInc.
Arguments:
pmodN - Current module (modified)
pmodO - Previous module by the same name (if any)
pimage - ptr to EXE image
Return Value:
None.
--*/
{
PMOD pmodP;
PCON pconN;
PCON pconO;
ENM_SRC enm_src;
PEXTERNAL pext;
DWORD AlphaBsrCount = 0;
SzComNamePMOD(pmodN, InternalError.CombinedFilenames);
DBEXEC(DB_INCRCALCPTRS, DBPRINT("\nMODULE = %s\n", InternalError.CombinedFilenames));
#ifdef INSTRUMENT
LogNoteEvent(Log, SZILINK, SZCALCPTRS, letypeEvent, "mod: %s", InternalError.CombinedFilenames);
#endif // INSTRUMENT
// for each pcon in new mod, find a matching con
// in the old module if possible
InitEnmSrc(&enm_src, pmodN);
while (FNextEnmSrc(&enm_src)) {
pconN = enm_src.pcon;
// Ignore ignoreable pcons. eg zero-sized pcons OR COMDATs not included;
// debug sections can be ignored as well.
if (pconN->flags & IMAGE_SCN_LNK_REMOVE || PsecPCON(pconN) == psecDebug) {
continue;
}
// Check to see if this pcon is an import data pcon
if (PsecPCON(pconN) == psecImportDescriptor) {
AllocSpaceForImportPCON(pconN);
if (errInc != errNone) {
return;
}
continue;
}
// Find a matching pcon
pconO = PconFindOldPMOD(pmodO, pconN);
if (!pconO) {
// New pcon
DBEXEC(DB_INCRCALCPTRS, DBPRINT("NEW %.8s cb=%.8lx\n",
pconN->pgrpBack->szName,
pconN->cbRawData));
#ifdef INSTRUMENT
LogNoteEvent(Log, SZILINK, SZCALCPTRS, letypeEvent, "new pcon %.8s cb=0x%.8lx",
pconN->pgrpBack->szName, pconN->cbRawData);
#endif // INSTRUMENT
FindSlotForPCON(pconN);
} else {
// Zap any relocs right away
if (fPowerMac) {
CHAR szBuffer[12];
// Code is pure in PowerMac and so there won't be any
// relocations in .text and .drectve sections
if (!(pconO->flags & IMAGE_SCN_CNT_CODE ||
pconO->flags & IMAGE_SCN_LNK_INFO ||
(PgrpPCON(pconO) == pgrpPdata))) {
AddArgumentToList(&ZappedBaseRelocList,
SzDup(_itoa(pconO->rva, szBuffer, 10)),
SzDup(_itoa(pconO->cbRawData - pconO->cbPad, szBuffer, 10)) );
}
} else {
// Intel, MIPS, and others
DeleteBaseRelocs(&pimage->bri, pconO->rva, pconO->cbRawData - pconO->cbPad);
}
if (pconN->cbRawData <= pconO->cbRawData) {
// Got enough room
DBEXEC(DB_INCRCALCPTRS, DBPRINT("GRW %.8s cb(o)=%.8lx cb(n)=%.8lx\n",
pconN->pgrpBack->szName,
pconO->cbRawData,
pconN->cbRawData));
#ifdef INSTRUMENT
LogNoteEvent(Log, SZILINK, SZCALCPTRS, letypeEvent, "pad %.8s cb(n):0x%.8lx cb(o):0x%.8lx cb(pad):0x%.4x",
pconN->pgrpBack->szName, pconN->cbRawData, pconO->cbRawData-pconO->cbPad,
pconO->cbPad);
#endif // INSTRUMENT
GrowPCON(pconN, pconO);
} else {
// Not enough room
DBEXEC(DB_INCRCALCPTRS, DBPRINT("OVF %.8s cb(o)=%.8lx cb(n)=%.8lx\n",
pconN->pgrpBack->szName,
pconO->cbRawData,
pconN->cbRawData));
#ifdef INSTRUMENT
LogNoteEvent(Log, SZILINK, SZCALCPTRS, letypeEvent, "ovf %.8s cb(n):0x%.8lx cb(o):0x%.8lx cb(pad):0x%.4x",
pconN->pgrpBack->szName, pconN->cbRawData, pconO->cbRawData-pconO->cbPad,
pconO->cbPad);
#endif // INSTRUMENT
OverflowInPCON(pconN, pconO, pimage);
}
}
if ((FetchContent(pconN->flags) == IMAGE_SCN_CNT_CODE) &&
(pimage->ImgFileHdr.Machine == IMAGE_FILE_MACHINE_R4000) &&
(pimage->Switch.Link.fPadMipsCode == TRUE) ) {
extern DWORD CheckMIPSCode(PCON);
DWORD cbAdjust = CheckMIPSCode(pconN);
if (cbAdjust != 0) {
if (cbAdjust <= pconN->cbPad) {
PCON pconP;
pconP = PconFindPrevPCON(pconN);
if (pconP) {
pconN->cbPad -= cbAdjust;
pconN->cbRawData -= cbAdjust;
pconN->foRawDataDest += cbAdjust;
pconN->rva += cbAdjust;
pconP->cbPad += cbAdjust;
pconP->cbRawData += cbAdjust;
} else {
DBEXEC(DB_INCRCALCPTRS, DBPRINT("CheckMIPSCode returned %d in first pcon\n", cbAdjust));
errInc = errPdata;
}
} else {
DBEXEC(DB_INCRCALCPTRS, DBPRINT("CheckMIPSCode returned %d\n", cbAdjust));
errInc = errPdata;
}
}
}
// Check status
if (errInc != errNone) {
return;
}
}
EndEnmSrc(&enm_src);
// Alloc space for COMMON data
pext = pmodN->pextFirstDefined;
while (pext) {
if (pext->Flags & EXTERN_COMMON) {
assert(pext->pcon);
FindSlotForPCON(pext->pcon);
}
pext = pext->pextNextDefined;
}
// Link in the new module & cut out the old (cmdline objs)
if (!FIsLibPMOD(pmodN)) {
pmodP = PmodFindPrevPMOD(pmodO);
if (pmodP) {
pmodP->pmodNext = pmodN;
} else {
pmodO->plibBack->pmodNext = pmodN;
}
pmodN->pmodNext = pmodO->pmodNext;
pmodN->plibBack = pmodO->plibBack;
assert(pmodN->imod == 0);
pmodN->imod = pmodO->imod;
FreePMOD(pimage, pmodO);
} else {
// New objects (from lib search)
assert(pmodN->plibBack);
pmodN->imod = NewIModIdx();
if (pmodN->imod >= IMODIDXMAC) {
Fatal(NULL, PDBLIMIT, NULL);
}
}
}
void
IncrCalcPtrsPMOD (
PMOD pmod,
PLIB plib,
PIMAGE pimage
)
{
PMOD pmodO;
// for modules from libs there is no existing MOD, we just add new MODs
if (plib) {
pmodO = PmodFind(plib, SzOrigFilePMOD(pmod), FoMemberPMOD(pmod));
} else {
pmodO = NULL;
}
CalcPtrsPMOD(pmod, pmodO, pimage);
// check for failures
if (errInc != errNone) {
#ifdef INSTRUMENT
LogNoteEvent(Log, SZILINK, SZCALCPTRS, letypeEvent,
"failed calcptrs, file: %s", SzOrigFilePMOD(pmod));
LogNoteEvent(Log, SZILINK, SZCALCPTRS, letypeEnd, NULL);
#endif // INSTRUMENT
return;
}
// add it to the pass2 list
DoPass2PMOD(pmod, TRUE);
// Set flag to tell them they have gone through pass1
pmod->LnkFlags |= MOD_DidPass1;
}
void
IncrCalcPtrs (
PIMAGE pimage
)
/*++
Routine Description:
Calculates new addresses for all the changed mods.
If it is not possible to assign an address, function
returns after setting the appropriate error value in errInc.
Arguments:
pimage - ptr to EXE image
Return Value:
None.
--*/
{
PMOD pmod;
PMOD pmodNext;
PLMOD plmod;
InternalError.Phase = "CalcPtrs";
InternalError.CombinedFilenames[0] = '\0';
#ifdef INSTRUMENT
LogNoteEvent(Log, SZILINK, SZCALCPTRS, letypeBegin, NULL);
#endif // INSTRUMENT
if (!fPowerMac) {
// setup psec pointers
psecBaseReloc = PsecFindNoFlags(ReservedSection.BaseReloc.Name, &pimage->secs);
psecImportDescriptor = PsecFind(NULL,
".idata",
ReservedSection.ImportDescriptor.Characteristics,
&pimage->secs,
&pimage->ImgOptHdr);
}
// walk the list of modified cmdline objects
pmod = plibModObjs->pmodNext;
while (pmod) {
pmodNext = pmod->pmodNext;
IncrCalcPtrsPMOD(pmod, pimage->plibCmdLineObjs, pimage);
if (errInc != errNone) {
return;
}
pmod = pmodNext;
}
plibModObjs->pmodNext = NULL;
// walk the list of new objs (added as aresult of lib srch)
plmod = plmodNewModsFromLibSrch;
while (plmod) {
IncrCalcPtrsPMOD(plmod->pmod, NULL, pimage);
plmod = plmod->plmodNext;
}
FreePLMODList(&plmodNewModsFromLibSrch);
// check if there is enough space for base relocs
// For PowerMac this is done at the end in MppcUpdateRelocTable in ppc.c
fNoBaseRelocs = (pimage->bri.rgfoBlk == NULL);
if (!fPowerMac && !pimage->Switch.Link.fFixed && pimage->bri.crelFree <
pimage->ImgOptHdr.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC].Size) {
errInc = errBaseReloc;
#ifdef INSTRUMENT
LogNoteEvent(Log, SZILINK, SZPASS1, letypeEvent, "not enough space for base relocs");
#endif // INSTRUMENT
}
#ifdef INSTRUMENT
LogNoteEvent(Log, SZILINK, SZCALCPTRS, letypeEnd, NULL);
#endif // INSTRUMENT
}
void
CollectWeakAndLazyExterns (
PMOD pmod
)
/*++
Routine Description:
Collect any weak & lazy externs defined by this mod.
Arguments:
pmod - pmod to delete from list
Return Value:
None.
--*/
{
PEXTERNAL pext = pmod->pextFirstDefined;
while (pext) {
if ((pext->Flags & (EXTERN_WEAK|EXTERN_LAZY)) && pext->Offset) {
AddExtToList(plpextWeak, TRUE, pext);
}
pext = pext->pextNextDefined;
}
}
void
DeletePMODFromRefList (
PMODS pmods,
PMOD pmod
)
/*++
Routine Description:
Deletes PMODs representing the modified files from the specified list.
Arguments:
pmods - ptr to first chunk of PMODs
pmod - pmod to delete from list
Return Value:
None.
--*/
{
while (pmods) {
PMOD *rgpmod = RgpmodPMODS(pmods);
DWORD i;
// is it referenced by a modified file?
for (i = 0; i < CPMODS; i++) {
if (rgpmod[i] == pmod) {
rgpmod[i] = NULL;
return;
}
}
// next chunk
pmods = pmods->pmodsNext;
}
}
void
DeleteReference (
PEXTERNAL pext,
PMOD pmod
)
/*++
Routine Description:
Deletes references to this symbol from modified files.
Arguments:
pext - ptr to external
pmod - ptr to MOD referencing this extern.
Return Value:
None.
--*/
{
assert(pext);
assert(pext->pmodOnly);
if (pext->Flags & EXTERN_MULT_REFS) {
DeletePMODFromRefList(pext->pmodsFirst, pmod);
} else {
assert(pext->pmodOnly == pmod);
pext->pmodOnly = NULL;
}
}
void
RemoveReferencesPMOD (
PMOD pmod
)
/*++
Routine Description:
2) remove references by modified objs to any
of the symbols.
Arguments:
pmod - ptr to a MOD
Return Value:
None.
--*/
{
ENM_EXT_LIST enmExtList;
InitEnmExtList(&enmExtList, pmod->plpextRef);
while (FNextEnmExtList(&enmExtList)) {
if (!enmExtList.pext) {
continue; // sometimes linker removes references (for bss)
}
DeleteReference(enmExtList.pext, pmod);
}
EndEnmExtList(&enmExtList);
}
void
MarkSymbolsUndefinedPMOD (
PIMAGE pimage,
PMOD pmod
)
/*++
Routine Description:
1) mark all symbols that were defined in the
modified objs as UNDEFINED.
Arguments:
pimage - ptr to IMAGE
pmod - ptr to a MOD
Return Value:
None.
--*/
{
PEXTERNAL pext = pmod->pextFirstDefined;
while (pext) {
PEXTERNAL pextNext = pext->pextNextDefined;
// if symbol was common free up space used
if (pext->Flags & EXTERN_COMMON) {
assert(PmodPCON(pext->pcon) == pmodLinkerDefined);
// free up space here itself so that we don't have to save the list
FreePCONSpace(PconFindPrevPCON(pext->pcon), pext->pcon, pimage);
pext->pcon = NULL;
}
// mark symbol as undefined
SetDefinedExt(pext, FALSE, pimage->pst);
pext->Flags &= ~(EXTERN_DEFINED | EXTERN_EMITTED);
pext = pextNext;
}
}
void
MarkSymbols (
PIMAGE pimage
)
/*++
Routine Description:
1) mark all symbols that were defined in the
modified objs as UNDEFINED and
2) remove references by modified objs to any
of the symbols.
Arguments:
pimage - ptr to EXE image
Return Value:
None.
--*/
{
ENM_MOD enm_mod;
// walk the cmdline objs.
InitEnmMod(&enm_mod, pimage->plibCmdLineObjs);
while (FNextEnmMod(&enm_mod)) {
// gather all "weak" & "lazy" externs.
CollectWeakAndLazyExterns(enm_mod.pmod);
// if dirty, undef symbols & remove references
if (IsDirtyPMOD(enm_mod.pmod)) {
MarkSymbolsUndefinedPMOD(pimage, enm_mod.pmod);
RemoveReferencesPMOD(enm_mod.pmod);
}
}
EndEnmMod(&enm_mod);
// walk the external symbol table
// REVIEW: we should remove this walk altogether
if (fPowerMac) {
PEXTERNAL pext;
InitEnumerateExternals(pimage->pst);
while ((pext = PexternalEnumerateNext(pimage->pst)) != NULL) {
// ignore whatever needs to be ignored
if ((pext->Flags & EXTERN_IGNORE) || !(pext->Flags & EXTERN_DEFINED) || !pext->pcon) {
continue;
}
// Reset bit for sy_TOCENTRYFIXEDUP so that it will be
// processed later
RESET_BIT(pext, sy_TOCENTRYFIXEDUP);
}
TerminateEnumerateExternals(pimage->pst);
}
}
ERRINC
ChckExtSym (
const char *szSym,
PIMAGE_SYMBOL psymObj,
PEXTERNAL pext,
BOOL fNewSymbol
)
/*++
Routine Description:
Checks to see if the extern has changed address.
Arguments:
szSym = symbol name
pext - ptr to external (values represent prior link)
psymObj - symbol being processed
fNewSymbol - TRUE if new symbol
Return Value:
One of the values of ERRINC (errNone, errDataMoved, errJmpTblOverflow)
--*/
{
// is it a func?
if (ISFCN(psymObj->Type)) {
// is it new? make sure we have room for one more thunk
if (fNewSymbol) {
DBEXEC(DB_SYMPROCESS,DBPRINT("sym= %s (NEW func)\n", szSym));
pext->Flags |= EXTERN_NEWFUNC;
// old function
} else {
if (pext->ImageSymbol.Value != psymObj->Value) {
DBEXEC(DB_SYMPROCESS,DBPRINT("sym= %s (func chng)", szSym));
DBEXEC(DB_SYMPROCESS,DBPRINT(" old addr= %.8lx, new addr= %.8lx\n",
pext->ImageSymbol.Value, psymObj->Value));
} else {
DBEXEC(DB_SYMPROCESS,DBPRINT("sym= %s (func unchng)\n", szSym));
}
pext->Flags |= EXTERN_DIRTY;
// if extern has fixups to it that don't go thru the jump table,
// need to do a pass2 on all mods that reference it - add it to data list.
if (pext->Flags & EXTERN_FUNC_FIXUP) {
AddToLext(&plextMovedData, pext);
}
}
// not a function (data)
} else {
if (fNewSymbol) {
DBEXEC(DB_SYMPROCESS,DBPRINT("sym= %s (NEW data)\n", szSym));
pext->Flags |= EXTERN_NEWDATA;
// Log_ILOG1("NEW data sym........: %s", szSym);
// return(errInc = errDataMoved);
// not new? check to see if addr has changed.
} else {
if (pext->ImageSymbol.Value != psymObj->Value) {
DBEXEC(DB_SYMPROCESS,DBPRINT("sym= %s (data chng)", szSym));
DBEXEC(DB_SYMPROCESS,DBPRINT(" old addr= %.8lx, new addr= %.8lx\n",
pext->ImageSymbol.Value, psymObj->Value));
#ifdef INSTRUMENT
LogNoteEvent(Log, SZILINK, SZPASS1, letypeEvent, "data moved:%s", szSym);
#endif // INSTRUMENT
// return(errInc = errDataMoved);
} else {
DBEXEC(DB_SYMPROCESS,DBPRINT("sym= %s (data unchng)\n", szSym));
}
// add to list of data whose addresses may change.
AddToLext(&plextMovedData, pext);
}
}
return errNone;
}
ERRINC
ChckAbsSym (
const char *szSym,
PIMAGE_SYMBOL psymObj,
PEXTERNAL pext,
BOOL fNewSymbol
)
/*++
Routine Description:
Checks to see if the absolute sym has changed address.
Arguments:
szSym = symbol name
pext - ptr to external (values represent prior link)
psymObj - symbol being processed
fNewSymbol - TRUE if new symbol
Return Value:
One of the values of ERRINC (errNone, errDataMoved, errJmpTblOverflow)
--*/
{
// new symbol
if (fNewSymbol) {
return errNone;
}
// old symbol
if (psymObj->Value != pext->ImageSymbol.Value) {
#ifdef INSTRUMENT
LogNoteEvent(Log, SZILINK, SZPASS1, letypeEvent, "chng in abs value: %s", szSym);
#endif // INSTRUMENT
return(errInc = errAbsolute);
}
return(errNone);
}
void
IncrAllocCommonPMOD (
PMOD pmod,
PIMAGE pimage
)
{
PEXTERNAL pext = pmod->pextFirstDefined;
// alloc a CON for each COMMON symbol
while (pext) {
if (pext->Flags & EXTERN_COMMON) {
assert(!pext->pcon);
AllocateCommonPEXT(pimage, pext);
AddToLext(&plextMovedData, pext);
assert(pext->pcon);
}
pext = pext->pextNextDefined;
}
}
void
IncrAllocateCommon (
PIMAGE pimage
)
{
PLMOD plmod;
PMOD pmod, pmodNext;
// walk the list of modified cmd line objs
pmod = plibModObjs->pmodNext;
while (pmod) {
pmodNext = pmod->pmodNext;
IncrAllocCommonPMOD(pmod, pimage);
pmod = pmodNext;
}
// walk the list of new objs (added as aresult of lib srch)
plmod = plmodNewModsFromLibSrch;
while (plmod) {
IncrAllocCommonPMOD(plmod->pmod, pimage);
plmod = plmod->plmodNext;
}
}
void
InitPconJmpTbl (
PIMAGE pimage
)
/*++
Routine Description:
Estimates count of new functions that can be added
to jump table without overflow.
Arguments:
pimage - ptr to EXE image
Return Value:
None.
--*/
{
PSEC psecText;
PGRP pgrpBase;
// Find .text section
psecText = PsecFind(NULL,
".text",
IMAGE_SCN_CNT_CODE | IMAGE_SCN_MEM_EXECUTE | IMAGE_SCN_MEM_READ,
&pimage->secs,
&pimage->ImgOptHdr);
if (psecText == NULL) {
pconJmpTbl = NULL;
return;
}
assert(psecText);
pgrpBase = psecText->pgrpNext;
assert(pgrpBase);
assert(pgrpBase->pconNext);
// first pcon is jmp tbl
pconJmpTbl = pgrpBase->pconNext;
}
void
IncrPass1 (
PIMAGE pimage
)
/*++
Routine Description:
Does an incremental Pass1.
Arguments:
pimage - ptr to EXE image
Return Value:
TRUE if it succeeded, FALSE on failure
--*/
{
DWORD i;
PARGUMENT_LIST arg;
switch (pimage->ImgFileHdr.Machine) {
case IMAGE_FILE_MACHINE_ALPHA:
ilink_info = &ALPHA_ilink;
cbJumpEntry = ilink_info->cbJumpEntry;
break;
case IMAGE_FILE_MACHINE_I386:
ilink_info = &I386_ilink;
cbJumpEntry = ilink_info->cbJumpEntry;
break;
case IMAGE_FILE_MACHINE_MPPC_601:
ilink_info = &MPPC_ilink;
cbJumpEntry = ilink_info->cbJumpEntry;
break;
case IMAGE_FILE_MACHINE_R4000:
case IMAGE_FILE_MACHINE_R10000:
ilink_info = &MIPS_ilink;
cbJumpEntry = ilink_info->cbJumpEntry;
break;
default:
assert(FALSE);
break;
}
// setup global ptrs to debug section (always)
psecDebug = PsecFindNoFlags(".debug", &pimage->secs);
assert(psecDebug);
pgrpCvSymbols = PgrpFind(psecDebug, ReservedSection.CvSymbols.Name);
pgrpCvTypes = PgrpFind(psecDebug, ReservedSection.CvTypes.Name);
pgrpCvPTypes = PgrpFind(psecDebug, ReservedSection.CvPTypes.Name);
pgrpFpoData = PgrpFind(psecDebug, ReservedSection.FpoData.Name);
psecException = PsecFindNoFlags(ReservedSection.Exception.Name, &pimage->secs);
// create a dummy library node for all modified command line objects
plibModObjs = PlibNew("inc_lib", 0L, &pimage->libs);
assert(plibModObjs);
// exclude dummy library from library search
plibModObjs->flags |= (LIB_DontSearch | LIB_LinkerDefined);
// estimate how many new functions can be handled before overflow
InitPconJmpTbl(pimage);
// reset count of relocs
// For PowerMac this is done in ppc.c in MppcDoIncrInit
pimage->ImgOptHdr.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC].Size = 0;
#ifdef INSTRUMENT
LogNoteEvent(Log, SZILINK, SZPASS1, letypeBegin, NULL);
#endif // INSTRUMENT
// make a pass over all modified files
for (i = 0, arg = ModFileList.First;
i < ModFileList.Count;
i++, arg = arg->Next) {
Pass1Arg(arg, pimage, plibModObjs);
if (errInc != errNone) {
#ifdef INSTRUMENT
LogNoteEvent(Log, SZILINK, SZPASS1, letypeEvent, "failed pass1, file: %s", arg->OriginalName);
LogNoteEvent(Log, SZILINK, SZPASS1, letypeEnd, NULL);
#endif // INSTRUMENT
return;
}
}
InternalError.CombinedFilenames[0] = '\0';
// Allocate CONs for EXTERN_COMMON symbols
// AllocateCommon(pimage);
#ifdef INSTRUMENT
LogNoteEvent(Log, SZILINK, SZPASS1, letypeEnd, NULL);
#endif // INSTRUMENT
}
void
CountBaseRelocsPMOD (
PMOD pmod,
DWORD *pcReloc
)
/*++
Routine Description:
Counts base reloc by counting relocs in each CON of pmod.
Arguments:
pmod - pointer to mod.
pcReloc - ptr to count of base relocs (approximate)
Return Value:
none.
--*/
{
(*pcReloc) += pmod->cReloc;
}
BOOL
FCheckRefByPMOD (
PEXTERNAL pext,
PMOD pmod,
PST pst,
DWORD *pcReloc
)
/*++
Routine Description:
Checks the reference by this mod.
Arguments:
pmod - ptr to a mod
Return Value:
FALSE if mod belongs to a lib.
--*/
{
BOOL fIsLib = FIsLibPMOD(pmod);
// if referenced by a lib - return
if (fIsLib) {
#ifdef INSTRUMENT
const char *szSym = SzNamePext(pext, pst);
LogNoteEvent(Log, SZILINK, "data-handling", letypeEvent,
"%s ref by lib %s", szSym, SzOrigFilePMOD(pmod));
#endif // INSTRUMENT
return(FALSE);
}
// is it referenced by a modified file?
if (!IsDirtyPMOD(pmod)) {
#ifdef INSTRUMENT
const char *szSym = SzNamePext(pext, pst);
LogNoteEvent(Log, SZILINK, "data-handling", letypeEvent,
"%s ref by unmod. file %s", szSym, SzOrigFilePMOD(pmod));
#endif // INSTRUMENT
// add the module to the pass2 list. no need to do pass1 on it.
assert (!FDidPass1PMOD(pmod));
if (!FDidPass1PMOD(pmod)) {
pmod->LnkFlags |= MOD_NoPass1;
}
DoPass2PMOD(pmod, FALSE);
// count number of base relocs
// This is no good for PowerMac
CountBaseRelocsPMOD(pmod, pcReloc);
}
return(TRUE);
}
BOOL
FRefByModFilesOnly (
PEXTERNAL pext,
PST pst,
DWORD *pcReloc
)
/*++
Routine Description:
checks if reference list is subset of modified list.
Arguments:
pext - extern (data).
pst - pointer to symbol table.
pcReloc - ptr to count of base relocs (approximate)
Return Value:
TRUE if reference list is a subset of modified list.
--*/
{
ENM_MOD_EXT enmModExt;
// no references
if (!pext->pmodsFirst) {
return(TRUE);
}
// walk the reference list
InitEnmModExt(&enmModExt, pext);
while (FNextEnmModExt(&enmModExt)) {
if (!enmModExt.pmod) {
// For ilink we remove references
continue;
}
if (!FCheckRefByPMOD(pext, enmModExt.pmod, pst, pcReloc)) {
return(FALSE);
}
}
return(TRUE);
}
void
CheckIfMovedDataRefByModFiles(
PST pst,
DWORD *pcReloc
)
/*++
Routine Description:
checks if public data moved is referenced only by some subset of modified files.
Arguments:
pst - pointer to symbol table.
pcReloc - On return will hold the count of base relocs on account of including
new objs for pass2.
Return Value:
None. Sets errInc as appropriate.
--*/
{
LEXT *plext = plextMovedData;
#ifdef INSTRUMENT
LogNoteEvent(Log, SZILINK, "data-handling", letypeBegin, NULL);
#endif // INSTRUMENT
// walk the public data list
while (plext) {
PEXTERNAL pext = plext->pext;
// if the address of extern data hasn't changed, go onto next
if (pext->FinalValue !=
(pext->ImageSymbol.Value+pext->pcon->rva)) {
// data moved!
if (fPowerMac && READ_BIT(pext, sy_TOCALLOCATED)) {
// Reset bit for sy_TOCENTRYFIXEDUP so that it will
// be fixed up in Pass2
RESET_BIT(pext, sy_TOCENTRYFIXEDUP);
}
if (!FRefByModFilesOnly(pext, pst, pcReloc)) {
// So ensure all references are subset of modified mods.
// if not pull in objs for a pass2.
errInc = errDataMoved;
break;
}
#ifdef INSTRUMENT
{
const char *szSym = SzNamePext(pext, pst);
LogNoteEvent(Log, SZILINK, "data-handling", letypeEvent, "%s ref by mod files", szSym);
}
#endif // INSTRUMENT
}
plext = plext->plextNext;
}
#ifdef INSTRUMENT
LogNoteEvent(Log, SZILINK, "data-handling", letypeEnd, NULL);
#endif // INSTRUMENT
}
void
ReleaseMovedDataRefList (
PIMAGE pimage
)
/* ++
++ */
{
LEXT *plext = plextMovedData;
// free the list of data externs
while (plextMovedData) {
if (fPowerMac) {
MppcFixIncrDataMove(plext->pext, pimage);
}
plext = plextMovedData->plextNext;
FreePv(plextMovedData);
plextMovedData = plext;
}
}
void
UpdateDebugDir (
PIMAGE pimage
)
/*++
Routine Description:
Updates the debug directory
Arguments:
pimage - ptr to EXE image
Return Value:
None.
--*/
{
PGRP pgrp;
PCON pcon;
PSEC psec;
if (pimage->Switch.Link.DebugInfo == None) {
// No debug info
return;
}
// find the cv signature pcon.
psec = PsecFindNoFlags(".debug", &pimage->secs);
assert(psec);
pgrp = PgrpFind(psec, ".debug$H");
assert(pgrp);
pcon = pgrp->pconNext;
assert(pcon);
// update the directory (assumes pdbfilename remains the same).
FileSeek(FileWriteHandle, pcon->foRawDataDest, SEEK_SET);
FileWrite(FileWriteHandle, &nb10i, sizeof(nb10i));
// update the fpo debug directory
if (pimage->fpoi.ifpoMax) {
IMAGE_DEBUG_DIRECTORY debugDir;
FileSeek(FileWriteHandle, pimage->fpoi.foDebugDir, SEEK_SET);
FileRead(FileWriteHandle, &debugDir, sizeof(IMAGE_DEBUG_DIRECTORY));
debugDir.SizeOfData = pimage->fpoi.ifpoMac * sizeof(FPO_DATA);
FileSeek(FileWriteHandle, -(LONG)sizeof(IMAGE_DEBUG_DIRECTORY), SEEK_CUR);
FileWrite(FileWriteHandle, &debugDir, sizeof(IMAGE_DEBUG_DIRECTORY));
}
}
void
UpdateImgHdrsAndComment (
PIMAGE pimage,
BOOL fStripRelocs
)
/*++
Routine Description:
Updates the image headers
Arguments:
pimage - ptr to EXE image
fStripRelocs - TRUE if base relocs need to be stripped.
Return Value:
None.
--*/
{
// update image hdr timestamp
_tzset();
time((time_t *)&pimage->ImgFileHdr.TimeDateStamp);
// mark it as fixed (!!!TEMPORARY!!!)
if (fStripRelocs) {
pimage->ImgFileHdr.Characteristics |= IMAGE_FILE_RELOCS_STRIPPED;
}
// Is it a PE image.
if (pimage->Switch.Link.fPE) {
// Update the stub if necessary
if (OAStub & OA_UPDATE) {
FileSeek(FileWriteHandle, 0, SEEK_SET);
FileWrite(FileWriteHandle, pimage->pbDosHeader, pimage->cbDosHeader);
}
CoffHeaderSeek = pimage->cbDosHeader;
}
// seek and write out updated image headers
FileSeek(FileWriteHandle, CoffHeaderSeek, SEEK_SET);
WriteFileHeader(FileWriteHandle, &pimage->ImgFileHdr);
// Update optional header & write out as well
if (fStripRelocs) {
pimage->ImgOptHdr.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC].Size = 0;
pimage->ImgOptHdr.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC].VirtualAddress = 0;
}
if (pextGp) {
pimage->ImgOptHdr.DataDirectory[IMAGE_DIRECTORY_ENTRY_GLOBALPTR].VirtualAddress = pextGp->FinalValue;
}
WriteOptionalHeader(FileWriteHandle, &pimage->ImgOptHdr,
pimage->ImgFileHdr.SizeOfOptionalHeader);
// update the comment as necessary
if (OAComment == OA_UPDATE || OAComment == OA_ZERO) {
DWORD cbComment = __max(pimage->SwitchInfo.cbComment, blkComment.cb);
BYTE *buf;
buf = (BYTE *) PvAllocZ(cbComment);
if (OAComment != OA_ZERO) {
memcpy(buf, blkComment.pb, blkComment.cb);
}
FileSeek(FileWriteHandle,
pimage->ImgFileHdr.NumberOfSections * sizeof(IMAGE_SECTION_HEADER), SEEK_CUR);
FileWrite(FileWriteHandle, buf, cbComment);
FreePv(buf);
}
}
INT
IncrBuildImage (
PPIMAGE ppimage
)
/*++
Routine Description:
Main driving routine that does the incremental build.
Arguments:
pimage - ptr to EXE image
Return Value:
0 on success, -1 on failure
--*/
{
BOOL fLib;
BOOL fNew;
BOOL fDel;
PIMAGE pimage = *ppimage;
// Instantiate value for linker defined mod
pmodLinkerDefined = pimage->pmodLinkerDefined;
// Init begins
#ifdef INSTRUMENT
LogNoteEvent(Log, SZILINK, SZINIT, letypeBegin, NULL);
#endif // INSTRUMENT
// Check to see if export object has changed
if (FExpFileChanged(&pimage->ExpInfo)) {
errInc = errExports;
#ifdef INSTRUMENT
LogNoteEvent(Log, SZILINK, SZINIT, letypeEnd, NULL);
#endif // INSTRUMENT
if (fTest) {
PostNote(NULL, EXPORTSCHANGED);
}
return CleanUp(ppimage);
}
// Determine set of changed files
InitModFileList(pimage, &fLib, &fNew, &fDel);
// Open the EXE image
FileWriteHandle = FileOpen(OutFilename, O_RDWR | O_BINARY, 0);
fOpenedOutFilename = TRUE;
// Any changes (LATER: should update the timestamp)
if (!ModFileList.Count) {
#ifdef INSTRUMENT
LogNoteEvent(Log, SZILINK, SZINIT, letypeEvent, "no mod changes");
#endif // INSTRUMENT
// Update the headers alone; timestamp and user values updated.
UpdateImgHdrsAndComment(pimage, FALSE);
#ifdef INSTRUMENT
LogNoteEvent(Log, SZILINK, SZINIT, letypeEnd, NULL);
#endif // INSTRUMENT
errInc = errNoChanges;
return CleanUp(ppimage);
}
#ifdef INSTRUMENT
LogNoteEvent(Log, SZILINK, SZINIT, letypeEvent,
"count of mod files: 0x%.4x", ModFileList.Count);
#endif // INSTRUMENT
#ifdef INSTRUMENT
LogNoteEvent(Log, SZILINK, SZINIT, letypeEnd, NULL);
#endif // INSTRUMENT
// New files OR deletion of objs OR mod of libs punt
if (fLib || fNew || fDel) {
if (fNew) {
errInc = errFileAdded;
if (fTest) {
PostNote(NULL, OBJADDED);
}
} else if (fDel) {
errInc = errFileDeleted;
if (fTest) {
PostNote(NULL, OBJREMOVED);
}
} else if (fLib) {
errInc = errLibChanged;
if (fTest) {
PostNote(NULL, LIBCHANGED);
}
}
return CleanUp(ppimage);
}
// Set up for cleanup
FilenameArguments = ModFileList;
if (pimage->ImgFileHdr.Machine == IMAGE_FILE_MACHINE_MPPC_601) {
fPowerMac = TRUE;
// Do PowerMac Specific initialization
MppcDoIncrInit(pimage);
}
// Make a pass over symbol table
DBEXEC(DB_SYMREFS, DumpReferences(pimage)); // DumpReferences() needs fixing.
MarkSymbols(*ppimage);
DBEXEC(DB_SYMREFS, DumpReferences(pimage));
// Do an incr pass1
InternalError.Phase = "Pass1";
IncrPass1(pimage);
if (errInc != errNone) {
return CleanUp(ppimage);
}
if ((pimage->ImgFileHdr.Machine == IMAGE_FILE_MACHINE_R4000) ||
(pimage->ImgFileHdr.Machine == IMAGE_FILE_MACHINE_R10000) ||
(pimage->ImgFileHdr.Machine == IMAGE_FILE_MACHINE_ALPHA)) {
// Find the GP symbol
pextGp = SearchExternSz(pimage->pst, "_gp");
}
// Resolve weak externs
ResolveExistingWeakAndLazyExterns(pimage);
ResolveWeakExterns(pimage, EXTERN_WEAK);
if (errInc != errNone) {
return CleanUp(ppimage);
}
// Check for unresolved externals
ProcessUndefinedExternals(pimage);
// Check to see if we need to search libraries
if (errInc == errUndefinedSyms) {
errInc = errNone;
// Do the library search
ResolveExternalsInLibs(pimage);
if (errInc != errNone && errInc != errUndefinedSyms) {
return CleanUp(ppimage);
}
}
// Resolve weak/lazy externs
ResolveWeakExterns(pimage, (EXTERN_WEAK|EXTERN_LAZY|EXTERN_ALIAS));
if (errInc != errNone) {
return CleanUp(ppimage);
}
// Check to see if we have any undefined externals
PrintUndefinedExternals(pimage->pst);
// Fail link if we have undefined symbols as in full link
if (UndefinedSymbols && !(pimage->Switch.Link.Force & ftUnresolved)) {
Fatal(OutFilename, UNDEFINEDEXTERNALS, UndefinedSymbols);
}
// Encountered error or we were still left with undefined symbols (REVIEW?)
assert(errInc != errUndefinedSyms);
if (errInc != errNone) {
return CleanUp(ppimage);
}
// Alloc common PCONs
IncrAllocateCommon(pimage);
// Check to see if all the mods included need to be included
if (!fPowerMac && CheckForUnrefLibMods(pimage)) {
errInc = errLibRefSetChanged;
return CleanUp(ppimage);
}
// Check for any multiple definitions that may cause us to full-link
CheckForMultDefns(pimage, plpextMultDef);
if (errInc != errNone) {
return CleanUp(ppimage);
}
// no output file generated if there are multiply defined symbols unless
// /FORCE:multiple was specified. In the latter case we need to do a
// non-incremental build. Otherwise on ilinks it will give us grief.
// if (fMultipleDefinitions && !(pimage->Switch.Link.Force & ftMultiple)) {
// Fatal(OutFilename, MULTIPLYDEFINEDSYMS);
// } else if (fMultipleDefinitions && (pimage->Switch.Link.Force & ftMultiple)) {
// Warning(OutFilename, CANNOTILINKINFUTURE);
// }
if (fPowerMac) {
MppcCheckIncrTables();
if (errInc != errNone) {
return CleanUp(ppimage);
}
}
// Calculate new addresses
InternalError.Phase = "CalcPtrs";
InternalError.CombinedFilenames[0] = '\0';
IncrCalcPtrs(pimage);
if (errInc != errNone) {
return CleanUp(ppimage);
}
if (pextGp) {
psecGp = PsecFind(
NULL,
ReservedSection.GpData.Name,
ReservedSection.GpData.Characteristics,
&pimage->secs,
&pimage->ImgOptHdr);
CalculateGpRange();
// Align the GP pointer on a quad-word. This is assumed for Alpha.
pextGp->FinalValue = pextGp->ImageSymbol.Value = ((rvaGp + rvaGpMax) / 2) & ~7;
}
if (pimage->ImgFileHdr.Machine == IMAGE_FILE_MACHINE_ALPHA) {
DWORD rvaCur = pimage->ImgOptHdr.BaseOfCode;
if (CalculateTextSectionSize(pimage, rvaCur) >= 0x400000) {
fAlphaCheckLongBsr = TRUE;
}
}
if (fPowerMac) {
CollectAndSort(pimage);
}
// Check if data movement is a problem
CheckIfMovedDataRefByModFiles(pimage->pst, &cReloc);
if (errInc != errNone) {
return CleanUp(ppimage);
}
if (!fPowerMac && !fNoBaseRelocs) {
// alloc space for collecting the base relocs
// For PowerMac, this is done in MppcCheckIncrTables()
if (pimage->pdatai.ipdataMac) {
unsigned long oldCrelFree = pimage->bri.crelFree;
DeleteBaseRelocs(&pimage->bri, psecException->rva,
pimage->pdatai.ipdataMac * sizeof(IMAGE_RUNTIME_FUNCTION_ENTRY));
cReloc += pimage->bri.crelFree - oldCrelFree;
}
pimage->ImgOptHdr.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC].Size
+= cReloc;
pbrCur = rgbr =
(BASE_RELOC *) PvAlloc(pimage->ImgOptHdr.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC].Size
* sizeof(BASE_RELOC));
pbrEnd = rgbr +
pimage->ImgOptHdr.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC].Size;
}
if (pimage->fpoi.ifpoMax) {
// Init fpo handler
FPOInit(pimage->fpoi.ifpoMax);
}
if (pimage->pdatai.ipdataMax) {
// Init pdata handler
PDATAInit(pimage->pdatai.ipdataMax);
}
if (fPowerMac) {
FixupEntryInitTerm(pextEntry, pimage);
MppcIncrFixExportDescriptors(pimage);
}
// Pass2 of changed mods
InternalError.Phase = "IncrPass2";
#ifdef INSTRUMENT
// log begin of pass2
LogNoteEvent(Log, SZILINK, SZPASS2, letypeBegin, NULL);
#endif // INSTRUMENT
// Allocate space for CvInfo Structs: needed for linenum info
CvInfo = (PCVINFO) PvAllocZ(Cmod(pimage->libs.plibHead) * sizeof(CVINFO));
Pass2(pimage);
if (errInc != errNone) {
return CleanUp(ppimage);
}
ReleaseMovedDataRefList(pimage);
#ifdef INSTRUMENT
LogNoteEvent(Log, SZILINK, SZPASS2, letypeEnd, NULL);
#endif // INSTRUMENT
// update fpo info
if (pimage->fpoi.ifpoMax) {
WriteFpoRecords(&pimage->fpoi, pgrpFpoData->foRawData);
if (errInc != errNone) {
return CleanUp(ppimage);
}
}
// handle debug info
UpdateDebugDir(pimage);
if (pimage->pdatai.ipdataMax) {
if (fPowerMac) {
assert(pgrpPdata);
WritePdataRecords(&pimage->pdatai, pgrpPdata->foRawData);
MppcFixCxxEHTableOnILink (pimage);
} else {
WritePdataRecords(&pimage->pdatai, psecException->foRawData);
}
if (errInc != errNone) {
return CleanUp(ppimage);
}
pimage->ImgOptHdr.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXCEPTION].Size =
pimage->pdatai.ipdataMac * sizeof(IMAGE_RUNTIME_FUNCTION_ENTRY);
assert(pimage->ImgOptHdr.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXCEPTION].VirtualAddress ==
(fPowerMac ? pgrpPdata->rva : psecException->rva));
}
// map file changes (or regenerate a new one) (LATER)
// based relocs
InternalError.Phase = "EmitRelocations";
InternalError.CombinedFilenames[0] = '\0';
if (fPowerMac) {
MppcUpdateRelocTable(pimage);
// Free the deleted Base Reloc List for PowerMac
FreeArgumentList(&ZappedBaseRelocList);
} else if (!fNoBaseRelocs) {
EmitRelocations(pimage);
}
if (fAlphaCheckLongBsr) {
assert(pimage->ImgFileHdr.Machine == IMAGE_FILE_MACHINE_ALPHA);
EmitAlphaThunks();
}
if (errInc != errNone) {
return CleanUp(ppimage);
}
// Update image headers as needed
InternalError.Phase = "UpdateImgHdrsAndComment";
UpdateImgHdrsAndComment(pimage, FALSE);
return CleanUp(ppimage);
}
INT
CleanUp (
PPIMAGE ppimage
)
/*++
Routine Description:
cleanup routine. errInc is global.
Arguments:
pimage - ptr to EXE image
Return Value:
0 on success, -1 on failure
--*/
{
BOOL fNotified = FALSE;
InternalError.Phase = "FinalPhase";
switch (errInc) {
case errOutOfDiskSpace:
fNotified = TRUE;
case errOutOfMemory:
if (!fNotified) {
if (fTest) {
PostNote(NULL, INTLIMITEXCEEDED);
}
fNotified = TRUE;
}
case errFpo:
case errPdata:
if (!fNotified) {
if (fTest) {
PostNote(NULL, PADEXHAUSTED);
}
fNotified = TRUE;
}
case errTypes:
if (!fNotified) {
if (fTest) {
PostNote(NULL, PRECOMPREQ);
}
fNotified = TRUE;
}
case errDbiFormat:
if (!fNotified) {
if (fTest) {
PostNote(NULL, DBIFORMAT);
}
fNotified = TRUE;
}
case errDataMoved:
if (!fNotified) {
if (fTest) {
PostNote(NULL, SYMREFSETCHNG);
}
fNotified = TRUE;
}
case errCalcPtrs:
if (!fNotified) {
if (fTest) {
PostNote(NULL, PADEXHAUSTED);
}
fNotified = TRUE;
}
// close up the image file
if (FileWriteHandle) {
FileClose(FileWriteHandle, TRUE);
FileWriteHandle = 0;
}
case errUndefinedSyms:
if (!fNotified) {
if (fTest) {
PostNote(NULL, SYMREFSETCHNG);
}
fNotified = TRUE;
}
case errWeakExtern:
if (!fNotified) {
if (fTest) {
PostNote(NULL, SYMREFSETCHNG);
}
fNotified = TRUE;
}
case errCommonSym:
if (!fNotified) {
if (fTest) {
PostNote(NULL, BSSCHNG);
}
fNotified = TRUE;
}
case errAbsolute:
if (!fNotified) {
if (fTest) {
PostNote(NULL, ABSSYMCHNG);
}
fNotified = TRUE;
}
case errMultDefFound:
if (!fNotified) {
fNotified = TRUE;
}
case errLibRefSetChanged:
if (!fNotified) {
if (fTest) {
PostNote(NULL, LIBREFSETCHNG);
}
fNotified = TRUE;
}
case errComdat:
if (!fNotified) {
if (fTest) {
PostNote(NULL, DIFFCOMDATS);
}
fNotified = TRUE;
}
case errJmpTblOverflow:
case errTocTblOverflow:
case errDescOverflow:
if (!fNotified) {
if (fTest) {
PostNote(NULL, PADEXHAUSTED, NULL, NULL);
}
fNotified = TRUE;
}
case errDirectives:
if (!fNotified) {
if (fTest) {
PostNote(NULL, DIFFDIRECTIVES, NULL, NULL);
}
fNotified = TRUE;
}
case errBaseReloc:
if (!fNotified) {
if (fTest) {
PostNote(NULL, PADEXHAUSTED);
}
fNotified = TRUE;
}
case errTooManyChanges:
case errFileAdded:
case errFileDeleted:
case errLibChanged:
case errExports:
#ifdef ILINKLOG
IlinkLog((UINT)-1);
#endif // ILINKLOG
// restore state
fIncrDbFile = FALSE;
// close up the inc file & delete it
FreeImage(ppimage, TRUE);
remove(szIncrDbFilename);
// remove any temporary files
FileCloseAll();
RemoveConvertTempFiles();
if (ModFileList.Count) {
FreeArgumentList(&ModFileList);
}
// return
#ifdef INSTRUMENT
LogNoteEvent(Log, SZILINK, NULL, letypeEvent, "failed");
#endif // INSTRUMENT
return -1;
case errNone:
#ifdef INSTRUMENT
LogNoteEvent(Log, SZILINK, NULL, letypeEvent, "success");
#endif // INSTRUMENT
case errNoChanges:
FileClose(FileWriteHandle, TRUE);
FileWriteHandle = 0;
SaveImage(*ppimage);
return 0;
default:
assert(0); // uhhuh!
} // end switch
assert(0); // nahnah!
return(-1);
}
#if DBG
void
DumpJmpTbl (
PCON pcon,
PVOID pvRaw
)
/*++
Routine Description:
Dumps the jump table contents.
Arguments:
pvRaw - pointer to raw data
Return Value:
None.
--*/
{
BYTE *p;
DumpPCON(pcon);
p = (BYTE *) pvRaw;
DBPRINT("---------BEGIN OF JMP TBL--------------\n");
for (;pcon->cbRawData > (DWORD) (p - (BYTE *) pvRaw);) {
if (fPowerMac) {
DWORD offset = DwSwap(*(DWORD *) p);
// Opcode is in the first 6 bits for PowerMac
DBPRINT("OP= 0x%.02x, ADDR=0x%.8lx\n",
(offset >> 24) & 0xFC,
(offset << 6) >> 6);
} else {
DBPRINT("OP= 0x%.02x, ADDR=0x%.8lx\n",
*p,
*(LONG UNALIGNED *) (p+ilink_info->address_offset));
}
p += CbJumpEntry();
}
DBPRINT("----------END OF JMP TBL---------------\n");
}
void
DumpReferences (
PIMAGE pimage
)
/*++
Routine Description:
Dumps all references.
Arguments:
pimage - ptr to EXE image
Return Value:
None.
--*/
{
PEXTERNAL pext;
INT i = 0;
DBPRINT("---------BEGIN OF SYMBOL REFERENCES--------------\n");
// walk the external symbol table
InitEnumerateExternals(pimage->pst);
while ((pext = PexternalEnumerateNext(pimage->pst)) != NULL) {
ENM_MOD_EXT enmModExt;
if ((pext->Flags & EXTERN_DEFINED) == 0) {
// Ignore whatever needs to be ignored
continue;
}
DBPRINT("sym= %s\n referenced by= ", SzNamePext(pext, pimage->pst));
// display references from modified files
InitEnmModExt(&enmModExt, pext);
while (FNextEnmModExt(&enmModExt)) {
PMOD pmod = enmModExt.pmod;
if (pmod == NULL) {
continue; // for ilink we remove references
}
DBPRINT("%s ", FIsLibPMOD(pmod) ?
pmod->plibBack->szName : SzOrigFilePMOD(pmod));
if (++i > 2) {
DBPRINT("\n");
i = 0;
}
}
if (i) {
DBPRINT("\n");
}
}
TerminateEnumerateExternals(pimage->pst);
DBPRINT("---------END OF SYMBOL REFERENCES--------------\n");
}
#endif // DBG
// REVIEW: assumes only one export object per DLL.
void
SaveExpFileInfo (
PEXPINFO pei,
const char *szFile,
DWORD ts,
BOOL fExpObj
)
/*++
Routine Description:
Saves export object info (DEF file or export object).
Arguments:
pei - ptr to export info
szFile - name of file
ts - timestamp
fExpObj - TRUE if file is an export object
Return Value:
None.
--*/
{
assert(szFile);
// an .exp file wasn't used
if (!fExpObj) {
struct _stat statfile;
szFile = Strdup(szFile);
assert(!ts);
if (_stat(szFile, &statfile) == -1) {
Fatal(NULL, CANTOPENFILE, szFile);
}
ts = statfile.st_mtime;
}
assert(ts);
// fill in fields
pei->szExpFile = szFile;
pei->tsExp = ts;
}
void
SaveExportInfo (
PIMAGE /* pimage */,
const char *szDef,
PEXPINFO pei
)
/*++
Routine Description:
Saves any exports for the dll/exe into the incr db (private heap)
Arguments:
psecs - pointer to sections list in image map
szDef - name of DEF file
pei - ptr to export info
Return Value:
None.
--*/
{
if (pgrpExport->pconNext != NULL) {
PMOD pmod;
// An export object was used
pmod = PmodPCON(pgrpExport->pconNext);
SaveExpFileInfo(pei, SzOrigFilePMOD(pmod), pmod->TimeStamp, 1);
return;
}
// DEF file was used
if (szDef && szDef[0] != '\0') {
SaveExpFileInfo(pei, szDef, 0, 0);
}
// save exports specified via cmd line only; directives checked separately
if (ExportSwitches.Count) {
PARGUMENT_LIST parg;
WORD i;
for (i = 0, parg = ExportSwitches.First;
i < ExportSwitches.Count;
i++, parg = parg->Next) {
if (parg->ModifiedName) {
// This export was specified in a directive
continue;
}
AddArgToListOnHeap(&pei->nlExports, parg);
}
}
}
BOOL
FExpFound (
PARGUMENT_LIST parg
)
/*++
Routine Description:
Looks for the export in the current export list.
Arguments:
parg - ptr to an export entry.
Return Value:
TRUE if found else FALSE
--*/
{
if (FArgOnList(&ExportSwitches, parg)) {
return(TRUE);
}
// Not found
#ifdef INSTRUMENT
LogNoteEvent(Log, SZILINK, NULL, letypeEvent, "exports changed: %s not found", parg->OriginalName);
#endif // INSTRUMENT
return(FALSE);
}
BOOL
FIsModFile (
PARGUMENT_LIST parg
)
/*++
Routine Description:
Checks to see if this directive is from a modified file.
REVIEW: currently works for objs only & not libs.
Arguments:
parg - ptr to an export entry.
Return Value:
TRUE if export belongs to a modified file.
--*/
{
PMOD pmod;
char szBuf[_MAX_PATH * 2];
assert(parg);
assert(parg->ModifiedName);
pmod = plibModObjs->pmodNext;
// walk the list of modified objs
while (pmod) {
// generate the combined name
SzComNamePMOD(pmod, szBuf);
// compare names
if (!_tcsicmp(szBuf, parg->ModifiedName)) {
return 1;
}
pmod = pmod->pmodNext;
}
// didn't find mod
return 0;
}
BOOL
FExportsChanged (
PEXPINFO pei,
BOOL fCmd
)
/*++
Routine Description:
Checks to see if any exports have changed since last link.
REVIEW: assumes changes in DEF/export file detected already.
Arguments:
pei - ptr to export info
fCmd - TRUE if test is for cmdline exports only.
Return Value:
TRUE if there were changes else FALSE
--*/
{
NAME_LIST nl;
PARGUMENT_LIST parg;
WORD i, cexp;
// no exp file was gen.(=> cmdline & directives ignored)
if (!pei->pmodGen && pei->szExpFile) {
WarningIgnoredExports(pei->szExpFile);
return(FALSE);
}
nl = pei->nlExports;
// compare the two lists
cexp = 0;
for (i = 0, parg = nl.First;
i < nl.Count;
i++, parg = parg->Next) {
// ignore directives when checking cmdline exports
if (fCmd && parg->ModifiedName) {
continue;
}
// if we are not checking cmdline exports, ignore them
if (!fCmd && !parg->ModifiedName) {
++cexp; // need to count
continue;
}
// check directives of modified files only
if (parg->ModifiedName && !FIsModFile(parg)) {
continue;
}
cexp++;
if (!FExpFound(parg)) {
return(TRUE);
}
}
// counts must be the same
if (cexp != ExportSwitches.Count) {
#ifdef INSTRUMENT
LogNoteEvent(Log, SZILINK, NULL, letypeEvent,
"export count was 0x%.4x, is 0x%.4x", cexp, ExportSwitches.Count);
#endif // INSTRUMENT
return(TRUE);
}
return(FALSE);
}
BOOL
FGenFileModified (
const char *szOrig,
const char *szNew,
DWORD ts
)
/*++
Routine Description:
Checks to see if linker generated files are same (name & ts).
Arguments:
szOrig - original name of file
szNew - newly specified name
ts - timestamp of original file
Return Value:
1 if changed else 0
--*/
{
struct _stat statfile;
if (_tcsicmp(szOrig, szNew)) {
#ifdef INSTRUMENT
LogNoteEvent(Log, SZILINK, SZINIT, letypeEvent, "file %s replaced by %s", szOrig, szNew);
#endif // INSTRUMENT
return 1;
}
if (_stat(szOrig, &statfile) == -1) {
#ifdef INSTRUMENT
LogNoteEvent(Log, SZILINK, SZINIT, letypeEvent, "file not accessible: %s", szNew);
#endif // INSTRUMENT
return 1;
}
if (ts != (DWORD)statfile.st_mtime) {
#ifdef INSTRUMENT
LogNoteEvent(Log, SZILINK, SZINIT, letypeEvent, "file modified: %s", szOrig);
#endif // INSTRUMENT
return 1;
}
return 0; // no changes
}
BOOL
FExpFileChanged (
PEXPINFO pei
)
/*++
Routine Description:
Checks to see if export-object/DEF-file was updated between links.
Caveat: assumes that if export object was used, DEF file is
ignored.
Arguments:
pei - ptr to export info
Return Value:
1 if changed else 0
--*/
{
// an export object was used; if a new exports obj is added it will get detected
// as a new file being added
if (!pei->pmodGen && pei->szExpFile) {
PARGUMENT_LIST parg;
parg = PargFindSz(pei->szExpFile, &FilenameArguments);
if (!parg) {
#ifdef INSTRUMENT
LogNoteEvent(Log, SZILINK, SZINIT, letypeEvent, "exp obj %s was used, now not", pei->szExpFile);
#endif // INSTRUMENT
return(TRUE);
}
assert(parg);
if (parg->TimeStamp != pei->tsExp) {
#ifdef INSTRUMENT
LogNoteEvent(Log, SZILINK, SZINIT, letypeEvent, "exp obj modified: %s", parg->OriginalName);
#endif // INSTRUMENT
return(TRUE);
}
return(FALSE);
}
// an exports object was generated. check for any changes to it and the correspodning import lib if any
if (pei->pmodGen) {
char szDrive[_MAX_DRIVE];
char szDir[_MAX_DIR];
char szFname[_MAX_FNAME];
char szExt[_MAX_EXT];
char szImplibFilename[_MAX_FNAME];
const char *szImplibT;
PMOD pmod;
pmod = pei->pmodGen;
if (FGenFileModified(SzOrigFilePMOD(pmod), SzOrigFilePMOD(pmod), pmod->TimeStamp)) {
return(TRUE);
}
assert(pei->szImpLib);
assert(pei->tsImpLib);
if ((szImplibT = ImplibFilename) == NULL) {
_splitpath(OutFilename, szDrive, szDir, szFname, szExt);
_makepath(szImplibFilename, szDrive, szDir, szFname, ".lib");
szImplibT = szImplibFilename;
}
if (FGenFileModified(pei->szImpLib, szImplibT, pei->tsImpLib)) {
return(TRUE);
}
}
// a DEF file was used previously;
if (pei->pmodGen && pei->szExpFile) {
struct _stat statfile;
if (DefFilename == NULL || DefFilename[0] == '\0') {
#ifdef INSTRUMENT
LogNoteEvent(Log, SZILINK, SZINIT, letypeEvent, ".def file %s no longer used", DefFilename, 0);
#endif // INSTRUMENT
return(TRUE); // DEF file no longer used
}
if (_tcsicmp(pei->szExpFile, DefFilename)) {
#ifdef INSTRUMENT
LogNoteEvent(Log, SZILINK, SZINIT, letypeEvent, "file %s replaced by %s", pei->szExpFile, DefFilename);
#endif // INSTRUMENT
return(TRUE); // DEF file replaced
}
if (_stat(pei->szExpFile, &statfile) == -1) {
Fatal(NULL, CANTOPENFILE, DefFilename); // DEf file not found
}
if (pei->tsExp != (DWORD)statfile.st_mtime) {
#ifdef INSTRUMENT
LogNoteEvent(Log, SZILINK, SZINIT, letypeEvent, ".def file modified %s", pei->szExpFile, 0);
#endif // INSTRUMENT
return(TRUE);
}
return(FALSE); // no changes
}
// check if a DEF file was specified for the first time
if (DefFilename != NULL && DefFilename[0] != '\0') {
return(TRUE);
}
// neither was used (note: changes in export specs via
// cmdline get detected while pocessing cmdline options).
return(FALSE);
}
void
WriteFpoRecords (
FPOI *pfpoi,
DWORD foFpo
)
/*++
Routine Description:
Updates/writes out the fpo information.
Arguments:
pfpoi - ptr to fpo info.
foFpo - file ptr to fpo.
Return Value:
None.
--*/
{
BOOL fMapped;
DWORD cbFpo = pfpoi->ifpoMax * sizeof(FPO_DATA);
PVOID pvRawData = PbMappedRegion(FileWriteHandle,
foFpo,
cbFpo);
fMapped = pvRawData != NULL ? TRUE : FALSE;
// if not mapped, alloc space for fpo records
if (!fMapped) {
pvRawData = PvAlloc(cbFpo);
// on an ilink read in fpo records
if (fIncrDbFile) {
FileSeek(FileWriteHandle, foFpo, SEEK_SET);
FileRead(FileWriteHandle, pvRawData, cbFpo);
}
}
pfpoi->rgfpo = (PFPO_DATA) pvRawData;
if (!FPOUpdate(pfpoi)) {
// on a full build, no failures expected
if (!fIncrDbFile) {
Fatal(NULL, INTERNAL_ERR);
}
errInc = errFpo;
#ifdef INSTRUMENT
LogNoteEvent(Log, SZILINK, "fpo", letypeEvent, "fpo pad overflow");
#endif // INSTRUMENT
if (!fMapped) {
FreePv(pvRawData);
}
return;
}
// zero out unused fpo entries (padding)
memset((BYTE *)pvRawData + (pfpoi->ifpoMac * sizeof(FPO_DATA)),
0,
cbFpo - (pfpoi->ifpoMac * sizeof(FPO_DATA)));
// if not mapped, need to write out the updated fpo records
if (!fMapped) {
FileSeek(FileWriteHandle, foFpo, SEEK_SET);
FileWrite(FileWriteHandle, pvRawData, cbFpo);
FreePv(pvRawData);
}
}
void
WritePdataRecords (
PDATAI *ppdatai,
DWORD foPdata
)
/*++
Routine Description:
Updates/writes out the pdata information.
Arguments:
ppdatai - ptr to pdata info.
foPdata - file ptr to pdata.
Return Value:
None.
--*/
{
BOOL fMapped;
DWORD cbPdata = ppdatai->ipdataMax * sizeof(IMAGE_RUNTIME_FUNCTION_ENTRY);
PVOID pvRawData = PbMappedRegion(FileWriteHandle,
foPdata,
cbPdata);
fMapped = (pvRawData != NULL);
// if not mapped, alloc space for Pdata records
if (!fMapped) {
pvRawData = PvAlloc(cbPdata);
// on an ilink read in Pdata records
if (fIncrDbFile) {
FileSeek(FileWriteHandle, foPdata, SEEK_SET);
FileRead(FileWriteHandle, pvRawData, cbPdata);
}
}
ppdatai->rgpdata = (PIMAGE_RUNTIME_FUNCTION_ENTRY) pvRawData;
if (!PDATAUpdate(ppdatai)) {
// On a full build, no failures expected
if (!fIncrDbFile) {
Fatal(NULL, INTERNAL_ERR);
}
errInc = errPdata;
#ifdef INSTRUMENT
LogNoteEvent(Log, SZILINK, "pdata", letypeEvent, "pdata pad overflow");
#endif // INSTRUMENT
if (!fMapped) {
FreePv(pvRawData);
}
return;
}
// if not mapped, need to write out the updated fpo records
if (!fMapped) {
FileSeek(FileWriteHandle, foPdata, SEEK_SET);
FileWrite(FileWriteHandle, pvRawData, cbPdata);
FreePv(pvRawData);
}
}
void
SaveDirectiveSz (
const char *Sz,
PST pstDirective,
PMOD pmod
)
/*++
Routine Description:
Save the directive.
Arguments:
Sz - directive string.
pstDirective - symbol table holding all directives.
pmod - ptr to mod that had the directives
Return Value:
None.
--*/
{
PEXTERNAL pext = LookupExternSz(pstDirective, Sz, NULL);
PLEXT plextNew = (PLEXT) Malloc(sizeof(LEXT));
plextNew->pext = pext;
plextNew->plextNext = pmod->plextDirectives;
pmod->plextDirectives = plextNew;
pmod->cDirectives++;
}
BOOL
FVerifyDirectivesPMOD (
PIMAGE pimage,
PMOD pmod,
PNAME_LIST pnl
)
/*++
Routine Description:
Verifies that the directives for the given mod haven't changed.
Arguments:
pimage - ptr to image.
pmod - ptr to mod that had the directives
pnl - the new set of directives seen in this mod.
Return Value:
None.
--*/
{
WORD i;
PARGUMENT_LIST pal;
PMOD pmodO;
// For library modules, ensure no new directives encountered (no changes possible)
if (FIsLibPMOD(pmod)) {
for (i = 0, pal = pnl->First;
i < pnl->Count;
i++, pal = pal->Next) {
PEXTERNAL pext = SearchExternSz(pimage->pstDirective, pal->OriginalName);
if (!pext) {
errInc = errDirectives;
return(FALSE);
}
} // end for
return(TRUE);
}
pmodO = PmodFind(pimage->plibCmdLineObjs, SzOrigFilePMOD(pmod), 0);
assert(pmodO);
pmod->cDirectives = pmodO->cDirectives;
pmod->plextDirectives = pmodO->plextDirectives;
// check the count
if (pnl->Count != pmod->cDirectives) {
errInc = errDirectives;
return(FALSE);
}
// compare individual directives
for (i = 0, pal = pnl->First;
i < pnl->Count;
i++, pal = pal->Next) {
PEXTERNAL pext = SearchExternSz(pimage->pstDirective, pal->OriginalName);
if (!pext) {
errInc = errDirectives;
return(FALSE);
}
if (!PlextFind(pmod->plextDirectives, pext)) {
errInc = errDirectives;
return(FALSE);
}
}
return(TRUE);
}
void
MarkExtern_FuncFixup (
PIMAGE_SYMBOL psym,
PIMAGE pimage,
PCON pcon
)
/*++
Routine Description:
Mark the extern representing this symbol as having a non-lego kind of
fixup (eg. func_sym+offset).
Arguments:
psym - ptr to symbols
pimage - ptr to image
pcon - contribution of the fixup
Return Value:
None.
--*/
{
PEXTERNAL pext;
const char *szName;
// fetch the extern representing this sym. Note that the offsets to
// long names are into the image long name table & not the object's.
szName = SzNameSymPst((*psym), pimage->pst);
pext = SearchExternSz(pimage->pst, szName);
assert(pext);
assert(pext->pcon);
// If the fixup is in the same mod as the definition, nothing to do
if (PmodPCON(pext->pcon) == PmodPCON(pcon)) {
return;
}
// mark the extern
pext->Flags |= EXTERN_FUNC_FIXUP;
}
//
// support routines for ensuring that all modules currently included in image
// as a result of library search are still required/accessed
//
// Algorithm: A garbage collection algorithm "mark & sweep" is used here
// to figure out if any mods are unreferenced.
//
static PLMOD plmodRefModList;
void
WalkRefListPMOD (
PMOD pmod,
PIMAGE pimage
)
/*++
Routine Description:
walks the list of all references made by this MOD.
Arguments:
pmod - ptr to MOD
pimage - ptr to image
Return Value:
None.
--*/
{
ENM_EXT_LIST enmExtList;
pmod->fInclude = TRUE;
InitEnmExtList(&enmExtList, pmod->plpextRef);
while (FNextEnmExtList(&enmExtList)) {
PMOD pmodT;
if (!enmExtList.pext) {
continue; // sometimes linker removes references (for bss)
}
if (enmExtList.pext->Flags & EXTERN_IGNORE) {
continue; // ignorable syms eg. syms no longer in use
}
if (enmExtList.pext->ImageSymbol.SectionNumber == IMAGE_SYM_ABSOLUTE) {
pmodT = FindPmodDefiningSym(pimage->psdAbsolute, enmExtList.pext);
} else {
pmodT = PmodPCON(enmExtList.pext->pcon);
}
// if pmod is pmodLinkerDefined find actual mod defining it (for bss)
if (pmodT == pmodLinkerDefined) {
pmodT = FindPmodDefiningSym(pimage->psdCommon, enmExtList.pext);
if (!pmodT) {
continue; // common was defined in a cmdline obj; we don't care
}
}
// add the referenced MOD to list if it hasn't been processed
assert(pmodT);
if (!pmodT->fInclude) {
AddToPLMODList(&plmodRefModList, pmodT);
}
}
EndEnmExtList(&enmExtList);
}
void
MarkAllRefPMODs (
PIMAGE pimage
)
/*++
Routine Description:
marks all MODs in libs that are referenced
Arguments:
pimage - ptr to image
Return Value:
None.
--*/
{
ENM_MOD enm_mod;
PLMOD plmod;
// Add all command line objs to list of referenced objs
InitEnmMod(&enm_mod, pimage->plibCmdLineObjs);
while (FNextEnmMod(&enm_mod)) {
AddToPLMODList(&plmodRefModList, enm_mod.pmod);
}
EndEnmMod(&enm_mod);
// Add the mod contributing the entrypoint
if (pimage->pmodEntryPoint) {
AddToPLMODList(&plmodRefModList, pimage->pmodEntryPoint);
}
// walk the list of MODs that are referenced
while (plmodRefModList) {
// pop the mod from the list
plmod = plmodRefModList;
plmodRefModList = plmodRefModList->plmodNext;
// walk its references
WalkRefListPMOD(plmod->pmod, pimage);
FreePv(plmod);
}
}
// Currently this is to handle the case where objs from oldnames.lib
// always appear to be not referenced.
BOOL
FHasSideEffectsPMOD(
PMOD pmod
)
{
ENM_SRC enmSrc;
// For now even if 1 contrib is in the image, assume
// it could have side effects
InitEnmSrc(&enmSrc, pmod);
while (FNextEnmSrc(&enmSrc)) {
if (!(enmSrc.pcon->flags & IMAGE_SCN_LNK_REMOVE) &&
enmSrc.pcon->cbRawData)
return(TRUE);
}
return(FALSE);
}
BOOL
AnyUnrefLibMods(
PIMAGE pimage
)
/*++
Routine Description:
checks to see if there are any unreferenced lib mods
Arguments:
pimage - ptr to image
Return Value:
TRUE if there is even 1 mod not referenced anymore.
--*/
{
ENM_LIB enm_lib;
InitEnmLib(&enm_lib, pimage->libs.plibHead);
while (FNextEnmLib(&enm_lib)) {
ENM_MOD enm_mod;
if (enm_lib.plib->flags & LIB_DontSearch) {
continue;
}
InitEnmMod(&enm_mod, enm_lib.plib);
while (FNextEnmMod(&enm_mod)) {
if (!enm_mod.pmod->fInclude && FHasSideEffectsPMOD(enm_mod.pmod)) {
EndEnmMod(&enm_mod);
EndEnmLib(&enm_lib);
return(TRUE);
}
}
EndEnmMod(&enm_mod);
}
EndEnmLib(&enm_lib);
return(FALSE);
}
BOOL
CheckForUnrefLibMods (
PIMAGE pimage
)
/*++
Routine Description:
checks to see if there are any unreferenced lib mods
Arguments:
pimage - ptr to image
Return Value:
TRUE if there is a library MOD no longer referenced
--*/
{
InternalError.Phase = "CheckForUnrefLibMods";
InternalError.CombinedFilenames[0] = '\0';
MarkAllRefPMODs(pimage);
return AnyUnrefLibMods(pimage);
}
//
// support for sym defn handling
//
void
RecordSymDef (
SYM_DEF **ppsd,
PEXTERNAL pext,
PMOD pmod
)
{
PSYM_DEF psd = (*ppsd);
while (psd) {
if (psd->pext == pext) {
psd->pmod = pmod; // update pmod if already in list (for bss redfn)
return;
}
psd = psd->psdNext;
}
psd = (SYM_DEF *) Malloc(sizeof(SYM_DEF));
psd->pext = pext;
psd->pmod = pmod;
psd->psdNext = (*ppsd);
(*ppsd) = psd;
}
PMOD
FindPmodDefiningSym (
SYM_DEF *psd,
PEXTERNAL pext
)
{
while (psd) {
if (psd->pext == pext) {
return psd->pmod;
}
psd = psd->psdNext;
}
return NULL;
}
// functions for ensuring that multiple definitions in libs aren't a problem
//
// Algorithm: The linker builds up a list of externs. If any on this list have
// multiple definitions than the behavior of the linker could be different on
// a full build. The list comprises only the symbols that are referenced by cmdline
// objs, already defined in a lib that weren't referenced by cmdline objs till now.
// These externs potentially can cause differences in behavior if they have definitions
// in a library before the library they were found in.
BOOL
IsSameDefn (
PEXTERNAL pext,
DWORD foMember,
PLIB plib
)
{
assert(FIsLibPCON(pext->pcon));
// convert foMember to value past arhive member (see ReadArchiveMemberHeader())
foMember = EvenByteAlign(foMember) + sizeof(IMAGE_ARCHIVE_MEMBER_HEADER);
// two defns are same if they came from same lib & mod
return(PmodPCON(pext->pcon)->plibBack == plib &&
PmodPCON(pext->pcon)->foMember == foMember);
}
void
MultDefFound (
PIMAGE pimage,
PLIB plib,
PLPEXT plpext
)
{
ENM_EXT_LIST enmExtList;
if (plib->szName != NULL) { // hack-o-rama: temp temp
char szFname[_MAX_FNAME];
char szExt[_MAX_EXT];
char szPath[_MAX_PATH];
_splitpath(plib->szName, NULL, NULL, szFname, szExt);
strcpy(szPath, szFname);
strcat(szPath, szExt);
if (!_ftcsicmp(szPath, "oldnames.lib")) {
return;
}
}
// prep lib for searching
PrepLibForSearching(pimage, plib);
// walk the list of symbols that could potentially have multiple defns.
InitEnmExtList(&enmExtList, plpext);
while (FNextEnmExtList(&enmExtList)) {
const char *szSym;
char **pszEntry;
DWORD isz;
BOOL fFound;
WORD iszIntMem;
DWORD iusOffIndex;
DWORD foMember;
if (!enmExtList.pext) {
continue;
}
szSym = SzNamePext(enmExtList.pext, pimage->pst);
// search for the sym
if (plib->flags & LIB_NewIntMem) {
pszEntry = (char **) bsearch(&szSym, plib->rgszSym,
(size_t) plib->csymIntMem, sizeof(char *), Compare);
fFound = (pszEntry != NULL);
} else {
fFound = FALSE;
for (isz = 0; isz < plib->csymIntMem; isz++) {
if (!strcmp(plib->rgszSym[isz], szSym)) {
fFound = TRUE;
break;
}
}
}
if (!fFound) {
continue;
}
// get the offset of mod that defines it
if (plib->flags & LIB_NewIntMem) {
iszIntMem = (WORD) (pszEntry - plib->rgszSym);
iusOffIndex = plib->rgusOffIndex[iszIntMem];
foMember = plib->rgulSymMemOff[iusOffIndex];
} else {
iszIntMem = (WORD) isz;
foMember = sgetl(&plib->rgulSymMemOff[iszIntMem]);
}
// does the current defn match with the defn just found?
if (!IsSameDefn(enmExtList.pext, foMember, plib)) {
errInc = errMultDefFound;
if (fTest) {
char *szOutput = SzOutputSymbolName(szSym, TRUE);
PostNote(NULL, MULTDEFNFOUND, szOutput);
if (szSym != szOutput) {
FreePv(szOutput);
}
}
return;
}
DelExtFromList(plpext, enmExtList.pext);
}
}
void
CheckForMultDefns (
PIMAGE pimage,
PLPEXT plpextMultDef
)
{
ENM_LIB enm_lib;
InternalError.Phase = "CheckForMultDefns";
InternalError.CombinedFilenames[0] = '\0';
// list empty
if (IsExtListEmpty(plpextMultDef)) {
return;
}
// search the libs for any multiple definitions
InitEnmLib(&enm_lib, pimage->libs.plibHead);
while (FNextEnmLib(&enm_lib)) {
if (enm_lib.plib->flags & LIB_DontSearch) {
continue;
}
MultDefFound(pimage, enm_lib.plib, plpextMultDef);
// check if we hit a multiple defn
if (errInc != errNone) {
return;
}
// no more externs to lookup
if (IsExtListEmpty(plpextMultDef)) {
return;
}
}
}
BOOL
NoRefsByCmdLineObjs (
PEXTERNAL pext
)
{
ENM_MOD_EXT enmModExt;
if (!pext->pmodOnly) {
// No references
return(TRUE);
}
// walk the list of referencing MODs kept at each sym
InitEnmModExt(&enmModExt, pext);
while (FNextEnmModExt(&enmModExt)) {
if (!enmModExt.pmod) {
continue; // for ilink we remove references
}
if (!FIsLibPMOD(enmModExt.pmod)) {
return(FALSE);
}
}
return(TRUE);
}
void
AddExtToMultDefList (
PEXTERNAL pext,
PIMAGE pimage
)
{
assert(pext->Flags & EXTERN_DEFINED);
// ignore absolutes (REVIEW: ignore?)
if (pext->ImageSymbol.SectionNumber == IMAGE_SYM_ABSOLUTE) {
return;
}
// ignore COMMON (don't give rise to multiple definition errors)
if (pext->Flags & EXTERN_COMMON) {
return;
}
if (fPowerMac && !pext->pcon) {
// This could be a descriptor which just got created
// We are already making sure that there are no duplicates
char *szSym = SzNamePext(pext, pimage->pst);
if (*szSym == '.') {
return;
}
}
assert(pext->pcon);
if (FIsLibPMOD(PmodPCON(pext->pcon)) &&
NoRefsByCmdLineObjs(pext)) {
AddExtToList(plpextMultDef, TRUE, pext);
}
}