able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/sdktools/link16/newfix.c

3716 lines
128 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*
* TITLE
* newfix.c
* Pete Stewart
* (C) Copyright Microsoft Corp 1984-89
* 12 October 1984
*
* DESCRIPTION
* This file contains routines for the linker that
* read and interpret fixup records during the second
* pass of the linking process.
*
*/
#include <minlit.h> /* Types and constants */
#include <bndtrn.h> /* Basic types and constants */
#include <bndrel.h> /* Relocation definitions */
#include <lnkio.h> /* Linker I/O definitions */
#include <newexe.h> /* DOS & 286 .EXE format structure def.s */
#if EXE386
#include <exe386.h> /* 386 .EXE format structure def.s */
#include <fixup386.h> /* Linker internal fixup representation */
#endif
#include <lnkmsg.h> /* Error messages */
#include <extern.h> /* External declarations */
#include <nmsg.h> /* Near message strings */
#define RelocWarn(a,b,c,d,e) FixErrSub(a,b,c,d,e,(FTYPE)FALSE)
#define RelocErr(a,b,c,d,e) FixErrSub(a,b,c,d,e,(FTYPE)TRUE)
#define FixupOverflow(a,b,c,d) RelocErr(ER_fixovf,a,b,c,d)
#define IsSELECTED(x) ((x)&SELECTED_BIT)
__inline void addword(BYTE *pdata, WORD w)
// add a word to the word at location pdata... enforce little endian add
// even if linker hosted on a big endian machine
{
w += pdata[0] + (pdata[1]<<BYTELN);
pdata[0] = (BYTE)w;
pdata[1] = (BYTE)(w>>BYTELN);
}
#if defined( _WIN32 )
#define fixword(x,y) ((*(WORD UNALIGNED *)(x)) = (WORD)(y))
#define fixdword(x,y) ((*(DWORD UNALIGNED *)(x)) = (DWORD)(y))
#else
#if M_I386
#define fixword(x,y) ((*(WORD *)(x)) = (WORD)(y))
#define fixdword(x,y) ((*(DWORD *)(x)) = (DWORD)(y))
#else
#define fixword(x,y) ((x)[0]) = (BYTE)(y); \
((x)[1]) = (BYTE)((y) >> BYTELN);
#define fixdword(x,y) ((x)[0]) = (BYTE)(y); \
((x)[1]) = (BYTE)((y) >> BYTELN); \
((x)[2]) = (BYTE)((y) >> (BYTELN*2)); \
((x)[3]) = (BYTE)((y) >> (BYTELN*3));
#endif // NOT M_I386
#endif // NOT _WIN32
#if OSEGEXE
extern RLCPTR rlcLidata; /* Pointer to LIDATA fixup array */
extern RLCPTR rlcCurLidata; /* Pointer to current LIDATA fixup */
# if ODOS3EXE OR defined(LEGO)
#define DoFixup (*pfProcFixup)
# else
#if EXE386
#define DoFixup Fix386
#else
#define DoFixup FixNew
#endif
# endif
#else
#define DoFixup FixOld
#endif
#if NOT ODOS3EXE
#define fNoGrpAssoc FALSE
#endif
WORD mpthdidx[RLCMAX]; /* f(thread) = tgt index */
KINDTYPE mpthdmtd[RLCMAX]; /* f(thread) = tgt method */
LOCAL WORD mpthdfidx[RLCMAX]; /* f(thread) = frm index */
LOCAL KINDTYPE mpthdfmtd[RLCMAX]; /* f(thread) = frm method */
FIXINFO fi; /* Fixup information record */
#if EXE386
LOCAL RATYPE objraCur; /* Current offset in object */
#endif
#if POOL_BAKPAT
LOCAL void * poolBakpat;
#endif
/*
* FUNCTION PROTOTYPES
*/
LOCAL void NEAR GetFixdat(void);
LOCAL unsigned char NEAR GetFixup(void);
#if OSEGEXE
LOCAL void NEAR SaveLiRel(RLCPTR pr);
LOCAL RATYPE NEAR FinishRlc(RLCPTR r,
unsigned short sa,
RATYPE ra);
#if NOT EXE386
#if O68K
LOCAL WORD NEAR GetFixupWord(BYTE *);
LOCAL DWORD NEAR GetFixupDword(BYTE *);
#else /* NOT O68K */
#define GetFixupWord getword
#define GetFixupDword getdword
#endif /* NOT O68K */
#endif /* NOT EXE386 */
#endif /* OSEGEXE */
LOCAL unsigned char NEAR lastbyte(unsigned char *pdata,
RATYPE ra,
unsigned char optest,
unsigned char opnew);
LOCAL void NEAR Getgsn(unsigned char kind,
unsigned short idx,
unsigned short *pgsn,
RATYPE *pra);
LOCAL unsigned char NEAR TransFAR(unsigned char *pdata,
RATYPE ra,
RATYPE raTarget);
LOCAL void NEAR StartAddrOld(void);
LOCAL unsigned short NEAR Mpgsnosn(unsigned short gsn);
LOCAL void NEAR GetFrameTarget(unsigned short *pgsnFrame,
unsigned short *pgsnTarget,
RATYPE *praTarget);
#if EXE386
LOCAL void NEAR Fix386();
#endif
#if ODOS3EXE
LOCAL WORD NEAR InOneGroup(WORD gsnTarget, WORD gsnFrame);
#endif
LOCAL WORD NEAR CallGateRequired(SATYPE saTarget);
extern void AddTceEntryPoint( APROPCOMDAT *pC );
/*
* GetFixdat:
*
* Process the FIXDAT byte of a FIXUPP record.
*/
LOCAL void NEAR GetFixdat()
{
REGISTER WORD fixdat; /* The FIXDAT byte */
WORD i; /* Temporary index */
fixdat = Gets(); /* Get FIXDAT byte */
i = (WORD) ((fixdat >> 4) & 7); /* Get frame info */
if (fixdat & F_BIT) /* If frame thread-specified */
{
i &= 3; /* Threads numbered from 0 to 3 */
fi.f_fmtd = mpthdfmtd[i]; /* Get method */
fi.f_fidx = mpthdfidx[i]; /* Get index */
}
else /* Else if frame explicit */
{
fi.f_fmtd = (KINDTYPE) i; /* Save frame method */
switch(i) /* Switch on frame method */
{
case F0: /* Index to get */
fi.f_fidx = GetIndex(1, (WORD) (snMac - 1));
break;
case F1:
fi.f_fidx = GetIndex(1, (WORD) (grMac - 1));
break;
case F2:
fi.f_fidx = (WORD) (GetIndex(1, EXTMAX) + QCExtDefDelta);
if (fi.f_fidx >= extMac)
InvalidObject();
break;
case F3: /* Frame number to punt */
WGets();
break;
case F4: /* Nothing to get */
case F5:
break;
default: /* Invalid object */
InvalidObject();
}
}
i = (WORD) (fixdat & 3); /* Get target info */
if (fixdat & T_BIT) /* If target given by thread */
{
fi.f_mtd = mpthdmtd[i]; /* Get method */
fi.f_idx = mpthdidx[i]; /* Get index */
}
else /* Else if target explicit */
{
fi.f_mtd = (KINDTYPE ) i; /* Save the method */
ASSERT(fi.f_mtd != 3); /* Unimplemented method */
fi.f_idx = GetIndex(1, EXTMAX); /* Get the index */
if (fi.f_mtd == 2)
{
fi.f_idx += (WORD) QCExtDefDelta;
if (fi.f_idx >= extMac)
InvalidObject();
}
}
#if OMF386
if(rect&1)
fi.f_disp = (fixdat & P_BIT) ? 0L : LGets();
else
#endif
fi.f_disp = (DWORD) ((fixdat & P_BIT) ? 0 : WGets());
/* Get displacement, if any */
}
/*
* GetFixup:
*
* Read and interpret a fixup record, storing the information in
* a buffer.
* Returns TRUE if fixup, FALSE if thread definition.
*/
LOCAL FTYPE NEAR GetFixup()
{
REGISTER WORD key; /* Key byte */
WORD cbData; /* End point */
key = Gets(); /* Get key byte */
if(!(key & THREAD_BIT)) /* If thread definition */
{
fi.f_mtd = (KINDTYPE ) ((key >> 2) & 7);
/* Get the thread method */
ASSERT(fi.f_mtd != 3); /* Unimplemented */
/*
* If target thread, take modulo 4 of method. Primary/secondary
* not specified by thread.
*/
if(!(key & D_BIT))
fi.f_mtd &= 3;
switch(fi.f_mtd) /* Switch on the thread method */
{
case 0: /* Thread specifies an index */
fi.f_idx = GetIndex(1, (WORD) (snMac - 1));
break;
case 1:
fi.f_idx = GetIndex(1, (WORD) (grMac - 1));
break;
case 2:
fi.f_idx = (WORD) (GetIndex(1, EXTMAX) + QCExtDefDelta);
/* Get index */
if (fi.f_idx >= extMac)
InvalidObject();
break;
case 3: /* Frame number (unimplemented) */
WGets(); /* Skip the frame number */
break;
case 4: /* No thread datum */
case 5:
break;
default: /* Error */
InvalidObject(); /* Die gracefully */
}
if(!(key & D_BIT)) /* If we have a target thread */
{
key &= 3; /* Get thread number */
mpthdmtd[key] = fi.f_mtd; /* Get method */
mpthdidx[key] = fi.f_idx; /* Get index */
}
else /* If we have a frame thread */
{
key &= 3; /* Get thread number */
mpthdfmtd[key] = fi.f_mtd;/* Get method */
mpthdfidx[key] = fi.f_idx;/* Get index */
}
return((FTYPE) FALSE); /* Not a fixup */
}
/*
* At this point, we know we have a fixup to perform.
*/
/* Get fixup location type */
#if EXE386
fi.f_loc = (WORD) ((key >> 2) & NRSTYP);
#else
#if OMF386
if(rect & 1)
fi.f_loc = (key >> 2) & NRSTYP;
else
#endif
fi.f_loc = (key >> 2) & 7;
#endif
fi.f_self = (FTYPE) ((key & M_BIT)? FALSE: TRUE);
/* Get fixup mode */
fi.f_dri = (WORD) (((key & 3) << 8) + Gets());
/* Get data record index */
cbData = vcbData;
/* Check if location goes beyond end of data record. */
switch(fi.f_loc)
{
case LOCOFFSET:
case LOCLOADOFFSET:
case LOCSEGMENT:
--cbData;
break;
case LOCPTR:
#if OMF386
case LOCOFFSET32:
case LOCLOADOFFSET32:
#endif
cbData -= 3;
break;
#if OMF386
case LOCPTR48:
cbData -= 5;
break;
#endif
}
if(fi.f_dri >= cbData)
Fatal(ER_badobj);
GetFixdat(); /* Process FIXDAT byte */
#if TCE
if(!vfPass1)
#endif
fi.f_add = !!*(WORD UNALIGNED *)(rgmi + fi.f_dri);
/* Check if fixup is additive */
return((FTYPE ) TRUE); /* This is a fixup */
}
/****************************************************************
* *
* FixErrSub: *
* *
* Report a fixup error. *
* *
****************************************************************/
void NEAR FixErrSub(msg,ra,gsnFrame,gsnTarget,raTarget,fErr)
MSGTYPE msg; /* Error message */
RATYPE ra; /* Relative addr of error */
SNTYPE gsnFrame;
SNTYPE gsnTarget;
RATYPE raTarget;
FTYPE fErr; /* True if increment err cnt */
{
BYTE *sb; /* Pointer to name */
#if EXE386
char *kind;
#endif
if (fDebSeg)
return; // Ignore warnings/errors for CV info
for(;;) /* Loop to give message */
{
sb = 1 + GetFarSb(GetHte(mpgsnrprop[vgsnCur])->cch);
#if EXE386
if(fErr)
OutError(msg,ra - mpsegraFirst[mpgsnseg[vgsnCur]],sb);
else
OutWarn(msg,ra - mpsegraFirst[mpgsnseg[vgsnCur]],sb);
switch(fi.f_loc)
{
case LOCSEGMENT:
kind = "Selector";
break;
case LOCPTR:
kind = "16:16 pointer";
break;
case LOCPTR48:
kind = "16:32 pointer";
break;
default:
kind = "";
break;
}
if(fi.f_mtd == KINDEXT && mpextprop && mpextprop[fi.f_idx])
FmtPrint(" %s '%s'\r\n",__NMSG_TEXT(N_tgtexternal),
1 + GetPropName(FetchSym(mpextprop[fi.f_idx],FALSE)));
else if (gsnTarget)
{ /* Output frame, target info */
FmtPrint(" %s: %s %s, %s %lx\r\n", kind,
__NMSG_TEXT(N_tgtseg),
1 + GetPropName(FetchSym(mpgsnrprop[gsnTarget],FALSE)),
__NMSG_TEXT(N_tgtoff), (RATYPE) raTarget);
}
#else
if(fErr)
OutError(msg,ra - mpgsndra[vgsnCur],sb);
else
OutWarn(msg,ra - mpgsndra[vgsnCur],sb);
if(fi.f_mtd == KINDEXT && mpextprop && mpextprop[fi.f_idx])
FmtPrint(" %s '%s'\r\n",__NMSG_TEXT(N_tgtexternal),
1 + GetPropName(FetchSym(mpextprop[fi.f_idx],FALSE)));
else if(gsnFrame && gsnTarget)
{ /* Output frame, target info */
FmtPrint(" %s %s", __NMSG_TEXT(N_frmseg),
1 + GetPropName(FetchSym(mpgsnrprop[gsnFrame], FALSE)));
FmtPrint(", %s %s", __NMSG_TEXT(N_tgtseg),
1 + GetPropName(FetchSym(mpgsnrprop[gsnTarget], FALSE)));
FmtPrint(", %s %lX\r\n",
__NMSG_TEXT(N_tgtoff), (RATYPE) raTarget);
}
#endif
if(!fLstFileOpen || bsErr == bsLst) break;
/* Exit loop */
bsErr = bsLst; /* Insure loop exit */
}
if (fLstFileOpen && fErr)
cErrors--; // We called OutError twice for one error
bsErr = stderr;
}
#if OSEGEXE
/*
* SaveLiRel : Save an LIDATA relocation record
*/
LOCAL void NEAR SaveLiRel (pr)
RLCPTR pr; /* Generic relocation record */
{
#if EXE386
LE_SOFF(*pr) = (WORD) (objraCur - vraCur);
#else
NR_SOFF(*pr) -= (WORD) vraCur; /* Save offset within LIDATA record */
#endif
if((char *) rlcCurLidata > (char *) &rgmi[DATAMAX - sizeof(RELOCATION)])
{ /* If too many fixups */
OutError(ER_fixmax);
/* Output error message */
return; /* Try next fixup */
}
FMEMCPY(rlcCurLidata++, pr, sizeof(RELOCATION));
/* Copy relocation into buffer */
}
/* HERE ARE THE RULES USED BY LINKER TO GENERATE ENTRY POINTS:
*
* +----+-------------+-------------+-------------+-------------+-------------+
* | \ | | | | |
* | \ referenced | data | code | code ring 2 | code ring 2 |
* |entry \ from | any ring | ring 3 |nonconforming| conforming |
* |point \ | | | | |
* |target \---------+-------------+-------------+-------------+-------------+
* | | | | | |
* |data | no entry | no entry | no entry | no entry |
* |nonexported | | | | |
* |------------------+-------------+-------------+-------------+-------------+
* | | | | | |
* |data | fixed entry | fixed entry | fixed entry | fixed entry |
* |exported | | | | |
* |------------------+-------------+-------------+-------------+-------------+
* | | | | | |
* |code ring 3 | no entry(1)| no entry(1)| invalid | invalid |
* |nonexported | | | | |
* |------------------+-------------+-------------+-------------+-------------+
* | | | | | |
* |code ring 3 | fixed entry | fixed entry | invalid | invalid |
* |exported | | | | |
* |------------------+-------------+-------------+-------------+-------------+
* |code ring 2 | | | | |
* |nonconforming |movable entry|movable entry| no entry(1)|movable entry|
* |nonexported | | | | |
* |------------------+-------------+-------------+-------------+-------------+
* |code ring 2 | | | | |
* |nonconforming |movable entry|movable entry| fixed entry |movable entry|
* |exported | | | | |
* |------------------+-------------+-------------+-------------+-------------+
* |code ring 2 | | | | |
* |conforming | no entry(1)| no entry(1)| no entry(1)| no entry(1)|
* |nonexported | | | | |
* |------------------+-------------+-------------+-------------+-------------+
* |code ring 2 | | | | |
* |conforming | fixed entry | fixed entry | fixed entry | fixed entry |
* |exported | | | | |
* |------------------+-------------+-------------+-------------+-------------+
*
* (1) If the entry point requires windows compatable prolog editing then
* this entry point must be defined as a "fixed entry".
*
*
* Forget about the note, (1), for now. I don't think it applies with
* PROTMODE.
* Ring 2 means IOPL, ring 3 means NOIOPL.
* To simplify the code we are taking advantage of segment attributes.
* I.e. force all the following segments to FIXED:
* data
* code ring 3
* code ring 2, conforming
* force to MOVABLE:
* code ring 2, nonconforming
* Then just use the segment attribute to determine what type of entry
* to generate. There are clearly two exceptions that you must check
* for:
* - code ring 2 nonconforming nonexported, referenced by code ring 2 nonconforming
* - code ring 2 nonconforming exported, referenced by code ring 2 nonconforming
*
*/
#if NOT QCLINK
/*** CallGateRequired - check if call gate required
*
* Purpose:
* Check if call gate is required for given target segment.
*
* Input:
* saTarget - fixup target segment (memory object)
*
* Output:
* Returns TRUE if call gate required, othrewise FALSE.
*
* Exceptions:
* None.
*
* Notes:
* None.
*
*************************************************************************/
LOCAL WORD NEAR CallGateRequired(SATYPE saTarget)
{
#if EXE386
return(FALSE);
#else
register WORD flags;
flags = mpsaflags[saTarget];
if ((vFlags & NEPROT) || TargetOs == NE_OS2)
{
// If the target entry point segment is NONCONFORMING IOPL CODE 16-bit
// and current segment is a different type, generate a callgate
return(IsCodeFlg(flags) &&
NonConfIOPL(flags) &&
mpsaflags[mpsegsa[vsegCur]] != flags);
}
else
{
// If target segment is non-absolute and movable, generate
// a movable-type fixup and a corresponding entry table entry:
return(flags & NSMOVE);
}
#endif
}
#endif
/*
* FinishRlc:
*
* Finish processing a relocation for a segmented-exe.
*/
LOCAL RATYPE NEAR FinishRlc(r,sa,ra)
RLCPTR r; /* Relocation record to finish */
SATYPE sa; /* Target file segment number */
RATYPE ra; /* Target offset */
{
if (!sa || sa >= saMac)
return(ra); /* Something is wrong */
#if NOT EXE386
#if NOT QCLINK
if (CallGateRequired(sa))
{
NR_SEGNO(*r) = BNDMOV; /* Reference is to movable segment */
NR_ENTRY(*r) = MpSaRaEto(sa,ra);/* Save Entry Table ordinal */
}
else
{
NR_SEGNO(*r) = (BYTE) sa; /* Reference is to fixed segment */
if (
#ifdef LEGO
#if OSEGEXE
!fKeepFixups &&
#endif
#endif /* LEGO */
((NR_STYPE(*r) & NRSTYP) == NRSSEG))
NR_ENTRY(*r) = (WORD) 0; /* For non call-gate base fixups force offset to zero */
else
{
#if O68K
if (iMacType != MAC_NONE && IsDataFlg(mpsaflags[sa]))
NR_ENTRY(*r) = (WORD) (ra - mpsadraDP[sa]);
/* Save offset into fixed segment */
else
#endif /* O68K */
NR_ENTRY(*r) = (WORD) ra;
/* Save offset into fixed segment */
}
}
#else
NR_SEGNO(*r) = (BYTE) sa; /* Reference is to fixed segment */
NR_ENTRY(*r) = (WORD) ra; /* Save offset into fixed segment */
#endif
#else
if (sa == SANIL)
{
RelocWarn(ER_badfixflat,objraCur,SNNIL,0,ra);
/* Oops ! - Flat relative refernce */
return((RATYPE)0); /* OS doesn't know object number zero */
}
LE_OBJNO(*r) = sa; /* Target object number */
if (CallGateRequired(sa))
{
NR_FLAGS(*r) |= NRRENT;
LE_IATORD(*r) = MpSaRaEto(sa,ra);
/* Save Entry Table ordinal */
}
else
{
/* Target is internal reference */
if ((NR_STYPE(*r) & NRSTYP) == NRSSEG)
ra = 0L; /* For non call-gate base fixups force offset to zero */
}
LE_TOFF(*r) = ra; /* Target offset */
#endif
if(TYPEOF(vrectData) == LIDATA) /* If we have an LIDATA record */
{
SaveLiRel(r); /* Save LIDATA relocation record */
return(0); /* Nothing to add */
}
#if EXE386
return(SaveFixup(mpsegsa[vsegCur],vpageCur,r));
#else
return(SaveFixup(mpsegsa[vsegCur],r));
/* Save fixup, return chain */
#endif
}
#endif /* OSEGEXE */
/*
* lastbyte:
*
* If the last byte before the current byte matches
* optest, then replace it with opnew and return TRUE;
* otherwise, return FALSE.
*/
LOCAL FTYPE NEAR lastbyte(pdata,ra,optest,opnew)
BYTE *pdata; /* Pointer into data record */
RATYPE ra; /* Offset in current segment */
BYTE optest; /* Op code to test against */
BYTE opnew; /* New op code */
{
BYTE FAR *pb; /* Byte pointer */
if(pdata > rgmi) /* If needed byte in buffer */
{
if(pdata[-1] != optest) return(FALSE);
/* Test fails if bytes differ */
pdata[-1] = opnew; /* Replace the op code */
return((FTYPE) TRUE); /* Test succeeds */
}
if(ra == 0) return(FALSE); /* Test fails if no byte to test */
if(fNewExe)
pb = mpsaMem[mpsegsa[vsegCur]] + ra - 1; /* Map in the desired byte */
else
pb = mpsegMem[vsegCur] + ra - 1; /* Map in the desired byte */
if(*pb != optest) return(FALSE); /* Test fails if bytes differ */
*pb = opnew; /* Replace the op code */
markvp(); /* Page has changed */
return((FTYPE) TRUE); /* Test succeeds */
}
#if OSEGEXE
/*
* DoIteratedFixups:
*
* Process fixups on an LIDATA record for a segmented-exe.
*/
void NEAR DoIteratedFixups(cb,pb)
WORD cb; /* Byte count */
BYTE *pb; /* Byte pointer */
{
RATYPE raChain; /* Fixup chain */
RATYPE raMin; /* Starting record offset */
RATYPE raMax; /* Ending record offset */
RLCPTR r; /* Relocation record */
WORD j; /* Index */
DWORD SrcOff;
if(rlcCurLidata == rlcLidata) return;
/* Nothing to do if no fixups */
raMin = (RATYPE)(pb - rgmi); /* Offset of start of data in record */
raMax = raMin + cb - 1; /* Offset of end of data in record */
r = rlcLidata;
while (r < rlcCurLidata)
{ /* Do for all fixups in array */
#if EXE386
SrcOff = LE_SOFF(*r);
#else
SrcOff = (DWORD) NR_SOFF(*r);
#endif
if(SrcOff >= (DWORD) raMin && SrcOff <= (DWORD) raMax)
{ /* If fixup lies in range of data */
j = (WORD) (SrcOff - (DWORD) raMin);
/* Get index off pb */
/* Calculate offset in segment */
#if EXE386
LE_SOFF(*r)= (WORD) ((vraCur + j) % (1 << pageAlign));
vpageCur = ((vraCur + j) >> pageAlign) + 1;
raChain = SaveFixup(mpsegsa[vsegCur], vpageCur, r);
/* Save the fixup reference */
#else
NR_SOFF(*r) = (WORD) (vraCur + j);
raChain = SaveFixup(mpsegsa[vsegCur],r);
/* Save the fixup reference */
if(!(NR_FLAGS(*r) & NRADD))
{ /* If not additive */
pb[j] = (BYTE) raChain;
/* Set low byte of chain */
pb[j + 1] = (BYTE)(raChain >> BYTELN);
/* Set high byte of chain */
}
#endif
/* Restore offset in record */
#if EXE386
LE_SOFF(*r)= (WORD) ((raMin + j) % (1 << pageAlign));
#else
NR_SOFF(*r) = (WORD) (raMin + j);
#endif
}
((RLCPTR ) r)++;
}
}
#endif /* OSEGEXE */
/*
* Getgsn:
*
* Obtain segment number and offset for the given fixup method and index.
* Return values are stored in pointers.
*/
LOCAL void NEAR Getgsn(kind,idx,pgsn,pra)
KINDTYPE kind; /* Kind of index */
WORD idx; /* The index */
SEGTYPE *pgsn; /* gsn (ref) */
RATYPE *pra; /* ra (ref) */
{
#if O68K
SATYPE sa;
#endif /* O68K */
switch(kind) /* Decide what to do */
{
case KINDSEG: /* Segment index */
#if FALSE
if(idx >= snMac) InvalidObject();
/* Make sure index not too big */
#endif
*pgsn = mpsngsn[idx]; /* Get gsn */
*pra = mpgsndra[*pgsn]; /* Get ra */
#if O68K
if (iMacType != MAC_NONE && IsDataFlg(mpsaflags[sa =
mpsegsa[mpgsnseg[*pgsn]]]))
*pra += mpsadraDP[sa]; /* Get data ra */
#endif /* O68K */
break;
case KINDGROUP: /* Group index */
#if FALSE
if(idx >= grMac) InvalidObject();
/* Make sure index not too big */
#endif
*pgsn = mpggrgsn[mpgrggr[idx]];
/* Get gsn */
*pra = mpgsndra[*pgsn]; /* Get ra */
#if O68K
if (iMacType != MAC_NONE && IsDataFlg(mpsaflags[sa =
mpsegsa[mpgsnseg[*pgsn]]]))
*pra += mpsadraDP[sa]; /* Get data ra */
#endif /* O68K */
break;
case KINDEXT: /* External index */
#if FALSE
if(idx >= extMac) InvalidObject();
/* Make sure index not too big */
#endif
*pgsn = mpextgsn[idx]; /* Get gsn */
*pra = mpextra[idx]; /* Get ra */
break;
default: /* All other kinds */
*pgsn = SEGNIL; /* No gsn */
*pra = 0; /* No ra */
break;
}
// If this is $$SYMBOLS segment then return logical offset
// NOT physical offset
if (fDebSeg) {
#if O68K
if (iMacType == MAC_NONE)
#endif
*pra -= mpsegraFirst[mpgsnseg[*pgsn]];
}
}
/*
* TransFAR : Possibly translate an intra-segment FAR call or jump
*
* If the given location looks like a FAR call or jump,
* translate it and return TRUE. Otherwise, do nothing and
* return FALSE.
*/
LOCAL FTYPE NEAR TransFAR (pdata, ra, raTarget)
BYTE *pdata; /* Pointer to fixup location */
RATYPE ra; /* Offset in current segment */
RATYPE raTarget; /* Target offset */
{
#if O68K
if (f68k)
return FALSE;
#else
static RATYPE raPrev;
static SATYPE saPrev; /* Location of the previous fixup */
if(raPrev + 4 == ra && saPrev == mpsegsa[vsegCur])
{
if(!fOverlays)
Fatal(ER_badfarcall); /* A far jump and/or ptr table present */
else
return(FALSE); /* The user can't turn off /FARC in an overlaid .exe */
}
else
{
raPrev = ra;
saPrev = mpsegsa[vsegCur];
}
if(lastbyte(pdata,ra,CALLFARDIRECT,NOP))
{ /* If fixing up long call direct */
*pdata++ = PUSHCS; /* Push CS */
*pdata++ = CALLNEARDIRECT;
/* Short call */
raTarget -= ra + 4; /* Make offset self-relative */
fixword(pdata, raTarget); /* store fixed up value */
return((FTYPE) TRUE); /* All done */
}
else if(lastbyte(pdata,ra,JUMPFAR,JUMPNEAR))
{ /* If long jump direct */
raTarget -= ra + 2; /* Make offset self-relative */
fixword(pdata, raTarget); /* store fixed up value */
pdata += 2;
*pdata++ = NOP; /* Change base to NOPs */
*pdata = NOP;
return((FTYPE) TRUE); /* All done */
}
return(FALSE);
#endif /* !O68K */
}
#if EXE386
/*
* Fix386:
*
* Procss a fixup for a linear-format exe.
*/
LOCAL void NEAR Fix386()
{
REGISTER BYTE *pdata; /* Pointer into data record */
RATYPE ra; /* Offset of location being fixed up */
SNTYPE gsnTarget; /* Target segment definition number */
SNTYPE gsnFrame; /* Frame segment definition number */
SEGTYPE segTarget; /* Target segment order number */
SATYPE saTarget; /* Target file segment number */
SATYPE saFrame; /* Frame file segment number */
RATYPE raTarget; /* Target offset */
RATYPE vBase; /* Target virtual base address - FLAT relative */
long vDist; /* Virtual distance between objects */
RATYPE raTmp; /* Temporary */
WORD dsa; /* Difference in sa's */
DWORD dummy;
RELOCATION r; /* Relocation item */
WORD locType; /* Type of location to be fixed up */
WORD fFlatRelative; /* TRUE if frame of pseudo group FLAT */
APROPSNPTR apropSnSrc; /* Ptr to a segment record */
DWORD srcFlags; /* Source segment flags */
APROPNAMEPTR apropName; /* Ptr to import */
DWORD align;
if (vgsnCur < gsnMac)
{
// Get source flags - only non-debug segments
apropSnSrc = (APROPSNPTR ) FetchSym(mpgsnrprop[vgsnCur], FALSE);
srcFlags = apropSnSrc->as_flags;
}
// Check for floating-point fixups here
if(fi.f_mtd == T2 &&
((mpextflags[fi.f_idx] & FFPMASK) || (mpextflags[fi.f_idx] & FFP2ND)))
return; /* Ignore f.p. fixups */
align = (1L << pageAlign) - 1;
memset(&r, 0, sizeof(struct le_rlc));
ra = vraCur + fi.f_dri; /* Get offset of fixup */
objraCur = ra;
vpageCur = (ra >> pageAlign) + 1; /* Set object page number */
LE_SOFF(r) = (WORD) (ra & align);
NR_STYPE(r) = (BYTE) fi.f_loc; /* Save fixup type */
#if FALSE
if (vpageCur == 1 && mpsegsa[vsegCur] == 1)
fprintf(stdout, "Processing fixup: type %02x; source offset %lx (page %x offset %x)\r\n",
fi.f_loc, ra, vpageCur, LE_SOFF(r));
#endif
pdata = &rgmi[fi.f_dri]; /* Set pointer to fixup location */
locType = (WORD) (fi.f_loc & NRSRCMASK);
/* Get location type */
Getgsn(fi.f_mtd, fi.f_idx, &gsnTarget, &raTarget);
// Check if frame of pseudo group FLAT
if (ggrFlat)
{
// FLAT pseudo group defined
if (fi.f_fmtd == KINDGROUP)
fFlatRelative = (WORD) (mpgrggr[fi.f_fidx] == ggrFlat);
else if (fi.f_fmtd == KINDTARGET && fi.f_mtd == KINDGROUP)
fFlatRelative = (WORD) (mpgrggr[fi.f_idx] == ggrFlat);
else
fFlatRelative = FALSE;
}
else
fFlatRelative = FALSE;
if (fFlatRelative &&
fi.f_mtd == KINDGROUP &&
mpgrggr[fi.f_idx] == ggrFlat)
RelocWarn(ER_badfixflat,objraCur,SNNIL, gsnTarget, raTarget);
// Pseudo group FLAT is an illegal fixup target
segTarget = mpgsnseg[gsnTarget]; // Get target object
saTarget = mpsegsa[segTarget]; // Get target object number
// Check for imports here. Depending on reference kind or place
// of the reference generate the run-time relocation or treat
// it as internal reference via thunk. The following cases
// generate run-time relocation:
//
// - 16:16 pointer
// - 16:16 gate pointer
//
// The 0:32 FLAT offset references are threated as internal references
// and the thunk address for given import is used as target address
// of fixup. Thunk does indirect jump via entry in Import Address
// Table which is processed by the loader.
if (fi.f_mtd == T2 && (mpextflags[fi.f_idx] & FIMPORT))
{
// If target is dynamic link
if (fDebSeg)
{
/* Import in $$SYMBOLS */
if (fi.f_loc == LOCSEGMENT)
{
fixword(pdata, 0); /* Install fake segment selector */
}
return;
}
else
{
// Emit run-time relocation if reference to imported symbol is:
//
// - it is NOT self-relative 32-bit FLAT offset
// - it is NOT 32-bit FLAT offset
// - there is no thunk allocated for this import (importing DATA)
//
// The self-relative 32-bit FLAT offset and 32-bit FLAT offset
// fixups have their target address redirected to the Thunk Table
// entry for a given imported symbol and treated as internal fixup.
apropName = (APROPNAMEPTR) FetchSym(mpextprop[fi.f_idx], TRUE);
if ((apropName->an_flags & IMPDATA) || (locType != LOCOFFSET32))
{
switch (locType)
{
case LOCLOBYTE: // Lo-byte (8-bit) fixup
case LOCSEGMENT: // Segment (16-bit) fixup
case LOCPTR: // "Pointer" (32-bit) fixup
case LOCLOADOFFSET: // Loader-resolved offset fixup
case LOCPTR48: // 48-bit pointer
case LOCOFFSET: // Offset (16-bit) fixup
OutError(ER_badfixpure32, 1 + GetPropName(mpextprop[fi.f_idx]));
break;
case LOCOFFSET32: // Offset (32-bit) fixup
break;
}
// Get index to the Import Address Table
LE_OBJNO(r) = (WORD) (mpsegsa[mpgsnseg[gsnImport]]);
LE_IDTIDX(r) = (WORD) (apropName->an_module - 1);
// Get Import Module Directory index
LE_IATORD(r) = (WORD) apropName->an_entry;
// Use FLAT entry
/* If we have an LIDATA record */
if (TYPEOF(vrectData) == LIDATA)
SaveLiRel(&r); /* Copy relocation into buffer */
else
raTarget = SaveFixup(mpsegsa[vsegCur],vpageCur, &r);
/* Record reference */
return; /* Next fixup item */
}
}
}
// Internal reference (non-import) or reference to import thunk
// It is assumed that we're always fixing up relative to the
// physical segment or group, not the logical segment. So the
// offset of the frame segment is not taken into account.
if (fi.f_fmtd == KINDLOCAT)
{
gsnFrame = vgsnCur;
}
else if (fi.f_fmtd == KINDTARGET)
{
gsnFrame = gsnTarget;
}
else
{
Getgsn((KINDTYPE) fi.f_fmtd, fi.f_fidx, &gsnFrame, &dummy);
}
// The original LINK4 behavior was to fix up relative
// to the physical segment. At one point it was changed
// to subtract the displacement of the target segment (from
// its physical segment) from the target value, if loc. type =
// offset and frame and tgt. method = T0. This was no good
// and the change was repealed. The /WARNFIXUP switch warns
// about fixups which may be affected.
if (fWarnFixup && fi.f_fmtd == KINDSEG && locType == LOCOFFSET
&& mpsegraFirst[mpgsnseg[gsnFrame]])
RelocWarn(ER_fixsegd,ra,gsnFrame,gsnTarget,raTarget);
if (fFlatRelative)
{
saFrame = 1; // Pseudo-group FLAT has frame of first object
gsnFrame = 0;
}
else
saFrame = mpsegsa[mpgsnseg[gsnFrame]];
// Get frame's object number
vBase = virtBase + mpsaBase[saTarget];
// Get TARGET object virtual base address
if (gsnTarget == SNNIL) // If no target info
{
if (locType == LOCPTR) // If "pointer" (4 byte) fixup
{
lastbyte(pdata,ra,CALLFARDIRECT,BREAKPOINT);
// Replace long call w/ breakpoint
return;
}
if (locType == LOCSEGMENT) return;
// Next fixup if "base" fixup
if (locType == LOCLOADOFFSET)
locType = LOCOFFSET; // Treat as regular offset
}
else
{
if (fi.f_self) // If self-relative fixup
{
if (saTarget != mpsegsa[vsegCur])
{
if (locType == LOCOFFSET)
RelocErr(ER_fixinter,ra,gsnFrame,gsnTarget,raTarget);
// 16-bit must be in same segment
if (fFlatRelative)
{
// If crossing object boundry include in raTarget
// virtual distance between objects.
//
// mpsaBase[mpsegsa[vsegCur]] --> ---+------------------+
// ^ | |
// | | |
// ra | mpsegsa[vsegCur] |
// | | |
// V | |
// ---+------------------+---
// | | ^
// . . |
// . . |
// . . |
// | | vDist
// +------------------+ |
// |
// V
// masaBase[saTarget] --> ---+------------------+---
// ^ | |
// | | |
// raTarget | saTarget |
// | | |
// V | |
// ---+------------------+
// | |
// . .
// . .
// . .
// | |
// +------------------+
//
vDist = (long) (mpsaBase[saTarget] - (mpsaBase[mpsegsa[vsegCur]] + ra));
raTarget += vDist;
}
}
else
raTarget -= ra;
if (locType == LOCOFFSET)
raTarget -= sizeof(WORD);
else if (locType == LOCOFFSET32 || locType == LOCLOADOFFSET32)
raTarget -= sizeof(DWORD);
else
raTarget -= sizeof(BYTE);
}
else if (saFrame != saTarget && !fFlatRelative)
{ /* If frame, target segs differ */
/* and not FLAT frame */
if (mpgsnseg[gsnFrame] <= segLast || segTarget <= segLast)
{ /* If either is non-absolute */
RelocWarn(ER_fixfrm,ra,gsnFrame,gsnTarget,raTarget);
saFrame = saTarget; /* assume target seg */
}
else
{
RelocWarn(ER_fixfrmab,ra,gsnFrame,gsnTarget,raTarget);
dsa = (WORD) (saTarget - saFrame);
raTmp = raTarget + ((dsa & 0xfff) << 4);
if(dsa >= 0x1000 || raTmp < raTarget)
{
raTarget += fi.f_disp;
#if OMF386
if ((rect & 1) && (fi.f_loc >= LOCOFFSET32))
raTarget += getdword(pdata);
else
#endif
raTarget += getword(pdata);
FixupOverflow(ra,gsnFrame,gsnTarget,raTarget);
}
raTarget = raTmp;
segTarget = mpgsnseg[gsnFrame];
/* Make target seg that of frame */
saTarget = mpsegsa[segTarget];
} /* Reset saTarget */
}
}
raTmp = raTarget;
raTarget += fi.f_disp;
if (locType >= LOCOFFSET32)
if (rect & 1)
raTarget += getdword(pdata);
else
{
RelocWarn(ER_fixtyp,ra,gsnFrame,gsnTarget,raTarget);
return;
}
else
raTarget += getword(pdata);
if (saTarget && fFlatRelative && !fi.f_self)
raTarget += vBase;
LE_FIXDAT(r) = raTarget;
if (saTarget && fFlatRelative && !fDebSeg)
{
// The FLAT-relative offset fixups need to be propagated into
// the .EXE file in the following cases:
//
// - for .EXE's - by user request
// - for .DLL's - only FLAT-relative offset fixups
if ((fKeepFixups || !IsAPLIPROG(vFlags)) &&
(locType == LOCOFFSET32 || locType == LOCLOADOFFSET32))
{
if (!fi.f_self)
{
FinishRlc(&r, saTarget, raTarget - vBase);
/* Don't pass virtual offsets */
}
#if FALSE
// Self-relative offset fixups crossing memory object
// boudry are not longer propagated to the exe for PE images
else if ((mpsegsa[vsegCur] != saTarget) && fKeepFixups)
{
FinishRlc(&r, saTarget, raTarget - vDist + sizeof(DWORD));
/* Don't pass virtual offsets */
}
#endif
}
else if (locType == LOCOFFSET)
{
if (!fi.f_self)
RelocWarn(ER_badfix16off,ra,gsnFrame,gsnTarget,raTarget);
else if (raTarget > LXIVK)
FixupOverflow(ra,gsnFrame,gsnTarget,raTarget);
/* For 16:16 alias raTarget must be <= 64k */
}
}
switch(locType) /* Switch on fixup type */
{
case LOCLOBYTE: /* 8-bit "lobyte" fixup */
raTarget = raTmp + B2W(pdata[0]) + fi.f_disp;
pdata[0] = (BYTE) raTarget;
if (raTarget >= 0x100 && fi.f_self)
FixupOverflow(ra,gsnFrame,gsnTarget,raTarget);
break;
case LOCHIBYTE: /* 8-bit "hibyte" fixup */
raTarget = raTmp + fi.f_disp;
pdata[0] = (BYTE) (B2W(pdata[0]) + (raTarget >> 8));
break;
case LOCLOADOFFSET: /* Loader-resolved offset fixup */
case LOCOFFSET: /* 16-bit "offset" fixup */
fixword(pdata, raTarget);
break;
case LOCLOADOFFSET32: /* 32-bit "offset" fixup */
case LOCOFFSET32: /* 32-bit "offset" fixup */
fixword(pdata, raTarget); /* Perform low word fixup */
pdata += 2;
raTarget >>= 16; /* Get high word */
fixword(pdata, raTarget); /* Perform fixup */
break;
case LOCSEGMENT: /* 16-bit "base" fixup */
#if SYMDEB
if(segTarget > segLast || fDebSeg)
#else
if(segTarget > segLast) /* If target segment absolute */
#endif
{
if (fDebSeg)
{
// For debug segments use logical segment number (seg)
// instead of physical segment number (sa)
saTarget = segTarget;
}
else
saTarget += getword(pdata);
/* Calculate base address */
fixword(pdata, saTarget); /* Store base address */
break; /* Done */
}
RelocErr(ER_fixbad,ra,gsnFrame,gsnTarget,raTarget);
break;
case LOCPTR48: /* 48-bit "pointer" fixup */
#if SYMDEB
if(segTarget > segLast || fDebSeg)
#else
if(segTarget > segLast) /* If target segment absolute */
#endif
{
fixword(pdata, raTarget); /* Store offset portion */
pdata += 2;
raTarget >>= WORDLN; /* Get high word */
fixword(pdata, raTarget); /* Store offset portion */
pdata += 2;
if (fDebSeg)
{
// For debug segments use logical segment number (seg)
// instead of physical segment number (sa)
saTarget = segTarget;
}
else
saTarget += getword(pdata); /* Calculate base address */
fixword(pdata, saTarget); /* Store base address */
break; /* Done */
}
RelocErr(ER_fixbad,ra,gsnFrame,gsnTarget,raTarget);
break;
case LOCPTR: /* 32-bit "pointer" fixup */
#if SYMDEB
if(segTarget > segLast || fDebSeg)
#else
if(segTarget > segLast) /* If target segment absolute */
#endif
{
fixword(pdata, raTarget); /* Store offset portion */
pdata += 2;
saTarget += getword(pdata);
/* Calculate base address */
fixword(pdata, saTarget); /* Store base address */
break; /* Done */
}
if (fFlatRelative)
RelocWarn(ER_badfix16ptr, ra, gsnFrame, gsnTarget, raTarget);
else
RelocErr(ER_fixbad,ra,gsnFrame,gsnTarget,raTarget);
break;
default: /* Unsupported fixup type */
RelocErr(ER_fixbad,ra,gsnFrame,gsnTarget,raTarget);
break;
}
}
#endif /* EXE386 */
#if OSEGEXE AND NOT EXE386
/*
* FixNew:
*
* Procss a fixup for a new-format exe.
*/
void NEAR FixNew ()
{
REGISTER BYTE *pdata; /* Pointer into data record */
RATYPE ra; /* Offset of location being fixed up */
SNTYPE gsnTarget; /* Target segment definition number */
SNTYPE gsnFrame; /* Frame segment definition number */
SEGTYPE segTarget; /* Target segment order number */
SATYPE saTarget; /* Target file segment number */
SEGTYPE segFrame; /* Frame segment order number */
SATYPE saFrame; /* Frame file segment number */
RATYPE raTarget; /* Target offset */
RATYPE raTmp; /* Temporary */
WORD dsa; /* Difference in sa's */
RATYPE dummy;
RELOCATION r; /* Relocation item */
memset(&r, 0, sizeof(RELOCATION));
ra = vraCur + (RATYPE) fi.f_dri; /* Get offset of fixup */
/* Save location in record */
NR_SOFF(r) = (WORD) ra;
NR_STYPE(r) = (BYTE) fi.f_loc; /* Save fixup type */
NR_FLAGS(r) = (BYTE) (fi.f_add? NRADD: 0);
if(fi.f_mtd == T2 && (mpextflags[fi.f_idx] & FFPMASK)
#if ILINK
&& !fQCIncremental // For real-mode incremental
// floating-point fixups are
// treated as normal symbol fixups
#endif
)
{ /* If floating-point fixup */
if (vFlags & NEPROT && TargetOs == NE_OS2)
return; /* If protected mode only, ignore */
NR_FLAGS(r) = NRROSF | NRADD;
NR_STYPE(r) = LOCLOADOFFSET;/* No 3-byte type, so we lie */
NR_OSTYPE(r) = (mpextflags[fi.f_idx] >> FFPSHIFT) & 7;
/* Type # = ordinal in table */
NR_OSRES(r) = 0; /* Clear reserved word */
SaveFixup(mpsegsa[vsegCur],&r);
return;
}
if(fi.f_mtd == T2 && (mpextflags[fi.f_idx] & FFP2ND))
return; /* Ignore secondary f.p. fixups */
pdata = &rgmi[fi.f_dri]; /* Set pointer to fixup location */
/*
* Check for imports here.
*/
if(fi.f_mtd == T2 && (mpextflags[fi.f_idx] & FIMPORT))
{ /* If target is dynamic link */
if (fDebSeg)
{
/* Import in $$SYMBOLS */
if (fi.f_loc == LOCSEGMENT)
{
fixword(pdata, 0); /* Install fake segment selector */
}
return;
}
/*
* Check for invalid import fixup types: self-rel, HIBYTE.
*/
if(fi.f_self)
{
RelocErr(ER_fixinter,ra,SNNIL,SNNIL,0L);
return;
}
else if(fi.f_loc == LOCHIBYTE)
{
RelocErr(ER_fixbad,ra,SNNIL,SNNIL,0L);
return;
}
else if(fi.f_loc == LOCOFFSET)/* Convert offset to runtime offset */
NR_STYPE(r) = LOCLOADOFFSET;
NR_FLAGS(r) |= (mpextflags[fi.f_idx] & FIMPORD)? NRRORD: NRRNAM;
/* Set flag */
if(fi.f_disp || fi.f_loc == LOCLOBYTE) NR_FLAGS(r) |= NRADD;
/* Additive if non-zero displacement
or lobyte */
#if M_BYTESWAP
NR_SEGNO(r) = (BYTE) mpextgsn[fi.f_idx];
NR_RES(r) = (BYTE)(mpextgsn[fi.f_idx] >> BYTELN);
#else
NR_MOD(r) = mpextgsn[fi.f_idx];
#endif
/* Get module specification */
NR_PROC(r) = (WORD) mpextra[fi.f_idx];
/* Get entry specification */
if(TYPEOF(vrectData) == LIDATA) /* If we have an LIDATA record */
{
SaveLiRel(&r); /* Copy relocation into buffer */
raTarget = 0; /* Not chained yet */
}
else raTarget = SaveFixup(mpsegsa[vsegCur],&r);
/* Record reference */
if(NR_FLAGS(r) & NRADD) raTarget = fi.f_disp;
/* If additive, install displacement */
if(fi.f_loc == LOCLOBYTE)
{
*pdata++ += (BYTE)(raTarget & 0xFF);
}
#if O68K
else if (fTBigEndian)
{
*pdata++ += (BYTE)((raTarget >> BYTELN) & 0xFF);
*pdata += (BYTE)(raTarget & 0xFF);
}
#endif /* O68K */
else
{
addword((BYTE *)pdata, (WORD)raTarget);
}
return; /* Next fixup item */
}
NR_FLAGS(r) |= NRRINT; /* Internal reference (non-import) */
Getgsn(fi.f_mtd, fi.f_idx, &gsnTarget, &raTarget);
/*
* It is assumed that we're always fixing up relative to the
* physical segment or group, not the logical segment. So the
* offset of the frame segment is not taken into account.
*/
if (fi.f_fmtd == KINDLOCAT)
{
gsnFrame = vgsnCur;
}
else if (fi.f_fmtd == KINDTARGET)
{
gsnFrame = gsnTarget;
}
else
{
Getgsn(fi.f_fmtd, fi.f_fidx, &gsnFrame, &dummy);
}
segTarget = mpgsnseg[gsnTarget]; /* Get target segment */
saTarget = mpsegsa[segTarget]; /* Get target file segment number */
segFrame = mpgsnseg[gsnFrame]; /* Get frame segment */
saFrame = mpsegsa[segFrame]; /* Get frame's file segment number */
/*
* The original LINK4 behavior was to fix up relative
* to the physical segment. At one point it was changed
* to subtract the displacement of the target segment (from
* its physical segment) from the target value, if loc. type =
* offset and frame and tgt. method = T0. This was no good
* and the change was repealed. The /WARNFIXUP switch warns
* about fixups which may be affected.
*/
if(fWarnFixup && fi.f_fmtd == KINDSEG && fi.f_loc == LOCOFFSET
&& mpsegraFirst[segFrame])
RelocWarn(ER_fixsegd,ra,gsnFrame,gsnTarget,raTarget);
#if O68K
/* 68k code does not permit segment fixups of any kind. */
if (f68k && !fDebSeg && ((1 << fi.f_loc) & ((1 << LOCSEGMENT) |
(1 << LOCPTR) | (1 << LOCPTR48))) != 0)
{
RelocErr(ER_fixbad, ra, gsnFrame, gsnTarget, raTarget + fi.f_disp);
return;
}
#endif /* O68K */
if(gsnTarget == SNNIL) /* If no target info */
{
if(fi.f_loc == LOCPTR) /* If "pointer" (4 byte) fixup */
{
lastbyte(pdata,ra,CALLFARDIRECT,BREAKPOINT);
/* Replace long call w/ breakpoint */
return;
}
if(fi.f_loc == LOCSEGMENT) return;
/* Next fixup if "base" fixup */
if(fi.f_loc == LOCLOADOFFSET)
fi.f_loc = LOCOFFSET; /* Treat as regular offset */
}
else
{
if(fi.f_self) /* If self-relative fixup */
{
#if O68K
if (iMacType != MAC_NONE)
{
switch (fi.f_loc)
{
case LOCOFFSET:
if (saTarget != mpsegsa[vsegCur])
{
NR_STYPE(r) = (BYTE)((NR_STYPE(r) & ~NRSTYP) | NRSOFF);
fi.f_loc = LOCLOADOFFSET;
}
else raTarget -= ra;
break;
case LOCOFFSET32:
if (saTarget != mpsegsa[vsegCur])
fi.f_loc = LOCLOADOFFSET32;
else raTarget -= ra - 2;
break;
}
}
else
#endif /* O68K */
{
if (saTarget != mpsegsa[vsegCur])
RelocErr(ER_fixinter,ra,gsnFrame,gsnTarget,raTarget);
/* Must be in same segment */
if(fi.f_loc == LOCOFFSET)
raTarget = raTarget - ra - 2;
#if OMF386
else if(fi.f_loc == LOCOFFSET32)
raTarget = raTarget - ra - 4;
#endif
else raTarget = raTarget - ra - 1;
}
}
else if (saFrame != saTarget)
{ /* If frame, target segs differ */
if (segFrame <= segLast || segTarget <= segLast)
{ /* If either is non-absolute */
RelocWarn(ER_fixfrm, ra, gsnFrame, gsnTarget, raTarget);
}
else
{
RelocWarn(ER_fixfrmab,ra,gsnFrame,gsnTarget,raTarget);
dsa = saTarget - saFrame;
raTmp = raTarget + ((dsa & 0xfff) << 4);
if(dsa >= 0x1000 || raTmp < raTarget)
{
raTarget += fi.f_disp;
#if OMF386
if ((rect & 1) && (fi.f_loc >= LOCOFFSET32))
raTarget += GetFixupDword(pdata);
else
#endif
raTarget += GetFixupWord(pdata);
FixupOverflow(ra,gsnFrame,gsnTarget,raTarget);
}
raTarget = raTmp;
}
segTarget = segFrame; /* Make target seg that of frame */
saTarget = saFrame; /* Reset saTarget */
}
}
raTmp = raTarget;
raTarget += fi.f_disp;
#if OMF386
if ((rect & 1) && (fi.f_loc >= LOCOFFSET32))
raTarget += GetFixupDword(pdata);
else
#endif
raTarget += GetFixupWord(pdata);
switch(fi.f_loc) /* Switch on fixup type */
{
case LOCLOBYTE: /* 8-bit "lobyte" fixup */
raTarget = raTmp + B2W(pdata[0]) + fi.f_disp;
pdata[0] = (BYTE) raTarget;
if(raTarget >= 0x100 && fi.f_self)
FixupOverflow(ra,gsnFrame,gsnTarget,raTarget);
break;
case LOCHIBYTE: /* 8-bit "hibyte" fixup */
raTarget = raTmp + fi.f_disp;
pdata[0] = (BYTE) (B2W(pdata[0]) + (raTarget >> 8));
break;
case LOCLOADOFFSET: /* Loader-resolved offset fixup */
NR_FLAGS(r) &= ~NRADD; /* Not additive */
if ((TargetOs == NE_WINDOWS && !(vFlags & NEPROT))
#if O68K
|| iMacType != MAC_NONE
#endif /* O68K */
)
raTarget = FinishRlc(&r, saTarget, raTarget);
/* Finish relocation record */
#if O68K
if (fTBigEndian)
{
*pdata++ = (BYTE)((raTarget >> BYTELN) & 0xFF);
*pdata = (BYTE)(raTarget & 0xFF);
}
else
#endif /* O68K */
{
fixword(pdata, raTarget);
}
/* Install old head of chain */
break;
case LOCOFFSET: /* 16-bit "offset" fixup */
#if O68K
/* For 68K, LOCOFFSET is a signed 16-bit offset fixup. */
if (f68k &&
(raTarget & ~0x7FFF) != 0 && (raTarget & ~0x7FFF) != ~0x7FFF)
FixupOverflow(ra,gsnFrame,gsnTarget,raTarget);
#endif /* O68K */
#if O68K
if (fTBigEndian)
{
*pdata++ = (BYTE)((raTarget >> BYTELN) & 0xFF);
*pdata = (BYTE)(raTarget & 0xFF);
}
else
#endif /* O68K */
{
fixword(pdata, raTarget);
}
/* Install old head of chain */
break;
#if OMF386
case LOCLOADOFFSET32: /* 32-bit "offset" fixup */
if(!(rect & 1)) break; /* Not 386 extension */
NR_FLAGS(r) &= ~NRADD; /* Not additive */
NR_STYPE(r) = (BYTE) ((NR_STYPE(r) & ~NRSTYP) | NROFF32);
raTarget = FinishRlc(&r,saTarget,raTarget);
/* Finish relocation record */
case LOCOFFSET32: /* 32-bit "offset" fixup */
#if O68K
if (fTBigEndian)
{
*pdata++ = (BYTE)((raTarget >> (BYTELN + WORDLN)) & 0xFF);
*pdata++ = (BYTE)((raTarget >> WORDLN) & 0xFF);
*pdata++ = (BYTE)((raTarget >> BYTELN) & 0xFF);
*pdata = (BYTE)(raTarget & 0xFF);
}
else
#endif /* O68K */
{
fixdword(pdata, raTarget);
}
/* Perform fixup */
break;
#endif /* OMF386 */
case LOCSEGMENT: /* 16-bit "base" fixup */
#if SYMDEB
if(segTarget > segLast || fDebSeg)
#else
if(segTarget > segLast) /* If target segment absolute */
#endif
{
if (fDebSeg)
{
// For debug segments use logical segment number (seg)
// instead of physical segment number (sa)
saTarget = segTarget;
}
else
saTarget += getword(pdata);
/* Calculate base address */
fixword(pdata, saTarget); /* Store base address */
break; /* Done */
}
/*
* Treat the displacment as an ordinal increment to saTarget,
* for huge model. It would seem logical to include the primary
* displacment, f_disp, but MASM has a quirk: an instruction of
* the form "mov ax,ASEGMENT" generates a fixup with f_disp equal
* to the length of the segment even though "mov ax,seg
* ASEGMENT" causes f_disp to be 0! So for compatibility we
* ignore f_disp.
* Then force the fixup to non-additive since the secondary
* displacement has been added to saTarget.
*/
if((saTarget += getword(pdata)) >= saMac)
FixupOverflow(ra,gsnFrame,gsnTarget,0L);
NR_FLAGS(r) &= ~NRADD;
#if FALSE
/*
* Too early to decide here. We don't know if a
* base fixup will require call-gate and if it
* does then we need the actual offset in call-gate.
*
* Forcing the offset to zero for base fixups:
* PRO's
* 1. Fewer fixup records in the .EXE.
* 2. No more than n dummy entries in the
* Entry Table for a program of n segments
* in the WORST case.
* CON's
* 1. Approximately n dummy entries in the
* Entry Table for a program of n segments
* in the AVERAGE case.
*/
raTarget = FinishRlc(&r,saTarget,0L);
/* Finish relocation record */
#else
/*
* Leaving the offset alone for base fixups:
* PRO's
* 1. No more than 1 or 2 dummy entries in the
* Entry Table for a program of n segments
* in the AVERAGE case.
* CON's
* 1. More fixup records in the .EXE.
* 2. Number of dummy entries in the Entry Table
* only bounded by the maximum allowable size
* of the Entry Table in the WORST CASE.
*/
raTarget = FinishRlc(&r,saTarget,raTarget);
/* Finish relocation record */
#endif
fixword(pdata, raTarget);
/* Install old head of chain */
break;
#if OMF386
case LOCPTR48: /* 48-bit "pointer" fixup */
if(!(rect & 1)) break; /* Not 386 extension */
NR_STYPE(r) = (BYTE) ((NR_STYPE(r) & ~NRSTYP) | NRPTR48);
fixword(pdata, raTarget);
pdata += 2;
raTarget >>= 16; /* Get high word, fall through ... */
#endif
case LOCPTR: /* 32-bit "pointer" fixup */
#if SYMDEB
if(segTarget > segLast || fDebSeg)
#else
if(segTarget > segLast) /* If target segment absolute */
#endif
{
fixword(pdata, raTarget);
pdata += 2;
/* Store offset portion */
if (fDebSeg)
{
// For debug segments use logical segment number (seg)
// instead of physical segment number (sa)
saTarget = segTarget;
}
else
saTarget += getword(pdata);
/* Calculate base address */
fixword(pdata, saTarget); /* Store base address */
break; /* Done */
}
if(fFarCallTrans && saTarget == mpsegsa[vsegCur]
&& (mpsaflags[saTarget] & NSTYPE) == NSCODE)
{ /* If intrasegment fixup */
if(TransFAR(pdata,ra,raTarget))
break;
}
/*
* Treat the high word at the location as an increment to the
* target segment index. Check for overflow and clear the high
* word at the location. Force fixup to be non-additive because
* the secondary displacement has already been added to raTarget.
*/
if((saTarget += getword(pdata + 2)) >= saMac)
FixupOverflow(ra,gsnFrame,gsnTarget,raTarget);
pdata[2] = pdata[3] = 0;
NR_FLAGS(r) &= ~NRADD;
#if NOT QCLINK
if (fOptimizeFixups)
{
// Check if pointer fixup (16:16 or 16:32) can be split into
// linker resolved offset fixup (16 or 32 bit) and loader
// resolved base (selector) fixup.
if (!CallGateRequired(saTarget))
{
fixword(pdata, raTarget); /* Store offset portion */
pdata += 2;
NR_STYPE(r) = (BYTE) LOCSEGMENT;
if (fi.f_loc == LOCPTR48)
NR_SOFF(r) += 4;
else
NR_SOFF(r) += 2;
raTarget = 0L;
}
}
#endif
raTarget = FinishRlc(&r,saTarget,raTarget);
/* Finish relocation record */
fixword(pdata, raTarget);
/* Install old head of chain */
break;
default: /* Unsupported fixup type */
RelocErr(ER_fixbad,ra,gsnFrame,gsnTarget,raTarget);
break;
}
}
#ifdef LEGO
/*
* FixNewKeep:
*
* Process a fixup for a new-format exe.
*/
void NEAR FixNewKeep()
{
BYTE *pdata; /* Pointer into data record */
RATYPE ra; /* Offset of location being fixed up */
SNTYPE gsnTarget; /* Target segment definition number */
SNTYPE gsnFrame; /* Frame segment definition number */
SEGTYPE segTarget; /* Target segment order number */
SATYPE saTarget; /* Target file segment number */
SEGTYPE segFrame; /* Frame segment order number */
SATYPE saFrame; /* Frame file segment number */
RATYPE raTarget; /* Target offset */
RATYPE raTmp; /* Temporary */
WORD dsa; /* Difference in sa's */
RATYPE dummy;
RELOCATION r; /* Relocation item */
memset(&r, 0, sizeof(RELOCATION));
ra = vraCur + (RATYPE) fi.f_dri; /* Get offset of fixup */
/* Save location in record */
NR_SOFF(r) = (WORD) ra;
NR_STYPE(r) = (BYTE) fi.f_loc; /* Save fixup type */
NR_FLAGS(r) = (BYTE) (fi.f_add ? NRADD : 0);
pdata = &rgmi[fi.f_dri]; /* Set pointer to fixup location */
if (fi.f_mtd == T2)
{
/* The target is an external symbol */
if (mpextflags[fi.f_idx] & FFPMASK)
{
/* This is a floating point fixup */
if (TargetOs == NE_OS2)
{
/* Floating point fixups are ignored in prot mode OS/2 */
return;
}
/* Emit an OS fixup. The loader will deal with these. */
NR_STYPE(r) = LOCLOADOFFSET;
NR_FLAGS(r) = NRROSF | NRADD;
NR_OSTYPE(r) = (mpextflags[fi.f_idx] >> FFPSHIFT) & 7;
NR_OSRES(r) = 0;
SaveFixup(mpsegsa[vsegCur], &r);
return;
}
if (mpextflags[fi.f_idx] & FFP2ND)
{
/* This is a secondary floating point fixup. */
/* These are always ignored. */
return;
}
/*
* Check for imports here.
*/
if (mpextflags[fi.f_idx] & FIMPORT)
{ /* If target is dynamic link */
if (fDebSeg)
{
/* Import in $$SYMBOLS */
if (fi.f_loc == LOCSEGMENT)
{
*pdata++ = 0; /* Install fake segment selector */
*pdata++ = 0;
}
return;
}
/*
* Check for invalid import fixup types: self-rel, HIBYTE.
*/
if (fi.f_self)
{
RelocErr(ER_fixinter, ra, SNNIL, SNNIL, 0L);
return;
}
if (fi.f_loc == LOCHIBYTE)
{
RelocErr(ER_fixbad, ra, SNNIL, SNNIL, 0L);
return;
}
/* Convert offset to runtime offset */
if (fi.f_loc == LOCOFFSET)
NR_STYPE(r) = LOCLOADOFFSET;
NR_FLAGS(r) |= (mpextflags[fi.f_idx] & FIMPORD) ? NRRORD : NRRNAM;
if (fi.f_disp || fi.f_loc == LOCLOBYTE)
NR_FLAGS(r) |= NRADD; /* Additive if non-zero displacement
or lobyte */
#if M_BYTESWAP
NR_SEGNO(r) = (BYTE) mpextgsn[fi.f_idx];
NR_RES(r) = (BYTE)(mpextgsn[fi.f_idx] >> BYTELN);
#else
NR_MOD(r) = mpextgsn[fi.f_idx];
#endif
/* Get module specification */
NR_PROC(r) = (WORD) mpextra[fi.f_idx];
/* Get entry specification */
if (TYPEOF(vrectData) == LIDATA)/* If we have an LIDATA record */
{
SaveLiRel(&r); /* Copy relocation into buffer */
raTarget = 0; /* Not chained yet */
}
else
{
raTarget = SaveFixup(mpsegsa[vsegCur], &r);
}
/* Record reference */
if (NR_FLAGS(r) & NRADD) /* If additive, install displacement */
raTarget = fi.f_disp;
if (fi.f_loc == LOCLOBYTE)
{
*pdata++ += (BYTE)(raTarget & 0xFF);
}
else
{
addword((BYTE *)pdata, (WORD)raTarget);
}
return; /* Next fixup item */
}
}
NR_FLAGS(r) |= NRRINT; /* Internal reference (non-import) */
Getgsn(fi.f_mtd, fi.f_idx, &gsnTarget, &raTarget);
/*
* It is assumed that we're always fixing up relative to the
* physical segment or group, not the logical segment. So the
* offset of the frame segment is not taken into account.
*/
if (fi.f_fmtd == KINDLOCAT)
{
gsnFrame = vgsnCur;
}
else if (fi.f_fmtd == KINDTARGET)
{
gsnFrame = gsnTarget;
}
else
{
Getgsn(fi.f_fmtd, fi.f_fidx, &gsnFrame, &dummy);
}
segTarget = mpgsnseg[gsnTarget]; /* Get target segment */
saTarget = mpsegsa[segTarget]; /* Get target file segment number */
segFrame = mpgsnseg[gsnFrame]; /* Get frame segment */
saFrame = mpsegsa[segFrame]; /* Get frame's file segment number */
/*
* The original LINK4 behavior was to fix up relative
* to the physical segment. At one point it was changed
* to subtract the displacement of the target segment (from
* its physical segment) from the target value, if loc. type =
* offset and frame and tgt. method = T0. This was no good
* and the change was repealed. The /WARNFIXUP switch warns
* about fixups which may be affected.
*/
if (fWarnFixup &&
(fi.f_fmtd == KINDSEG) &&
(fi.f_loc == LOCOFFSET) &&
mpsegraFirst[segFrame])
RelocWarn(ER_fixsegd, ra, gsnFrame, gsnTarget, raTarget);
if (gsnTarget == SNNIL) /* If no target info */
{
if (fi.f_loc == LOCPTR) /* If "pointer" (4 byte) fixup */
{
lastbyte(pdata, ra, CALLFARDIRECT, BREAKPOINT);
/* Replace long call w/ breakpoint */
return;
}
if (fi.f_loc == LOCSEGMENT) /* Next fixup if "base" fixup */
return;
if (fi.f_loc == LOCLOADOFFSET)
fi.f_loc = LOCOFFSET; /* Treat as regular offset */
}
else
{
if (fi.f_self) /* If self-relative fixup */
{
if (saTarget != mpsegsa[vsegCur])
{
RelocErr(ER_fixinter, ra, gsnFrame, gsnTarget, raTarget);
return;
}
/* Must be in same segment */
if (fi.f_loc == LOCOFFSET)
raTarget -= ra + sizeof(WORD);
#if OMF386
else if (fi.f_loc == LOCOFFSET32)
raTarget -= ra + sizeof(DWORD);
#endif /* OMF386 */
else
raTarget -= ra + sizeof(BYTE);
}
else if (saFrame != saTarget)
{
/* If frame, target segs differ */
if (segFrame <= segLast || segTarget <= segLast)
{
/* If either is non-absolute */
RelocWarn(ER_fixfrm, ra, gsnFrame, gsnTarget, raTarget);
}
else
{
RelocWarn(ER_fixfrmab, ra, gsnFrame, gsnTarget, raTarget);
dsa = saTarget - saFrame;
raTmp = raTarget + ((dsa & 0xfff) << 4);
if (dsa >= 0x1000 || raTmp < raTarget)
{
raTarget += fi.f_disp;
#if OMF386
if ((rect & 1) && (fi.f_loc >= LOCOFFSET32))
raTarget += GetFixupDword(pdata);
else
#endif /* OMF386 */
raTarget += GetFixupWord(pdata);
FixupOverflow(ra, gsnFrame, gsnTarget, raTarget);
}
raTarget = raTmp;
}
segTarget = segFrame; /* Make target seg that of frame */
saTarget = saFrame; /* Reset saTarget */
}
}
raTmp = raTarget;
raTarget += fi.f_disp;
if (fDebSeg || fi.f_self)
{
/* If fKeepFixups is TRUE, the value stored at the fixed up */
/* location is not added to the target address. The fixup will */
/* be emitted as an additive fixup and the loader will add in */
/* the bias.
/* If the fixup is being applied to a debug segment, the offset is */
/* added because these fixups aren't handled by the loader. In */
/* other words, they can not be kept. */
/* If the fixup is being applied is self-relative, the offset is */
/* added because the loaded doesn't handle self-relative fixups. */
/* While the fixed up word would have the correct value, the target */
/* of the fixup would be artifical. */
#if OMF386
if ((rect & 1) && (fi.f_loc >= LOCOFFSET32))
raTarget += GetFixupDword(pdata);
else
#endif /* OMF386 */
raTarget += GetFixupWord(pdata);
}
switch (fi.f_loc) /* Switch on fixup type */
{
case LOCLOBYTE: /* 8-bit "lobyte" fixup */
raTarget = raTmp + B2W(pdata[0]) + fi.f_disp;
pdata[0] = (BYTE) raTarget;
if (raTarget >= 0x100 && fi.f_self)
FixupOverflow(ra, gsnFrame, gsnTarget, raTarget);
break;
case LOCHIBYTE: /* 8-bit "hibyte" fixup */
raTarget = raTmp + fi.f_disp;
pdata[0] = (BYTE) (B2W(pdata[0]) + (raTarget >> 8));
break;
case LOCLOADOFFSET: /* Loader-resolved offset fixup */
/* There are no LOCLOADOFFSET fixups that are */
/* self-relative or applied to debug segments. */
/* Force non-external fixups to be additive. The C */
/* compiler may emit a BAKPAT to a fixed up word. If the */
/* fixup is chained the BAKPAT will corrupt the chain. */
/* This does not occur when the target is external. We */
/* special case this so that the number of fixups is */
/* reduced. */
if (fi.f_mtd != T2)
NR_FLAGS(r) |= NRADD;
raTarget = FinishRlc(&r, saTarget, raTarget);
if (NR_FLAGS(r) & NRADD)
break;
fixword(pdata, raTarget);
break;
case LOCOFFSET: /* 16-bit "offset" fixup */
if (!fDebSeg && !fi.f_self)
{
/* Force non-external fixups to be additive. The C */
/* compiler may emit a BAKPAT to a fixed up word. If the */
/* fixup is chained the BAKPAT will corrupt the chain. */
/* This does not occur when the target is external. We */
/* special case this so that the number of fixups is */
/* reduced. */
if (fi.f_mtd != T2)
NR_FLAGS(r) |= NRADD;
NR_STYPE(r) = LOCLOADOFFSET;
raTarget = FinishRlc(&r, saTarget, raTarget);
if (NR_FLAGS(r) & NRADD)
break;
}
fixword(pdata, raTarget);
break;
case LOCSEGMENT: /* 16-bit "base" fixup */
#if SYMDEB
if (segTarget > segLast || fDebSeg)
#else
if (segTarget > segLast) /* If target segment absolute */
#endif
{
if (fDebSeg)
{
// For debug segments use logical segment number (seg)
// instead of physical segment number (sa)
saTarget = segTarget;
}
else
{
saTarget += getword(pdata);
}
/* Store base address */
fixword(pdata, saTarget);
break;
}
raTarget = FinishRlc(&r, saTarget, raTarget);
if (NR_FLAGS(r) & NRADD)
break;
fixword(pdata, raTarget);
break;
case LOCPTR: /* 32-bit "pointer" fixup */
#if SYMDEB
if (segTarget > segLast || fDebSeg)
#else
if (segTarget > segLast) /* If target segment absolute */
#endif
{
/* Store offset portion */
fixword(pdata, raTarget);
pdata += 2;
if (fDebSeg)
{
// For debug segments use logical segment number (seg)
// instead of physical segment number (sa)
saTarget = segTarget;
}
else
{
saTarget += getword(pdata);
}
/* Store base address */
fixword(pdata, saTarget);
break;
}
/* Force non-external fixups to be additive. The C */
/* compiler may emit a BAKPAT to a fixed up word. If the */
/* fixup is chained the BAKPAT will corrupt the chain. */
/* This does not occur when the target is external. We */
/* special case this so that the number of fixups is */
/* reduced. */
if (fi.f_mtd != T2)
NR_FLAGS(r) |= NRADD;
/* Check segment to see if fixup must be additive */
else if (getword(pdata + 2) != 0)
NR_FLAGS(r) |= NRADD;
raTarget = FinishRlc(&r, saTarget, raTarget);
if (NR_FLAGS(r) & NRADD)
break;
fixword(pdata, raTarget);
break;
#if OMF386
/* NOTE: Support for 32 bit fixups in 16 bit images is a joke. */
/* NOTE: The Windows loader doesn't understand these. We fake */
/* NOTE: out Windows by converting these fixups to NRSOFF type. */
/* NOTE: The Chicago loader now understands NROFF32 fixups so */
/* NOTE: we now use this type. This will generate an executable */
/* NOTE: that doesn't work under Windows 3.x. Oh Well! */
case LOCLOADOFFSET32: /* 32-bit Loader-resolved offset fixup */
/* There are no LOCLOADOFFSET32 fixups that are */
/* self-relative or applied to debug segments. */
/* Force non-external fixups to be additive. The C */
/* compiler may emit a BAKPAT to a fixed up word. If the */
/* fixup is chained the BAKPAT will corrupt the chain. */
/* This does not occur when the target is external. We */
/* special case this so that the number of fixups is */
/* reduced. */
if (fi.f_mtd != T2)
NR_FLAGS(r) |= NRADD;
if (raTarget > 0xffff)
RelocErr(ER_fixbad, ra, gsnFrame, gsnTarget, raTarget);
NR_STYPE(r) = NROFF32;
raTarget = FinishRlc(&r, saTarget, raTarget);
if (NR_FLAGS(r) & NRADD)
break;
fixdword(pdata, raTarget);
break;
case LOCOFFSET32: /* 32-bit "offset" fixup */
if (!fDebSeg && !fi.f_self)
{
/* Force non-external fixups to be additive. The C */
/* compiler may emit a BAKPAT to a fixed up word. If the */
/* fixup is chained the BAKPAT will corrupt the chain. */
/* This does not occur when the target is external. We */
/* special case this so that the number of fixups is */
/* reduced. */
if (fi.f_mtd != T2)
NR_FLAGS(r) |= NRADD;
if (raTarget > 0xffff)
RelocErr(ER_fixbad, ra, gsnFrame, gsnTarget, raTarget);
NR_STYPE(r) = NROFF32;
raTarget = FinishRlc(&r, saTarget, raTarget);
if (NR_FLAGS(r) & NRADD)
break;
}
fixdword(pdata, raTarget);
break;
case LOCPTR48: /* 48-bit "pointer" fixup */
#if SYMDEB
if (segTarget > segLast || fDebSeg)
#else
if (segTarget > segLast) /* If target segment absolute */
#endif
{
/* Store offset portion */
fixdword(pdata, raTarget);
pdata += 4;
if (fDebSeg)
{
// For debug segments use logical segment number (seg)
// instead of physical segment number (sa)
saTarget = segTarget;
}
else
{
saTarget += getword(pdata);
}
/* Store base address */
fixword(pdata, saTarget);
break;
}
/* Force non-external fixups to be additive. The C */
/* compiler may emit a BAKPAT to a fixed up word. If the */
/* fixup is chained the BAKPAT will corrupt the chain. */
/* This does not occur when the target is external. We */
/* special case this so that the number of fixups is */
/* reduced. */
if (fi.f_mtd != T2)
NR_FLAGS(r) |= NRADD;
/* Check segment to see if fixup must be additive */
else if (getword(pdata + 4) != 0)
NR_FLAGS(r) |= NRADD;
NR_STYPE(r) = NRPTR48;
raTarget = FinishRlc(&r, saTarget, raTarget);
if (NR_FLAGS(r) & NRADD)
break;
fixdword(pdata, raTarget);
break;
#endif /* OMF386 */
default: /* Unsupported fixup type */
RelocErr(ER_fixbad, ra, gsnFrame, gsnTarget, raTarget);
break;
}
}
#endif /* LEGO */
#if O68K
/*
* GetFixupWord:
*
* Gets a word depending of the value of fTBigEndian and fDebSeg
*/
LOCAL WORD NEAR GetFixupWord (pdata)
BYTE *pdata;
{
if (fTBigEndian && !fDebSeg)
{
return (WORD)((B2W(pdata[0]) << BYTELN) + B2W(pdata[1]));
}
else
{
return getword(pdata);
}
}
/*
* GetFixupDword:
*
* Gets a dword depending of the value of fTBigEndian and fDebSeg
*/
LOCAL DWORD NEAR GetFixupDword (pdata)
BYTE *pdata;
{
if (fTBigEndian && !fDebSeg)
{
return (DWORD)((((((B2L(pdata[0]) << BYTELN) + B2L(pdata[1])) << BYTELN)
+ B2L(pdata[2])) << BYTELN) + B2L(pdata[3]));
}
else
{
return getdword(pdata);
}
}
#endif /* O68K */
#endif /* OSEGEXE AND NOT EXE386 */
#if ODOS3EXE OR OIAPX286
/*
* StartAddrOld:
*
* Process a MODEND record with a start address for an old-format exe.
*/
LOCAL void NEAR StartAddrOld ()
{
SEGTYPE gsnTarget;
SEGTYPE gsnFrame;
RATYPE raTarget; /* Fixup target offset */
RATYPE ra;
SATYPE dsa;
SEGTYPE segTarget; /* Target segment */
SEGTYPE segFrame;
GetFrameTarget(&gsnFrame,&gsnTarget,&raTarget);
/* Get fixup information */
if(gsnFrame == SEGNIL) gsnFrame = gsnTarget;
/* Use target val. if none given */
segFrame = mpgsnseg[gsnFrame]; /* Get frame segment */
segTarget = mpgsnseg[gsnTarget];/* Get target segment */
dsa = mpsegsa[segTarget] - mpsegsa[segFrame];
/* Calculate base delta */
#if NOT OIAPX286
if(dsa > 0x1000)
FixupOverflow(raTarget + fi.f_disp,gsnFrame,gsnTarget,raTarget);
/* Delta > 64Kbytes */
ra = dsa << 4;
if(0xFFFF - ra < raTarget) /* If addition would overflow */
{
ra = ra - 0xFFFF + raTarget;
/* Fix up addition */
--ra;
FixupOverflow(raTarget + fi.f_disp,gsnFrame,gsnTarget,raTarget);
}
else ra = ra + raTarget;
/* Else perform addition */
#endif
#if OIAPX286
if(dsa) FixupOverflow(raTarget + fi.f_disp,gsnFrame,gsnTarget,raTarget);
/* No intersegment fixups */
ra = raTarget; /* Use target offset */
#endif
#if EXE386
if((rect & 1) && ra + fi.f_disp < ra)
{
ra = ra - 0xFFFFFFFF + fi.f_disp;
--ra;
FixupOverflow(raTarget + fi.f_disp,gsnFrame,gsnTarget,raTarget);
}
else if (!(rect & 1) && 0xFFFF - ra < fi.f_disp)
#else
if(0xFFFF - ra < fi.f_disp) /* If addition would overflow */
#endif
{
ra = ra - 0xFFFF + fi.f_disp;
/* Fix up addition */
--ra;
FixupOverflow(raTarget + fi.f_disp,gsnFrame,gsnTarget,raTarget);
}
else ra = ra + fi.f_disp; /* Else perform addition */
if(segStart == SEGNIL)
{
segStart = segFrame;
raStart = ra;
if(fLstFileOpen) /* If there is a listing file */
{
if(vcln) /* If writing line numbers */
{
NEWLINE(bsLst); /* End of line */
vcln = 0; /* Start on new line */
}
fprintf(bsLst,GetMsg(MAP_entry),
mpsegsa[segStart],raStart);/* Print entry point */
}
}
}
#endif /* ODOS3EXE OR OIAPX286 */
/****************************************************************
* *
* EndRec: *
* *
* This function is called to process the information *
* contained in a MODEND (type 8AH) record concerning the *
* program starting address. The function does not return a *
* meaningful value. *
* See pp. 80-81 in "8086 Object Module Formats EPS." *
* *
****************************************************************/
void NEAR EndRec(void)
{
WORD modtyp; /* MODEND record modtyp byte */
SEGTYPE gsnTarget;
RATYPE ra;
modtyp = Gets(); /* Read modtyp byte */
if(modtyp & FSTARTADDRESS) /* If execution start address given */
{
ASSERT(modtyp & 1); /* Must have logical start address */
GetFixdat(); /* Get target information */
#if ODOS3EXE OR OIAPX286
/* Start address processed differently for DOS 3.x exes */
if(!fNewExe)
{
StartAddrOld();
return;
}
#endif
#if OSEGEXE
switch(fi.f_mtd) /* Switch on target method */
{
case T0: /* Segment index */
gsnTarget = mpsngsn[fi.f_idx];
ra = mpgsndra[gsnTarget];
break;
case T1: /* Group index */
gsnTarget = mpggrgsn[mpgrggr[fi.f_idx]];
ra = mpgsndra[gsnTarget];
break;
case T2: /* External index */
if(mpextflags[fi.f_idx] & FIMPORT)
{
OutError(ER_impent);
return;
}
gsnTarget = mpextgsn[fi.f_idx];
ra = mpextra[fi.f_idx];
break;
}
if(segStart == SEGNIL) /* If no entry point specified */
{
segStart = mpgsnseg[gsnTarget];
/* Get starting file segment number */
raStart = ra + fi.f_disp;
/* Get starting offset */
if(fLstFileOpen) /* If there is a listing file */
{
if(vcln) /* If writing line numbers */
{
NEWLINE(bsLst); /* End of line */
vcln = 0; /* Start on new line */
}
#if NOT QCLINK
/* Check if segStart is code */
#if EXE386
if (!IsEXECUTABLE(mpsaflags[mpsegsa[segStart]]))
#else
if((mpsaflags[mpsegsa[segStart]] & NSTYPE) != NSCODE
&& !fRealMode && (TargetOs == NE_OS2 || TargetOs == NE_WINDOWS))
#endif
OutError(ER_startaddr);
#endif
fprintf(bsLst,"\r\nProgram entry point at %04x:%04x\r\n",
mpsegsa[segStart],raStart); /* Print entry point */
}
}
#endif /* OSEGEXE */
}
}
#if ODOS3EXE OR OXOUT
/****************************************************************
* *
* RecordSegmentReference: *
* *
* Generate a loadtime relocation for a DOS3 exe. *
* *
****************************************************************/
void NEAR RecordSegmentReference(seg,ra,segDst)
SEGTYPE seg;
RATYPE ra;
SEGTYPE segDst;
{
SEGTYPE segAbsLast; /* Last absolute segemnt */
DOSRLC rlc; // Relocation address
long xxaddr; /* Twenty bit address */
void FAR *pTmp;
RUNRLC FAR *pRunRlc;
#if OVERLAYS
WORD iov; /* Overlay number */
#endif
#if FEXEPACK
WORD frame; /* Frame part of 20-bit address */
FRAMERLC FAR *pFrameRlc;
#endif
#if SYMDEB
if(fSymdeb && seg >= segDebFirst) /* Skip if debug segment */
return;
#endif
#if ODOS3EXE
segAbsLast = segLast + csegsAbs; /* Calc. last absolute seg no. */
if(vfDSAlloc) --segAbsLast;
if(segDst > segLast && segDst <= segAbsLast) return;
/* Don't bother if absolute segment */
#endif
if (TYPEOF(vrectData) == LIDATA)
ompimisegDstIdata[ra - vraCur] = (char) segDst;
else /* Else if not iterated data */
{
#if OVERLAYS
iov = mpsegiov[seg]; /* Get overlay number */
ASSERT(fOverlays || iov == IOVROOT);
/* If no overlays then iov = IOVROOT */
#endif
#if FEXEPACK
#if OVERLAYS
if (iov == 0) /* If root */
#endif
if (fExePack)
{
/*
* Optimize this reloc: form the 20-bit address, the
* frame is the high-order 4 bits, forming an index
* into mpframcRle (count of relocs by frame), which
* then forms an index into the packed relocation area,
* where the low-order 16 bits are stored. Finally,
* increment the frame's reloc count and return.
*/
xxaddr = ((RATYPE) mpsegsa[seg] << 4) + (RATYPE) ra;
frame = (WORD) ((xxaddr >> 16) & 0xf);
pFrameRlc = &mpframeRlc[frame];
if (pFrameRlc->count > 0x7fff)
Fatal(ER_relovf);
ra = (RATYPE) (xxaddr & 0xffffL);
if (pFrameRlc->count >= pFrameRlc->count)
{
// We need more memory to store this relocation
if (pFrameRlc->rgRlc == NULL)
{
pFrameRlc->rgRlc = (WORD FAR *) GetMem(DEF_FRAMERLC*sizeof(WORD));
pFrameRlc->size = DEF_FRAMERLC;
}
else if (pFrameRlc->count >= pFrameRlc->size)
{
// Reallocate array of packed relocation offsets
pTmp = GetMem((pFrameRlc->size << 1)*sizeof(WORD));
FMEMCPY(pTmp, pFrameRlc->rgRlc, pFrameRlc->count*sizeof(WORD));
FFREE(pFrameRlc->rgRlc);
pFrameRlc->rgRlc = pTmp;
pFrameRlc->size <<= 1;
}
}
pFrameRlc->rgRlc[pFrameRlc->count] = (WORD) ra;
pFrameRlc->count++;
return;
}
#endif /* FEXEPACK */
rlc.sa = (WORD) mpsegsa[seg]; /* Get segment address */
rlc.ra = (WORD) ra; /* Save relative address */
#if OVERLAYS
pRunRlc = &mpiovRlc[iov];
if (pRunRlc->count >= pRunRlc->count)
{
// We need more memory to store this relocation
if (pRunRlc->rgRlc == NULL)
{
pRunRlc->rgRlc = (DOSRLC FAR *) GetMem(DEF_RUNRLC * CBRLC);
pRunRlc->size = DEF_RUNRLC;
}
else if (pRunRlc->count >= pRunRlc->size)
{
// Reallocate array of packed relocation offsets
pTmp = GetMem((pRunRlc->size << 1) * CBRLC);
FMEMCPY(pTmp, pRunRlc->rgRlc, pRunRlc->count * CBRLC);
FFREE(pRunRlc->rgRlc);
pRunRlc->rgRlc = pTmp;
pRunRlc->size <<= 1;
}
}
pRunRlc->rgRlc[pRunRlc->count] = rlc;
pRunRlc->count++;
#endif
}
}
#endif /* ODOS3EXE OR OXOUT */
#if OVERLAYS
/****************************************************************
* *
* Mpgsnosn: *
* *
* Map global segment number to overlay segment number. *
* *
****************************************************************/
LOCAL SNTYPE NEAR Mpgsnosn(gsn)
SNTYPE gsn; /* Global SEGDEF number */
{
SNTYPE hgsn; /* Gsn hash value */
hgsn = (SNTYPE)(gsn & ((1 << LG2OSN) - 1)); /* Take the low-order bits */
while(mposngsn[htgsnosn[hgsn]] != gsn)
{ /* While match not found */
if((hgsn += HTDELTA) >= OSNMAX) hgsn -= OSNMAX;
/* Calculate next hash value */
}
return(htgsnosn[hgsn]); /* Return overlay segment number */
}
#endif
#if ODOS3EXE OR OIAPX286
LOCAL void NEAR GetFrameTarget(pgsnFrame,pgsnTarget,praTarget)
SEGTYPE *pgsnFrame; /* Frame index */
SEGTYPE *pgsnTarget; /* Target index */
RATYPE *praTarget; /* Target offset */
{
RATYPE dummy;
WORD i;
/* Method no: Frame specification:
* 0 segment index
* 1 group index
* 2 external index
* 3 frame number
* 4 implicit (location)
* 5 implicit (target)
* 6 none
* 7 invalid
*/
if(fi.f_fmtd == KINDTARGET) /* If frame is target's frame */
{
fi.f_fmtd = fi.f_mtd; /* Use target frame kind */
fi.f_fidx = fi.f_idx; /* Use target index */
}
if (fi.f_fmtd == KINDEXT && !fNoGrpAssoc)
{ /* If frame given by pub sym */
if(fi.f_fidx >= extMac) InvalidObject();
/* Make sure index not too big */
if((i = mpextggr[fi.f_fidx]) != GRNIL)
/* If symbol has group association */
*pgsnFrame = mpggrgsn[i]; /* Get gsn for group */
else *pgsnFrame = mpextgsn[fi.f_fidx];
/* Else return target gsn */
}
else if (fi.f_fmtd == KINDLOCAT && !fNoGrpAssoc)
{ /* If frame current segment */
*pgsnFrame = vgsnCur; /* Frame is location's segment */
}
else
{
Getgsn(fi.f_fmtd, fi.f_fidx, pgsnFrame, &dummy);
}
Getgsn(fi.f_mtd, fi.f_idx, pgsnTarget, praTarget);
/* Get gsn and ra, if any */
}
LOCAL WORD NEAR InOneGroup(WORD gsnTarget, WORD gsnFrame)
{
WORD ggrFrame; /* Fixup frame group */
WORD ggrTarget; /* Fixup frame group */
APROPSNPTR apropSn; /* Ptr to a segment record */
if (gsnFrame != SNNIL)
{
apropSn = (APROPSNPTR ) FetchSym(mpgsnrprop[gsnFrame], FALSE);
ggrFrame = apropSn->as_ggr;
}
else
ggrFrame = GRNIL;
if (gsnTarget != SNNIL)
{
apropSn = (APROPSNPTR ) FetchSym(mpgsnrprop[gsnTarget], FALSE);
ggrTarget = apropSn->as_ggr;
}
else
ggrFrame = GRNIL;
return(ggrFrame != GRNIL && ggrTarget != GRNIL && ggrFrame == ggrTarget);
}
LOCAL void NEAR AddThunk(SEGTYPE gsnTarget, SEGTYPE *psegTarget, RATYPE *praTarget)
{
#pragma pack(1) /* This data must be packed */
struct _thunk
{
BYTE thunkInt;
BYTE ovlInt;
WORD osnTgt;
WORD osnOff;
}
thunk;
#pragma pack() /* Stop packing */
// We need a new thunk
if (ovlThunkMac < (WORD) (ovlThunkMax - 1))
{
thunk.thunkInt = INTERRUPT;
thunk.ovlInt = (BYTE) vintno;
thunk.osnTgt = Mpgsnosn(gsnTarget);
thunk.osnOff = (WORD) *praTarget;
*praTarget = ovlThunkMac * OVLTHUNKSIZE;
*psegTarget = mpgsnseg[gsnOverlay];
MoveToVm(sizeof(struct _thunk), (BYTE *) &thunk, mpgsnseg[gsnOverlay], *praTarget);
/* Store thunk */
#if FALSE
fprintf(stdout, "%d. Thunk at %x:%04lx; Target osn = %x:%x\r\n",
ovlThunkMac , mpgsnseg[gsnOverlay], *praTarget, thunk.osnTgt, thunk.osnOff);
#endif
ovlThunkMac++;
}
else
{
Fatal(ER_ovlthunk, ovlThunkMax);
}
}
/*** DoThunking - generate thunk for inter-overlay calls
*
* Purpose:
* When the dynamic overlays are requested redirect all FAR calls or
* references to aproppriate thunks. If this is first call/reference
* to given symbol then add its thunk to the OVERLAY_THUNKS segment.
*
* Input:
* gsnTarget - global segment number of the fixup target
* psegTarget - poiter to logical segment number of the fixup target
* praTarget - pointer offset of the fixup target inside gsnTarget
*
* Output:
* The gsn and offset of the target are replaced by the gsn and offset
* of the thunk for target. For first references to a given symbol
* the thunk is created in OVERLAY_THUNKS segment (referenced via
* gsnOverlay global) and the current position in thunk segment is
* updated (ovlThunkMac).
*
* Exceptions:
* No space in OVERLAY_THUNKS for new thunk - fatal error - display message
* suggesting use of /DYNAMIC:<nnn> with <nnn> greater then current value.
*
* Notes:
* None.
*
*************************************************************************/
LOCAL void NEAR DoThunking(SEGTYPE gsnTarget, SEGTYPE *psegTarget, RATYPE *praTarget)
{
APROPNAMEPTR apropName; /* Public symbol property */
switch(fi.f_mtd)
{
case KINDEXT:
// Target is external
apropName = (APROPNAMEPTR) FetchSym(mpextprop[fi.f_idx], FALSE);
if (apropName->an_thunk != THUNKNIL)
{
// We already allocated thunk for this target
*praTarget = apropName->an_thunk;
*psegTarget = mpgsnseg[gsnOverlay];
#if FALSE
fprintf(stdout, "Using thunk for '%s' at %x:%04lx\r\n",
1 + GetPropName(apropName), mpgsnseg[gsnOverlay], *praTarget);
#endif
}
else
{
// We need new thunk for new target
AddThunk(gsnTarget, psegTarget, praTarget);
apropName = (APROPNAMEPTR) FetchSym(mpextprop[fi.f_idx], TRUE);
apropName->an_thunk = *praTarget;
#if FALSE
fprintf(stdout, "%d. Thunk for '%s' at %x:%04lx; Target osn = %x:%x\r\n",
ovlThunkMac, 1 + GetPropName(apropName), mpgsnseg[gsnOverlay], *praTarget, thunk.osnTgt, thunk.osnOff);
#endif
}
break;
case KINDSEG:
AddThunk(gsnTarget, psegTarget, praTarget);
break;
default:
InvalidObject();
}
}
/*
* FixOld:
*
* Process a fixup for an old-format exe.
*/
void NEAR FixOld ()
{
REGISTER BYTE *pdata; /* Pointer into data record */
SEGTYPE segTarget; /* Fixup target segment */
SEGTYPE segFrame; /* Fixup frame segment */
SEGTYPE gsnTarget;
SEGTYPE gsnFrame;
RATYPE raTarget; /* Fixup target rel. addr. */
RATYPE raTmp;
RATYPE ra; /* Current location offset */
long dra;
WORD dsa;
WORD saTmp; /* Temporary base variable */
#if OVERLAYS
WORD fFallThrough;
WORD fThunk;
fFallThrough = FALSE;
fThunk = FALSE;
#endif
ra = vraCur + fi.f_dri; /* Get rel. addr. of fixup */
pdata = &rgmi[fi.f_dri]; /* Set pointer to fixup location */
GetFrameTarget(&gsnFrame,&gsnTarget,&raTarget);
/* Process the FIXDAT byte */
segTarget = mpgsnseg[gsnTarget]; /* Get target segment */
if(gsnFrame != SNNIL) segFrame = mpgsnseg[gsnFrame];
else segFrame = SEGNIL;
if(vsegCur == SEGNIL) return;
if(gsnTarget == SNNIL)
{
if(fi.f_loc == LOCPTR) /* If "pointer" (4 byte) fixup */
{
if(mpsegFlags[vsegCur] & FCODE)
lastbyte(pdata,ra,CALLFARDIRECT,BREAKPOINT);
/* Replace long call w/ breakpoint */
return;
}
/* Return if "base" (2 byte) fixup */
if(fi.f_loc == LOCSEGMENT) return;
}
else
{
if (!fDebSeg && segFrame != SEGNIL)
{
dsa = mpsegsa[segTarget] - mpsegsa[segFrame];
#if NOT OIAPX286
dra = dsa << 4;
raTmp = raTarget + dra;
if(dsa >= 0x1000 || raTmp < raTarget)
FixupOverflow(ra,gsnFrame,gsnTarget,raTarget);
raTarget = raTmp;
segTarget = segFrame;
#else
if(dsa) /* No intersegment fixups */
FixupOverflow(ra,gsnFrame,gsnTarget,raTarget);
#endif
}
else segFrame = segTarget; /* Else use target's seg as frame */
if(fi.f_self) /* If self-relative fixup */
{
/* Here we process intersegment self-relative fixups.
* We assume that the only way this can work is if the
* both the target segment and the current segment assume
* the same CS, and that CS is the frame segment of the
* fixup. A common example is if vsegCur and segTarget
* are in the same group represented by segFrame.
* If this is true, vsegCur must be >= segFrame, so we
* use this assumption in checking for fixup overflow and
* adjusting the target offset.
*/
if (vsegCur != segTarget && !InOneGroup(gsnTarget, gsnFrame))
RelocWarn(ER_fixovfw,ra,gsnFrame,vgsnCur,raTarget);
/*
* First, determine the distance from segFrame to vsegCur in
* paragraphs and bytes.
*/
dsa = mpsegsa[vsegCur] - mpsegsa[segFrame];
/* dra is the adjustment to make ra relative to segFrame */
dra = (dsa & 0xFFF) << 4;
#if NOT OIAPX286
/* If the distance is >= 64K, or if the current offset ra plus
* plus the adjustment dra is >= 64K, or if vsegCur is above
* segFrame (see above), then we have fixup overflow.
*/
if (dsa >= 0x1000 || (WORD) (0xFFFF - ra) < (WORD) dra)
FixupOverflow(ra,gsnFrame,vgsnCur,raTarget);
#else
/* In protected mode, intersegment self-relative fixups won't
* work.
*/
if(dsa)
FixupOverflow(ra,gsnFrame,vgsnCur,raTarget);
#endif
/* Determine the fixup value which is raTarget minus the current
* location, ra. Adjust ra upward by dra to make it relative
* to segFrame, then adjust by the length of the location type
* (assume LOCOFFSET as the most common). This reduces to the
* expression below.
*/
raTarget = raTarget - dra - ra - 2;
/* Adjust for less likely LOCtypes */
if(fi.f_loc == LOCLOBYTE)
raTarget += 1;
#if OMF386
else if(fi.f_loc >= LOCOFFSET32)
raTarget -= 2;
#endif
}
}
raTmp = raTarget;
raTarget += fi.f_disp;
#if OMF386
if ((rect & 1) && (fi.f_loc >= LOCOFFSET32))
raTarget += getdword(pdata);
else
#endif
raTarget += getword(pdata);
switch(fi.f_loc) /* Switch on fixup type */
{
case LOCLOBYTE: /* 8-bit "lobyte" fixup */
raTarget = raTmp + B2W(pdata[0]) + fi.f_disp;
pdata[0] = (BYTE) raTarget;
if(raTarget >= 0x100 && fi.f_self)
FixupOverflow(ra,gsnFrame,gsnTarget,raTarget);
break;
case LOCHIBYTE: /* 8-bit "hibyte" fixup */
raTarget = raTmp + fi.f_disp;
pdata[0] = (BYTE) (B2W(pdata[0]) + (raTarget >> 8));
break;
#if OMF386
case LOCOFFSET32: /* 32-bit "offset" fixup */
case LOCLOADOFFSET32:
if(!(rect & 1)) break; /* Not 386 extension */
fixword(pdata, raTarget);
pdata += 2;
raTarget >>= 16; /* Get high word, fall through ... */
#if OVERLAYS
fFallThrough = TRUE;
#endif
#endif
case LOCOFFSET: /* 16-bit "offset" fixup */
case LOCLOADOFFSET:
#if OVERLAYS
if (fDynamic && !fFallThrough && !fDebSeg &&
(fi.f_loc == LOCLOADOFFSET) &&
(mpsegFlags[vsegCur] & FCODE) && mpsegiov[segTarget])
DoThunking(gsnTarget, &segTarget, &raTarget);
#endif
fixword(pdata, raTarget);
/* Perform fixup */
break;
#if OMF386
case LOCPTR48: /* 48-bit "pointer" fixup */
if(!(rect & 1)) break; /* Not 386 extension */
fixword(pdata, raTarget);
pdata += 2;
raTarget >>= 16; /* Get high word, fall through ... */
#endif
case LOCPTR: /* 32-bit "pointer" fixup */
#if OVERLAYS
if (!fDebSeg)
{ /* If root-overlay or interoverlay */
if (fDynamic)
{
// Gererate thunk if:
//
// - target is in overlay and
// - current position is in different overlay or
// - current position is in the same overlay but
// in a different segment (assuming initialization
// of a far pointer to the function)
if (mpsegiov[segTarget] &&
((mpsegiov[vsegCur] != mpsegiov[segTarget]) ||
(mpsegiov[vsegCur] != IOVROOT && vsegCur != segTarget)))
{
DoThunking(gsnTarget, &segTarget, &raTarget);
fThunk = (FTYPE) TRUE;
}
}
else if (mpsegiov[segTarget] &&
(mpsegiov[vsegCur] != mpsegiov[segTarget]))
{
if ((mpsegFlags[vsegCur] & FCODE) &&
lastbyte(pdata,ra,CALLFARDIRECT,INTERRUPT))
{ /* If fixing up long call direct */
*pdata++ = vintno; /* Interrupt number */
*pdata++ = (BYTE) Mpgsnosn(gsnTarget);
/* Target overlay segment number */
*pdata++ = (BYTE) (raTarget & 0xFF);
/* Lo word of offset */
*pdata = (BYTE)((raTarget >> BYTELN) & 0xFF);
/* Hi word of target */
break; /* All done */
}
}
}
#endif
if (!fDebSeg && fFarCallTrans &&
mpsegsa[segTarget] == mpsegsa[vsegCur] &&
(mpsegFlags[segTarget] & FCODE)
#if OVERLAYS
&& mpsegiov[vsegCur] == mpsegiov[segTarget] && !fThunk
#endif
)
{ /* If intrasegment fixup in the same overlay */
if(TransFAR(pdata,ra,raTarget))
break;
}
/* Root-root, overlay-root, and intraoverlay are normal calls */
fixword(pdata, raTarget); /* Fix up offset */
pdata += 2;
/* Advance to segment part and fall through . . . */
ra += 2;
#if OVERLAYS
fFallThrough = TRUE;
#endif
case LOCSEGMENT: /* 16-bit "base" fixup */
#if OVERLAYS
if (fDynamic && !fDebSeg &&
(mpsegFlags[vsegCur] & FCODE) && mpsegiov[segTarget])
{
if(!fFallThrough)
{
OutWarn(ER_farovl, 1+GetPropName(FetchSym(mpgsnrprop[gsnTarget],FALSE)),
1+GetPropName(FetchSym(mpgsnrprop[gsnOverlay],FALSE)));
segTarget = mpgsnseg[gsnOverlay];
}
else
{
/* intra-overlay pointer fixups not supported - caviar:6806 */
OutError(ER_farovldptr);
}
}
#endif
if (fDebSeg)
{
// For debug segments use logical segment number (seg)
// instead of physical segment number (sa)
saTmp = segTarget;
}
else
{
saTmp = mpsegsa[segTarget];
// If MS OMF, high word is a segment ordinal, for huge model
// Shift left by appropriate amount to get selector
#if OEXE
if (vfNewOMF && !fDynamic)
saTmp += (B2W(pdata[0]) + (B2W(pdata[1]) << BYTELN)) << 12;
else
saTmp += B2W(pdata[0]) + (B2W(pdata[1]) << BYTELN);
/* Note fixup is ADDITIVE */
#endif
#if OIAPX286 OR OXOUT
if(vfNewOMF)
saTmp += (B2W(pdata[0]) + (B2W(pdata[1]) << BYTELN)) << 3;
#endif
/* Note that base fixups are NOT ADDITIVE for Xenix. This is
* to get around a bug in "as" which generates meaningless
* nonzero values at base fixup locations.
*/
#if OIAPX286
/* Hack for impure model: code and data are packed into
* one physical segment which at runtime is accessed via 2
* selectors. The code selector is 8 below the data selector.
*/
if(!fIandD && (mpsegFlags[segTarget] & FCODE))
saTmp -= 8;
#endif
}
fixword(pdata, saTmp); /* Perform fixup */
#if NOT OIAPX286
if (!fDebSeg)
RecordSegmentReference(vsegCur,ra,segTarget);
/* Record reference */
#endif
break;
default: /* Unsupported fixup type */
RelocErr(ER_fixbad,ra,gsnFrame,gsnTarget,raTarget);
break;
}
}
#endif /* ODOS3EXE OR OIAPX286 */
/*
* FixRc2:
*
* Process a FIXUPP record. This is a top-level routine which passes
* work out to various subroutines.
*/
void NEAR FixRc2(void) /* Process a fixup record */
{
#if 0
#if SYMDEB
// this code is dead -- fDebSeg && !fSymdeb is never true [rm]
if (fDebSeg && !fSymdeb)
{
// If no /CodeView - skip fixups for debug segments
SkipBytes((WORD) (cbRec - 1));
return;
}
#endif
#endif
if (fSkipFixups)
{
fSkipFixups = (FTYPE) FALSE; // Only one FIXUP record can be skipped
SkipBytes((WORD) (cbRec - 1));
return;
}
while (cbRec > 1)
{
// While fixups or threads remain
// Get information on fixup
if (!GetFixup())
continue; // Fixup thread - keep registering them
// If absolute segment skip fixup
if (vgsnCur == 0xffff)
{
SkipBytes((WORD) (cbRec - 1));
return;
}
#if SYMDEB
if (fDebSeg)
{
if (fi.f_loc == LOCLOADOFFSET)
fi.f_loc = LOCOFFSET; /* Save Cmerge's butts */
#if OMF386
if (fi.f_loc == LOCOFFSET32 || fi.f_loc == LOCPTR48)
fi.f_fmtd = F5; /* Temp fix until compiler is fixed */
#endif
}
#endif
DoFixup();
}
}
// BAKPAT record bookeeping
typedef struct bphdr // BAKPAT bucket
{
struct bphdr FAR *next; // Next bucket
SNTYPE gsn; // Segment index
WORD cnt; // # of BAKPAT entries
BYTE loctyp; // Location type
BYTE fComdat; // TRUE if NBAKPAT
struct bpentry FAR *patch; // Table of BAKPAT entries
}
BPHDR;
struct bpentry // BAKPAT entry
{
RATYPE ra; // Offset to location to patch
#if OMF386
long value; // Value to add to patch location
#else
int value; // Value to add to patch location
#endif
};
LOCAL BPHDR FAR *pbpFirst; // List of BAKPAT buckets
LOCAL BPHDR FAR *pbpLast; // Tail of BAKPAT list
/*
* BakPat : Process a BAKPAT record (0xb2)
*
* Just accumulate the record information in virtual memory;
* we will do the backpatching later.
*/
void NEAR BakPat()
{
BPHDR FAR *pHdr; // BAKPAT bucket
WORD cEntry;
WORD comdatIdx; // COMDAT symbol index
DWORD comdatRa; // Starting COMDAT offset
APROPCOMDATPTR comdat; // Pointer to symbol table entry
#if POOL_BAKPAT
if (!poolBakpat)
poolBakpat = PInit();
#endif
/* Get the segment index and location type */
#if POOL_BAKPAT
pHdr = (BPHDR FAR *) PAlloc(poolBakpat, sizeof(BPHDR));
#else
pHdr = (BPHDR FAR *) GetMem(sizeof(BPHDR));
#endif
if (TYPEOF(rect) == BAKPAT)
{
pHdr->fComdat = (FTYPE) FALSE;
pHdr->gsn = mpsngsn[GetIndex(1, (WORD) (snMac - 1))];
pHdr->loctyp = (BYTE) Gets();
comdatRa = 0L;
}
else
{
pHdr->fComdat = (BYTE) TRUE;
pHdr->loctyp = (BYTE) Gets();
comdatIdx = GetIndex(1, (WORD) (lnameMac - 1));
comdat = (APROPCOMDATPTR ) PropRhteLookup(mplnamerhte[comdatIdx], ATTRCOMDAT, FALSE);
if ((comdat->ac_obj != vrpropFile) || !IsSELECTED (comdat->ac_flags))
{
// Skip the nbakpat if it concerns an unselected comdat
// or a comdat from other .obj
SkipBytes((WORD) (cbRec - 1));
return;
}
else
{
if (comdat != NULL)
{
pHdr->gsn = comdat->ac_gsn;
comdatRa = comdat->ac_ra;
}
else
InvalidObject(); // Invalid module
}
}
/* If BAKPAT record for CV info and /CO not used - skip record */
#if SYMDEB
if (pHdr->gsn == 0xffff)
{
SkipBytes((WORD) (cbRec - 1));
return; /* Good-bye! */
}
#endif
switch(pHdr->loctyp)
{
case LOCLOBYTE:
case LOCOFFSET:
#if OMF386
case LOCOFFSET32:
#endif
break;
default:
InvalidObject();
}
/* Determine # of entries */
#if OMF386
if (rect & 1)
pHdr->cnt = (WORD) ((cbRec - 1) >> 3);
else
#endif
pHdr->cnt = (WORD) ((cbRec - 1) >> 2);
if (pHdr->cnt == 0)
{
#if NOT POOL_BAKPAT
FFREE(pHdr);
#endif
return;
}
#if DEBUG
sbModule[sbModule[0]+1] = '\0';
fprintf(stdout, "\r\nBakPat in module %s, at %x, entries : %x", sbModule+1, lfaLast,pHdr->cnt);
fprintf(stdout, " pHdr %x, pbpLast %x ", pHdr, pbpLast);
fprintf(stdout, "\r\n gsn %d ", pHdr->gsn);
fflush(stdout);
#endif
// Store all the BAKPAT entries
#if POOL_BAKPAT
pHdr->patch = (struct bpentry FAR *) PAlloc(poolBakpat, pHdr->cnt * sizeof(struct bpentry));
#else
pHdr->patch = (struct bpentry FAR *) GetMem(pHdr->cnt * sizeof(struct bpentry));
#endif
cbBakpat = 1; // only need to show backpatches are present [rm]
cEntry = 0;
while (cbRec > 1)
{
#if OMF386
if (rect & 1)
{
pHdr->patch[cEntry].ra = LGets() + comdatRa;
pHdr->patch[cEntry].value = LGets();
}
else
#endif
{
pHdr->patch[cEntry].ra = (WORD) (WGets() + comdatRa);
pHdr->patch[cEntry].value = WGets();
}
cEntry++;
}
// Add bucket to the list
if (pbpFirst == NULL)
pbpFirst = pHdr;
else
pbpLast->next = pHdr;
pbpLast = pHdr;
}
/*
* FixBakpat : Fix up backpatches
* Called at the end of processing a module in Pass 2.
*/
void NEAR FixBakpat(void)
{
BPHDR FAR *pHdr;
BPHDR FAR *pHdrNext=NULL;
WORD n;
BYTE FAR *pSegImage; /* Segment memory image */
SEGTYPE seg; /* Logical segment index */
#if DEBUG
int i,iTotal=0,j=1;
char *ibase;
fprintf(stdout, "\r\nFixBakpat, pbpFirst : %x ", pbpFirst);
#endif
// Go through the backpatch list and do the backpatches
for (pHdr = pbpFirst; pHdr != NULL; pHdr = pHdrNext)
{
// While there are backpatches remaining, do them
#if DEBUG
fprintf(stdout, "\r\nBAKPAT at %x, entries : %x ",pHdr,pHdr->cnt);
#endif
for (n = 0; n < pHdr->cnt; n++)
{
// Determine the address of the patch location
#if SYMDEB
if (pHdr->gsn & 0x8000)
pSegImage = ((APROPFILEPTR) vrpropFile)->af_cvInfo->cv_sym + pHdr->patch[n].ra;
/* In debug segment */
else
{
#endif
seg = mpgsnseg[pHdr->gsn];
if(fNewExe)
pSegImage = mpsaMem[mpsegsa[seg]];
else
pSegImage = mpsegMem[seg];
/* In other segment */
pSegImage += pHdr->patch[n].ra;
if (!pHdr->fComdat)
pSegImage += mpgsndra[pHdr->gsn];
else
pSegImage += mpsegraFirst[seg];
#if SYMDEB
}
#endif
#if DEBUG
fprintf(stdout, "\r\nseg %d, mpsegsa[seg] sa %d ", seg, mpsegsa[seg]);
fprintf(stdout, "mpsaMem[seg] %x, mpsegraFirst[seg] %x, pHdr->patch[n].ra %x\r\n",
mpsaMem[seg], (int)mpsegraFirst[seg], (int)pHdr->patch[n].ra);
fprintf(stdout, " gsn %x, mpgsndra[gsn] %x ",pHdr->gsn,mpgsndra[pHdr->gsn]);
ibase = pSegImage - pHdr->patch[n].ra;
iTotal = (int) ibase;
for(i=0; i<50; i++)
{
if(j==1)
{
fprintf( stdout,"\r\n\t%04X\t",iTotal);
}
fprintf( stdout,"%02X ",*((char*)ibase+i));
iTotal++;
if(++j > 16)
j=1;
}
fprintf(stdout, "\r\nseg:ra %x:%x, value : %x",seg,pHdr->patch[n].ra,pHdr->patch[n].value);
fflush(stdout);
#endif
/* Do the fixup according to the location type */
switch(pHdr->loctyp)
{
case LOCLOBYTE:
pSegImage[0] += (BYTE) pHdr->patch[n].value;
break;
case LOCOFFSET:
((WORD FAR *) pSegImage)[0] += (WORD) pHdr->patch[n].value;
break;
#if OMF386
case LOCOFFSET32:
((DWORD FAR *) pSegImage)[0]+= (DWORD) pHdr->patch[n].value;
break;
#endif
}
}
pHdrNext = pHdr->next;
#if NOT POOL_BAKPAT
FFREE(pHdr);
#endif
}
#if POOL_BAKPAT
PReinit(poolBakpat); // reuse same memory again...
#endif
pbpFirst = NULL;
cbBakpat = 0;
}
#if TCE
void NEAR FixRc1(void) /* Process a fixup record */
{
if (fSkipFixups)
{
fSkipFixups = (FTYPE) FALSE; // Only one FIXUP record can be skipped
SkipBytes((WORD) (cbRec - 1));
pActiveComdat = NULL;
return;
}
while (cbRec > 1)
{
// While fixups or threads remain
// Get information on fixup
if (!GetFixup())
continue; // Fixup thread - keep registering them
if(fi.f_mtd == KINDEXT)
{
RBTYPE rhte;
APROPCOMDAT *pUsedComdat;
if( mpextprop && mpextprop[fi.f_idx]) // Is there a COMDAT with this name?
{
rhte = RhteFromProp(mpextprop[fi.f_idx]);
ASSERT(rhte);
pUsedComdat = PropRhteLookup(rhte, ATTRCOMDAT, FALSE);
if(pActiveComdat)
{
if(pUsedComdat)
{
AddComdatUses(pActiveComdat, pUsedComdat);
#if TCE_DEBUG
fprintf(stdout, "\r\nCOMDAT %s uses COMDAT %s ", 1 + GetPropName(pActiveComdat) ,1+ GetPropName(mpextprop[fi.f_idx]));
#endif
}
else
{
AddComdatUses(pActiveComdat, mpextprop[fi.f_idx]);
#if TCE_DEBUG
fprintf(stdout, "\r\nCOMDAT %s uses EXTDEF %s ", 1 + GetPropName(pActiveComdat) ,1+ GetPropName(mpextprop[fi.f_idx]));
#endif
}
}
else // no COMDAT of this name
{
if(pUsedComdat)
{
pUsedComdat->ac_fAlive = TRUE;
if(!fDebSeg)
{
AddTceEntryPoint(pUsedComdat);
#if TCE_DEBUG
fprintf(stdout, "\r\nLEDATA uses COMDAT %s ", 1 + GetPropName(mpextprop[fi.f_idx]));
sbModule[sbModule[0]+1] = '\0';
fprintf(stdout, " module %s, offset %x ", sbModule+1, lfaLast);
#endif
}
}
else
{
if(((APROPUNDEFPTR)mpextprop[fi.f_idx])->au_attr == ATTRUND)
{
#if TCE_DEBUG
fprintf(stdout, "\r\nLEDATA uses EXTDEF %s ", 1 + GetPropName(mpextprop[fi.f_idx]));
#endif
((APROPUNDEFPTR)mpextprop[fi.f_idx])->au_fAlive = TRUE;
}
}
}
}
}
}
pActiveComdat = NULL;
}
#endif
Reference in a new issue Copy permalink