archive
/
windows-server-2003
mirror of https://github.com/selfrender/Windows-Server-2003
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Leaked source code of windows server 2003
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2 Commits
1 Branch
0 Tags
1.5 GiB
 
 
 
 
 
 
Tree: 7b07a90fc1
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '7b07a90fc1'
${ noResults }
windows-server-2003/sdktools/debuggers/symtodbg/symcvt/cvcommon.c

816 lines
19 KiB
Raw Blame History

/*++
Copyright 1996 - 1997 Microsoft Corporation
Module Name:
cvcommon.c
Abstract:
This file contians a set of common routines which are used in
doing symbol conversions from one type of symbols to CodeView
symbols.
Author:
Wesley A. Witt (wesw) 19-April-1993
Jim Schaad (jimsch) 22 May 1993
--*/
#include <windows.h>
#include <stdlib.h>
#include "cv.h"
#include "symcvt.h"
#include "cvcommon.h"
typedef struct tagSYMHASH {
DWORD dwHashVal; // hash value for the symbol
DWORD dwHashBucket; // hash bucket number
DATASYM32 * dataSym; // pointer to the symbol info
} SYMHASH;
typedef struct tagOFFSETSORT {
DWORD dwOffset; // offset for the symbol
DWORD dwSection; // section number of the symbol
DATASYM32 * dataSym; // pointer to the symbol info
} OFFSETSORT;
int __cdecl SymHashCompare( const void *arg1, const void *arg2 );
int __cdecl OffsetSortCompare( const void *arg1, const void *arg2 );
DWORD
CreateSignature( PPOINTERS p )
/*++
Routine Description:
Creates the CODEVIEW signature record. Currently this converter only
generates NB09 data (MS C/C++ 8.0).
Arguments:
p - pointer to a POINTERS structure (see symcvt.h)
Return Value:
number of records generates, this is always 1.
--*/
{
OMFSignature *omfSig;
omfSig = (OMFSignature *) p->pCvCurr;
strcpy( omfSig->Signature, "NB09" );
omfSig->filepos = 0;
p->pCvStart.size += sizeof(OMFSignature);
p->pCvCurr = (PUCHAR) p->pCvCurr + sizeof(OMFSignature);
return 1;
} /* CreateSignature() */
DWORD
CreateDirectories( PPOINTERS p )
/*++
Routine Description:
This is the control function for the generation of the CV directories.
It calls individual functions for the generation of specific types of
debug directories.
Arguments:
p - pointer to a POINTERS structure (see symcvt.h)
Return Value:
the number of directories created.
--*/
{
OMFDirHeader *omfDir = (OMFDirHeader *)p->pCvCurr;
OMFSignature *omfSig = (OMFSignature *)p->pCvStart.ptr;
OMFDirEntry *omfDirEntry = NULL;
omfSig->filepos = (DWORD)p->pCvCurr - (DWORD)p->pCvStart.ptr;
omfDir->cbDirHeader = sizeof(OMFDirHeader);
omfDir->cbDirEntry = sizeof(OMFDirEntry);
omfDir->cDir = 0;
omfDir->lfoNextDir = 0;
omfDir->flags = 0;
p->pCvStart.size += sizeof(OMFDirHeader);
p->pCvCurr = (PUCHAR) p->pCvCurr + sizeof(OMFDirHeader);
omfDir->cDir += CreateModuleDirectoryEntries( p );
omfDir->cDir += CreatePublicDirectoryEntries( p );
omfDir->cDir += CreateSegMapDirectoryEntries( p );
omfDir->cDir += CreateSrcModulesDirectoryEntries( p );
strcpy(p->pCvCurr, "NB090000");
p->pCvStart.size += 8;
p->pCvCurr += 8;
*((DWORD *) (p->pCvCurr-4)) = p->pCvStart.size;
return omfDir->cDir;
} /* CreateDirectories() */
DWORD
CreateModuleDirectoryEntries( PPOINTERS p )
/*++
Routine Description:
Creates directory entries for each module in the image.
Arguments:
p - pointer to a POINTERS structure (see symcvt.h)
Return Value:
the number of directory entries created.
--*/
{
OMFDirEntry *omfDirEntry = NULL;
OMFModule *m = NULL;
OMFModule *mNext = NULL;
DWORD i = 0;
DWORD mSize = 0;
DWORD lfo = (DWORD)p->pCvModules.ptr - (DWORD)p->pCvStart.ptr;
m = (OMFModule *) p->pCvModules.ptr;
for (i=0; i<p->pCvModules.count; i++) {
mNext = NextMod(m);
omfDirEntry = (OMFDirEntry *) p->pCvCurr;
mSize = (DWORD)mNext - (DWORD)m;
omfDirEntry->SubSection = sstModule;
omfDirEntry->iMod = (USHORT) i + 1;
omfDirEntry->lfo = lfo;
omfDirEntry->cb = mSize;
lfo += mSize;
p->pCvStart.size += sizeof(OMFDirEntry);
p->pCvCurr = (PUCHAR) p->pCvCurr + sizeof(OMFDirEntry);
m = mNext;
}
return p->pCvModules.count;
} /* CreateModuleDirectoryEntries() */
DWORD
CreatePublicDirectoryEntries( PPOINTERS p )
/*++
Routine Description:
Creates the directory entry for the global publics.
Arguments:
p - pointer to a POINTERS structure (see symcvt.h)
Return Value:
the number of directory entries created, always 1.
--*/
{
OMFDirEntry *omfDirEntry = (OMFDirEntry *) p->pCvCurr;
omfDirEntry->SubSection = sstGlobalPub;
omfDirEntry->iMod = 0xffff;
omfDirEntry->lfo = (DWORD)p->pCvPublics.ptr - (DWORD)p->pCvStart.ptr;
omfDirEntry->cb = p->pCvPublics.size;
p->pCvStart.size += sizeof(OMFDirEntry);
p->pCvCurr = (PUCHAR) p->pCvCurr + sizeof(OMFDirEntry);
return 1;
} /* CreatePublicDirectoryEntries() */
DWORD
CreateSegMapDirectoryEntries( PPOINTERS p )
/*++
Routine Description:
Creates the directory entry for the segment map.
Arguments:
p - pointer to a POINTERS structure (see symcvt.h)
Return Value:
the number of directory entries created, always 1.
--*/
{
OMFDirEntry *omfDirEntry = (OMFDirEntry *) p->pCvCurr;
omfDirEntry->SubSection = sstSegMap;
omfDirEntry->iMod = 0xffff;
omfDirEntry->lfo = (DWORD)p->pCvSegMap.ptr - (DWORD)p->pCvStart.ptr;
omfDirEntry->cb = p->pCvSegMap.size;
p->pCvStart.size += sizeof(OMFDirEntry);
p->pCvCurr = (PUCHAR) p->pCvCurr + sizeof(OMFDirEntry);
return 1;
} /* CreateSegMapDirectoryEntries() */
DWORD
CreateSrcModulesDirectoryEntries( PPOINTERS p )
/*++
Routine Description:
Creates directory entries for each source module in the image.
Arguments:
p - pointer to a POINTERS structure (see symcvt.h)
Return Value:
the number of directory entries created.
--*/
{
OMFDirEntry *omfDirEntry = NULL;
DWORD i;
DWORD lfo = (DWORD)p->pCvSrcModules.ptr - (DWORD)p->pCvStart.ptr;
DWORD j = lfo;
OMFSourceModule *m;
//
// if there were no linenumber conversions then bail out
//
if (!p->pCvSrcModules.count) {
return 0;
}
for (i=0; i<p->pCvSrcModules.count; i++) {
if (!p->pMi[i].SrcModule) {
continue;
}
omfDirEntry = (OMFDirEntry *) p->pCvCurr;
omfDirEntry->SubSection = sstSrcModule;
omfDirEntry->iMod = (USHORT) p->pMi[i].iMod;
omfDirEntry->lfo = lfo;
omfDirEntry->cb = p->pMi[i].cb;
m = (OMFSourceModule*) p->pMi[i].SrcModule;
lfo += omfDirEntry->cb;
p->pCvStart.size += sizeof(OMFDirEntry);
p->pCvCurr = (PUCHAR) p->pCvCurr + sizeof(OMFDirEntry);
}
free( p->pMi );
return p->pCvSrcModules.count;
} /* CreateSrcModulesDirectoryEntries() */
#define byt_toupper(b) (b & 0xDF)
#define dwrd_toupper(dw) (dw & 0xDFDFDFDF)
DWORD
DWordXorLrl( char *szSym )
/*++
Routine Description:
This function will take an ascii character string and generate
a hash for that string. The hash algorithm is the CV NB09 hash
algorithm.
Arguments:
szSym - a character pointer, the first char is the string length
Return Value:
The generated hash value.
--*/
{
char *pName = szSym+1;
int cb = (int)(*szSym & 0x000000FF); // byte to int conversion.
char *pch;
char c;
DWORD hash = 0, ulEnd = 0;
DWORD UNALIGNED *pul;
// Replace all "::" with "__" for hashing purposes
c = *(pName+cb);
*(pName+cb) = '\0';
pch = strstr( pName, "::" );
if ( pch ) {
*pch++ = '_';
*pch = '_';
}
*(pName+cb) = c;
// If we're standard call, skip the trailing @999
pch = pName + cb - 1;
while (isdigit(*pch)) {
pch--;
}
if (*pch == '@') {
cb = pch - pName;
}
// If we're fastcall, skip the leading '@'
if (*pName == '@') {
pName++;
cb--;
}
// Calculate the odd byte hash.
while (cb & 3) {
ulEnd |= byt_toupper (pName[cb-1]);
ulEnd <<=8;
cb--;
}
pul = (DWORD UNALIGNED *)pName;
// calculate the dword hash for the remaining
while (cb) {
hash ^= dwrd_toupper(*pul);
hash = _lrotl (hash, 4);
pul++;
cb -=4;
}
// or in the remainder
hash ^= ulEnd;
return hash;
} /* DWordXorLrl() */
OMFModule *
NextMod(
OMFModule * pMod
)
/*++
Routine Description:
description-of-function.
Arguments:
argument-name - Supplies | Returns description of argument.
.
.
Return Value:
return-value - Description of conditions needed to return value. - or -
None.
--*/
{
char * pb;
pb = (char *) &(pMod->SegInfo[pMod->cSeg]);
pb += *pb + 1;
pb = (char *) (((unsigned long) pb + 3) & ~3);
return (OMFModule *) pb;
} /* NextMod() */
int
__cdecl
SymHashCompare(
const void * arg1,
const void * arg2
)
/*++
Routine Description:
Sort compare function for sorting SYMHASH records by hashed
bucket number.
Arguments:
arg1 - record #1
arg2 - record #2
Return Value:
-1 - record #1 is < record #2
0 - records are equal
1 - record #1 is > record #2
--*/
{
if (((SYMHASH*)arg1)->dwHashBucket < ((SYMHASH*)arg2)->dwHashBucket) {
return -1;
}
if (((SYMHASH*)arg1)->dwHashBucket > ((SYMHASH*)arg2)->dwHashBucket) {
return 1;
}
// BUGBUG: Should we second sort on the hash value?
return 0;
} /* SymHashCompare() */
// Symbol Offset/Hash structure
typedef struct _SOH {
DWORD uoff;
DWORD ulHash;
} SOH;
#define MINHASH 6 // Don't create a hash with fewer than 6 slots
DWORD
CreateSymbolHashTable(
PPOINTERS p
)
/*++
Routine Description:
Creates the CV symbol hash table. This hash table is used
primarily by debuggers to access symbols in a quick manner.
Arguments:
p - pointer to a POINTERS structure (see symcvt.h)
Return Value:
The number of buckets is the hash table.
--*/
{
DWORD i;
DWORD j;
int k;
DWORD numsyms;
DWORD numbuckets;
OMFSymHash *omfSymHash;
DATASYM32 *dataSymStart;
DATASYM32 *dataSym;
LPVOID pHashData;
USHORT *pCHash;
DWORD *pHashTable;
DWORD *pBucketCounts;
DWORD *pChainTable;
SYMHASH *symHashStart;
SYMHASH *symHash;
// DWORD dwHashVal;
char * sz;
numsyms = p->pCvPublics.count;
numbuckets = (numsyms+9) / 10;
numbuckets = (1 + numbuckets) & ~1;
numbuckets = __max(numbuckets, MINHASH);
symHashStart =
symHash = (SYMHASH *) malloc( numsyms * sizeof(SYMHASH) );
if (symHashStart == NULL) {
return 0;
}
memset( symHashStart, 0, numsyms * sizeof(SYMHASH) );
pHashData = (LPVOID) p->pCvCurr;
pCHash = (USHORT *) pHashData;
pHashTable = (DWORD *) ((DWORD)pHashData + sizeof(DWORD));
pBucketCounts = (DWORD *) ((DWORD)pHashTable +
(sizeof(DWORD) * numbuckets));
memset(pBucketCounts, 0, sizeof(DWORD) * numbuckets);
pChainTable = (DWORD *) ((DWORD)pBucketCounts +
((sizeof(ULONG) * numbuckets)));
omfSymHash = (OMFSymHash *) p->pCvPublics.ptr;
dataSymStart =
dataSym = (DATASYM32 *) ((DWORD)omfSymHash + sizeof(OMFSymHash));
*pCHash = (USHORT)numbuckets;
/*
* cruise thru the symbols and calculate the hash values
* and the hash bucket numbers; save the info away for later use
*/
for (i=0; i<numsyms; i++, symHash++) {
switch( dataSym->rectyp ) {
case S_PUB16:
sz = dataSym->name;
break;
case S_PUB32:
sz = ((DATASYM32 *) dataSym)->name;
break;
default:
continue;
}
symHash->dwHashVal = DWordXorLrl( sz );
symHash->dwHashBucket = symHash->dwHashVal % numbuckets;
pBucketCounts[symHash->dwHashBucket] += 1;
symHash->dataSym = dataSym;
dataSym = ((DATASYM32 *) ((char *) dataSym + dataSym->reclen + 2));
}
qsort( (void*)symHashStart, numsyms, sizeof(SYMHASH), SymHashCompare );
j = (char *)pChainTable - (char *)pHashData;
for (i=0, k = 0;
i < numbuckets;
k += pBucketCounts[i], i += 1, pHashTable++ )
{
*pHashTable = (DWORD) j + (k * sizeof(DWORD) * 2);
}
dataSymStart = (DATASYM32 *) (PUCHAR)((DWORD)omfSymHash);
for (i=0,symHash=symHashStart; i<numsyms; i++,symHash++,pChainTable++) {
*pChainTable = (DWORD) (DWORD)symHash->dataSym - (DWORD)dataSymStart;
++pChainTable;
*pChainTable = symHash->dwHashVal;
}
UpdatePtrs( p, &p->pCvSymHash, (LPVOID)pChainTable, numsyms );
omfSymHash->symhash = 10;
omfSymHash->cbHSym = p->pCvSymHash.size;
free( symHashStart );
return numbuckets;
} /* CreateSymbolHashTable() */
VOID
UpdatePtrs( PPOINTERS p, PPTRINFO pi, LPVOID lpv, DWORD count )
/*++
Routine Description:
This function is called by ALL functions that put data into the
CV data area. After putting the data into the CV memory this function
must be called. It will adjust all of the necessary pointers so the
the next guy doesn't get hosed.
Arguments:
p - pointer to a POINTERS structure (see symcvt.h)
pi - the CV pointer that is to be updated
lpv - current pointer into the CV data
count - the number of items that were placed into the CV data
Return Value:
void
--*/
{
if (!count) {
return;
}
pi->ptr = p->pCvCurr;
pi->size = (DWORD) ((DWORD)lpv - (DWORD)p->pCvCurr);
pi->count = count;
p->pCvStart.size += pi->size;
p->pCvCurr = (PUCHAR) lpv;
return;
} /* UpdatePtrs() */
int
__cdecl
OffsetSortCompare( const void *arg1, const void *arg2 )
/*++
Routine Description:
Sort compare function for sorting OFFETSORT records by section number.
Arguments:
arg1 - record #1
arg2 - record #2
Return Value:
-1 - record #1 is < record #2
0 - records are equal
1 - record #1 is > record #2
--*/
{
if (((OFFSETSORT*)arg1)->dwSection < ((OFFSETSORT*)arg2)->dwSection) {
return -1;
}
if (((OFFSETSORT*)arg1)->dwSection > ((OFFSETSORT*)arg2)->dwSection) {
return 1;
}
if (((OFFSETSORT*)arg1)->dwOffset < ((OFFSETSORT*)arg2)->dwOffset) {
return -1;
}
if (((OFFSETSORT*)arg1)->dwOffset > ((OFFSETSORT*)arg2)->dwOffset) {
return 1;
}
return 0;
} /* OffsetSortCompare() */
DWORD
CreateAddressSortTable( PPOINTERS p )
/*++
Routine Description:
Creates the CV address sort table. This hash table is used
primarily by debuggers to access symbols in a quick manner when
all you have is an address.
Arguments:
p - pointer to a POINTERS structure (see symcvt.h)
Return Value:
The number of sections in the table.
--*/
{
DWORD i;
DWORD j;
int k;
DWORD numsyms = p->pCvPublics.count;
DWORD numsections;
OMFSymHash *omfSymHash;
DATASYM32 *dataSymStart;
DATASYM32 *dataSym;
LPVOID pAddressData;
USHORT *pCSeg;
DWORD *pSegTable;
DWORD *pOffsetCounts;
DWORD *pOffsetTable;
OFFSETSORT *pOffsetSortStart;
OFFSETSORT *pOffsetSort;
extern int CSymSegs;
if (p->iptrs.fileHdr) {
numsections = p->iptrs.fileHdr->NumberOfSections;
} else if (p->iptrs.sepHdr) {
numsections = p->iptrs.sepHdr->NumberOfSections;
} else {
numsections = CSymSegs;
}
pOffsetSortStart =
pOffsetSort = (OFFSETSORT *) malloc( numsyms * sizeof(OFFSETSORT) );
if (pOffsetSort == NULL) {
return 0;
}
memset( pOffsetSortStart, 0, numsyms * sizeof(OFFSETSORT) );
pAddressData = (LPVOID) p->pCvCurr;
pCSeg = (USHORT *) pAddressData;
pSegTable = (DWORD *) ((DWORD)pAddressData + sizeof(DWORD));
pOffsetCounts = (DWORD *) ((DWORD)pSegTable +
(sizeof(DWORD) * numsections));
pOffsetTable = (DWORD *) ((DWORD)pOffsetCounts +
((sizeof(DWORD) * numsections)));
// if (numsections & 1) {
// pOffsetTable = (DWORD *) ((DWORD)pOffsetTable + 2);
// }
omfSymHash = (OMFSymHash *) p->pCvPublics.ptr;
dataSymStart =
dataSym = (DATASYM32 *) ((DWORD)omfSymHash + sizeof(OMFSymHash));
*pCSeg = (USHORT)numsections;
for (i=0;
i<numsyms;
i++, pOffsetSort++)
{
switch(dataSym->rectyp) {
case S_PUB16:
pOffsetSort->dwOffset = dataSym->off;
pOffsetSort->dwSection = dataSym->seg;
break;
case S_PUB32:
pOffsetSort->dwOffset = ((DATASYM32 *) dataSym)->off;
pOffsetSort->dwSection = ((DATASYM32 *) dataSym)->seg;
}
pOffsetSort->dataSym = dataSym;
pOffsetCounts[pOffsetSort->dwSection - 1] += 1;
dataSym = ((DATASYM32 *) ((char *) dataSym + dataSym->reclen + 2)); }
//#if 0
qsort((void*)pOffsetSortStart, numsyms, sizeof(OFFSETSORT), OffsetSortCompare );
//#endif
j = (DWORD) (DWORD)pOffsetTable - (DWORD)pAddressData;
for (i=0, k=0;
i < numsections;
k += pOffsetCounts[i], i += 1, pSegTable++)
{
*pSegTable = (DWORD) j + (k * sizeof(DWORD) * 2);
}
dataSymStart = (DATASYM32 *) (PUCHAR)((DWORD)omfSymHash);
for (i=0, pOffsetSort=pOffsetSortStart;
i < numsyms;
i++, pOffsetSort++, pOffsetTable++)
{
*pOffsetTable = (DWORD)pOffsetSort->dataSym - (DWORD)dataSymStart;
pOffsetTable++;
*pOffsetTable = pOffsetSort->dwOffset;
}
UpdatePtrs( p, &p->pCvAddrSort, (LPVOID)pOffsetTable, numsyms );
omfSymHash->addrhash = 12;
omfSymHash->cbHAddr = p->pCvAddrSort.size;
free( pOffsetSortStart );
return numsections;
} /* CreateAddressSort() */