mirror of https://github.com/lianthony/NT4.0
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.
561 lines
12 KiB
561 lines
12 KiB
#include "dis32.h"
|
|
#include <alphaops.h>
|
|
#include "disalpha.h"
|
|
|
|
|
|
PIMAGE_RELOCATION
|
|
FindRelocation(ULONG Value, PIMAGE_SECTION_HEADER pSection)
|
|
{
|
|
PIMAGE_RELOCATION pReloc;
|
|
INT k = 0;
|
|
LONG SymIndex = -1;
|
|
pFileList File = FilesList;
|
|
|
|
pReloc = FilesList->pRelocations;
|
|
|
|
if ((File == NULL) ||
|
|
(File->pSymbolTable == NULL))
|
|
return NULL;
|
|
|
|
while ( k < pSection->NumberOfRelocations ) {
|
|
INT skip = 0;
|
|
|
|
switch( ArchitectureType) {
|
|
case IMAGE_FILE_MACHINE_ALPHA:
|
|
if (pReloc->Type == IMAGE_REL_ALPHA_PAIR ||
|
|
pReloc->Type == IMAGE_REL_ALPHA_ABSOLUTE) {
|
|
skip = 1;
|
|
}
|
|
break;
|
|
case IMAGE_FILE_MACHINE_R3000:
|
|
case IMAGE_FILE_MACHINE_R4000:
|
|
if (pReloc->Type == IMAGE_REL_MIPS_PAIR) {
|
|
skip = 1;
|
|
}
|
|
break;
|
|
case IMAGE_FILE_MACHINE_I386:
|
|
break;
|
|
}
|
|
|
|
if (pReloc->VirtualAddress == Value && skip == 0) {
|
|
return pReloc;
|
|
}
|
|
pReloc++;
|
|
k++;
|
|
}
|
|
|
|
if (SymIndex < 0)
|
|
return NULL;
|
|
}
|
|
|
|
|
|
PIMAGE_SYMBOL
|
|
FindObjSymbolByRelocation(ULONG Value, PIMAGE_SECTION_HEADER pSection)
|
|
{
|
|
PIMAGE_RELOCATION pReloc;
|
|
PIMAGE_SYMBOL pSym;
|
|
INT k = 0;
|
|
LONG SymIndex = -1;
|
|
pFileList File = FilesList;
|
|
|
|
pReloc = FilesList->pRelocations;
|
|
|
|
if ((File == NULL) ||
|
|
(File->pSymbolTable == NULL))
|
|
return NULL;
|
|
|
|
while ( k < pSection->NumberOfRelocations ) {
|
|
INT skip = 0;
|
|
|
|
switch( ArchitectureType) {
|
|
case IMAGE_FILE_MACHINE_ALPHA:
|
|
if (pReloc->Type == IMAGE_REL_ALPHA_MATCH ||
|
|
pReloc->Type == IMAGE_REL_ALPHA_PAIR ||
|
|
pReloc->Type == IMAGE_REL_ALPHA_ABSOLUTE) {
|
|
skip = 1;
|
|
}
|
|
break;
|
|
case IMAGE_FILE_MACHINE_R3000:
|
|
case IMAGE_FILE_MACHINE_R4000:
|
|
if (pReloc->Type == IMAGE_REL_MIPS_PAIR) {
|
|
skip = 1;
|
|
}
|
|
break;
|
|
case IMAGE_FILE_MACHINE_I386:
|
|
break;
|
|
}
|
|
|
|
if (pReloc->VirtualAddress == Value && skip == 0) {
|
|
SymIndex = pReloc->SymbolTableIndex;
|
|
break;
|
|
}
|
|
pReloc++;
|
|
k++;
|
|
}
|
|
|
|
if (SymIndex < 0)
|
|
return NULL;
|
|
|
|
//
|
|
// get symbol
|
|
//
|
|
|
|
pSym = (PIMAGE_SYMBOL)File->pSymbolTable;
|
|
pSym = &pSym[SymIndex];
|
|
|
|
return pSym;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
PIMAGE_SYMBOL
|
|
FindObjSymbolByAddress(ULONG value, ULONG Section)
|
|
{
|
|
pFileList File = FilesList; // global file list entry.
|
|
ULONG high;
|
|
ULONG low;
|
|
ULONG middle;
|
|
ULONG val;
|
|
ULONG escape = FALSE;
|
|
|
|
if (Option.Mask & DEBUG) {
|
|
fprintf(stderr,"Entry: find_exe_symbol\n");
|
|
}
|
|
|
|
if ((File == NULL) ||
|
|
(File->SymbolCount[Section] == 0))
|
|
return NULL;
|
|
|
|
//
|
|
// Binary Search the executable symbols and look for Value
|
|
//
|
|
|
|
high = File->SymbolCount[Section]-1;
|
|
low = 0;
|
|
|
|
do {
|
|
if (high-low == 1)
|
|
escape = TRUE;
|
|
|
|
middle = (high+low)/2;
|
|
val = File->pSectionSymbols[Section][middle].Value;
|
|
|
|
if (val == value)
|
|
return File->pSectionSymbols[Section][middle].pSymbol;
|
|
else if (val < value)
|
|
low = middle;
|
|
else
|
|
high = middle;
|
|
} while ((high > low) && !escape);
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
|
|
PIMAGE_SYMBOL
|
|
FindExeSymbol(ULONG value)
|
|
{
|
|
pFileList File = FilesList; // global file list entry.
|
|
ULONG high;
|
|
ULONG low;
|
|
ULONG middle;
|
|
ULONG val;
|
|
ULONG escape = FALSE;
|
|
|
|
if (Option.Mask & DEBUG) {
|
|
fprintf(stderr,"Entry: find_exe_symbol\n");
|
|
}
|
|
|
|
if ((File == NULL) ||
|
|
(File->SymbolCount[0] == 0))
|
|
return NULL;
|
|
|
|
//
|
|
// Binary Search the executable symbols and look for Value
|
|
//
|
|
|
|
high = File->SymbolCount[0]-1;
|
|
low = 0;
|
|
|
|
do {
|
|
if (high-low == 1)
|
|
escape = TRUE;
|
|
|
|
middle = (high+low)/2;
|
|
val = File->pSectionSymbols[0][middle].Value;
|
|
|
|
if (val == value) {
|
|
|
|
//
|
|
// hack! (wim)
|
|
//
|
|
|
|
if (File->pSectionSymbols[0][middle].pSymbol->StorageClass ==
|
|
IMAGE_SYM_CLASS_STATIC) {
|
|
low = middle;
|
|
} else
|
|
return File->pSectionSymbols[0][middle].pSymbol;
|
|
} else if (val < value)
|
|
low = middle;
|
|
else
|
|
high = middle;
|
|
} while ((high > low) && !escape);
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/* BlankFill - blank-fill buffer
|
|
*
|
|
* Purpose:
|
|
* To fill the buffer at *pBuf with blanks until
|
|
* position count is reached.
|
|
*
|
|
* Input:
|
|
* None.
|
|
*
|
|
* Output:
|
|
* None.
|
|
*
|
|
***********************************************************************/
|
|
|
|
PUCHAR BlankFill(PUCHAR inbuf, PUCHAR bufstart, ULONG count)
|
|
{
|
|
*inbuf++ = ' ';
|
|
|
|
while (inbuf < bufstart + count) {
|
|
*inbuf++ = ' ';
|
|
}
|
|
|
|
return inbuf;
|
|
}
|
|
|
|
/* OutputHex - output hex value
|
|
*
|
|
* Purpose:
|
|
* Output the value in outvalue into the buffer
|
|
* pointed by *pBuf. The value may be signed
|
|
* or unsigned depending on the value fSigned.
|
|
*
|
|
* Input:
|
|
* outvalue - value to output
|
|
* length - length in digits
|
|
* fSigned - TRUE if signed else FALSE
|
|
*
|
|
* Output:
|
|
* None.
|
|
*
|
|
***********************************************************************/
|
|
|
|
UCHAR HexDigit[16] = {
|
|
'0', '1', '2', '3', '4', '5', '6', '7',
|
|
'8', '9', 'a', 'b', 'c', 'd', 'e', 'f'
|
|
};
|
|
|
|
PUCHAR OutputHex (PUCHAR buf, ULONG outvalue, ULONG length, BOOLEAN fSigned)
|
|
{
|
|
UCHAR digit[32];
|
|
LONG index = 0;
|
|
|
|
if (fSigned)
|
|
if ((LONG)outvalue < 0) {
|
|
*buf++ = '-';
|
|
outvalue = - (LONG)outvalue;
|
|
} else {
|
|
if (Option.Mask & ASSEMBLE_ME) {
|
|
*buf++ = '+';
|
|
}
|
|
}
|
|
|
|
if (Option.Mask & ASSEMBLE_ME) {
|
|
*buf++ = '0';
|
|
*buf++ = 'x';
|
|
}
|
|
|
|
do {
|
|
digit[index++] = HexDigit[outvalue & 0xf];
|
|
outvalue >>= 4;
|
|
}
|
|
while ((fSigned && outvalue) || (!fSigned && index < (LONG)length));
|
|
while (--index >= 0)
|
|
*buf++ = digit[index];
|
|
|
|
return buf;
|
|
}
|
|
|
|
/* Output HexCode
|
|
*
|
|
* Purpose:
|
|
* Output the value pointed by *ppchMemBuf of the specified
|
|
* length. The value is treated as unsigned and leading
|
|
* zeroes are printed.
|
|
*
|
|
* Input:
|
|
* *ppchBuf - pointer to text buffer to fill
|
|
* *pchValue - pointer to memory buffer to extract value
|
|
* length - length in bytes of value
|
|
*
|
|
* Output:
|
|
* *ppchBuf - pointer updated to next text character
|
|
* *ppchMemBuf - pointer update to next memory byte
|
|
*
|
|
*************************************************************************/
|
|
|
|
PUCHAR OutputHexCode(PUCHAR buf, PUCHAR pchValue, INT length)
|
|
{
|
|
unsigned char chMem;
|
|
|
|
while (length--) {
|
|
chMem = *pchValue++;
|
|
*buf++ = HexDigit[chMem >> 4];
|
|
*buf++ = HexDigit[chMem & 0x0f];
|
|
}
|
|
|
|
return buf;
|
|
}
|
|
|
|
|
|
|
|
/* Output HexString
|
|
*
|
|
* Purpose:
|
|
* Output the value pointed by *ppchMemBuf of the specified
|
|
* length. The value is treated as unsigned and leading
|
|
* zeroes are printed.
|
|
*
|
|
* Input:
|
|
* *ppchBuf - pointer to text buffer to fill
|
|
* *pchValue - pointer to memory buffer to extract value
|
|
* length - length in bytes of value
|
|
*
|
|
* Output:
|
|
* *ppchBuf - pointer updated to next text character
|
|
* *ppchMemBuf - pointer update to next memory byte
|
|
*
|
|
*************************************************************************/
|
|
|
|
PUCHAR OutputHexString (PUCHAR buf, PUCHAR pchValue, INT length)
|
|
{
|
|
unsigned char chMem;
|
|
|
|
pchValue += length;
|
|
while (length--) {
|
|
chMem = *--pchValue;
|
|
*buf++ = HexDigit[chMem >> 4];
|
|
*buf++ = HexDigit[chMem & 0x0f];
|
|
}
|
|
|
|
return buf;
|
|
}
|
|
|
|
|
|
|
|
/* Output Hex signed
|
|
*
|
|
* Purpose:
|
|
* Output the value pointed by *ppchMemBuf of the specified
|
|
* length. The value is treated as unsigned and leading
|
|
* zeroes are printed.
|
|
*
|
|
* Input:
|
|
* *ppchBuf - pointer to text buffer to fill
|
|
* *pchValue - pointer to memory buffer to extract value
|
|
* length - length in bytes of value
|
|
*
|
|
* Output:
|
|
* *ppchBuf - pointer updated to next text character
|
|
* *ppchMemBuf - pointer update to next memory byte
|
|
*
|
|
*************************************************************************/
|
|
|
|
PUCHAR OutputHexValue(PUCHAR buf, PUCHAR pchValue, INT length, INT dispflag)
|
|
{
|
|
UCHAR digit[8];
|
|
LONG index = 0;
|
|
LONG value;
|
|
|
|
switch (length) {
|
|
case 1: value = (long)(*(char *)pchValue);
|
|
break;
|
|
|
|
case 2: value = (long)(*(UNALIGNED short *)pchValue);
|
|
break;
|
|
|
|
default: value = (long)(*(UNALIGNED long *)pchValue);
|
|
break;
|
|
}
|
|
length = length << 1;
|
|
|
|
if (dispflag) {
|
|
if (value < 0) {
|
|
*buf++ = '-';
|
|
value = -value;
|
|
} else {
|
|
*buf++ = '+';
|
|
}
|
|
}
|
|
|
|
|
|
*buf++ = '0';
|
|
*buf++ = 'x';
|
|
|
|
for (index = length-1; index != -1; index--) {
|
|
digit[index] = (char)(value & 0xf);
|
|
value >>= 4;
|
|
}
|
|
index = 0;
|
|
while (digit[index] == '0' && index < length - 1)
|
|
index++;
|
|
while (index < length)
|
|
*buf++ = HexDigit[digit[index++]];
|
|
|
|
return buf;
|
|
}
|
|
|
|
|
|
|
|
/* OutputCountString - output string (counted)
|
|
*
|
|
* Purpose:
|
|
* Copy the string into the buffer pointed by pBuf.
|
|
*
|
|
* Input:
|
|
* *pStr - pointer to string
|
|
* len - length to output
|
|
*
|
|
* Output:
|
|
* None.
|
|
*
|
|
***********************************************************************/
|
|
|
|
PUCHAR OutputCountString (PUCHAR buf, PUCHAR pStr, ULONG len)
|
|
{
|
|
while (len-- && *pStr)
|
|
*buf++ = *pStr++;
|
|
|
|
return buf;
|
|
}
|
|
|
|
/* OutputString - output string
|
|
*
|
|
* Purpose:
|
|
* Copy the string into the buffer pointed by pBuf.
|
|
*
|
|
* Input:
|
|
* *pStr - pointer to string
|
|
*
|
|
* Output:
|
|
* None.
|
|
*
|
|
***********************************************************************/
|
|
|
|
PUCHAR OutputString (PUCHAR buf, PUCHAR pStr)
|
|
{
|
|
while (*pStr)
|
|
*buf++ = *pStr++;
|
|
|
|
return buf;
|
|
}
|
|
|
|
PUCHAR OutputFReg (PUCHAR buf, ULONG regnum)
|
|
{
|
|
*buf++ = 'f';
|
|
if (regnum > 9)
|
|
*buf++ = (UCHAR)('0' + regnum / 10);
|
|
*buf++ = (UCHAR)('0' + regnum % 10);
|
|
|
|
return buf;
|
|
}
|
|
|
|
|
|
|
|
PUCHAR OutputSymbol(PUCHAR buf, PIMAGE_SYMBOL pSym, ULONG val )
|
|
{
|
|
PUCHAR pSymbolString;
|
|
pFileList File = FilesList; // global file list entry.
|
|
UCHAR SymbolBuf[16];
|
|
UCHAR SymbolBufForDot[16];
|
|
INT digits;
|
|
ULONG ShortName;
|
|
|
|
//
|
|
// get symbol name
|
|
//
|
|
|
|
memset(SymbolBuf, 0, sizeof(SymbolBuf));
|
|
|
|
if (pSym == NULL) {
|
|
if (Option.Mask & ASSEMBLE_ME) {
|
|
*buf++ = 't';
|
|
*buf++ = '1'; // tmp
|
|
}
|
|
buf = OutputHex(buf, val, 8, FALSE);
|
|
} else {
|
|
pSymbolString = GetSymbolString( pSym, &ShortName );
|
|
|
|
if (ShortName) {
|
|
strncpy(SymbolBuf, pSymbolString, 8);
|
|
SymbolBuf[8] = '\0';
|
|
pSymbolString = SymbolBuf;
|
|
}
|
|
|
|
if (Option.Mask & ASSEMBLE_ME) {
|
|
if (pSymbolString[0] == '.') {
|
|
memset(SymbolBufForDot, 0, sizeof(SymbolBufForDot));
|
|
SymbolBufForDot[0] = pSymbolString[1];
|
|
(VOID)OutputHex(&SymbolBufForDot[1], val, 8, FALSE);
|
|
pSymbolString = SymbolBufForDot;
|
|
}
|
|
}
|
|
|
|
buf = OutputString(buf, pSymbolString);
|
|
|
|
if (!(Option.Mask & ASSEMBLE_ME) && val != 0) {
|
|
buf = OutputString(buf, "+0x");
|
|
digits = HexDigits(val);
|
|
buf = OutputHex(buf, val, digits, FALSE);
|
|
}
|
|
}
|
|
|
|
return buf;
|
|
}
|
|
|
|
|
|
INT
|
|
HexDigits( ULONG val )
|
|
{
|
|
INT digits = 1;
|
|
|
|
while( val ){
|
|
val = val >> 4;
|
|
digits++;
|
|
}
|
|
|
|
return digits;
|
|
}
|
|
|
|
PUCHAR
|
|
GetSymbolString( PIMAGE_SYMBOL pSymbol, PULONG ShortName )
|
|
{
|
|
pFileList File = FilesList;
|
|
static PUCHAR NoSym = "No Such Symbol";
|
|
PUCHAR pSymbolString = NoSym;
|
|
|
|
*ShortName = FALSE;
|
|
|
|
if (pSymbol) {
|
|
if (pSymbol->N.Name.Short == 0) {
|
|
if (File->pStringTable) {
|
|
pSymbolString = (PUCHAR)File->pStringTable;
|
|
pSymbolString = &pSymbolString[pSymbol->N.Name.Long];
|
|
}
|
|
} else {
|
|
pSymbolString = (PUCHAR)pSymbol->N.ShortName;
|
|
*ShortName = TRUE;
|
|
}
|
|
}
|
|
|
|
return pSymbolString;
|
|
}
|