CV_uoff32_t
WINAPI
PHGetNearestHsym(
LPADDR lpaddr,
HEXE hexe,
PHSYM phsym
)
{
CV_uoff32_t dCur = CV_MAXOFFSET;
LPEXE lpexe;
LPEXG lpexg;
*phsym = NULL;
if (!VerifyHexe (hexe)) {
return dCur;
}
SHWantSymbols(hexe);
lpexe = (LPEXE) LLLock (hexe);
if (lpexe->hexg != hexgNull) {
lpexg = (LPEXG) LLLock (lpexe->hexg);
*phsym = FindNearest (lpexg, lpaddr, (LPL) &dCur);
LLUnlock(lpexe->hexg);
}
LLUnlock(hexe);
return dCur;
}
HTYPE LOADDS PASCAL THGetTypeFromIndex ( HMOD hmod, THIDX index ) {
HTYPE htype = (HTYPE)NULL;
if ( hmod && !CV_IS_PRIMITIVE (index) ) {
HEXG hexg = SHHexgFromHmod ( hmod );
LPEXG lpexg = LLLock ( hexg );
#ifdef HOST32 //{
if (lpexg->ppdb) {
assert (lpexg->ptpi);
if (index < TypesQueryTiMac(lpexg->ptpi)) {
if (!TypesQueryPbCVRecordForTi(lpexg->ptpi, index, (PB*) &htype)){
htype = (HTYPE) NULL;
}
}
}
else {
htype = NB09GetTypeFromIndex (lpexg, index);
}
#else // }{
htype = NB09GetTypeFromIndex (lpexg, index);
#endif // }
LLUnlock( hexg );
}
return htype;
}
LPCH
WINAPI
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;
}
HSYM
WINAPI
FindNameInStatics(
HSYM hsym,
PCXT pcxt,
LPSSTR lpsstr,
SHFLAG fCase,
PFNCMP pfnCmp,
PCXT pcxtOut
)
{
HEXG hexg = hexgNull;
HMOD hmod = hmodNull;
LPEXG lpexg = NULL;
LPGST lpgst = NULL;
SYMPTR psym = NULL;
*pcxtOut = *pcxt;
pcxtOut->hProc = NULL;
pcxtOut->hBlk = NULL;
if (!pcxt->hGrp) {
return NULL;
}
hexg = SHHexgFromHmod (pcxt->hGrp);
lpexg = (LPEXG) LLLock (hexg);
psym = FindNameHashedInStatics(lpexg, (SYMPTR) hsym, lpsstr, pfnCmp, fCase, &hmod);
if (hmod != hmodNull) {
pcxtOut->hMod = pcxt->hGrp = hmod;
switch (psym->rectyp) {
case S_LPROC32:
case S_GPROC32:
case S_LPROC16:
case S_GPROC16:
case S_LPROCMIPS:
case S_GPROCMIPS:
emiAddr (pcxtOut->addr) = (HEMI) SHHexeFromHmod (hmod);
SHAddrFromHsym (&pcxtOut->addr, psym);
SHHPROCFrompCXT(pcxtOut) = psym;
break;
default: {
LPMDS lpmds = (LPMDS) hmod;
SetAddrFromMod(lpmds, &pcxtOut->addr);
emiAddr (pcxtOut->addr) = (HEMI) SHHexeFromHmod (hmod);
ADDR_IS_LI (pcxtOut->addr) = TRUE;
break;
}
}
}
LLUnlock (hexg);
return psym;
}
HSYM
WINAPI
SHFindNameInTypes(
PCXT pcxt,
LPSSTR lpsstr,
SHFLAG fCase,
PFNCMP pfnCmp,
PCXT pcxtOut
)
{
HEXG hexg = hexgNull;
LPEXG lpexg = NULL;
UDTPTR psym = NULL;
char szBuf[256];
unsigned iHash;
TI ti;
*pcxtOut = *pcxt;
pcxtOut->hProc = NULL;
pcxtOut->hBlk = NULL;
if (!pcxt->hMod || ( lpsstr->searchmask & SSTR_NoHash )) {
return NULL;
}
hexg = SHHexgFromHmod ( pcxt->hMod );
lpexg = (LPEXG)LLLock ( hexg );
if (!lpexg->ptpi) {
LLUnlock ( hexg );
return NULL;
}
if (!STABFindUDTSym(lpexg->pstabUDTSym, lpsstr, pfnCmp, fCase, &psym, &iHash)) {
TPI* ptpi = 0;
#ifdef HOST32
#if CC_LAZYTYPES
if ( ((LPMDS)pcxt->hMod)->pmod ) { /* use the mod's type server */
ModQueryTpi( ((LPMDS)pcxt->hMod)->pmod, &ptpi );
}
#endif
#endif
if ( ptpi == 0 ) ptpi = lpexg->ptpi;
lpStrToSz(lpsstr, szBuf);
assert(ptpi);
if (!TypesQueryTiForUDT(ptpi, szBuf, fCase, &ti) ||
!STABAddUDTSym(lpexg->pstabUDTSym, lpsstr, iHash, &psym)) {
LLUnlock ( hexg );
return NULL;
}
assert(psym);
psym->typind = ti;
}
LLUnlock ( hexg );
return (SYMPTR) psym;
}
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);
HANDLE hfile = SYOpen (lpexg->lszDebug);
HST hst = MHAlloc ((UINT) lpmds->cbhst);
if (hfile == INVALID_HANDLE_VALUE || 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;
}
}
HSYM
WINAPI
PHFindNameInPublics(
HSYM hsym,
HEXE hexe,
LPSSTR lpsstr,
SHFLAG fCase,
PFNCMP pfnCmp
)
{
SYMPTR psym = NULL;
LPEXE lpexe;
LPEXG lpexg;
SHWantSymbols(hexe);
if (hexe != hexeNull) {
lpexe = (LPEXE) LLLock (hexe);
if (lpexe->hexg == hexgNull) {
psym = (SYMPTR)NULL;
} else {
lpexg = (LPEXG) LLLock (lpexe->hexg);
if (lpsstr->searchmask & SSTR_NoHash) {
psym = FindNameLinearInPubs (lpexg, (SYMPTR)hsym, lpsstr, pfnCmp, fCase);
} else {
psym = FindNameHashedInPubs (lpexg, (SYMPTR)hsym, lpsstr, pfnCmp, fCase, NULL);
}
LLUnlock (lpexe->hexg);
}
LLUnlock (hexe);
}
return psym;
}
HSYM
WINAPI
SHFindNameInGlobal(
HSYM hsym,
PCXT pcxt,
LPSSTR lpsstr,
SHFLAG fCase,
PFNCMP pfnCmp,
PCXT pcxtOut
)
{
HEXG hexg;
LPEXG lpexg;
HEXE hexe;
LPEXE lpexe;
HMOD hmod = hmodNull;
LPGST lpgst = NULL;
SYMPTR psym = NULL;
*pcxtOut = *pcxt;
pcxtOut->hProc = NULL;
pcxtOut->hBlk = NULL;
if (!pcxt->hMod) {
return NULL;
}
hexe = SHHexeFromHmod(pcxt->hGrp ? pcxt->hGrp : pcxt->hMod);
lpexe = (LPEXE) LLLock(hexe);
hexg = lpexe->hexg;
lpexg = (LPEXG) LLLock (hexg);
LLUnlock(hexe);
// Make sure these symbols are loaded.
// SHWantSymbols(hexe);
if (lpsstr->searchmask & SSTR_NoHash) {
psym = FindNameLinearInGlobs (lpexg, (SYMPTR) hsym, lpsstr, pfnCmp, fCase);
} else {
psym = FindNameHashedInGlobs (lpexg, (SYMPTR) hsym, lpsstr, pfnCmp, fCase, &hmod);
if (hmod != hmodNull) {
pcxtOut->hMod = pcxt->hGrp = hmod;
switch (psym->rectyp) {
case S_LPROC32:
case S_GPROC32:
case S_LPROC16:
case S_GPROC16:
case S_LPROCMIPS:
case S_GPROCMIPS:
emiAddr (pcxtOut->addr) = (HEMI) SHHexeFromHmod (hmod);
SHAddrFromHsym (&pcxtOut->addr, psym);
SHHPROCFrompCXT(pcxtOut) = psym;
break;
default: {
LPMDS lpmds = (LPMDS) hmod;
SetAddrFromMod(lpmds, &pcxtOut->addr);
emiAddr (pcxtOut->addr) = (HEMI) SHHexeFromHmod (hmod);
ADDR_IS_LI (pcxtOut->addr) = TRUE;
break;
}
}
}
}
LLUnlock (hexg);
return psym;
}
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) {
_TCHAR * lpch = (_TCHAR *)lpexg->lpchFileNames;
_TCHAR * 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 + cbNameLen(lpch) - cbName + 1, cchName)) {
memset(szPathOMF, 0, _MAX_CVPATH);
memcpy(szPathOMF, lpch + 1, cbNameLen(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 += cbNameLen(lpch) + 1;
}
}
LLUnlock(lpexe->hexg);
}
LLUnlock(hexe);
return fRet;
}
BOOL
SLFLineToAddrExtended (
HSF hsf,
DWORD line,
WORD * piSegStart,
WORD * piEntryFind,
LPADDR lpaddr,
SHOFF * lpcbLn,
DWORD * rgwNearestLines
)
{
DWORD 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] = 0x7fffffff;
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;
DWORD wLine = 0;
DWORD 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);
SE_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;
}
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 ];
_TCHAR * lpch = (_TCHAR *)
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, (_TCHAR *) lpch + cbNameLen(lpch) - cbName + 1, cchName)) {
memset(szPathOMF, 0, _MAX_CVPATH);
memcpy(szPathOMF, lpch + 1, cbNameLen(lpch));
_tsplitpath(szPathOMF, NULL, NULL, szFile, szExt);
if (!_tcsicmp (szFileSrc, szFile) &&
!_tcsicmp (szExtSrc, szExt))
{
isfFound = isf;
break;
}
}
}
}
LLUnlock (lpmds->hexg);
return isfFound;
}