Microsoft/NT4
Microsoft/NT4
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
NT4/private/sdktools/vctools/debugger/sapi/sl.cpp

1768 lines
47 KiB
C++
Raw Permalink Normal View History

First commit
2001-01-01 00:00:00 +01:00
// sl.cxx -- all routines to work with the source line information
//
// Copyright <C> 1991, Microsoft Corporation
//
// Revisions:
//
// 19-Dec-91 Davidgra
// [00] Cache in SLFLineToAddr & SLLineFromAddr
//
// 03-Jan-92 ArthurC
// [01] Added argument to SLFLineToAddr
//
// 01-Dec-94 BryanT
// Merge with NT codebase.
//
// Purpose:
// To query information for the source module, source file, and
// source line information tables.
#include "shinc.hpp"
#pragma hdrstop
#define cbndsAllocBlock 512
typedef struct _BNDS {
WORD ilnStart;
WORD ilnEnd;
} BNDS; // BouNDS
typedef BNDS *LPBNDS;
LOCAL HST HstFromLpmds (LPMDS);
LOCAL BOOL FCheckSLOrder (LPSL);
LOCAL LPBNDS BuildBounds (WORD, LPUL, LPW);
__inline VOID SortSM (LPSM);
__inline VOID SortSL (LPSL);
__inline WORD FindPosition (LPBNDS, WORD, LPUL, ULONG);
__inline LPBNDS InsertBlock (WORD, WORD, LPBNDS, LPW, LPW);
__inline WORD ScanBlock (LPUL, WORD, WORD, ULONG);
__inline VOID SortOffFromBounds (WORD, LPBNDS, WORD, LPUL);
__inline VOID SortLnFromBounds (WORD, LPBNDS, WORD, LPW);
__inline VOID SortFromBounds (WORD, LPBNDS, WORD, LPV, WORD);
#define SIZEOFBASE 4
#define SIZEOFSTARTEND 8
#define SIZEOFLINENUMBER 2
#define SIZEOFHEADER 4
#define SIZEOFSEG 2
#define SIZEOFNAME 2
// Internal support routines
// Low level routines to tranverse the source module, source file and
// source line information tables
//
// List of internal support functions
LPW
PsegFromSMIndex (
LPSM lpsm,
WORD iseg
)
{
assert (lpsm != NULL)
assert (iseg < lpsm->cSeg);
return ((LPW)
((CHAR *) lpsm +
SIZEOFHEADER +
(SIZEOFBASE * lpsm->cFile) +
(SIZEOFSTARTEND * lpsm->cSeg) +
(SIZEOFSEG * iseg)
)
);
}
// GetSMBounds
//
// Purpose: Get the segment number and start/end offset pair for the
// segment (iseg) contributing to the module lpsm.
// Input:
// lpsmCur - pointer to the current source module table.
// iseg - the index of the segment contributing to
// the module to get the bounds for.
//
// Returns a pointer to a start/end offset pair
__inline LPOFP
GetSMBounds (
LPSM lpsm,
WORD iSeg
)
{
assert (lpsm != NULL);
assert (iSeg < lpsm->cSeg);
return ((LPOFP) ((CHAR *) lpsm +
SIZEOFHEADER +
(SIZEOFBASE * lpsm->cFile) +
(sizeof (OFP) * iSeg)));
}
LPW
PsegFromSFIndex (
LPSM lpsm,
LPSF lpsf,
WORD iseg
)
{
ULONG ulBase = 0;
assert (lpsf != NULL)
assert (iseg < lpsf->cSeg);
ulBase = *((ULONG *) ((LPCH)lpsf + SIZEOFHEADER + (SIZEOFBASE * iseg)));
return (LPW) ((LPCH) lpsm + ulBase);
}
// GetSFBounds
//
// Purpose: Get the next/first start address from the Source File table.
//
// Input:
// lpsmCur - pointer to the current source module table.
// lpiStart - pointer to index of the current file pointer
// 0 if getting first in list.
// lpulNext - pointer to the next source file block.
//
// Returns:
// lpulNext - set to pointer to next source file. NULL
// if no more entries.
__inline LPOFP
GetSFBounds (
LPSF lpsf,
WORD iseg
)
{
assert (lpsf != NULL)
assert (iseg < lpsf->cSeg);
return (LPOFP) ((CHAR *) lpsf +
SIZEOFHEADER +
(SIZEOFBASE * lpsf->cSeg) +
(sizeof (OFP) * iseg));
}
// GetLpsfFromIndex
//
// Purpose: From the current source module, and source file pointer find
// the next one.
//
// Input:
// lpsmCur - pointer to the current source module table.
// isfCur - index of the current file pointer
// 0 if getting first in list.
// Returns:
// lpsfNext - set to pointer to next source file. NULL
// not found.
LPSF
GetLpsfFromIndex (
LPSM lpsmCur,
WORD iFile
)
{
LPSF lpsfNext = NULL;
BOOL fRet = TRUE;
assert (lpsmCur != NULL)
if (lpsmCur && iFile < lpsmCur->cFile) {
lpsfNext = (LPSF) ((CHAR *)lpsmCur + lpsmCur->baseSrcFile[iFile]);
}
return lpsfNext;
}
// LpsfFromAddr
//
// Purpose: Find the pointer to the source file that the addr falls into
//
// Input:
// lpaddr - pointer to address package
// lpsf - pointer to lpsf that contain addr in range
// lpsmCur - pointer to current source module table.
//
// Returns:
// lpsf - contain pointer to source file if addr is
// in range. Unchanged if could not find file.
BOOL
FLpsfFromAddr (
LPADDR lpaddr,
LPSM lpsmCur,
LPSF * plpsf,
LPW lpwFileIndex,
LPW lpwSegIndex
)
{
WORD iFile = 0;
BOOL fFound = FALSE;
assert (lpsmCur != (LPSM) NULL)
assert (lpaddr != (LPADDR) NULL)
while (iFile < lpsmCur->cFile && !fFound) {
WORD iseg = 0;
LPSF lpsf = GetLpsfFromIndex (lpsmCur, iFile);
while (iseg < lpsf->cSeg && !fFound) {
WORD seg = *PsegFromSFIndex (lpsmCur, lpsf, iseg);
LPOFP lpofp = GetSFBounds (lpsf, iseg);
if ((GetAddrSeg (*lpaddr) == seg) &&
(GetAddrOff (*lpaddr) >= lpofp->offStart) &&
(GetAddrOff (*lpaddr) <= lpofp->offEnd))
{
*lpwFileIndex = iFile;
*lpwSegIndex = iseg;
*plpsf = lpsf;
fFound = TRUE;
}
iseg++;
}
iFile++;
}
return fFound;
}
// LpchGetName
__inline LPCH
LpchGetName (
LPSF lpsf
)
{
LPCH lpch = NULL;
assert (lpsf != NULL)
lpch = (LPCH) ((CHAR *)lpsf +
SIZEOFHEADER +
(SIZEOFBASE * lpsf->cSeg) +
(SIZEOFSTARTEND * lpsf->cSeg));
return lpch;
}
// LpsfFromName
short
IsfFromName (
BOOL fExactMatch,
short isfStart,
LSZ lszName,
LPMDS lpmds
)
{
short isfFound = -1;
short isf = isfStart;
LPEXG lpexg = (LPEXG) LLLock (lpmds->hexg);
if (lpexg->lpefi) {
CHAR szFileSrc [ _MAX_CVFNAME ];
CHAR szExtSrc [ _MAX_CVEXT ];
WORD cbName = 0;
WORD cchName = 0;
LSZ lszFileExt = NULL;
int imds = lpmds->imds - 1;
_tsplitpath(lszName, NULL, NULL, szFileSrc, szExtSrc);
// If fExactMatch, the path must match the OMF
if (fExactMatch) {
cbName = _tcslen(lszName);
cchName = _tcslen(lszName);
lszFileExt = lszName;
} else {
cbName = _tcslen(szExtSrc) + _tcslen(szFileSrc);
cchName = _tcslen(szExtSrc) + _tcslen(szFileSrc);
lszFileExt = lszName + _tcslen(lszName) - cbName;
}
for (isf = isfStart; isf < (short) lpexg->rgculFile [ imds ]; isf++) {
CHAR szPathOMF [ _MAX_CVPATH ];
CHAR szFile [ _MAX_CVFNAME ];
CHAR szExt [ _MAX_CVEXT ];
_TXCHAR * lpch = (_TXCHAR *)
lpexg->lpchFileNames +
(lpexg->rgichFile [ (WORD) (lpexg->rgiulFile [ imds ]) + isf ]);
// IMPORTANT NOTE:
//
// Below, it is VITAL for DBCS to use the number of CHARACTERS
// to compare as opposed to the number of bytes or the DBCS
// strnicmp will fail!
if (!_tcsnicmp (lszFileExt, (_TXCHAR *) lpch + *lpch - cbName + 1, cchName)) {
memset(szPathOMF, 0, _MAX_CVPATH);
memcpy(szPathOMF, lpch + 1, *lpch);
_tsplitpath(szPathOMF, NULL, NULL, szFile, szExt);
if (!_tcsicmp (szFileSrc, szFile) &&
!_tcsicmp (szExtSrc, szExt))
{
isfFound = isf;
break;
}
}
}
}
LLUnlock (lpmds->hexg);
return isfFound;
}
// GetLpslFromIndex
//
// Purpose: Get the next line number entry
__inline LPSL
GetLpslFromIndex (
LPSM lpsmCur,
LPSF lpsfCur,
WORD iSeg
)
{
LPSL lpsl = NULL;
BOOL fRet = TRUE;
assert (lpsfCur != NULL)
if (iSeg < lpsfCur->cSeg) {
lpsl = (LPSL) ((CHAR *)lpsmCur +
lpsfCur->baseSrcLn [iSeg]);
}
return lpsl;
}
BOOL
FLpslFromAddr (
LPADDR lpaddr,
LPSM lpsm,
LPSL * plpsl
)
{
WORD iSeg = 0;
WORD iSegCur = 0;
WORD iFileCur = 0;
BOOL fFound = FALSE;
BOOL fRet = FALSE;
LPSF lpsf = NULL;
assert (lpsm != NULL)
assert (lpaddr != NULL)
// First, do a high level pass to see if the address actually exists
// within the given module.
while (iSeg < lpsm->cSeg) {
WORD seg = *PsegFromSMIndex (lpsm, iSeg);
LPOFP lpofp = GetSMBounds (lpsm, iSeg);
if ((GetAddrSeg (*lpaddr) == seg) &&
(GetAddrOff (*lpaddr) >= lpofp->offStart) &&
(GetAddrOff (*lpaddr) <= lpofp->offEnd)
) {
break;
}
iSeg++;
}
// We know it is in this module, so now find the correct file
if (iSeg < lpsm->cSeg &&
FLpsfFromAddr (lpaddr, lpsm, &lpsf, &iFileCur, &iSegCur))
{
*plpsl = GetLpslFromIndex (lpsm, lpsf, iSegCur);
fRet = TRUE;
}
return fRet;
}
// OffsetFromIndex
//
// Purpose: Get the next line number entry
__inline BOOL
OffsetFromIndex (
LPSL lpslCur,
WORD iPair,
ULONG * lpulOff
)
{
BOOL fRet = FALSE;
assert (lpslCur != NULL)
assert (lpulOff != NULL)
if (iPair < lpslCur->cLnOff) {
*lpulOff = lpslCur->offset [ iPair ];
fRet = TRUE;
}
return fRet;
}
// LineFromIndex
//
// Purpose: Get the next line number entry
__inline BOOL
LineFromIndex (
LPSL lpslCur,
WORD iPair,
USHORT * lpusLine
)
{
BOOL fRet = FALSE;
ULONG ul;
assert (lpslCur != NULL)
assert (lpusLine != NULL)
if (iPair < lpslCur->cLnOff) {
ul = (sizeof (LONG) * lpslCur->cLnOff) + (sizeof (WORD) * iPair);
*lpusLine = *(USHORT *)((CHAR *) lpslCur->offset + ul);
fRet = TRUE;
}
return fRet;
}
//
// Exported APIs
//
// SLHmodFromHsf - Return the module in which a source file is used
//
// Purpose: Given a source file, return an HMOD indicating which
// module it was compiled into.
//
// Input: hexe - handle to the EXE in which to look, or NULL for all
// hsf - handle to source file for which to find module
//
// Returns: handle to the module into which this source file was
// compiled
//
// Notes: REVIEW: BUG: It's possible (mainly in C++ but also in C)
// for a source file to be used in more than one module
// (e.g. a C++ header file with inline functions, or a C
// header file with a static function). This function just
// finds the first one, which is very misleading.
HMOD
SLHmodFromHsf (
HEXE hexe,
HSF hsf
)
{
HEXE hexeCur = hexe;
HMOD hmod = 0;
LPSF lpsfCur = NULL;
BOOL fFound = FALSE;
LPMDS lpmds = NULL;
WORD iFile;
if (hsf != HsfCache.Hsf) {
// to get an Hmod from hsf we must loop through
// exe's to Hmods and compare hsfs associated to the
// hmod
while (hexeCur = (hexe ? hexe : SHGetNextExe (hexeCur))) {
while ((hmod = SHGetNextMod (hexeCur, hmod)) && !fFound) {
lpmds = (LPMDS) hmod;
if (lpmds != NULL && lpmds->hst) {
for (iFile = 0; iFile < ((LPSM) lpmds->hst)->cFile; iFile++) {
if (hsf == GetLpsfFromIndex ((LPSM)lpmds->hst, iFile)) {
HsfCache.Hmod = hmod;
HsfCache.Hsf = hsf;
fFound = TRUE;
break;
}
}
}
}
if (hexe != (HEXE) NULL || fFound) {
//
// if given an exe to search don't go any further.
//
break;
}
}
}
return HsfCache.Hmod;
}
// SLLineFromAddr - Return info about the source line for an address
//
// Purpose: Given an address return line number that corresponds.
// Also return count bytes for the given line, and the delta
// between the address that was passed in and the first byte
// corresponding to this source line.
//
// Input: lpaddr - address for which we want source line info
//
// Output: *lpwLine - the (one-based) line for this address
// *lpcb - the number of bytes of code that were generated
// for this source line
// *lpdb - the offset of *lpaddr minus the offset for the
// beginning of the line
//
// Returns: TRUE if source was found, FALSE if not
//
// Notes:
// 1. add parameter for hexe start
BOOL
SLLineFromAddr (
LPADDR lpaddr,
LPW lpwLine,
SHOFF * lpcb,
SHOFF * lpdb
)
{
HMOD hmod = (HMOD) NULL;
LPMDS lpmds = NULL;
CXT cxtT = {0};
LPSL lpsl = NULL;
WORD cPair;
WORD i;
HEXE hexe;
UOFFSET maxOff = CV_MAXOFFSET;
BOOL fRet = FALSE;
short low;
short mid;
short high;
ULONG ulOff;
USHORT usLine;
assert (lpaddr != NULL)
assert (lpwLine != NULL)
if (!ADDR_IS_LI (*lpaddr)) {
SYUnFixupAddr (lpaddr);
}
if (emiAddr (*lpaddr) == emiAddr (AddrCache.addr) &&
GetAddrSeg (*lpaddr) == GetAddrSeg (AddrCache.addr) &&
GetAddrOff (*lpaddr) >= GetAddrOff (AddrCache.addr) &&
GetAddrOff (*lpaddr) < GetAddrOff (AddrCache.addr) + AddrCache.cb - 1)
{
*lpwLine = AddrCache.wLine;
if (lpcb) {
*lpcb = AddrCache.cb - 1;
}
if (lpdb) {
*lpdb = GetAddrOff (*lpaddr) - GetAddrOff (AddrCache.addr);
}
return TRUE;
}
*lpwLine = 0;
if (SHSetCxtMod (lpaddr, &cxtT) != NULL) {
hmod = SHHMODFrompCXT (&cxtT);
if (hmod != (HMOD) NULL &&
(lpmds = (LPMDS) hmod) != NULL &&
lpmds && HstFromLpmds (lpmds) &&
FLpslFromAddr (lpaddr, (LPSM) lpmds->hst, &lpsl))
{
hexe = SHHexeFromHmod (SHHMODFrompCXT (&cxtT));
cPair = lpsl->cLnOff;
for (i = 0; i < cPair; i++) {
if (OffsetFromIndex (lpsl, i, &ulOff)) {
if (emiAddr (*lpaddr) == (HEMI) hexe) {
// set up for the search routine
low = 0;
high = lpsl->cLnOff - 1;
// binary search for the offset
while (low <= high) {
mid = (low + high) / 2;
if (OffsetFromIndex (lpsl, mid, &ulOff)) {
if (GetAddrOff (*lpaddr) < (UOFFSET) ulOff) {
high = mid - 1;
} else if (GetAddrOff (*lpaddr) > (UOFFSET) ulOff) {
low = mid + 1;
} else if (LineFromIndex (lpsl, mid, &usLine)) {
*lpwLine = usLine;
maxOff = 0;
high = mid;
goto found;
}
}
}
// if we didn't find it, get the closet but earlier line
// high should be one less than low.
if (OffsetFromIndex (lpsl, high, &ulOff)) {
if (low &&
((GetAddrOff (*lpaddr) -
(UOFFSET) ulOff) <
maxOff)
) {
maxOff = (UOFFSET) (GetAddrOff (*lpaddr) -
(UOFFSET) ulOff);
if (LineFromIndex (lpsl, high, &usLine)) {
*lpwLine = (WORD) usLine;
//goto found;
}
}
}
}
}
}
}
}
found:
if (*lpwLine != 0) {
ULONG ulOff = 0;
ULONG ulOffNext = 0;
AddrCache.wLine = *lpwLine;
AddrCache.cb = 0;
while (AddrCache.cb == 0 && (high + 1 < (int) lpsl->cLnOff)) {
if (OffsetFromIndex (lpsl, (WORD)(high + 1), &ulOffNext) &&
OffsetFromIndex (lpsl, high, &ulOff)) {
AddrCache.cb = (int) (ulOffNext - ulOff);
if (AddrCache.cb != 0) {
LineFromIndex (lpsl, high, lpwLine);
AddrCache.wLine = *lpwLine;
break;
}
}
high += 1;
}
if (AddrCache.cb == 0) {
LPSF lpsf = NULL;
WORD iFile = 0;
WORD iseg = 0;
if (FLpsfFromAddr (lpaddr, (LPSM) lpmds->hst, &lpsf, &iFile, &iseg)
&&
OffsetFromIndex (lpsl, high, &ulOff))
{
AddrCache.cb = (int) (GetSFBounds (lpsf, iseg)->offEnd - ulOff + 1);
}
}
if (lpcb != NULL) {
*lpcb = AddrCache.cb - 1;
}
if (lpdb != NULL) {
if (OffsetFromIndex (lpsl, high, &ulOff)) {
*lpdb = GetAddrOff (*lpaddr) - ulOff;
}
}
AddrCache.addr = *lpaddr;
SetAddrOff (&AddrCache.addr, ulOff);
fRet = TRUE;
}
return fRet;
}
// SLFLineToAddrExteneded - Return the address for a given source line
//
// Purpose: Given a line and filename derive an an address. This is
// an extended version of LineToAddr to be able to search through
// a source line table when there are multiple entries in the
// source line table for a single line.
//
// Input: hsf - handle to the source file
// line - the source line
// *piSegStart - segment table in hsf to start search at
// *piEntryFind - find the nth entry in *piSegStart
//
// Output: *piSegStart - segment table in hsf line found at. Only valid
// when TRUE is returned!
// *piEntryFind - index to begin search in next call to this fn
// *lpaddr - the address for this source line
// *lpcbLn - the number of bytes of code that were generated
// for this source line
// rgwNearestLines[] - The nearest line below ([0]) and above ([1])
// which generated code.
//
// *** Below means lower LINE NUMBER not where it
// would be on the screen!!!!!
//
// Returns: TRUE for success, FALSE for failure
//
// Exceptions: lpNearestLines may not be valid if the return value is TRUE
BOOL
SLFLineToAddrExtended (
HSF hsf,
WORD line,
WORD * piSegStart,
WORD * piEntryFind,
LPADDR lpaddr,
SHOFF * lpcbLn,
WORD * rgwNearestLines
)
{
WORD rgwRet[2];
ADDR addr = {0};
SHOFF cbln = 0;
HMOD hmod;
BOOL fRet = FALSE;
LPSF lpsf = NULL;
WORD cEntryRemain;
if (piEntryFind) {
cEntryRemain = *piEntryFind;
} else {
cEntryRemain = 0;
}
rgwRet[0] = 0;
rgwRet[1] = 0x7FFF;
lpsf = (LPSF) hsf;
ADDR_IS_LI (addr) = TRUE;
// We need to get a mod.
if (hmod = SLHmodFromHsf ((HEXE) NULL, hsf)) {
HEXE hexe = SHHexeFromHmod (hmod);
LPMDS lpmds = (LPMDS) hmod;
// Set the fFlat and fOff32 bits base on the exe
HEXG hexg = ((LPEXE) LLLock (hexe))->hexg;
LLUnlock (hexe);
if (((LPEXG) LLLock (hexg))->fIsPE) {
// REVIEW - billjoy - should we check machine type or something?
ADDRLIN32 (addr);
} else {
// REVIEW - billjoy - should we check machine type or something?
//ADDR????
}
LLUnlock (hexg);
if ((lpmds != NULL) && (lpsf != NULL)) {
WORD i;
for (i = *piSegStart; !fRet && i < lpsf->cSeg; i++) {
ULONG ulOff;
WORD iLn;
LPSL lpsl = NULL;
LPSL lpslNear = NULL;
WORD wLine = 0;
WORD wLineNear = 0;
lpsl = GetLpslFromIndex ((LPSM) lpmds->hst, lpsf, i);
for (iLn = 0; iLn < lpsl->cLnOff; iLn++) {
//
// look through all of the lines in the table
//
BOOL fT = LineFromIndex (lpsl, iLn, &wLine);
assert (fT);
if (wLine == line) {
LPOFP lpofp;
fT = OffsetFromIndex (lpsl, iLn, &ulOff);
assert (fT);
SetAddrOff (&addr, ulOff);
SetAddrSeg (&addr, lpsl->Seg);
emiAddr (addr) = (HEMI) hexe;
if (iLn + 1 < lpsl->cLnOff) {
//
// if the next line is in range
//
OffsetFromIndex(lpsl, (WORD)(iLn+1), &ulOff);
//
// if we have a next line get the range
// based on next line.
//
cbln = ulOff - GetAddrOff (addr);
if (cbln == (SHOFF) 0) {
if (wLine < rgwRet[1]) {
rgwRet[1] = wLine;
}
continue;
}
} else {
// if we don't have a next line then
// get the range from the boundry
lpofp = GetSFBounds (lpsf, i);
// GetSFBounds offEnd is inclusive
// for the source range. Need to
// add 1 for the count bytes!
cbln = lpofp->offEnd - ulOff + 1;
// the end information is probably the same as the
// beginning offset for the last line in the file.
// So for now I will make a wild guess at the
// size of average epilog code. 10 bytes.
if (!cbln) {
cbln = 10;
}
}
*piSegStart = i;
if (!cEntryRemain--) {
if (piEntryFind) {
*piEntryFind += 1;
}
fRet = TRUE;
break;
}
} else {
if (wLine < line) {
if (wLine > rgwRet[0]) {
rgwRet[0] = wLine;
}
} else {
if (wLine < rgwRet[1]) {
rgwRet[1] = wLine;
}
}
}
}
// If continuing search, reset to stop at 1st
// entry in next table
if (!fRet) {
cEntryRemain = 0;
if (piEntryFind) {
*piEntryFind = 0;
}
}
}
}
}
if(lpaddr) {
*lpaddr = addr;
}
if(lpcbLn) {
*lpcbLn = cbln;
}
if(rgwNearestLines) {
rgwNearestLines[0] = rgwRet[0];
rgwNearestLines[1] = rgwRet[1];
}
return fRet;
}
// SLFLineToAddr - Return the address for a given source line
//
// Purpose: Given a line and filename derive an an address.
//
// Input: hsf - handle to the source file
// line - the source line
//
// Output: *lpaddr - the address for this source line
// *lpcbLn - the number of bytes of code that were generated
// for this source line
// rgwNearestLines[] - The nearest line below ([0]) and above ([1])
// which generated code.
//
// *** Below means lower LINE NUMBER not where it
// would be on the screen!!!!!
//
// Returns: TRUE for success, FALSE for failure
//
// Exceptions: lpNearestLines may not be valid if the return value is TRUE
BOOL
SLFLineToAddr (
HSF hsf,
WORD line,
LPADDR lpaddr,
SHOFF * lpcbLn,
WORD * rgwNearestLines
)
{
if ((hsf != LineCache.hsf) ||
(line != LineCache.wLine))
{
WORD iSegStart = 0;
LineCache.fRet = SLFLineToAddrExtended(hsf,
line,
&iSegStart,
NULL,
&LineCache.addr,
&LineCache.cbLn,
LineCache.rgw);
LineCache.hsf = hsf;
LineCache.wLine = line;
}
if (lpaddr) {
*lpaddr = LineCache.addr;
}
if (lpcbLn) {
*lpcbLn = LineCache.cbLn;
}
if (rgwNearestLines) {
rgwNearestLines[ 0 ] = LineCache.rgw [ 0 ];
rgwNearestLines[ 1 ] = LineCache.rgw [ 1 ];
}
return LineCache.fRet;
}
// SLFFileInHexe - Is specified file a source contributor to hexe?
//
// Purpose: Determine if the file specified will have source line
// information in this exe.
//
// Input:
// hexe Exe (hexg) to search
// fExactMatch If TRUE, lszFile and OMF path must match. If FALSE,
// only the basename and extension must match.
// lszFile Name of file to search for in OMF
//
// Returns: TRUE if file is found in exe's OMF
//
// Notes: This is a FAST search. Just go through the file
// list from exg.lpchFileNames.
BOOL
SLFFileInHexe(
HEXE hexe,
BOOL fExactMatch,
LSZ lszFile
)
{
BOOL fRet = FALSE;
LPEXG lpexg;
LPEXE lpexe;
assert(hexe);
lpexe = (LPEXE)LLLock(hexe);
// Make sure that there's and exg for this exe
if (lpexg = (LPEXG)LLLock(lpexe->hexg)) {
// The code below is copied from IsfFromName (FYI -markbro)
if (lpexg->lpchFileNames) {
_TXCHAR * lpch = (_TXCHAR *)lpexg->lpchFileNames;
_TXCHAR * lpchMax = lpch + lpexg->cbFileNames;
CHAR szFileSrc [ _MAX_CVFNAME ];
CHAR szExtSrc [ _MAX_CVEXT ];
WORD cbName = 0;
WORD cchName = 0;
LSZ lszFileExt = NULL;
_splitpath(lszFile, NULL, NULL, szFileSrc, szExtSrc);
// If fExactMatch, the path must match the OMF
if (fExactMatch) {
cbName = _tcslen(lszFile);
cchName = _tcslen(lszFile);
lszFileExt = lszFile;
} else {
cbName = _tcslen(szExtSrc) + _tcslen(szFileSrc);
cchName = _tcslen(szExtSrc) + _tcslen(szFileSrc);
lszFileExt = lszFile + _tcslen(lszFile) - cbName;
}
// Stop when we've found something or the end of the table is found.
while(!fRet && lpch < lpchMax) {
CHAR szPathOMF [ _MAX_CVPATH ];
CHAR szFile [ _MAX_CVFNAME ];
CHAR szExt [ _MAX_CVEXT ];
// IMPORTANT NOTE:
//
// Below, it is VITAL for DBCS to use the number of CHARACTERS
// to compare as opposed to the number of bytes or the DBCS
// strnicmp will fail!
if (!_tcsnicmp (lszFileExt, lpch + *lpch - cbName + 1, cchName)) {
memset(szPathOMF, 0, _MAX_CVPATH);
memcpy(szPathOMF, lpch + 1, *lpch);
_tsplitpath(szPathOMF, NULL, NULL, szFile, szExt);
if (!_tcsicmp (szFileSrc, szFile) &&
!_tcsicmp (szExtSrc, szExt))
{
fRet = TRUE;
}
}
// Skip to the next name in the table
lpch += *lpch + 1;
}
}
LLUnlock(lpexe->hexg);
}
LLUnlock(hexe);
return fRet;
}
// SLCAddrFromLine - get all addresses which match the requested line
//
// Purpose: Given a line and filename derive all addresses within
// the specified exe
//
// Input: hexe - exe/dll to search in (if NULL, use all)
// hmod - module of hexe to search in (if NULL, use all in hexe)
// lszFile - file name
// line - the source line
//
// Output: *lplpslp - pointer to slp array (allocated by this function)
// containing return value # of pairs
//
// Returns: number of pairs found in exe
int
SLCAddrFromLine (
HEXE hexeStart,
HMOD hmodStart,
LSZ lszFileT,
WORD line,
LPSLP *lplpslp
)
{
LPSLP lpslp = (LPSLP)NULL;
int cslp = 0;
HMOD hmod = hmodStart;
HEXE hexe = hexeStart;
int iPass;
char szFileBuf[_MAX_PATH];
LPSTR lszFile;
assert(lplpslp);
assert(lszFileT);
assert(*lszFileT != '\0');
// If the filename is quoted, remove the quotes.
if ((*lszFileT == '\"') && (*(lszFileT + _tcslen(lszFileT) - 1) == '\"')) {
lszFile = szFileBuf;
memcpy(lszFile, _tcsinc(lszFileT), _tcslen(lszFileT) - 2);
lszFile[_tcslen(lszFileT)-2] = '\0';
} else {
lszFile = lszFileT;
}
if ((SlCache.cslp != -1) &&
(hexeStart == SlCache.hexe) &&
(hmodStart == SlCache.hmod) &&
(line == SlCache.line) &&
(!_tcscmp(lszFile, SlCache.szFile)))
{
if ((SlCache.cslp == 0) ||
!(lpslp = (LPSLP)MHAlloc(sizeof(SLP) * (SlCache.cslp))))
{
*lplpslp = NULL;
return 0;
}
assert(SlCache.lpslp != NULL);
memcpy(lpslp, SlCache.lpslp, sizeof(SLP) * SlCache.cslp);
*lplpslp = lpslp;
return SlCache.cslp;
}
// Two passes, first pass, see if there is an exact match. If there aren't
// any exact matches, try to match just the file.ext name. When OMF file
// names are fully qualified, we should expect to always find a match on
// the first pass. This will help out with the case where there are two
// different file.ext's in the exes/dlls loaded.
for(iPass = 0; iPass < 2 && !lpslp; ++iPass) {
// Loop through all of the exes that we know about. We may want
// to change this later
while(hexeStart || (hexe = SHGetNextExe(hexe))) {
// Extra fast scan to see if the file is in the list of files for the exe
if (SLFFileInHexe(hexe, (BOOL)!iPass, lszFile)) {
while(hmodStart || (hmod = SHGetNextMod(hexe, hmod))) {
LPMDS lpmds = (LPMDS) hmod;
short isf;
short isfNext = -1;
do {
isf = isfNext + 1;
// Search for the filename in the current module
isfNext = IsfFromName((BOOL)!iPass, isf, lszFile, lpmds);
if (isfNext != -1) {
HSF hsf;
SHOFF cb;
ADDR addr;
WORD iSeg = 0;
WORD iEntry = 0;
hsf = (HSF)GetLpsfFromIndex(
(LPSM) HstFromLpmds(lpmds),
isfNext
);
// Reuse the original version. Since we have gotten our
// own hsf, we know that we will get the correct line
// number table
while(SLFLineToAddrExtended(hsf,
line,
&iSeg,
&iEntry,
&addr,
&cb,
(LPW)NULL))
{
// This could be smarter to allocate blocks, but the
// regular case will be that this will only happen
// once rather than multiple times, so just eat up
// a little CPU for simplicity
if (lpslp) {
lpslp = (LPSLP)MHRealloc(lpslp,
sizeof(SLP) * (cslp + 1));
}
else {
lpslp = (LPSLP)MHAlloc(sizeof(SLP));
}
// Additional check to see that the allocation
// actually succeeded before copying the data
if (lpslp) {
lpslp[ cslp ].cb = cb;
lpslp[ cslp ].addr = addr;
++cslp;
}
}
}
} while(isfNext != -1);
// If a module is specified, then DON'T loop through the rest of
// the modules
if (hmodStart) {
break;
}
}
}
// If a module is specified, DON'T loop through any of the remaining
// modules or exes. Also, if an exe is specified, don't go through
// any mor exes either
if (hmodStart || hexeStart) {
break;
}
}
}
*lplpslp = lpslp;
// Only free up if we need to
if (SlCache.cslp < cslp) {
if (SlCache.lpslp) {
MHFree(SlCache.lpslp);
}
SlCache.lpslp = (LPSLP)MHAlloc(sizeof(SLP) * cslp);
if (SlCache.lpslp == NULL) {
return(0);
}
}
if (cslp) {
memcpy(SlCache.lpslp, lpslp, sizeof(SLP) * cslp);
}
_tcscpy(SlCache.szFile, lszFile);
SlCache.hexe = hexeStart;
SlCache.hmod = hmodStart;
SlCache.line = line;
SlCache.cslp = cslp;
return cslp;
}
// SLNameFromHsf - Return the filename for an HSF
//
// Purpose: Get the filename associated to an HSF
//
// Input: hsf - handle to a source file
//
// Returns: Length-prefixed pointer to the filename.
// *** NOTE *** This is an ST!!! It's length-prefixed,
// and it's NOT guaranteed to be null-terminated!
LPCH
SLNameFromHsf (
HSF hsf
)
{
LPCH lpch = NULL;
if (hsf) {
lpch = LpchGetName ((LPSF) hsf);
}
return(lpch);
}
// SLNameFromHmod - Return the filename for an HMOD
//
// Purpose: Get one filename associated with an HMOD. Each module
// of a program may have many source files associated
// with it (e.g., "foo.hpp", "bar.hpp", and "foo.cpp"),
// depending on whether there is code in any included
// files. The iFile parameter can be used to loop
// through all the files.
//
// Input: hmod - handle to a module
// iFile - ONE-based index indicating which filename to
// return
//
// Returns: Length-prefixed pointer to the filename.
// *** NOTE *** This is an ST!!! It's length-prefixed,
// and it's NOT guaranteed to be null-terminated!
//
// Notes: The filenames are NOT in any special order (you can't
// assume, for example, that the last one is the "real"
// source file.)
//
// Also, unfortunately (due to the linker), there may be
// duplicates!!! One module may have two occurrences of
// "foo.hpp".
#pragma optimize ("", off)
LPCH
SLNameFromHmod (
HMOD hmod,
WORD iFile
)
{
LPCH lpch = NULL;
LPMDS lpmds;
LPEXG lpexg;
if ((lpmds = (LPMDS) hmod) &&
(lpexg = (LPEXG) LLLock (lpmds->hexg)))
{
UINT imod = lpmds->imds - 1;
if (imod < lpexg->cMod && iFile <= lpexg->rgculFile [imod]) {
lpch = lpexg->lpchFileNames +
(lpexg->rgichFile [(WORD) (lpexg->rgiulFile [imod]) + iFile - 1]);
}
LLUnlock (lpmds->hexg);
}
return lpch;
}
#pragma optimize ("", on)
// SLFQueryModSrc - Query whether a module has symbolic information
//
// Purpose: Query whether a module has symbolic information
//
// Input: hmod - module to check for source
//
// Returns: TRUE if this module has symbolic information, FALSE
// if not
BOOL
SLFQueryModSrc (
HMOD hmod
)
{
LPMDS lpmds = (LPMDS) hmod;
BOOL fRet = lpmds->hst != NULL || lpmds->ulhst;
return fRet;
}
// SLHsfFromPcxt - Return source file for a context
//
// Purpose: Return the source file that a particular CXT is from
//
// Input: pcxt - pointer to CXT for which to find source file
//
// Returns: handle to source file, or NULL if not found
HSF
SLHsfFromPcxt (
PCXT pcxt
)
{
LPMDS lpmds = (LPMDS) SHHMODFrompCXT(pcxt);
WORD iFile = 0;
WORD iSeg = 0;
LPSF lpsf = NULL;
if (lpmds != NULL && HstFromLpmds (lpmds) != NULL) {
FLpsfFromAddr (SHpADDRFrompCXT (pcxt),
(LPSM) lpmds->hst,
&lpsf,
&iFile,
&iSeg);
}
return (HSF) lpsf;
}
// SLHsfFromFile - return HSF for a given source filename
//
// Purpose: Given a module and a source filename, return the HSF
// that corresponds
//
// Input: hmod - module to check for this filename (can't be NULL)
// lszFile - filename and extension
//
// Returns: handle to source file, or NULL if not found
//
// Notes: ONLY the filename and extension of lszFile are
// matched! There must be no path on the lszFile
HSF
SLHsfFromFile (
HMOD hmod,
LSZ lszFile
)
{
// We need to handle the no-hit case w/o loading source info
LPSF lpsf = NULL;
LPMDS lpmds = (LPMDS) hmod;
char szFileBuf[_MAX_PATH];
LPSTR lszFileT;
assert(lszFile);
assert(*lszFile != '\0');
// If the filename is quoted, remove the quotes.
if ((*lszFile == '\"') && (*(lszFile + _tcslen(lszFile) - 1) == '\"')) {
lszFileT = szFileBuf;
memcpy(lszFileT, _tcsinc(lszFile), _tcslen(lszFile) - 2);
lszFileT[_tcslen(lszFile)-2] = '\0';
} else {
lszFileT = lszFile;
}
if (lpmds != NULL) {
short isf = IsfFromName (FALSE, 0, lszFileT, lpmds);
if (isf != -1) {
lpsf = GetLpsfFromIndex ((LPSM) HstFromLpmds (lpmds), isf);
}
}
return lpsf;
}
LOCAL HST
HstFromLpmds (
LPMDS lpmds
)
{
if (lpmds->hst != NULL) {
return lpmds->hst;
} else if (lpmds->pmod) {
// Allocate space for this module's line number information,
// then load it from the PDB and sort it.
if (!ModQueryLines(lpmds->pmod, 0, (CB *)&lpmds->cbhst) ||
!(lpmds->cbhst) ||
!(lpmds->hst = MHAlloc(lpmds->cbhst)))
return 0;
if (ModQueryLines(lpmds->pmod, (PB)lpmds->hst, (CB *)&lpmds->cbhst)) {
SortSM((LPSM)lpmds->hst);
return lpmds->hst;
} else {
MHFree(lpmds->hst);
lpmds->hst = 0;
return 0;
}
} else if (lpmds->ulhst == 0) {
return NULL;
} else {
assert(FALSE); // We should never hit this code now
// that we're mapped.
LPEXG lpexg = (LPEXG) LLLock (lpmds->hexg);
INT hfile = SYOpen (lpexg->lszDebug);
HST hst = MHAlloc ((UINT) lpmds->cbhst);
if (hfile == -1 || hst == NULL) {
LLUnlock (lpmds->hexg);
return NULL;
}
if (SYSeek(hfile, lpmds->ulhst, SEEK_SET) != (LONG) lpmds->ulhst) {
assert(FALSE);
}
if (SYReadFar (hfile, (LPB) hst, (UINT) lpmds->cbhst) != lpmds->cbhst) {
assert (FALSE);
}
SYClose (hfile);
lpmds->hst = hst;
LLUnlock (lpmds->hexg);
SortSM ((LPSM)hst);
return hst;
}
}
__inline VOID
SortSM (
LPSM lpsm
)
{
short isf = 0;
LPSF lpsf = NULL;
while ((lpsf = GetLpsfFromIndex (lpsm, isf)) != NULL) {
WORD isl = 0;
LPSL lpsl = NULL;
while ((lpsl = GetLpslFromIndex (lpsm, lpsf, isl)) != NULL) {
if (!FCheckSLOrder (lpsl)) {
SortSL (lpsl);
}
isl += 1;
}
isf += 1;
}
}
BOOL
FCheckSLOrder (
LPSL lpsl
)
{
BOOL fSorted = TRUE;
int fChanged = FALSE;
int coff = lpsl->cLnOff;
LPUL rgoff = lpsl->offset;
LPW rgln = (LPW) &lpsl->offset [ coff ];
int ioff = 0;
for (ioff = 1; ioff < coff; ioff++) {
if (rgoff [ioff] == rgoff[ioff-1]) {
// Yes this is extremely slow, but it is safe, and the
// condition that causes this move should only happen
// in a very odd case when the QC back end screws up.
memmove(&rgoff[ioff - 1],
&rgoff[ioff],
(coff - ioff) * sizeof(ULONG));
memmove(&rgln[ioff - 1],
&rgln[ioff],
(coff - ioff) * sizeof(WORD));
fChanged = TRUE;
coff -= 1;
}
else if (rgoff [ ioff ] < rgoff [ ioff - 1 ]) {
fSorted = FALSE;
}
}
if (fChanged) {
memmove(&rgoff[coff],
rgln,
coff * sizeof(WORD));
lpsl->cLnOff = coff;
}
return fSorted;
}
__inline VOID
SortOffFromBounds (
WORD cbnds,
LPBNDS rgbnds,
WORD coff,
LPUL rgoff
)
{
SortFromBounds (cbnds, rgbnds, coff, rgoff, sizeof (ULONG));
}
__inline VOID
SortLnFromBounds (
WORD cbnds,
LPBNDS rgbnds,
WORD cln,
LPW rgln
)
{
SortFromBounds (cbnds, rgbnds, cln, rgln, sizeof (WORD));
}
__inline VOID
SortFromBounds (
WORD cbnds,
LPBNDS rgbnds,
WORD cv,
LPV rgv,
WORD cbv
)
{
LPV lpv = MHAlloc (cbv * cv);
WORD ibnds = 0;
WORD iv = 0;
if (lpv == NULL) {
return;
}
for (ibnds = 0; ibnds < cbnds; ibnds++) {
WORD cvT = rgbnds [ ibnds ].ilnEnd - rgbnds [ ibnds ].ilnStart + 1;
memcpy(((LPB) lpv) + (iv * cbv),
((LPB) rgv) + (rgbnds[ibnds].ilnStart * cbv),
cvT * cbv);
iv += cvT;
}
memcpy(rgv, lpv, cbv * cv);
MHFree(lpv);
}
__inline VOID
SortSL (
LPSL lpsl
)
{
WORD coff = lpsl->cLnOff;
LPUL rgoff = lpsl->offset;
LPW rgln = (LPW) &lpsl->offset [ coff ];
WORD cbnds = 0;
LPBNDS rgbnds = NULL;
rgbnds = BuildBounds (coff, rgoff, &cbnds);
if (rgbnds != NULL) {
SortOffFromBounds (cbnds, rgbnds, coff, rgoff);
SortLnFromBounds (cbnds, rgbnds, coff, rgln );
MHFree (rgbnds);
}
}
__inline WORD
FindPosition (
LPBNDS rgbnds,
WORD cbnds,
LPUL rgoff,
ULONG uoff
)
{
WORD ibnds = 0;
// This should be a binary search - but existing test cases
// contain so few blocks that I'm not going to bother right now
while (ibnds < cbnds) {
if (rgoff [ rgbnds [ ibnds ].ilnEnd ] > uoff) {
break;
}
ibnds += 1;
}
return ibnds;
}
__inline LPBNDS
InsertBlock (
WORD ibnds,
WORD cbnds,
LPBNDS rgbnds,
LPW lpcbndsMax,
LPW lpcbndsAlloc
)
{
if (*lpcbndsMax + cbnds > *lpcbndsAlloc) {
// If the insert is going to run over the currently allocated
// block array, reallocate it to give more room
rgbnds = (LPBNDS) MHRealloc(rgbnds, sizeof(BNDS) * (*lpcbndsAlloc + cbndsAllocBlock));
*lpcbndsAlloc += cbndsAllocBlock;
}
if (ibnds < *lpcbndsMax) {
// If we're somewhere in the middle of the array, we need
// to shift the remainder up in memory.
memmove(&rgbnds[ibnds + cbnds],
&rgbnds[ibnds],
(*lpcbndsMax - ibnds) * sizeof(BNDS));
}
*lpcbndsMax += cbnds;
return rgbnds;
}
__inline WORD
ScanBlock (
LPUL rgoff,
WORD coff,
WORD ioff,
ULONG uoffMax
)
{
while (ioff + 1 < coff &&
rgoff [ ioff + 1 ] > rgoff [ ioff ] &&
rgoff [ ioff + 1 ] < uoffMax)
{
ioff += 1;
}
return ioff;
}
LPBNDS
BuildBounds (
WORD coff,
LPUL rgoff,
LPW lpcbnds
)
{
LPBNDS rgbnds = (LPBNDS) MHAlloc (sizeof (BNDS) * cbndsAllocBlock);
WORD cbndsAlloc = cbndsAllocBlock;
WORD cbnds = 0;
WORD ioff = 0;
while (ioff < coff) {
ULONG uoffCurr = rgoff [ ioff ];
ULONG uoffMax = 0;
WORD ibnds = FindPosition (rgbnds, cbnds, rgoff, uoffCurr);
if (ibnds == cbnds) {
// We're after all other known blocks, so our max
// is "infinity"
uoffMax = 0xFFFFFFFF;
rgbnds = InsertBlock (ibnds, 1, rgbnds, &cbnds, &cbndsAlloc);
} else if (rgoff [ rgbnds [ ibnds ].ilnStart ] > uoffCurr) {
// We're at an insertion point, not in the middle of
// another block candidate
uoffMax = rgoff [ rgbnds [ ibnds ].ilnStart ];
rgbnds = InsertBlock (ibnds, 1, rgbnds, &cbnds, &cbndsAlloc);
} else {
// We're in the middle of another block candidate, so we
// must split it in two
rgbnds = InsertBlock (ibnds, 2, rgbnds, &cbnds, &cbndsAlloc);
// Start of ibnds is already set
rgbnds [ ibnds ].ilnEnd = ScanBlock (
rgoff,
coff,
rgbnds [ ibnds ].ilnStart,
uoffCurr
);
rgbnds [ ibnds + 2 ].ilnStart = rgbnds [ ibnds ].ilnEnd + 1;
// End of ibnds + 2 is already set
uoffMax = rgoff [ rgbnds [ ibnds + 2 ].ilnStart ];
ibnds += 1;
}
rgbnds [ ibnds ].ilnStart = ioff;
rgbnds [ ibnds ].ilnEnd = ScanBlock (rgoff, coff, ioff, uoffMax);
ioff = rgbnds [ ibnds ].ilnEnd + 1;
}
*lpcbnds = cbnds;
return rgbnds;
}
Reference in New Issue Copy Permalink