2508 lines
71 KiB
C
2508 lines
71 KiB
C
/*
|
|
* Copyright Microsoft Corporation 1985-1987
|
|
*
|
|
* This Module contains Proprietary Information of Microsoft
|
|
* Corporation and should be treated as Confidential.
|
|
*/
|
|
|
|
/****************************************************************
|
|
* *
|
|
* NEWDEB.C *
|
|
* *
|
|
* Symbolic debugging support. *
|
|
* *
|
|
****************************************************************/
|
|
|
|
#include <minlit.h> /* Basic types and constants */
|
|
#include <bndtrn.h> /* More types and constants */
|
|
#include <bndrel.h> /* Types and constants */
|
|
#include <lnkio.h> /* Linker input/output */
|
|
#if OIAPX286
|
|
#include <xenfmt.h> /* Xenix executable format defs. */
|
|
#endif
|
|
#if OEXE
|
|
#include <newexe.h> /* Segmented executable format */
|
|
#endif
|
|
#if EXE386
|
|
#include <exe386.h>
|
|
#endif
|
|
#include <lnkmsg.h> /* Error messages */
|
|
#include <extern.h> /* External function declarations */
|
|
#ifndef CVVERSION
|
|
#if OIAPX286
|
|
#define CVVERSION 0 /* Assume new CV exe format */
|
|
#else
|
|
#define CVVERSION 1 /* Assume new CV exe format */
|
|
#endif
|
|
#endif
|
|
#if (CPU8086 OR CPU286)
|
|
#define TFAR far
|
|
#else
|
|
#define TFAR
|
|
#endif
|
|
#include <newdeb.h> /* Symbolic debug types */
|
|
extern SEGTYPE segAdjCom; /* Segment moved by 0x100 in .com programs */
|
|
#if AUTOVM
|
|
BYTE FAR * NEAR FetchSym1(RBTYPE rb, WORD Dirty);
|
|
#define FETCHSYM FetchSym1
|
|
#define PROPSYMLOOKUP EnterName
|
|
#else
|
|
#define FETCHSYM FetchSym
|
|
#define PROPSYMLOOKUP EnterName
|
|
#endif
|
|
|
|
#define CVDEBUG FALSE
|
|
#define SRCDEBUG FALSE
|
|
|
|
#define DNT_START 64
|
|
#define Round2Dword(x) (((x) + 3L) & ~3L)
|
|
|
|
typedef struct raPair
|
|
{
|
|
DWORD raStart;
|
|
DWORD raEnd;
|
|
}
|
|
RAPAIR;
|
|
|
|
/*
|
|
* FUNCTION PROTOTYPES
|
|
*/
|
|
|
|
LOCAL WORD NEAR IsDebTyp(APROPSNPTR prop);
|
|
LOCAL WORD NEAR IsDebSym(APROPSNPTR prop);
|
|
LOCAL int NEAR OutLibSec(void);
|
|
void NEAR GetName(AHTEPTR ahte, BYTE *pBuf);
|
|
LOCAL DWORD NEAR OutSrcModule(CVSRC FAR *pSrcLines);
|
|
LOCAL void NEAR PutDnt(DNT *pDnt);
|
|
LOCAL WORD NEAR HasCVinfo(APROPFILEPTR apropFile);
|
|
LOCAL void NEAR OutModules(void);
|
|
LOCAL void NEAR Pad2Dword(void);
|
|
#if CVDEBUG
|
|
LOCAL void NEAR DumpDNT(DNT *pDnt);
|
|
#endif
|
|
|
|
extern long lfaBase; /* Base address */
|
|
extern int fSameComdat; /* Set if LINSYM to the same COMDAT */
|
|
|
|
/*
|
|
* CodeView signature - if changes notify the developers of the
|
|
* following programs:
|
|
* - QuickC
|
|
* - Resource Compiler - Windows and PM
|
|
* - CodeView and its utilities
|
|
*/
|
|
char szSignature[4] = "NB05";
|
|
|
|
RBTYPE rhteDebSrc; /* Class "DEBSRC" virt addr */
|
|
RBTYPE rhteDebSym; /* Class "DEBSYM" virt addr */
|
|
RBTYPE rhteDebTyp; /* Class "DEBTYP" virt addr */
|
|
RBTYPE rhteTypes;
|
|
RBTYPE rhteSymbols;
|
|
RBTYPE rhte0Types;
|
|
RBTYPE rhte0Symbols;
|
|
LOCAL SBTYPE sbLastModule; /* Name of THEADR last observed */
|
|
#if NOT CVVERSION
|
|
LOCAL long lfaDebHdr; /* Position of section table */
|
|
LOCAL long lfaSegMod;
|
|
#endif
|
|
LOCAL WORD dntMax; // DNT table size
|
|
LOCAL WORD dntMac; // Count of DNT entries in table
|
|
LOCAL DNT FAR *rgDnt; // Table of DNT entries
|
|
LOCAL DWORD FAR *fileBase; // Table of offsets to source file info
|
|
LOCAL RAPAIR FAR *raSeg; // Table of physical starting and ending offsets
|
|
// of the contribution to the logical segments
|
|
LOCAL WORD FAR *segNo; // Table of physical segment indicies
|
|
LOCAL WORD cMac; // Current number of elements in the above tables
|
|
|
|
#ifdef CVPACK_MONDO
|
|
#define CVPACK_SHARED 1
|
|
#define REVERSE_MODULE_ORDER_FOR_CVPACK 1
|
|
#else
|
|
#define CVPACK_SHARED 0
|
|
#define REVERSE_MODULE_ORDER_FOR_CVPACK 0
|
|
#endif
|
|
|
|
//these macros help to make the source not so cluttered with #ifdefs...
|
|
|
|
#if CVPACK_SHARED
|
|
|
|
#define IF_NOT_CVPACK_SHARED(x)
|
|
#define WriteCopy(x,y) WriteSave(TRUE, x, y)
|
|
#define WriteNocopy(x,y) WriteSave(FALSE, x, y)
|
|
#define FTELL_BSRUNFILE() lposCur
|
|
#define LINK_TRACE(x)
|
|
|
|
|
|
// cvpack might read parts of the header more than once, we use this
|
|
// constant to ensure that at least CB_HEADER_SAVE bytes are always
|
|
// available to be re-read by cvpack
|
|
|
|
#define CB_HEADER_SAVE 128
|
|
|
|
void WriteSave(FTYPE fCopy, void *pv, UINT cb);
|
|
void WriteFlushSignature(void);
|
|
void WriteFlushAll(void);
|
|
|
|
// cvpack cached blocks...
|
|
|
|
typedef struct _BL
|
|
{
|
|
long lpos; // position of this block in the file
|
|
BYTE * pb; // pointer to bytes in this block
|
|
} BL;
|
|
|
|
#define iblNil (-1)
|
|
|
|
static long lposCur; // current position in the file
|
|
static long lposMac; // size of the file
|
|
static long iblLim; // number of blocks used
|
|
static long iblCur; // current block we are reading
|
|
static long iblMac; // number of blocks allocated
|
|
static long cbRealBytes; // number of bytes actually written to the file
|
|
static int ichCur; // index within the current block
|
|
static int cbCur; // number of bytes left in the current block
|
|
|
|
static BL *rgbl; // array of buffered write blocks
|
|
|
|
// number of bytes in a particular block
|
|
|
|
__inline int CbIbl(int ibl)
|
|
{
|
|
// compute the difference between this block and the next block
|
|
// unless this is the last block then use lposMac
|
|
|
|
if (ibl == iblLim - 1)
|
|
return lposMac - rgbl[ibl].lpos;
|
|
else
|
|
return rgbl[ibl+1].lpos - rgbl[ibl].lpos;
|
|
}
|
|
|
|
#define C_BL_INIT 256
|
|
#else
|
|
#define IF_NOT_CVPACK_SHARED(x) x
|
|
#define WriteCopy(x,y) WriteExe(x,y)
|
|
#define WriteNocopy(x,y) WriteExe(x,y)
|
|
#define FTELL_BSRUNFILE() ftell(bsRunfile)
|
|
#define LINK_TRACE(x)
|
|
#endif
|
|
|
|
#if CVDEBUG
|
|
LOCAL void NEAR DumpDNT(DNT *pDnt)
|
|
{
|
|
if (pDnt == NULL)
|
|
return;
|
|
|
|
fprintf(stdout, "iMod = %d(0x%x)", pDnt->iMod, pDnt->iMod);
|
|
switch (pDnt->sst)
|
|
{
|
|
case SSTMODULES:
|
|
case SSTMODULES4:
|
|
fprintf(stdout, " SSTMODULES: ");
|
|
break;
|
|
|
|
case SSTTYPES:
|
|
case SSTTYPES4:
|
|
fprintf(stdout, " SSTYPES: ");
|
|
break;
|
|
|
|
case SSTPUBLICS:
|
|
case SSTPUBLICS4:
|
|
fprintf(stdout, " SSTPUBLICS: ");
|
|
break;
|
|
|
|
case SSTPUBLICSYM:
|
|
fprintf(stdout, " SSTPUBLICSYM: ");
|
|
break;
|
|
|
|
case SSTSYMBOLS:
|
|
case SSTSYMBOLS4:
|
|
fprintf(stdout, " SSTSYMBOLS: ");
|
|
break;
|
|
|
|
case SSTALIGNSYM:
|
|
fprintf(stdout, " SSTALIGNSYM: ");
|
|
break;
|
|
|
|
case SSTSRCLINES:
|
|
case SSTNSRCLINES:
|
|
case SSTSRCLNSEG:
|
|
fprintf(stdout, " SSTSRCLINES: ");
|
|
break;
|
|
|
|
case SSTSRCMODULE:
|
|
fprintf(stdout, " SSTSRCMODULE: ");
|
|
break;
|
|
|
|
case SSTLIBRARIES:
|
|
case SSTLIBRARIES4:
|
|
fprintf(stdout, " SSTLIBRARIES: ");
|
|
break;
|
|
|
|
case SSTGLOBALSYM:
|
|
fprintf(stdout, " SSTGLOBALSYM: ");
|
|
break;
|
|
|
|
case SSTGLOBALPUB:
|
|
fprintf(stdout, " SSTGLOBALPUB: ");
|
|
break;
|
|
|
|
case SSTGLOBALTYPES:
|
|
fprintf(stdout, " SSTGLOBALTYPES: ");
|
|
break;
|
|
|
|
case SSTMPC:
|
|
fprintf(stdout, " SSTMPC: ");
|
|
break;
|
|
|
|
case SSTSEGMAP:
|
|
fprintf(stdout, " SSTSEGMAP: ");
|
|
break;
|
|
|
|
case SSTSEGNAME:
|
|
fprintf(stdout, " SSTSEGNAME: ");
|
|
break;
|
|
|
|
case SSTIMPORTS:
|
|
fprintf(stdout, " SSTIMPORTS: ");
|
|
break;
|
|
|
|
default:
|
|
fprintf(stdout, " UNKNOWN !?!: ");
|
|
break;
|
|
}
|
|
fprintf(stdout, "file offset 0x%lx; size 0x%x\r\n",
|
|
lfaBase+pDnt->lfo, pDnt->cb);
|
|
}
|
|
#endif
|
|
|
|
#if SRCDEBUG
|
|
LOCAL void NEAR DumpSrcLines(DWORD vLines)
|
|
{
|
|
CVSRC cvSrc;
|
|
CVGSN cvGsn;
|
|
CVLINE cvLine;
|
|
DWORD curSrc;
|
|
DWORD curGsn;
|
|
DWORD curLine;
|
|
SBTYPE fileName;
|
|
DWORD i;
|
|
WORD j;
|
|
|
|
|
|
fprintf(stdout, "\r\nList at %lx\r\n\r\n", vLines);
|
|
for (curSrc = vLines; curSrc != 0L; curSrc = cvSrc.vpNext)
|
|
{
|
|
memcpy(&cvSrc, mapva(curSrc, FALSE), sizeof(CVSRC));
|
|
memcpy(fileName, mapva(cvSrc.vpFileName, FALSE), cvSrc.cbName);
|
|
fileName[cvSrc.cbName] = '\0';
|
|
fprintf(stdout, "'%s' --> code segments: %lu; source lines: %lu\r\n", fileName, cvSrc.cSegs, cvSrc.cLines);
|
|
|
|
for (curGsn = cvSrc.vpGsnFirst; curGsn != 0L; curGsn = cvGsn.vpNext)
|
|
{
|
|
memcpy(&cvGsn, mapva(curGsn, FALSE), sizeof(CVGSN));
|
|
fprintf(stdout, " Logical segment %d; source lines: %d; start: %lx; end: %lx\r\n", cvGsn.seg, cvGsn.cLines, cvGsn.raStart, cvGsn.raEnd);
|
|
|
|
for (curLine = cvGsn.vpLineFirst, i = 1L; curLine != 0L; curLine = cvLine.vpNext)
|
|
{
|
|
memcpy(&cvLine, mapva(curLine, FALSE), sizeof(CVLINE));
|
|
for (j = 0; j < cvLine.cPair; j++, i++)
|
|
fprintf(stdout, " %8lu: %u:%lx\r\n", i, cvLine.rgLn[j], cvLine.rgOff[j]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
|
|
/****************************************************************
|
|
* *
|
|
* Initialize variables for symbolic debug processing. *
|
|
* Pass 1. *
|
|
* *
|
|
****************************************************************/
|
|
|
|
void NEAR InitDeb1 (void)
|
|
{
|
|
#if ODOS3EXE
|
|
if (vfDSAlloc)
|
|
{
|
|
OutWarn(ER_dbgdsa);
|
|
vfDSAlloc = FALSE;
|
|
}
|
|
#endif
|
|
#if FEXEPACK
|
|
if (fExePack)
|
|
{
|
|
OutWarn(ER_dbgexe);
|
|
fExePack = FALSE;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
void InitDbRhte ()
|
|
{
|
|
PROPSYMLOOKUP((BYTE *) "\006DEBTYP", ATTRNIL, TRUE);
|
|
rhteDebTyp = vrhte;
|
|
PROPSYMLOOKUP((BYTE *) "\006DEBSYM", ATTRNIL, TRUE);
|
|
rhteDebSym = vrhte;
|
|
PROPSYMLOOKUP((BYTE *) "\006 TYPES", ATTRNIL, TRUE);
|
|
rhte0Types = vrhte;
|
|
PROPSYMLOOKUP((BYTE *) "\010 SYMBOLS", ATTRNIL, TRUE);
|
|
rhte0Symbols = vrhte;
|
|
PROPSYMLOOKUP((BYTE *) "\007$$TYPES", ATTRNIL, TRUE);
|
|
rhteTypes = vrhte;
|
|
PROPSYMLOOKUP((BYTE *) "\011$$SYMBOLS", ATTRNIL, TRUE);
|
|
rhteSymbols = vrhte;
|
|
}
|
|
|
|
|
|
LOCAL void NEAR Pad2Dword(void)
|
|
{
|
|
WORD cb; // Number of bytes to write
|
|
static DWORD dwZero;
|
|
|
|
// Calculate needed padding
|
|
|
|
cb = (WORD)(sizeof(DWORD)-((WORD) FTELL_BSRUNFILE() % sizeof(DWORD)));
|
|
|
|
if (cb != sizeof(DWORD))
|
|
WriteCopy(&dwZero, cb);
|
|
}
|
|
|
|
/*** GetName - get symbol associated with given property cell
|
|
*
|
|
* Purpose:
|
|
* Find the symbol which has given property.
|
|
*
|
|
* Input:
|
|
* - ahte - pointer to property cell
|
|
* - pBuf - pointer to ASCII buffer
|
|
*
|
|
* Output:
|
|
* No explicit value is passed. If symbol is found the it is
|
|
* copied into buffer
|
|
*
|
|
* Exceptions:
|
|
* None.
|
|
*
|
|
* Notes:
|
|
* This functional duplicate of GetPropName, but we want to
|
|
* call both function as near.
|
|
*
|
|
*************************************************************************/
|
|
|
|
void NEAR GetName(AHTEPTR ahte, BYTE *pBuf)
|
|
{
|
|
while(ahte->attr != ATTRNIL)
|
|
ahte = (AHTEPTR ) FETCHSYM(ahte->rhteNext, FALSE);
|
|
FMEMCPY((char FAR *) pBuf, ahte->cch, B2W(ahte->cch[0]) + 1);
|
|
if (B2W(pBuf[0]) < SBLEN)
|
|
pBuf[pBuf[0] + 1] = '\0';
|
|
else
|
|
pBuf[pBuf[0]] = '\0';
|
|
}
|
|
|
|
/*** DebPublic - prepare symbols for debugger
|
|
*
|
|
* Purpose:
|
|
* When the /CODEVIEW option is used then all PUBDEFs and COMDEFs
|
|
* defined in a given object file are linked into one list. This
|
|
* function adds one symbol to the list and updates the combined
|
|
* size of symbols
|
|
*
|
|
* Input:
|
|
* vrprop - virtual pointer to symbol descriptor
|
|
* rt - OMF record type
|
|
*
|
|
* Output:
|
|
* No explicit value is returned.
|
|
* Side effects:
|
|
* - symbol is attached to the module symbol list
|
|
*
|
|
* Exceptions:
|
|
* None.
|
|
*
|
|
* Notes:
|
|
* Symbols are placed on the list in reverse order of their apperance
|
|
* in the object file.
|
|
*
|
|
*************************************************************************/
|
|
|
|
|
|
void DebPublic(RBTYPE vrprop, WORD rt)
|
|
{
|
|
APROPFILEPTR apropFile; // Pointer to file entry
|
|
APROPNAMEPTR apropName; // Real pointer to PUBDEF descriptor
|
|
APROPUNDEFPTR apropUndef; // Real pointer to COMDEF descriptor
|
|
APROPALIASPTR apropAlias; // Real pointer to ALIAS descriptor
|
|
RBTYPE symNext; // Virtual pointer to the next symbol
|
|
|
|
|
|
// Update the appropriate field in the current file symtab entry
|
|
|
|
apropFile = ((APROPFILEPTR ) FETCHSYM(vrpropFile, TRUE));
|
|
symNext = apropFile->af_publics;
|
|
apropFile->af_publics = vrprop;
|
|
apropName = (APROPNAMEPTR) FETCHSYM(vrprop, TRUE);
|
|
if (TYPEOF(rt) == PUBDEF)
|
|
apropName->an_sameMod = symNext;
|
|
else if (TYPEOF(rt) == COMDEF)
|
|
{
|
|
apropUndef = (APROPUNDEFPTR) apropName;
|
|
apropUndef->au_sameMod = symNext;
|
|
}
|
|
else if (TYPEOF(rt) == ALIAS)
|
|
{
|
|
apropAlias = (APROPALIASPTR) apropName;
|
|
apropAlias->al_sameMod = symNext;
|
|
}
|
|
}
|
|
|
|
|
|
LOCAL WORD NEAR IsDebTyp (prop)
|
|
APROPSNPTR prop; /* Pointer to segment record */
|
|
{
|
|
return(prop->as_attr == ATTRLSN && prop->as_rCla == rhteDebTyp);
|
|
}
|
|
|
|
LOCAL WORD NEAR IsDebSym (prop)
|
|
APROPSNPTR prop; /* Pointer to segment record */
|
|
{
|
|
return(prop->as_attr == ATTRLSN && prop->as_rCla == rhteDebSym);
|
|
}
|
|
|
|
|
|
/*** DoDebSrc - store source line information
|
|
*
|
|
* Purpose:
|
|
* Stores source line information from object file.
|
|
*
|
|
* Input:
|
|
* No explicit value is passed.
|
|
*
|
|
* Global variables:
|
|
* - vaCVMac - virtual pointer to the free space in the CV info buffer
|
|
*
|
|
* Output:
|
|
* Returns TRUE if the cv info has been stored in the VM ,or FALSE otherwise.
|
|
* Side effects:
|
|
* - source line information is stored in the VM
|
|
*
|
|
* Exceptions:
|
|
* More than 32Mb of CV information - dispaly error and quit
|
|
*
|
|
* Notes:
|
|
* None.
|
|
*
|
|
*************************************************************************/
|
|
|
|
#pragma check_stack(on)
|
|
|
|
WORD DoDebSrc(void)
|
|
{
|
|
WORD cbRecSav; // LINNUM record size
|
|
APROPFILEPTR apropFile; // Current object file property cell
|
|
static SATYPE prevGsn = 0; // GSN of previous LINNUM record
|
|
GSNINFO gsnInfo; // GSN info for this LINNUM
|
|
static CVSRC FAR *pCurSrc; // Pointer to the current file source info
|
|
CVGSN FAR *pCurGsn; // Pointer to the current code segment descriptor
|
|
CVGSN FAR *pcvGsn; // Real pointer to the code segment descriptor
|
|
CVLINE FAR *pCurLine; // Pointer to the current offset/line pair bucket
|
|
RATYPE ra; // Offset
|
|
WORD line; // Line number
|
|
RATYPE raPrev; // Offset of the previous line
|
|
WORD fChangeInSource;
|
|
WORD fComdatSplit;
|
|
DWORD gsnStart; // Start of this gsn
|
|
APROPSNPTR apropSn;
|
|
WORD align;
|
|
WORD threshold;
|
|
#if !defined( M_I386 ) && !defined( _WIN32 )
|
|
SBTYPE nameBuf;
|
|
#endif
|
|
|
|
|
|
cbRecSav = cbRec;
|
|
if (!GetGsnInfo(&gsnInfo))
|
|
return(FALSE);
|
|
|
|
// If LINNUM record is empty, don't do anything
|
|
|
|
if (cbRec == 1)
|
|
return(FALSE);
|
|
|
|
apropFile = (APROPFILEPTR ) FETCHSYM(vrpropFile, TRUE);
|
|
|
|
// If there is a new source file allocate new CVSRC structure
|
|
// and link it to the current object file descriptor
|
|
|
|
fChangeInSource = (WORD) (apropFile->af_Src == 0 || !SbCompare(sbModule, sbLastModule,TRUE));
|
|
|
|
if (fChangeInSource)
|
|
{
|
|
#if CVDEBUG
|
|
sbModule[sbModule[0]+1]='\0';
|
|
sbLastModule[sbLastModule[0]+1]='\0';
|
|
fprintf(stdout, "Change in source file; from '%s' to '%s'\r\n", &sbLastModule[1], &sbModule[1]);
|
|
#endif
|
|
// Search the list of CVSRC structures for this object
|
|
// file and find out if we heave already seen this source file
|
|
|
|
for (pCurSrc = apropFile->af_Src; pCurSrc;)
|
|
{
|
|
#if defined(M_I386) || defined( _WIN32 )
|
|
if (SbCompare(sbModule, pCurSrc->fname, TRUE))
|
|
#else
|
|
FMEMCPY((char FAR *) nameBuf, pCurSrc->fname, pCurSrc->fname[0] + 1);
|
|
if (SbCompare(sbModule, nameBuf, TRUE))
|
|
#endif
|
|
break;
|
|
else
|
|
pCurSrc = pCurSrc->next;
|
|
}
|
|
|
|
if (pCurSrc == NULL)
|
|
{
|
|
// New source file
|
|
|
|
pCurSrc = (CVSRC FAR *) GetMem(sizeof(CVSRC));
|
|
pCurSrc->fname = GetMem(sbModule[0] + 1);
|
|
FMEMCPY(pCurSrc->fname, (char FAR *) sbModule, sbModule[0] + 1);
|
|
|
|
if (apropFile->af_Src == NULL)
|
|
apropFile->af_Src = pCurSrc;
|
|
else
|
|
apropFile->af_SrcLast->next = pCurSrc;
|
|
|
|
apropFile->af_SrcLast = pCurSrc;
|
|
}
|
|
else
|
|
{
|
|
// We have already seen this source file
|
|
}
|
|
memcpy(sbLastModule, sbModule, B2W(sbModule[0]) + 1);
|
|
}
|
|
else
|
|
{
|
|
// Use descriptor set last time we changed source files
|
|
}
|
|
|
|
// Allocate the new CVGSN structure if any of the following is true
|
|
//
|
|
// - this is first batch of source lines
|
|
// - there is a change in GSNs
|
|
// - there is a change in source file
|
|
// - we have source lines for explicitly allocated COMDAT
|
|
// In this last case we assume that the begin portion of a
|
|
// given logical segment (gsn) has been filled with contributions
|
|
// from many object files. Because COMDATs are allocated after all
|
|
// the object files are read, then adding source
|
|
// lines of COMDAT to the source lines of preceeding LEDATA records
|
|
// will mask the contributions from other object files, as the picture
|
|
// below shows:
|
|
//
|
|
// +-------------+<--+
|
|
// | | |
|
|
// | LEDATA from | |
|
|
// | a.obj | |
|
|
// | | |
|
|
// +-------------+ |
|
|
// | | | Without splitting into fake CVGSN
|
|
// | LEDATA from | \ the source line for a.obj will
|
|
// | b.obj | / hide the LEDATA contribution from b.obj
|
|
// | | |
|
|
// +-------------+ |
|
|
// | | |
|
|
// | COMDAT from | |
|
|
// | a.obj | |
|
|
// | | |
|
|
// +-------------+<--+
|
|
// | |
|
|
// | COMDAT from |
|
|
// | b.obj |
|
|
// | |
|
|
// +-------------+
|
|
//
|
|
// This will be unnecessary only if COMDAT from a.obj immediately
|
|
// follows LEDATA from a.obj
|
|
|
|
fComdatSplit = FALSE;
|
|
pCurGsn = pCurSrc->pGsnLast;
|
|
if (pCurGsn)
|
|
{
|
|
// Assume we will be using the current CVGSN
|
|
|
|
if (gsnInfo.fComdat)
|
|
{
|
|
// Source lines from LINSYM - Calculate the threshold
|
|
|
|
apropSn = (APROPSNPTR ) FETCHSYM(mpgsnrprop[gsnInfo.gsn], FALSE);
|
|
if (gsnInfo.comdatAlign)
|
|
align = gsnInfo.comdatAlign;
|
|
else
|
|
align = (WORD) ((apropSn->as_tysn >> 2) & 7);
|
|
|
|
threshold = 1;
|
|
switch (align)
|
|
{
|
|
case ALGNWRD:
|
|
threshold = 2;
|
|
break;
|
|
#if OMF386
|
|
case ALGNDBL:
|
|
threshold = 4;
|
|
break;
|
|
#endif
|
|
case ALGNPAR:
|
|
threshold = 16;
|
|
break;
|
|
|
|
case ALGNPAG:
|
|
threshold = 256;
|
|
break;
|
|
}
|
|
|
|
// Check if we have to split CVGSN for this COMDAT
|
|
|
|
fComdatSplit = !fSameComdat &&
|
|
!(apropSn->as_fExtra & COMDAT_SEG) &&
|
|
(gsnInfo.comdatRa - pCurGsn->raEnd > threshold);
|
|
|
|
}
|
|
else
|
|
{
|
|
// Source lines from LINNUM
|
|
|
|
if (pCurGsn->flags & SPLIT_GSN)
|
|
{
|
|
// The LINNUM record following the LINSYM record that
|
|
// caused CVGSN split - we have to move back on CVGSN
|
|
// list until we find first CVGSN not marked as SPLIT_GSN
|
|
|
|
for (pcvGsn = pCurGsn->prev; pcvGsn != (CVGSN FAR *) pCurSrc;)
|
|
{
|
|
if (!(pcvGsn->flags & SPLIT_GSN))
|
|
break;
|
|
else
|
|
pcvGsn = pcvGsn->prev;
|
|
}
|
|
|
|
if (pcvGsn == (CVGSN FAR *) pCurSrc)
|
|
{
|
|
// There are only SPLIT_GSN on the list - make new CVGSN
|
|
|
|
prevGsn = 0;
|
|
}
|
|
else
|
|
{
|
|
// Use the first non SPLIT_GSN CVGSN as current one
|
|
|
|
pCurGsn = pcvGsn;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if ((prevGsn == 0) ||
|
|
(mpgsnseg[gsnInfo.gsn] != mpgsnseg[prevGsn]) ||
|
|
fChangeInSource ||
|
|
fComdatSplit)
|
|
{
|
|
// Make new CVGSN
|
|
// Remember LOGICAL segment
|
|
|
|
pCurGsn = (CVGSN FAR *) GetMem(sizeof(CVGSN));
|
|
pCurGsn->seg = mpgsnseg[gsnInfo.gsn];
|
|
|
|
// The start and end offset will be derived from line number/offset pairs
|
|
|
|
pCurGsn->raStart = 0xffffffff;
|
|
if (fComdatSplit)
|
|
pCurGsn->flags |= SPLIT_GSN;
|
|
if (pCurSrc->pGsnFirst == NULL)
|
|
{
|
|
pCurSrc->pGsnFirst = pCurGsn;
|
|
pCurGsn->prev = (CVGSN FAR *) pCurSrc;
|
|
}
|
|
else
|
|
{
|
|
pCurSrc->pGsnLast->next = pCurGsn;
|
|
pCurGsn->prev = pCurSrc->pGsnLast;
|
|
}
|
|
pCurSrc->pGsnLast = pCurGsn;
|
|
pCurSrc->cSegs++;
|
|
#if CVDEBUG
|
|
sbModule[sbModule[0]+1] = '\0';
|
|
fprintf(stdout, "New code segment in '%s'; prevGsn = %x; newGsn = %x %s\r\n", &sbModule[1], prevGsn, gsnInfo.gsn, fComdatSplit ? "COMDAT split" : "");
|
|
#endif
|
|
prevGsn = gsnInfo.gsn;
|
|
}
|
|
|
|
// Get the offset/line bucket
|
|
|
|
if (pCurGsn->pLineFirst == NULL)
|
|
{
|
|
pCurLine = (CVLINE FAR *) GetMem(sizeof(CVLINE));
|
|
pCurGsn->pLineFirst = pCurLine;
|
|
pCurGsn->pLineLast = pCurLine;
|
|
}
|
|
else
|
|
pCurLine = pCurGsn->pLineLast;
|
|
|
|
// Fill in offset/line bucket
|
|
|
|
if (gsnInfo.fComdat)
|
|
gsnStart = gsnInfo.comdatRa;
|
|
else
|
|
gsnStart = mpgsndra[gsnInfo.gsn] - mpsegraFirst[pCurGsn->seg];
|
|
|
|
raPrev = 0xffff;
|
|
while (cbRec > 1) // While not at checksum
|
|
{
|
|
GetLineOff(&line, &ra);
|
|
|
|
ra += gsnStart;
|
|
|
|
// We have to eliminate line pairs with same ra (for MASM 5.1)
|
|
|
|
if(ra == raPrev)
|
|
continue;
|
|
raPrev = ra;
|
|
|
|
// Remember the smallest LOGICAL offset for source line
|
|
|
|
if (ra < pCurGsn->raStart)
|
|
pCurGsn->raStart = ra;
|
|
|
|
if (line != 0)
|
|
{
|
|
if (pCurLine->cPair >= CVLINEMAX)
|
|
{
|
|
pCurLine->next = (CVLINE FAR *) GetMem(sizeof(CVLINE));
|
|
pCurLine = pCurLine->next;
|
|
pCurGsn->pLineLast = pCurLine;
|
|
}
|
|
|
|
pCurLine->rgOff[pCurLine->cPair] = ra;
|
|
pCurLine->rgLn[pCurLine->cPair] = line;
|
|
pCurLine->cPair++;
|
|
pCurSrc->cLines++;
|
|
pCurGsn->cLines++;
|
|
}
|
|
}
|
|
|
|
// Remember last line LOGICAL offset
|
|
|
|
pCurGsn->raEnd = ra;
|
|
#if CVDEBUG
|
|
fprintf(stdout, "New source lines for the 0x%x logical code segment; lines %d\r\n start offset %x:%lx end offset %x:%lx; physical address of logical segment %x:%lx\r\n",
|
|
pCurGsn->seg, pCurGsn->cLines, pCurGsn->seg, pCurGsn->raStart, pCurGsn->seg, pCurGsn->raEnd, mpsegsa[pCurGsn->seg], mpsegraFirst[pCurGsn->seg]);
|
|
#endif
|
|
|
|
// If /LINENUMBERS and list file open, back up
|
|
|
|
if (vfLineNos && fLstFileOpen)
|
|
{
|
|
#if ALIGN_REC
|
|
pbRec += (cbRec - cbRecSav);
|
|
#else
|
|
fseek(bsInput, (long)cbRec - cbRecSav, 1);
|
|
#endif
|
|
cbRec = cbRecSav;
|
|
}
|
|
return(TRUE);
|
|
}
|
|
|
|
#pragma check_stack(off)
|
|
|
|
/*** CheckTables - check space in table used by OutSrcModule
|
|
*
|
|
* Purpose:
|
|
* While building the new source module subsection linker needs
|
|
* to store a lot of information about given source file. Since
|
|
* we can't predict how many source files were compiled to obtain
|
|
* this object module or to how many logical segments this object
|
|
* module contributes code we have to dynamically resize appropriate
|
|
* tables.
|
|
*
|
|
* Input:
|
|
* cFiles - number of source files compiled to produce
|
|
* this object module
|
|
* cSegs - number of logical segments this object module
|
|
* contributes to.
|
|
*
|
|
* Output:
|
|
* No explicit value is returned. As a side effect the following
|
|
* tables are allocated or reallocated:
|
|
*
|
|
* fileBase - table of offsets to source file info
|
|
* raSeg - table of physical starting and ending offsets
|
|
* of the contribution to the logical segments
|
|
* segNo - table of physical segment indicies
|
|
*
|
|
* Exceptions:
|
|
* Memory allocation problems - fatal error and exit.
|
|
*
|
|
* Notes:
|
|
* When we reallocated the tables we don't have to copy
|
|
* their old content, because it was used in the previous
|
|
* object module.
|
|
*
|
|
*************************************************************************/
|
|
|
|
LOCAL void NEAR CheckTables(WORD cFiles, WORD cSegs)
|
|
{
|
|
WORD cCur;
|
|
|
|
cCur = (WORD) (cFiles < cSegs ? cSegs : cFiles);
|
|
if (cCur > cMac)
|
|
{
|
|
// We have to reallocate tables or allocate for the first time
|
|
|
|
if (fileBase)
|
|
FFREE(fileBase);
|
|
if (raSeg)
|
|
FFREE(raSeg);
|
|
if (segNo)
|
|
FFREE(segNo);
|
|
|
|
fileBase = (DWORD FAR *) GetMem(cCur*sizeof(DWORD));
|
|
raSeg = (RAPAIR FAR *) GetMem(cCur*sizeof(RAPAIR));
|
|
segNo = (WORD FAR *) GetMem(cCur*sizeof(WORD));
|
|
cMac = cCur;
|
|
}
|
|
}
|
|
|
|
|
|
/*** OutSrcModule - write CV source module
|
|
*
|
|
* Purpose:
|
|
* Create the CV 4.00 format source module descrbing the source line
|
|
* number to addressing mapping information for one object file
|
|
*
|
|
* Input:
|
|
* - pSrcLines - the list of source file information blocks
|
|
*
|
|
* Output:
|
|
* Total size of the subsection in bytes.
|
|
*
|
|
* Exceptions:
|
|
* None.
|
|
*
|
|
* Notes:
|
|
* None.
|
|
*
|
|
*************************************************************************/
|
|
|
|
|
|
LOCAL DWORD NEAR OutSrcModule(CVSRC FAR *pSrcLines)
|
|
{
|
|
CVSRC FAR *pCurSrc; // Pointer to current source file
|
|
CVGSN FAR *pCurGsn; // Pointer to current code segment
|
|
CVLINE FAR *pLine; // Pointer to source line bucket
|
|
WORD cFiles; // Number of source files
|
|
WORD cSegs; // Number of code segments
|
|
WORD xFile;
|
|
WORD xSeg;
|
|
DWORD sizeTotal; // Size of source subsection
|
|
DWORD srcLnBase;
|
|
WORD counts[2];
|
|
CVLINE FAR *pTmp;
|
|
|
|
|
|
#if SRCDEBUG
|
|
DumpSrcLines(vaLines);
|
|
#endif
|
|
|
|
// Count total number of source files, total number of code segments
|
|
|
|
for (pCurSrc = pSrcLines, cFiles = 0, cSegs = 0; pCurSrc; cFiles++, pCurSrc = pCurSrc->next)
|
|
cSegs += pCurSrc->cSegs;
|
|
|
|
CheckTables(cFiles, cSegs);
|
|
sizeTotal = (DWORD) (2*sizeof(WORD) + cFiles*sizeof(DWORD) +
|
|
cSegs*(sizeof(raSeg[0]) + sizeof(WORD)));
|
|
sizeTotal = Round2Dword(sizeTotal);
|
|
|
|
// Make second pass througth the source files and fill in
|
|
// source module header
|
|
|
|
for (pCurSrc = pSrcLines, xFile = 0, xSeg = 0; xFile < cFiles && pCurSrc; xFile++, pCurSrc = pCurSrc->next)
|
|
{
|
|
fileBase[xFile] = sizeTotal;
|
|
|
|
// Add the size of this source file information:
|
|
//
|
|
// Source file header:
|
|
//
|
|
// +------+------+------------+--------------+------+-------------+
|
|
// | WORD | WORD | cSeg*DWORD | 2*cSeg*DWORD | BYTE | cbName*BYTE |
|
|
// +------+------+------------+--------------+------+-------------+
|
|
//
|
|
|
|
sizeTotal += (2*sizeof(WORD) +
|
|
pCurSrc->cSegs*(sizeof(DWORD) + sizeof(raSeg[0])) +
|
|
sizeof(BYTE) + pCurSrc->fname[0]);
|
|
|
|
// Pad to DWORD boundary
|
|
|
|
sizeTotal = Round2Dword(sizeTotal);
|
|
|
|
// Walk code segment list
|
|
|
|
for (pCurGsn = pCurSrc->pGsnFirst; pCurGsn; pCurGsn = pCurGsn->next, xSeg++)
|
|
{
|
|
raSeg[xSeg].raStart = pCurGsn->raStart;
|
|
raSeg[xSeg].raEnd = pCurGsn->raEnd;
|
|
segNo[xSeg] = pCurGsn->seg;
|
|
|
|
// Add size of the offset/line table
|
|
//
|
|
// +------+------+-------------+------------+
|
|
// | WORD | WORD | cLine*DWORD | cLine*WORD |
|
|
// +------+------+-------------+------------+
|
|
|
|
sizeTotal += (2*sizeof(WORD) +
|
|
pCurGsn->cLines*(sizeof(DWORD) + sizeof(WORD)));
|
|
|
|
// Pad to DWORD boundary
|
|
|
|
sizeTotal = Round2Dword(sizeTotal);
|
|
}
|
|
}
|
|
|
|
// Write source module header
|
|
|
|
counts[0] = cFiles;
|
|
counts[1] = cSegs;
|
|
WriteCopy(counts, sizeof(counts));
|
|
WriteCopy(fileBase, cFiles*sizeof(DWORD));
|
|
WriteCopy(raSeg, cSegs*sizeof(RAPAIR));
|
|
WriteCopy(segNo, cSegs*sizeof(WORD));
|
|
|
|
// Pad to DWORD boundary
|
|
|
|
Pad2Dword();
|
|
|
|
// Make third pass througth the source files and fill in
|
|
// the source file header and write offset/line pairs
|
|
|
|
for (pCurSrc = pSrcLines, srcLnBase = fileBase[0]; pCurSrc != NULL;
|
|
pCurSrc = pCurSrc->next, xFile++)
|
|
{
|
|
// Add the size of source file header:
|
|
//
|
|
// +------+------+------------+--------------+------+-------------+
|
|
// | WORD | WORD | cSeg*DWORD | 2*cSeg*DWORD | BYTE | cbName*BYTE |
|
|
// +------+------+------------+--------------+------+-------------+
|
|
//
|
|
|
|
srcLnBase += (2*sizeof(WORD) +
|
|
pCurSrc->cSegs*(sizeof(DWORD) + sizeof(raSeg[0])) +
|
|
sizeof(BYTE) + pCurSrc->fname[0]);
|
|
|
|
// Round to DWORD boundary
|
|
|
|
srcLnBase = Round2Dword(srcLnBase);
|
|
|
|
// Walk code segment list and store base offsets for source
|
|
// line offset/line pairs and record start/stop offsets of
|
|
// code segments
|
|
|
|
for (xSeg = 0, pCurGsn = pCurSrc->pGsnFirst; pCurGsn != NULL;
|
|
pCurGsn = pCurGsn->next, xSeg++)
|
|
{
|
|
fileBase[xSeg] = srcLnBase;
|
|
srcLnBase += (2*sizeof(WORD) +
|
|
pCurGsn->cLines*(sizeof(DWORD) + sizeof(WORD)));
|
|
|
|
// Round to DWORD boundary
|
|
|
|
srcLnBase = Round2Dword(srcLnBase);
|
|
raSeg[xSeg].raStart = pCurGsn->raStart;
|
|
raSeg[xSeg].raEnd = pCurGsn->raEnd;
|
|
}
|
|
|
|
// Write source file header
|
|
|
|
counts[0] = (WORD) pCurSrc->cSegs;
|
|
counts[1] = 0;
|
|
WriteCopy(counts, sizeof(counts));
|
|
WriteCopy(fileBase, pCurSrc->cSegs*sizeof(DWORD));
|
|
WriteCopy(raSeg, pCurSrc->cSegs*sizeof(RAPAIR));
|
|
WriteCopy(pCurSrc->fname, pCurSrc->fname[0] + 1);
|
|
|
|
// Pad to DWORD boundary
|
|
|
|
Pad2Dword();
|
|
|
|
// Walk code segment list and write offsets/line pairs
|
|
|
|
for (pCurGsn = pCurSrc->pGsnFirst; pCurGsn != NULL; pCurGsn = pCurGsn->next)
|
|
{
|
|
// Write segment index and number of offset/line pairs
|
|
|
|
counts[0] = pCurGsn->seg;
|
|
counts[1] = pCurGsn->cLines;
|
|
WriteCopy(counts, sizeof(counts));
|
|
|
|
// Write offsets
|
|
|
|
for (pLine = pCurGsn->pLineFirst; pLine != NULL; pLine = pLine->next)
|
|
WriteCopy(&(pLine->rgOff), pLine->cPair * sizeof(DWORD));
|
|
|
|
// Write line numbers
|
|
|
|
for (pLine = pCurGsn->pLineFirst; pLine != NULL; pLine = pLine->next)
|
|
WriteCopy(&(pLine->rgLn), pLine->cPair * sizeof(WORD));
|
|
|
|
// Pad to DWORD boundary
|
|
|
|
Pad2Dword();
|
|
|
|
// Free memory
|
|
|
|
for (pLine = pCurGsn->pLineFirst; pLine != NULL;)
|
|
{
|
|
pTmp = pLine->next;
|
|
FFREE(pLine);
|
|
pLine = pTmp;
|
|
}
|
|
}
|
|
}
|
|
return(sizeTotal);
|
|
}
|
|
|
|
|
|
/*** SaveCode - save code segment information in MODULES entry
|
|
*
|
|
* Purpose:
|
|
* For every module (.OBJ file) save the information about code segments
|
|
* this module contributes to. COMDATs are threated as contibutions to
|
|
* the logical segment, so each gets its entry in the CVCODE list attached
|
|
* to the given .OBJ file (module).
|
|
*
|
|
* Input:
|
|
* gsn - global segment index of logical segment to which this module
|
|
* contributes
|
|
* cb - size (in bytes) of contribution
|
|
* raInit - offset of the contribution inside the logical segment; this
|
|
* nonzero only for COMDATs.
|
|
*
|
|
* Output:
|
|
* No explicit value is returned. The list of CVCODE attached to the
|
|
* .OBJ file (module) is updated.
|
|
*
|
|
* Exceptions:
|
|
* None.
|
|
*
|
|
* Notes:
|
|
* None.
|
|
*
|
|
*************************************************************************/
|
|
|
|
void SaveCode(SNTYPE gsn, DWORD cb, DWORD raInit)
|
|
{
|
|
CVCODE FAR *pSegCur; // Pointer to the current code segment
|
|
APROPFILEPTR apropFile;
|
|
|
|
apropFile = (APROPFILEPTR) vrpropFile;
|
|
|
|
// Save code segment if module has CV info
|
|
|
|
pSegCur = (CVCODE FAR *) GetMem(sizeof(CVCODE));
|
|
|
|
// Store LOGICAL segment, offset and size of the contribution
|
|
|
|
pSegCur->seg = mpgsnseg[gsn];
|
|
if (raInit != 0xffffffffL)
|
|
pSegCur->ra = raInit;
|
|
else
|
|
pSegCur->ra = mpgsndra[gsn] - mpsegraFirst[mpgsnseg[gsn]];
|
|
pSegCur->cb = cb;
|
|
|
|
// Add to the CV code list
|
|
|
|
if (apropFile->af_Code == NULL)
|
|
apropFile->af_Code = pSegCur;
|
|
else
|
|
apropFile->af_CodeLast->next = pSegCur;
|
|
apropFile->af_CodeLast = pSegCur;
|
|
apropFile->af_cCodeSeg++;
|
|
}
|
|
|
|
/****************************************************************
|
|
* *
|
|
* DO SYMBOLIC DEBUG STUFF FOR MODULE JUST PROCESSED. *
|
|
* Pass 2. *
|
|
* *
|
|
****************************************************************/
|
|
|
|
void DebMd2(void)
|
|
{
|
|
APROPFILEPTR apropFile;
|
|
|
|
sbLastModule[0] = 0; /* Force recognition of new THEADR */
|
|
apropFile = (APROPFILEPTR) vrpropFile;
|
|
if (apropFile->af_cvInfo)
|
|
++segDebLast;
|
|
}
|
|
|
|
/*** PutDnt - store subsection directory entry in the table
|
|
*
|
|
* Purpose:
|
|
* Copy current subsection directory to the DNT table. If no more
|
|
* room in the table reallocate table doubling its size.
|
|
*
|
|
* Input:
|
|
* - pDnt - pointer to the current directory entry
|
|
*
|
|
* Output:
|
|
* No explicit value is returned.
|
|
*
|
|
* Exceptions:
|
|
* None.
|
|
*
|
|
* Notes:
|
|
* None.
|
|
*
|
|
*************************************************************************/
|
|
|
|
LOCAL void NEAR PutDnt(DNT *pDnt)
|
|
{
|
|
WORD newSize;
|
|
if (dntMac >= dntMax)
|
|
{
|
|
if(dntMax)
|
|
{
|
|
newSize = dntMax << 1;
|
|
#if defined(M_I386) || defined( _WIN32 )
|
|
rgDnt = (DNT *) REALLOC(rgDnt, newSize * sizeof(DNT));
|
|
#else
|
|
rgDnt = (DNT FAR *) _frealloc(rgDnt, newSize * sizeof(DNT));
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
newSize = DNT_START;
|
|
rgDnt = (DNT*) GetMem ( newSize * sizeof(DNT) );
|
|
}
|
|
if (rgDnt == NULL)
|
|
Fatal(ER_memovf);
|
|
dntMax = newSize;
|
|
}
|
|
|
|
|
|
|
|
rgDnt[dntMac] = *pDnt;
|
|
dntMac++;
|
|
#if CVDEBUG
|
|
DumpDNT(pDnt);
|
|
#endif
|
|
}
|
|
|
|
#pragma check_stack(on)
|
|
|
|
/*** OutModule - write out module subsection
|
|
*
|
|
* Purpose:
|
|
* Write into the executable file the module subsections for all
|
|
* object files compiled with CV information. Only CV 4.0 format.
|
|
*
|
|
* Input:
|
|
* - apropFile - pointer to the current object file descriptor
|
|
*
|
|
* Output:
|
|
* No explicit value is retuned.
|
|
* Side effects:
|
|
* - module subsections in executable file
|
|
*
|
|
* Exceptions:
|
|
* None.
|
|
*
|
|
* Notes:
|
|
* None.
|
|
*
|
|
*************************************************************************/
|
|
|
|
LOCAL DWORD NEAR OutModule(APROPFILEPTR apropFile)
|
|
{
|
|
SBTYPE sbName;
|
|
SSTMOD4 module;
|
|
CVCODE FAR *pSegCur;
|
|
CODEINFO codeOnt;
|
|
WORD cOnt;
|
|
|
|
|
|
module.ovlNo = (WORD) apropFile->af_iov;
|
|
module.iLib = (WORD) (apropFile->af_ifh + 1);
|
|
module.cSeg = apropFile->af_cCodeSeg;
|
|
module.style[0] = 'C';
|
|
module.style[1] = 'V';
|
|
|
|
// Get file name or library module name
|
|
|
|
if (apropFile->af_ifh != FHNIL && apropFile->af_rMod != RHTENIL)
|
|
GetName((AHTEPTR) apropFile->af_rMod, sbName);
|
|
else
|
|
GetName((AHTEPTR) apropFile, sbName);
|
|
|
|
#if CVDEBUG
|
|
sbName[sbName[0]+1] = '\0';
|
|
fprintf(stdout, "\r\nCV info for %s\r\n", &sbName[1]);
|
|
#endif
|
|
|
|
// Write sstModule header followed by the list of code contributions
|
|
|
|
WriteCopy(&module, sizeof(SSTMOD4));
|
|
pSegCur = apropFile->af_Code;
|
|
codeOnt.pad = 0;
|
|
for (cOnt = 0; cOnt < module.cSeg && pSegCur; cOnt++, pSegCur = pSegCur->next)
|
|
{
|
|
codeOnt.seg = pSegCur->seg;
|
|
codeOnt.off = pSegCur->ra;
|
|
codeOnt.cbOnt = pSegCur->cb;
|
|
WriteCopy(&codeOnt, sizeof(CODEINFO));
|
|
#if CVDEBUG
|
|
fprintf(stdout, " Logical segment %d; offset 0x%lx; size 0x%lx\r\n",
|
|
codeOnt.seg, codeOnt.off, codeOnt.cbOnt);
|
|
#endif
|
|
}
|
|
|
|
// Write object file name
|
|
|
|
WriteCopy(sbName, B2W(sbName[0]) + 1);
|
|
return(sizeof(SSTMOD4) + B2W(sbName[0]) + 1 + module.cSeg * sizeof(CODEINFO));
|
|
}
|
|
|
|
|
|
/*** OutPublics - write sstPublics subsection
|
|
*
|
|
* Purpose:
|
|
* Write sstPublics subsection of the CV information. The subsection
|
|
* conforms to the new CV 4.0 format.
|
|
*
|
|
* Input:
|
|
* - firstPub - virtual pointer to the list of public symbols defined
|
|
* in a given object module
|
|
*
|
|
* Output:
|
|
* Total size of the subsection in bytes.
|
|
*
|
|
* Exceptions:
|
|
* None.
|
|
*
|
|
* Notes:
|
|
* None.
|
|
*
|
|
*************************************************************************/
|
|
|
|
LOCAL DWORD NEAR OutPublics(RBTYPE firstPub)
|
|
{
|
|
PUB16 pub16; // CV public descriptor - 16-bit
|
|
PUB32 pub32; // CV public descriptor - 32-bit
|
|
APROPNAMEPTR apropPub; // Real pointer to public descriptor
|
|
APROPSNPTR apropSn; // Real pointer to segment descriptor
|
|
RBTYPE curPub; // Virtual pointer to the current public symbol
|
|
WORD f32Bit; // TRUE if public defined in 32-bit segment
|
|
DWORD sizeTotal; // Total size of subsection
|
|
SNTYPE seg; // Symbol base
|
|
RATYPE ra; // Symbol offset
|
|
WORD CVtype; // CV info type index
|
|
SBTYPE sbName; // Public symbol
|
|
char *pPub;
|
|
WORD len;
|
|
|
|
|
|
// Initialize
|
|
|
|
curPub = firstPub;
|
|
pub16.idx = S_PUB16;
|
|
pub32.idx = S_PUB32;
|
|
sizeTotal = 1L;
|
|
WriteCopy(&sizeTotal, sizeof(DWORD));// sstPublicSym signature
|
|
sizeTotal = sizeof(DWORD);
|
|
while (curPub != 0L)
|
|
{
|
|
f32Bit = FALSE;
|
|
apropPub = (APROPNAMEPTR) FETCHSYM(curPub, FALSE);
|
|
curPub = apropPub->an_sameMod;
|
|
if (apropPub->an_attr == ATTRALIAS)
|
|
apropPub = (APROPNAMEPTR) FETCHSYM(((APROPALIASPTR) apropPub)->al_sym, FALSE);
|
|
|
|
if (apropPub->an_attr != ATTRPNM)
|
|
continue;
|
|
|
|
ra = apropPub->an_ra;
|
|
if (apropPub->an_gsn) // If not absolute symbol
|
|
{
|
|
seg = mpgsnseg[apropPub->an_gsn];
|
|
// If this is a .com program and the segment is the one
|
|
// moved by 0x100, adjust accordingly the SegMap entry
|
|
if(seg == segAdjCom)
|
|
{
|
|
#if FALSE
|
|
GetName((AHTEPTR) apropPub, sbName);
|
|
sbName[sbName[0]+1] = '\0';
|
|
fprintf(stdout, "\r\nCorrecting public %s : %lx -> %lx", sbName+1, ra, ra+0x100);
|
|
fflush(stdout);
|
|
#endif
|
|
ra += 0x100;
|
|
}
|
|
|
|
CVtype = 0; // Should be this apropPub->an_CVtype
|
|
// but cvpack can't handle it.
|
|
#if O68K
|
|
if (iMacType == MAC_NONE)
|
|
#endif
|
|
ra -= mpsegraFirst[seg];
|
|
#if CVDEBUG
|
|
GetName((AHTEPTR) apropPub, sbName);
|
|
sbName[sbName[0]+1] = '\0';
|
|
fprintf(stdout, "'%s' --> logical address %2x:%lx; physical address %2x:%lx\r\n",
|
|
&sbName[1], seg, ra, mpsegsa[seg], apropPub->an_ra);
|
|
#endif
|
|
apropSn = (APROPSNPTR) FETCHSYM(mpgsnrprop[apropPub->an_gsn], FALSE);
|
|
#if EXE386
|
|
f32Bit = TRUE;
|
|
#else
|
|
f32Bit = (WORD) Is32BIT(apropSn->as_flags);
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
seg = 0; // Else no base
|
|
CVtype = T_ABS; // CV absolute symbol type
|
|
f32Bit = (WORD) (ra > LXIVK);
|
|
}
|
|
|
|
GetName((AHTEPTR) apropPub, sbName);
|
|
|
|
if (f32Bit)
|
|
{
|
|
pub32.len = (WORD) (sizeof(PUB32) + B2W(sbName[0]) + 1 - sizeof(WORD));
|
|
pub32.off = ra;
|
|
pub32.seg = seg;
|
|
pub32.type = CVtype;
|
|
pPub = (char *) &pub32;
|
|
len = sizeof(PUB32);
|
|
}
|
|
else
|
|
{
|
|
pub16.len = (WORD) (sizeof(PUB16) + B2W(sbName[0]) + 1 - sizeof(WORD));
|
|
pub16.off = (WORD) ra;
|
|
pub16.seg = seg;
|
|
pub16.type = CVtype;
|
|
pPub = (char *) &pub16;
|
|
len = sizeof(PUB16);
|
|
}
|
|
WriteCopy(pPub, len);
|
|
|
|
// Output length-prefixed name
|
|
|
|
WriteCopy(sbName, sbName[0] + 1);
|
|
sizeTotal += (len + B2W(sbName[0]) + 1);
|
|
}
|
|
return(sizeTotal);
|
|
}
|
|
|
|
/*** OutSegMap - write segment map
|
|
*
|
|
* Purpose:
|
|
* This subsection was introduced in CV 4.0. This subsection
|
|
* maps the logical segments to physical segments. It also gives
|
|
* the names and sizes of each logical segment.
|
|
*
|
|
* Input:
|
|
* No explicit value is passed.
|
|
* Global variables:
|
|
* - mpsegsa - table mapping logical segment number to its physical
|
|
* segment number or address
|
|
* - mpsaflags - table mapping physicla segment index to its flags
|
|
* - mpseggsn - table mapping the logical segment index to its global
|
|
* segment index
|
|
* - mpgsnprop - table mapping global segment index to its symbol table
|
|
* descriptor
|
|
* - mpggrgsn - table mapping global group index to global segment index
|
|
* - mpggrrhte - table mapping global group index to group name
|
|
*
|
|
* Output:
|
|
* Function returns the size of segment map.
|
|
*
|
|
* Exceptions:
|
|
* None.
|
|
*
|
|
* Notes:
|
|
* None.
|
|
*
|
|
*************************************************************************/
|
|
|
|
LOCAL DWORD NEAR OutSegMap(void)
|
|
{
|
|
SEGTYPE seg; // Logical segment index
|
|
APROPSNPTR apropSn; // Real pointer to logical segment descriptor
|
|
SATYPE sa; // Physical segment index
|
|
WORD iName; // Index to free space in segment name table
|
|
DWORD sizeTotal; // Total size of the subsection
|
|
SEGINFO segInfo; // CV segment descriptor
|
|
SBTYPE segName; // Segment name
|
|
AHTEPTR ahte; // Real pointer to symbol table hash table
|
|
RBTYPE vpClass; // Virtual pointer to class descriptor
|
|
GRTYPE ggr; // Global group index
|
|
SATYPE saDGroup; // DGroup's sa
|
|
WORD counts[2];
|
|
|
|
iName = 0;
|
|
counts[0] = (WORD) (segLast + ggrMac - 1);
|
|
counts[1] = (WORD) segLast;
|
|
WriteCopy(counts, sizeof(counts));
|
|
sizeTotal = sizeof(counts);
|
|
|
|
saDGroup = mpsegsa[mpgsnseg[mpggrgsn[ggrDGroup]]];
|
|
|
|
// Write all logical segments
|
|
|
|
for (seg = 1; seg <= segLast; ++seg)// For all logical segments
|
|
{
|
|
memset(&segInfo, 0, sizeof(SEGINFO));
|
|
|
|
if (fNewExe)
|
|
segInfo.flags.fSel = TRUE;
|
|
|
|
sa = mpsegsa[seg];
|
|
|
|
if (fNewExe)
|
|
{
|
|
#if EXE386
|
|
segInfo.flags.f32Bit = TRUE;
|
|
#else
|
|
segInfo.flags.f32Bit = (WORD) (Is32BIT(mpsaflags[sa]));
|
|
#endif
|
|
|
|
if (IsDataFlg(mpsaflags[sa]))
|
|
{
|
|
segInfo.flags.fRead = TRUE;
|
|
#if EXE386
|
|
if (IsWRITEABLE(mpsaflags[sa]))
|
|
#else
|
|
if (!(mpsaflags[sa] & NSEXRD))
|
|
#endif
|
|
segInfo.flags.fWrite = TRUE;
|
|
}
|
|
else
|
|
{
|
|
segInfo.flags.fExecute = TRUE;
|
|
|
|
#if EXE386
|
|
if (IsREADABLE(mpsaflags[sa]))
|
|
#else
|
|
if (!(mpsaflags[sa] & NSEXRD))
|
|
#endif
|
|
segInfo.flags.fRead = TRUE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (mpsegFlags[seg] & FCODE)
|
|
{
|
|
segInfo.flags.fRead = TRUE;
|
|
segInfo.flags.fExecute = TRUE;
|
|
}
|
|
else
|
|
{
|
|
segInfo.flags.fRead = TRUE;
|
|
segInfo.flags.fWrite = TRUE;
|
|
}
|
|
}
|
|
|
|
// Look up segment definition
|
|
|
|
apropSn = (APROPSNPTR) FETCHSYM(mpgsnrprop[mpseggsn[seg]], FALSE);
|
|
vpClass = apropSn->as_rCla;
|
|
#if OVERLAYS
|
|
if (!fNewExe)
|
|
segInfo.ovlNbr = apropSn->as_iov;
|
|
#endif
|
|
// if segment doesn't belong to any group it's ggr is 0
|
|
if (apropSn->as_ggr != GRNIL)
|
|
segInfo.ggr = (WORD) (apropSn->as_ggr + segLast - 1);
|
|
|
|
// If segment is a DGROUP member, write DGROUP normalized address
|
|
|
|
if(apropSn->as_ggr == ggrDGroup)
|
|
{
|
|
segInfo.sa = saDGroup;
|
|
segInfo.phyOff = mpsegraFirst[seg] + ((sa - saDGroup) << 4);
|
|
}
|
|
else
|
|
{
|
|
segInfo.sa = sa;
|
|
segInfo.phyOff = mpsegraFirst[seg];
|
|
}
|
|
// If this is a .com program and the segment is the one moved by 0x100
|
|
// write all the publics at the original addresses, because the offset
|
|
// adjustment will be made in the SegMap table
|
|
if(seg == segAdjCom)
|
|
{
|
|
segInfo.phyOff -= 0x100;
|
|
}
|
|
segInfo.cbSeg = apropSn->as_cbMx;
|
|
GetName((AHTEPTR) apropSn, segName);
|
|
if (segName[0] != '\0')
|
|
{
|
|
segInfo.isegName = iName;
|
|
iName += (WORD) (B2W(segName[0]) + 1);
|
|
}
|
|
else
|
|
segInfo.isegName = 0xffff;
|
|
ahte = (AHTEPTR) FETCHSYM(vpClass, FALSE);
|
|
if (ahte->cch[0] != 0)
|
|
{
|
|
segInfo.iclassName = iName;
|
|
iName += (WORD) (B2W(ahte->cch[0]) + 1);
|
|
}
|
|
else
|
|
segInfo.iclassName = 0xffff;
|
|
WriteCopy(&segInfo, sizeof(SEGINFO));
|
|
sizeTotal += sizeof(SEGINFO);
|
|
}
|
|
|
|
// Write all groups
|
|
|
|
for (ggr = 1; ggr < ggrMac; ggr++)
|
|
{
|
|
memset(&segInfo, 0, sizeof(SEGINFO));
|
|
|
|
segInfo.flags.fGroup = TRUE;
|
|
|
|
if (fNewExe)
|
|
segInfo.flags.fSel = TRUE;
|
|
|
|
segInfo.sa = mpsegsa[mpgsnseg[mpggrgsn[ggr]]];
|
|
|
|
if (fNewExe)
|
|
segInfo.cbSeg = mpsacb[segInfo.sa];
|
|
else
|
|
{
|
|
segInfo.cbSeg = 0L;
|
|
if (mpggrgsn[ggr] != SNNIL)
|
|
{
|
|
// If group has members
|
|
|
|
for (seg = 1; seg <= segLast; seg++)
|
|
{
|
|
apropSn = (APROPSNPTR) FETCHSYM(mpgsnrprop[mpseggsn[seg]], FALSE);
|
|
if (apropSn->as_ggr == ggr)
|
|
{
|
|
segInfo.cbSeg += apropSn->as_cbMx;
|
|
#if OVERLAYS
|
|
segInfo.ovlNbr = apropSn->as_iov;
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
}
|
|
segInfo.isegName = iName;
|
|
ahte = (AHTEPTR) FETCHSYM(mpggrrhte[ggr], FALSE);
|
|
iName += (WORD) (B2W(ahte->cch[0]) + 1);
|
|
segInfo.iclassName = 0xffff;
|
|
WriteCopy(&segInfo, sizeof(SEGINFO));
|
|
sizeTotal += sizeof(SEGINFO);
|
|
}
|
|
return(sizeTotal);
|
|
}
|
|
|
|
/*** OutSegNames - write segment name table
|
|
*
|
|
* Purpose:
|
|
* This subsection was introduced in CV 4.0.
|
|
* The segment name subsection contains all of the logical segment,
|
|
* class and group names. Each name is a zero terminated ASCII string.
|
|
*
|
|
* Input:
|
|
* No explicit value is passed.
|
|
* Global variables:
|
|
* - mpseggsn - table mapping the logical segment index to its global
|
|
* segment index
|
|
* - mpgsnprop - table mapping global segment index to its symbol table
|
|
* descriptor
|
|
* - mpggrrhte - table mapping global group index to group name
|
|
*
|
|
* Output:
|
|
* Function returns the size of segment name table.
|
|
*
|
|
* Exceptions:
|
|
* None.
|
|
*
|
|
* Notes:
|
|
* None.
|
|
*
|
|
*************************************************************************/
|
|
|
|
LOCAL DWORD NEAR OutSegNames(void)
|
|
{
|
|
SEGTYPE seg; // Logical segment index
|
|
APROPSNPTR apropSn; // Real pointer to logical segment descriptor
|
|
DWORD sizeTotal; // Size of the segment name table
|
|
SBTYPE name; // A name
|
|
RBTYPE vpClass; // Virtual pointer to class descriptor
|
|
GRTYPE ggr; // Global group index
|
|
|
|
|
|
|
|
sizeTotal = 0L;
|
|
|
|
// Write names of all logical segments
|
|
|
|
for (seg = 1; seg <= segLast; ++seg)
|
|
{
|
|
// Look up segment definition
|
|
|
|
apropSn = (APROPSNPTR ) FETCHSYM(mpgsnrprop[mpseggsn[seg]], FALSE);
|
|
vpClass = apropSn->as_rCla;
|
|
GetName((AHTEPTR) apropSn, name);
|
|
WriteCopy(&name[1], B2W(name[0]) + 1);
|
|
sizeTotal += (B2W(name[0]) + 1);
|
|
GetName((AHTEPTR ) FETCHSYM(vpClass, FALSE), name);
|
|
WriteCopy(&name[1], B2W(name[0]) + 1);
|
|
sizeTotal += (B2W(name[0]) + 1);
|
|
}
|
|
|
|
// Write names of all groups
|
|
|
|
for (ggr = 1; ggr < ggrMac; ggr++)
|
|
{
|
|
GetName((AHTEPTR ) FETCHSYM(mpggrrhte[ggr], FALSE), name);
|
|
WriteCopy(&name[1], B2W(name[0]) + 1);
|
|
sizeTotal += (B2W(name[0]) + 1);
|
|
}
|
|
return(sizeTotal);
|
|
}
|
|
|
|
/*** OutSst - write subsections
|
|
*
|
|
* Purpose:
|
|
* For every object file with CV information write its sstModule,
|
|
* sstTypes, sstPublics, sstSymbols and sstSrcModule.
|
|
* Build subsection directory.
|
|
*
|
|
* Input:
|
|
* No explicit value is passed.
|
|
* Global variables used:
|
|
* - rprop1stFile - virtual pointer to the first object file descriptor
|
|
*
|
|
* Output:
|
|
* No explicit value is returned.
|
|
* Side effects:
|
|
* - subsections in the executable file
|
|
* - subsection directory in the VM
|
|
*
|
|
* Exceptions:
|
|
* I/O errors - display error message and quit
|
|
*
|
|
* Notes:
|
|
* None.
|
|
*
|
|
*************************************************************************/
|
|
|
|
LOCAL void NEAR OutSst(void)
|
|
{
|
|
APROPFILEPTR apropFile; // Real pointer to file entry
|
|
RBTYPE rbFileNext; // Virtual pointer the next file descriptor
|
|
struct dnt dntCur; // Current subsection directory entry
|
|
CVINFO FAR *pCvInfo; // Pointer to the CV info descriptor
|
|
|
|
#if CVPACK_SHARED
|
|
#if REVERSE_MODULE_ORDER_FOR_CVPACK
|
|
|
|
RBTYPE rbFileCur;
|
|
RBTYPE rbFileLast;
|
|
|
|
// reverse module list in place
|
|
// I've been waiting all my life to actually *need* this code... [rm]
|
|
|
|
// this will cause us to write the modules tables in REVERSE order
|
|
// (this gives better swapping behaviour in the cvpack phase
|
|
// because the modules cvpack will visit first will be the ones that
|
|
// are still resident...
|
|
|
|
rbFileCur = rprop1stFile;
|
|
rbFileLast = NULL;
|
|
while (rbFileCur != NULL)
|
|
{
|
|
apropFile = (APROPFILEPTR ) FETCHSYM(rbFileCur, TRUE);
|
|
rbFileNext = apropFile->af_FNxt;// Get pointer to next file
|
|
apropFile->af_FNxt = rbFileLast;
|
|
rbFileLast = rbFileCur;
|
|
rbFileCur = rbFileNext;
|
|
}
|
|
rprop1stFile = rbFileLast;
|
|
#endif
|
|
|
|
#endif
|
|
|
|
rbFileNext = rprop1stFile;
|
|
dntCur.iMod = 1;
|
|
while (rbFileNext != NULL) // For every module
|
|
{
|
|
apropFile = (APROPFILEPTR ) FETCHSYM(rbFileNext, TRUE);
|
|
rbFileNext = apropFile->af_FNxt;// Get pointer to next file
|
|
|
|
// Skip this module if no debug info for it
|
|
|
|
if (!apropFile->af_cvInfo && !apropFile->af_publics && !apropFile->af_Src)
|
|
continue;
|
|
|
|
pCvInfo = apropFile->af_cvInfo;
|
|
|
|
// sstModules
|
|
|
|
dntCur.sst = SSTMODULES4;
|
|
dntCur.lfo = FTELL_BSRUNFILE() - lfaBase;
|
|
dntCur.cb = OutModule(apropFile);
|
|
PutDnt(&dntCur);
|
|
|
|
// sstTypes
|
|
|
|
if (pCvInfo && pCvInfo->cv_cbTyp > 0L)
|
|
{
|
|
Pad2Dword();
|
|
if (apropFile->af_flags & FPRETYPES)
|
|
dntCur.sst = SSTPRETYPES;
|
|
else
|
|
dntCur.sst = SSTTYPES4;
|
|
dntCur.lfo = FTELL_BSRUNFILE() - lfaBase;
|
|
dntCur.cb = pCvInfo->cv_cbTyp;
|
|
WriteNocopy(pCvInfo->cv_typ, pCvInfo->cv_cbTyp);
|
|
IF_NOT_CVPACK_SHARED(FFREE(pCvInfo->cv_typ));
|
|
PutDnt(&dntCur);
|
|
}
|
|
|
|
// sstPublics
|
|
|
|
if (apropFile->af_publics && !fSkipPublics)
|
|
{
|
|
Pad2Dword();
|
|
dntCur.sst = SSTPUBLICSYM;
|
|
dntCur.lfo = FTELL_BSRUNFILE() - lfaBase;
|
|
dntCur.cb = OutPublics(apropFile->af_publics);
|
|
PutDnt(&dntCur);
|
|
}
|
|
|
|
// sstSymbols
|
|
|
|
if (pCvInfo && pCvInfo->cv_cbSym > 0L)
|
|
{
|
|
Pad2Dword();
|
|
dntCur.sst = SSTSYMBOLS4;
|
|
dntCur.lfo = FTELL_BSRUNFILE() - lfaBase;
|
|
dntCur.cb = pCvInfo->cv_cbSym;
|
|
WriteNocopy(pCvInfo->cv_sym, pCvInfo->cv_cbSym);
|
|
IF_NOT_CVPACK_SHARED(FFREE(pCvInfo->cv_sym));
|
|
PutDnt(&dntCur);
|
|
}
|
|
|
|
// sstSrcModule
|
|
|
|
if (apropFile->af_Src)
|
|
{
|
|
Pad2Dword();
|
|
dntCur.sst = SSTSRCMODULE;
|
|
dntCur.lfo = FTELL_BSRUNFILE() - lfaBase;
|
|
dntCur.cb = OutSrcModule(apropFile->af_Src);
|
|
PutDnt(&dntCur);
|
|
}
|
|
|
|
dntCur.iMod++;
|
|
}
|
|
|
|
// sstLibraries
|
|
|
|
Pad2Dword();
|
|
dntCur.sst = SSTLIBRARIES4;
|
|
dntCur.iMod = (short) 0xffff;
|
|
dntCur.lfo = FTELL_BSRUNFILE() - lfaBase;
|
|
dntCur.cb = OutLibSec();
|
|
PutDnt(&dntCur);
|
|
|
|
// sstSegMap
|
|
|
|
Pad2Dword();
|
|
dntCur.sst = SSTSEGMAP;
|
|
dntCur.lfo = FTELL_BSRUNFILE() - lfaBase;
|
|
dntCur.cb = OutSegMap();
|
|
PutDnt(&dntCur);
|
|
|
|
// sstSegNames
|
|
|
|
Pad2Dword();
|
|
dntCur.sst = SSTSEGNAME;
|
|
dntCur.lfo = FTELL_BSRUNFILE() - lfaBase;
|
|
dntCur.cb = OutSegNames();
|
|
PutDnt(&dntCur);
|
|
FFREE(fileBase);
|
|
FFREE(raSeg);
|
|
FFREE(segNo);
|
|
}
|
|
|
|
#pragma check_stack(off)
|
|
|
|
/*
|
|
* OutLibSec : Output sstLibraries subsection to bsRunfile
|
|
*
|
|
* Path prefix is stripped from library name.
|
|
* If no libraries, don't output anything.
|
|
*
|
|
* Parameters: none
|
|
* Returns: Number of bytes in Libraries subsection
|
|
*/
|
|
LOCAL int NEAR OutLibSec ()
|
|
{
|
|
WORD ifh;
|
|
AHTEPTR ahte;
|
|
int cb = 0;
|
|
BYTE *pb;
|
|
|
|
if (ifhLibMac == 0)
|
|
return(0);
|
|
|
|
// Libraries subsection consists of a list of library
|
|
// names which will be indexed by library numbers in the
|
|
// sstModules. Those indexes are 1-based.
|
|
|
|
// cb == 0, use it to write a single byte
|
|
WriteCopy(&cb, 1); // 0th entry is null for now
|
|
|
|
cb++;
|
|
for (ifh = 0; ifh < ifhLibMac; ifh++)
|
|
{
|
|
if (mpifhrhte[ifh] != RHTENIL)
|
|
{
|
|
ahte = (AHTEPTR) FETCHSYM(mpifhrhte[ifh],FALSE);
|
|
#if OSXENIX
|
|
pb = GetFarSb(ahte->cch);
|
|
#else
|
|
pb = StripDrivePath(GetFarSb(ahte->cch));
|
|
#endif
|
|
}
|
|
else
|
|
pb = "";
|
|
WriteCopy(pb, pb[0] + 1);
|
|
cb += 1 + B2W(pb[0]);
|
|
}
|
|
return(cb);
|
|
}
|
|
|
|
/*** OutDntDir - write subsection directory
|
|
*
|
|
* Purpose:
|
|
* Write subsection directory
|
|
*
|
|
* Input:
|
|
* No explicit value is passed.
|
|
* Global variables:
|
|
* - dntPageMac - number of VM pages with DNTs
|
|
*
|
|
* Output:
|
|
* Function returns the size of the directory in bytes.
|
|
*
|
|
* Exceptions:
|
|
* I/O problems - display error message and quit
|
|
*
|
|
* Notes:
|
|
* None.
|
|
*
|
|
*************************************************************************/
|
|
|
|
|
|
LOCAL DWORD NEAR OutDntDir(void)
|
|
{
|
|
DNTHDR hdr; // Directory header
|
|
|
|
|
|
hdr.cbDirHeader = sizeof(DNTHDR);
|
|
hdr.cbDirEntry = sizeof(DNT);
|
|
hdr.cDir = dntMac;
|
|
hdr.lfoDirNext = 0L;
|
|
hdr.flags = 0L;
|
|
|
|
// Write header
|
|
|
|
WriteCopy(&hdr, sizeof(DNTHDR));
|
|
|
|
// Write directory
|
|
|
|
WriteCopy((char FAR *) rgDnt, dntMac * sizeof(DNT));
|
|
FFREE(rgDnt);
|
|
return(sizeof(DNTHDR) + dntMac * sizeof(DNT));
|
|
}
|
|
|
|
/*** OutDebSection - allow debugging
|
|
*
|
|
* Purpose:
|
|
* Append to the executable file the CV information. ONLY CV 4.00
|
|
* format supported.
|
|
*
|
|
* Input:
|
|
* No explicit value is passed.
|
|
* Global variables:
|
|
* - too many to list
|
|
*
|
|
* Output:
|
|
* No explicit value is returned.
|
|
* Side effects:
|
|
* - what do you think ??
|
|
*
|
|
* Exceptions:
|
|
* I/O problems - display error message and quit
|
|
*
|
|
* Notes:
|
|
* None.
|
|
*
|
|
*************************************************************************/
|
|
|
|
|
|
void OutDebSections(void)
|
|
{
|
|
long lfaDir; // File address of Directory
|
|
DWORD dirSize; // Directory size
|
|
long tmp;
|
|
|
|
|
|
#if CVPACK_SHARED
|
|
long * plfoDir; // pointer to directory data
|
|
|
|
fseek(bsRunfile, 0L, 2); // Go to end of file
|
|
lfaBase = ftell(bsRunfile); // Remember base address
|
|
lposCur = lfaBase; // set current position...
|
|
|
|
WriteCopy(szSignature, sizeof(szSignature)); // Signature dword
|
|
WriteCopy(&tmp, sizeof(tmp)); // Skip lfoDir field
|
|
plfoDir = (long *)rgbl[iblLim-1].pb;// remember address of lfoDir
|
|
|
|
OutSst(); // Output subsections
|
|
|
|
lfaDir = lposCur; // Remember where directory starts
|
|
|
|
*plfoDir = lfaDir - lfaBase; // fix up lfoDir field
|
|
|
|
dirSize = OutDntDir(); // Output subsection directory
|
|
WriteCopy(szSignature, sizeof(szSignature));
|
|
// Signature dword
|
|
tmp = (lfaDir + dirSize + 2*sizeof(DWORD)) - lfaBase;
|
|
WriteCopy(&tmp, sizeof(long)); // Distance from EOF to base
|
|
|
|
// write out the bits that cvpack won't overwrite...
|
|
|
|
if (fCVpack)
|
|
WriteFlushSignature();
|
|
else
|
|
WriteFlushAll();
|
|
|
|
cbRealBytes = ftell(bsRunfile); // # of real bytes actually written
|
|
lposMac = lposCur;
|
|
iblCur = iblNil;
|
|
#else
|
|
fseek(bsRunfile, 0L, 2); // Go to end of file
|
|
lfaBase = FTELL_BSRUNFILE(); // Remember base address
|
|
WriteExe(szSignature, sizeof(szSignature));
|
|
// Signature dword
|
|
fseek(bsRunfile,4L,1); // Skip lfoDir field
|
|
OutSst(); // Output subsections
|
|
lfaDir = FTELL_BSRUNFILE(); // Remember where directory starts
|
|
fseek(bsRunfile, lfaBase + 4, 0); // Go to lfoDir field
|
|
tmp = lfaDir - lfaBase;
|
|
WriteExe(&tmp, sizeof(long)); // Fix it up
|
|
fseek(bsRunfile, lfaDir, 0); // Go back to directory
|
|
dirSize = OutDntDir(); // Output subsection directory
|
|
WriteExe(szSignature, sizeof(szSignature));
|
|
// Signature dword
|
|
tmp = (lfaDir + dirSize + 2*sizeof(DWORD)) - lfaBase;
|
|
WriteExe(&tmp, sizeof(long)); // Distance from EOF to base
|
|
fseek(bsRunfile, 0L, 2); // Seek to EOF just in case
|
|
#endif
|
|
}
|
|
|
|
#if CVPACK_SHARED
|
|
|
|
//
|
|
// write data to cvpack memory cache area
|
|
//
|
|
|
|
void
|
|
WriteSave(FTYPE fCopy, void *pb, UINT cb)
|
|
{
|
|
if (!rgbl)
|
|
{
|
|
rgbl = (BL *)GetMem(sizeof(BL) * C_BL_INIT);
|
|
iblMac = C_BL_INIT;
|
|
iblLim = 0;
|
|
}
|
|
|
|
// if this memory isn't going to stay around, then copy it
|
|
if (fCopy)
|
|
{
|
|
void *pbT = (void *)GetMem(cb);
|
|
memcpy(pbT, pb, cb);
|
|
pb = pbT;
|
|
}
|
|
|
|
if (iblLim == iblMac)
|
|
{
|
|
BL *rgblT;
|
|
|
|
rgblT = (BL *)GetMem(sizeof(BL) * iblMac * 2);
|
|
memcpy(rgblT, rgbl, sizeof(BL) * iblMac);
|
|
iblMac *= 2;
|
|
FFREE(rgbl);
|
|
rgbl = rgblT;
|
|
}
|
|
|
|
rgbl[iblLim].lpos = lposCur;
|
|
rgbl[iblLim].pb = pb;
|
|
iblLim++;
|
|
lposCur += cb;
|
|
}
|
|
|
|
// we want to write a few of the blocks because cvpack won't rewrite the
|
|
// first bit... [rm]
|
|
|
|
void WriteFlushSignature()
|
|
{
|
|
int ibl, cb;
|
|
|
|
// we know that the signature and offset are written in two pieces...
|
|
// if this changes we need to change the magic '2' below [rm]
|
|
|
|
for (ibl = 0; ibl < 2; ibl++)
|
|
{
|
|
cb = rgbl[ibl+1].lpos - rgbl[ibl].lpos;
|
|
WriteExe(rgbl[ibl].pb, cb);
|
|
}
|
|
}
|
|
|
|
void WriteFlushAll()
|
|
{
|
|
int ibl, cb;
|
|
|
|
for (ibl = 0; ibl < iblLim - 1; ibl++)
|
|
{
|
|
cb = rgbl[ibl+1].lpos - rgbl[ibl].lpos;
|
|
WriteExe(rgbl[ibl].pb, cb);
|
|
}
|
|
|
|
cb = lposCur - rgbl[ibl].lpos;
|
|
WriteExe(rgbl[ibl].pb, cb);
|
|
}
|
|
|
|
// the following are the various callback functions needed to support
|
|
// the cvpack library when we are attempting to not write out the
|
|
// unpacked types and symbols
|
|
|
|
#include <io.h>
|
|
|
|
extern int printf(char *,...);
|
|
|
|
int __cdecl
|
|
link_chsize (int fh, long size)
|
|
{
|
|
LINK_TRACE(printf("chsize(%06d, %08ld)\n", fh, size));
|
|
|
|
// we must keep track of the new size so that we will correctly
|
|
// process lseeks that are relative to the end of the file
|
|
|
|
lposMac = size;
|
|
|
|
return(_chsize(fh,size));
|
|
}
|
|
|
|
|
|
int __cdecl
|
|
link_close (int x)
|
|
{
|
|
LINK_TRACE(printf("close (%06d)\n", x));
|
|
|
|
return(_close(x));
|
|
}
|
|
|
|
void __cdecl
|
|
link_exit (int x)
|
|
{
|
|
LINK_TRACE(printf("exit (%06d)\n", x));
|
|
#if USE_REAL
|
|
RealMemExit();
|
|
#endif
|
|
exit(x);
|
|
}
|
|
|
|
long __cdecl
|
|
link_lseek (int fh, long lpos, int mode)
|
|
{
|
|
int ibl;
|
|
|
|
LINK_TRACE(printf("lseek (%d, %08ld, %2d)\n", fh, lpos, mode));
|
|
|
|
// if we have no cache blocks, just forward the request...
|
|
// this will happen on a /CvpackOnly invocation
|
|
|
|
if (rgbl == NULL)
|
|
return _lseek(fh, lpos, mode);
|
|
|
|
// adjust lpos so that we are always doing an absolute seek
|
|
|
|
if (mode == 1)
|
|
lpos = lposCur + lpos;
|
|
else if (mode == 2)
|
|
lpos = lposMac + lpos;
|
|
|
|
// check for a bogus seek
|
|
|
|
if (lpos > lposMac || lpos < 0)
|
|
{
|
|
// this used to be an internal error... but cvpack sometimes does
|
|
// try to seek beyond the end of the file when it is trying to
|
|
// distinguish a PE exe from an unsegmented DOS exe
|
|
// instead of panicing, we just return failure
|
|
|
|
return(-1);
|
|
}
|
|
|
|
// if we are in the midst of reading a block, then free that block
|
|
// cvpack never reads the same data twice
|
|
|
|
if (iblCur != iblNil)
|
|
{
|
|
// first check if we're in the header -- we might come back to that...
|
|
if (rgbl[iblCur].lpos > cbRealBytes + CB_HEADER_SAVE)
|
|
{
|
|
long lposCurMin, lposCurMac;
|
|
|
|
// check for a seek that is within the current bucket
|
|
// in case we're skipping within the current block
|
|
|
|
lposCurMin = rgbl[iblCur].lpos;
|
|
|
|
if (iblCur < iblLim)
|
|
lposCurMac = rgbl[iblCur+1].lpos;
|
|
else
|
|
lposCurMac = lposMac;
|
|
|
|
if (lpos < lposCurMin || lpos >= lposCurMac)
|
|
{
|
|
FFREE(rgbl[iblCur].pb);
|
|
rgbl[iblCur].pb = NULL;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
// if this seek is not in the debug area of the .exe use the real lseek
|
|
|
|
if (lpos < cbRealBytes)
|
|
{
|
|
iblCur = iblNil;
|
|
lposCur = lpos;
|
|
return(_lseek(fh,lpos,0));
|
|
}
|
|
|
|
// see if we are searching forward (the normal case)
|
|
// if we are, search from the current block, otherwise search from
|
|
// the start (linear search but OK because cvpack doesn't
|
|
// jump around much, it just uses lseek to skip a few bytes here and
|
|
// there)
|
|
|
|
if (lpos > lposCur && iblCur != iblNil)
|
|
ibl = iblCur;
|
|
else
|
|
ibl = 0;
|
|
|
|
// set the current position
|
|
|
|
lposCur = lpos;
|
|
|
|
// loop through the buffered writes looking for the requested position
|
|
|
|
for (; ibl < iblLim - 1; ibl++)
|
|
{
|
|
if (lpos >= rgbl[ibl].lpos && lpos < rgbl[ibl+1].lpos)
|
|
break; // found bucket
|
|
}
|
|
|
|
// set the bucket number, offset within the bucket, and number of bytes
|
|
// left in the bucket
|
|
|
|
iblCur = ibl;
|
|
ichCur = lpos - rgbl[ibl].lpos;
|
|
cbCur = CbIbl(ibl) - ichCur;
|
|
|
|
// check to make sure we haven't seeked back to a buffer that we already
|
|
// freed...
|
|
|
|
ASSERT(rgbl[iblCur].pb != NULL);
|
|
|
|
// make sure we get the boundary case... if cvpack is requesting to go to
|
|
// the end of the data that we have written then we MUST seek because
|
|
// cvpack might be about to write out the packed stuff...
|
|
|
|
if (lposCur == cbRealBytes)
|
|
_lseek(fh, lpos, 0);
|
|
|
|
// we set up the current position earlier... return it now
|
|
|
|
return(lposCur);
|
|
}
|
|
|
|
|
|
int __cdecl
|
|
link_open (const char * x, int y)
|
|
{
|
|
LINK_TRACE(printf("open (%s, %06d)\n", x, y));
|
|
|
|
// setup the static variables to a safe state
|
|
// the current position is the start of file and there is no buffer
|
|
// active (iblCur = iblNil)
|
|
|
|
iblCur = iblNil;
|
|
lposCur = 0;
|
|
|
|
return(_open(x,y));
|
|
}
|
|
|
|
int __cdecl
|
|
link_read (int fh, char *pch, unsigned int cb)
|
|
{
|
|
int cbRem;
|
|
|
|
LINK_TRACE(printf("read (%d, %06u)\n", fh, cb));
|
|
|
|
if (rgbl == NULL)
|
|
return _read(fh, pch, cb);
|
|
|
|
// special case zero byte read, not really necessary but
|
|
// avoids any potential problems with trying to setup empty
|
|
// buffers etc. -- it should just fall out anyways but
|
|
// just to be safe [rm]
|
|
|
|
if (cb == 0)
|
|
return 0;
|
|
|
|
// if there is no buffer active, then just forward the read
|
|
// note that if we are invoked with /CvpackOnly this test will
|
|
// always succeed
|
|
|
|
if (iblCur == iblNil)
|
|
{
|
|
if (lposCur + ((long)(unsigned long)cb) < cbRealBytes)
|
|
{
|
|
lposCur += cb;
|
|
return(_read(fh,pch,cb));
|
|
}
|
|
else
|
|
{
|
|
int cbReal = cbRealBytes - lposCur;
|
|
|
|
if (_read(fh, pch, cbReal) != cbReal)
|
|
return -1;
|
|
|
|
if (link_lseek(fh, cbRealBytes, 0) != cbRealBytes)
|
|
return -1;
|
|
|
|
// set the number of bytes remaining to be read in
|
|
|
|
cbRem = cb - cbReal;
|
|
pch += cb - cbReal;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// set the number of bytes remaining to be read in
|
|
cbRem = cb;
|
|
}
|
|
|
|
while (cbRem)
|
|
{
|
|
// check if the number of bytes we need to read is less than
|
|
// the number left in the current buffer
|
|
|
|
if (cbRem <= cbCur)
|
|
{
|
|
// we can read all the remaining bytes from the current buffer
|
|
// so do it. Copy bytes and adjust the number of bytes left
|
|
// in this buffer, the index into the buffer, and the current
|
|
// position in the file
|
|
|
|
memcpy(pch, rgbl[iblCur].pb+ichCur, cbRem);
|
|
cbCur -= cbRem;
|
|
ichCur += cbRem;
|
|
lposCur += cbRem;
|
|
|
|
#ifdef DUMP_CVPACK_BYTES
|
|
{
|
|
int i;
|
|
for (i=0;i<cb;i++)
|
|
{
|
|
if ((i&15) == 0)
|
|
printf("%04x: ", i);
|
|
printf("%02x ", pch[i]);
|
|
if ((i&15)==15)
|
|
printf("\n");
|
|
}
|
|
}
|
|
if ((i&15))
|
|
printf("\n");
|
|
#endif
|
|
return cb;
|
|
}
|
|
else
|
|
{
|
|
// in this case, the read is bigger than the current buffer
|
|
// we'll be reading the whole buffer and then moving to the
|
|
// next buffer
|
|
|
|
|
|
// first read in the rest of this buffer
|
|
|
|
memcpy(pch, rgbl[iblCur].pb+ichCur, cbCur);
|
|
|
|
// adjust the number of bytes remaining and the current file
|
|
// position...
|
|
|
|
pch += cbCur;
|
|
cbRem -= cbCur;
|
|
lposCur += cbCur;
|
|
|
|
// we won't be coming back to this buffer, so return it to the
|
|
// system and mark it as freed
|
|
|
|
// first check if we're in the header -- we might come back to that
|
|
if (rgbl[iblCur].lpos > cbRealBytes + CB_HEADER_SAVE)
|
|
{
|
|
FFREE(rgbl[iblCur].pb);
|
|
rgbl[iblCur].pb = NULL;
|
|
}
|
|
|
|
// move forward to the next bucket, if there are no more buckets
|
|
// then this is an ERROR -- we'll be returning the number of
|
|
// bytes that we managed to read
|
|
|
|
iblCur++;
|
|
if (iblCur == iblLim)
|
|
{
|
|
iblCur = iblNil;
|
|
break;
|
|
}
|
|
|
|
// check to make sure that we are not reading data that
|
|
// we've already freed (yipe!)
|
|
|
|
ASSERT(rgbl[iblCur].pb != NULL);
|
|
|
|
// check to make sure that the current position agrees with
|
|
// the position that this buffer is supposed to occur at
|
|
|
|
ASSERT(lposCur == rgbl[iblCur].lpos);
|
|
|
|
// ok, everything is safe now, set the index into the current
|
|
// buffer and the number of bytes left in the buffer, then
|
|
// run the loop again until we've read in all the bytes we need
|
|
|
|
ichCur = 0;
|
|
cbCur = CbIbl(iblCur);
|
|
}
|
|
}
|
|
|
|
// return the number of bytes we actually read
|
|
return cb - cbRem;
|
|
}
|
|
|
|
long __cdecl
|
|
link_tell (int x)
|
|
{
|
|
LINK_TRACE(printf("tell (%06d)\n", x));
|
|
|
|
if (iblCur != iblNil)
|
|
return(lposCur);
|
|
|
|
return(_tell(x));
|
|
}
|
|
|
|
|
|
int __cdecl
|
|
link_write (int x, const void * y, unsigned int z)
|
|
{
|
|
LINK_TRACE(printf("write (%06d,%08lx,%06u)\n", x, y, z));
|
|
|
|
return(_write(x,y,z));
|
|
}
|
|
|
|
#ifdef CVPACK_DEBUG_HELPER
|
|
void dumpstate()
|
|
{
|
|
printf("lposCur= %d\n", lposCur);
|
|
printf("iblCur = %d\n", iblCur);
|
|
printf("ichCur = %d\n", ichCur);
|
|
printf("cbReal = %d\n", cbRealBytes);
|
|
printf("lposMac= %d\n", lposMac);
|
|
}
|
|
#endif
|
|
|
|
#else
|
|
#ifdef CVPACK_MONDO
|
|
|
|
#include <io.h>
|
|
|
|
int __cdecl
|
|
link_chsize (int x, long y)
|
|
{
|
|
return(_chsize(x,y));
|
|
}
|
|
|
|
int __cdecl
|
|
link_close (int x)
|
|
{
|
|
return(_close(x));
|
|
}
|
|
|
|
void __cdecl
|
|
link_exit (int x)
|
|
{
|
|
#if USE_REAL
|
|
RealMemExit();
|
|
#endif
|
|
exit(x);
|
|
}
|
|
|
|
long __cdecl
|
|
link_lseek (int x, long y, int z)
|
|
{
|
|
return(_lseek(x,y,z));
|
|
}
|
|
|
|
|
|
int __cdecl
|
|
link_open (const char *x, int y)
|
|
{
|
|
return(_open(x,y));
|
|
}
|
|
|
|
int __cdecl
|
|
link_read (int x, void *y, unsigned int z)
|
|
{
|
|
return(_read(x,y,z));
|
|
}
|
|
|
|
long __cdecl
|
|
link_tell (int x)
|
|
{
|
|
return(_tell(x));
|
|
}
|
|
|
|
|
|
int __cdecl
|
|
link_write (int x, const void * y, unsigned int z)
|
|
{
|
|
return(_write(x,y,z));
|
|
}
|
|
#endif
|
|
#endif
|