1berry/pawn-compiler
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Remove amx.c from pawndisasm's sources

Browse Source 
We don't need the whole AMX in order to compile pawndisasm, only a handful of
alignment functions (amx_AlignXXX) that are used in amxdbg.c. Just copy those
functions to amxdbg.

As a bonus, we don't have to fix compile warnings in amx.c now. (maybe somebody
will fix them some day in a distant future...)
This commit is contained in:
Zeex 2017-12-30 19:21:48 +06:00
parent 11199da210
commit 8fe5558d7e
2 changed files with 146 additions and 30 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

175
source/amx/amxdbg.c
View File

@ -30,6 +30,123 @@
#include "amx.h"
#include "amxdbg.h"
#if PAWN_CELL_SIZE==16
#define dbg_AlignCell(v) dbg_Align16(v)
#elif PAWN_CELL_SIZE==32
#define dbg_AlignCell(v) dbg_Align32(v)
#elif PAWN_CELL_SIZE==64 && (defined _I64_MAX || defined HAVE_I64)
#define dbg_AlignCell(v) dbg_Align64(v)
#else
#error Unsupported cell size
#endif
#if !defined NDEBUG
static int check_endian(void)
{
uint16_t val=0x00ff;
unsigned char *ptr=(unsigned char *)&val;
/* "ptr" points to the starting address of "val". If that address
* holds the byte "0xff", the computer stored the low byte of "val"
* at the lower address, and so the memory lay out is Little Endian.
*/
assert(*ptr==0xff || *ptr==0x00);
#if BYTE_ORDER==BIG_ENDIAN
return *ptr==0x00; /* return "true" if big endian */
#else
return *ptr==0xff; /* return "true" if little endian */
#endif
}
#endif
#if BYTE_ORDER==BIG_ENDIAN || PAWN_CELL_SIZE==16
static void swap16(uint16_t *v)
{
unsigned char *s = (unsigned char *)v;
unsigned char t;
assert(sizeof(*v)==2);
/* swap two bytes */
t=s[0];
s[0]=s[1];
s[1]=t;
}
#endif
#if BYTE_ORDER==BIG_ENDIAN || PAWN_CELL_SIZE==32
static void swap32(uint32_t *v)
{
unsigned char *s = (unsigned char *)v;
unsigned char t;
assert_static(sizeof(*v)==4);
/* swap outer two bytes */
t=s[0];
s[0]=s[3];
s[3]=t;
/* swap inner two bytes */
t=s[1];
s[1]=s[2];
s[2]=t;
}
#endif
#if (BYTE_ORDER==BIG_ENDIAN || PAWN_CELL_SIZE==64) && (defined _I64_MAX || defined HAVE_I64)
static void swap64(uint64_t *v)
{
unsigned char *s = (unsigned char *)v;
unsigned char t;
assert(sizeof(*v)==8);
t=s[0];
s[0]=s[7];
s[7]=t;
t=s[1];
s[1]=s[6];
s[6]=t;
t=s[2];
s[2]=s[5];
s[5]=t;
t=s[3];
s[3]=s[4];
s[4]=t;
}
#endif
uint16_t * AMXAPI dbg_Align16(uint16_t *v)
{
assert_static(sizeof(*v)==2);
assert(check_endian());
#if BYTE_ORDER==BIG_ENDIAN
swap16(v);
#endif
return v;
}
uint32_t * AMXAPI dbg_Align32(uint32_t *v)
{
assert_static(sizeof(*v)==4);
assert(check_endian());
#if BYTE_ORDER==BIG_ENDIAN
swap32(v);
#endif
return v;
}
#if defined _I64_MAX || defined HAVE_I64
uint64_t * AMXAPI dbg_Align64(uint64_t *v)
{
assert(sizeof(*v)==8);
assert(check_endian());
#if BYTE_ORDER==BIG_ENDIAN
swap64(v);
#endif
return v;
}
#endif /* _I64_MAX || HAVE_I64 */
int AMXAPI dbg_FreeInfo(AMX_DBG *amxdbg)
{
@ -68,9 +185,9 @@ int AMXAPI dbg_LoadInfo(AMX_DBG *amxdbg, FILE *fp)
if (fread(&amxhdr, sizeof amxhdr, 1, fp) == 0)
return AMX_ERR_FORMAT;
#if BYTE_ORDER==BIG_ENDIAN
amx_Align32((uint32_t*)&amxhdr.size);
amx_Align16(&amxhdr.magic);
amx_Align16(&dbghdr.flags);
dbg_Align32((uint32_t*)&amxhdr.size);
dbg_Align16(&amxhdr.magic);
dbg_Align16(&dbghdr.flags);
#endif
if (amxhdr.magic != AMX_MAGIC)
return AMX_ERR_FORMAT;
@ -83,15 +200,15 @@ int AMXAPI dbg_LoadInfo(AMX_DBG *amxdbg, FILE *fp)
return AMX_ERR_FORMAT;
#if BYTE_ORDER==BIG_ENDIAN
amx_Align32((uint32_t*)&dbghdr.size);
amx_Align16(&dbghdr.magic);
amx_Align16(&dbghdr.flags);
amx_Align16(&dbghdr.files);
amx_Align16(&dbghdr.lines);
amx_Align16(&dbghdr.symbols);
amx_Align16(&dbghdr.tags);
amx_Align16(&dbghdr.automatons);
amx_Align16(&dbghdr.states);
dbg_Align32((uint32_t*)&dbghdr.size);
dbg_Align16(&dbghdr.magic);
dbg_Align16(&dbghdr.flags);
dbg_Align16(&dbghdr.files);
dbg_Align16(&dbghdr.lines);
dbg_Align16(&dbghdr.symbols);
dbg_Align16(&dbghdr.tags);
dbg_Align16(&dbghdr.automatons);
dbg_Align16(&dbghdr.states);
#endif
if (dbghdr.magic != AMX_DBG_MAGIC)
return AMX_ERR_FORMAT;
@ -136,7 +253,7 @@ int AMXAPI dbg_LoadInfo(AMX_DBG *amxdbg, FILE *fp)
assert(amxdbg->filetbl != NULL);
amxdbg->filetbl[index] = (AMX_DBG_FILE *)ptr;
#if BYTE_ORDER==BIG_ENDIAN
amx_AlignCell(&amxdbg->filetbl[index]->address);
dbg_AlignCell(&amxdbg->filetbl[index]->address);
#endif
for (ptr = ptr + sizeof(AMX_DBG_FILE); *ptr != '\0'; ptr++)
/* nothing */;
@ -147,8 +264,8 @@ int AMXAPI dbg_LoadInfo(AMX_DBG *amxdbg, FILE *fp)
amxdbg->linetbl = (AMX_DBG_LINE*)ptr;
#if BYTE_ORDER==BIG_ENDIAN
for (index = 0; index < dbghdr.lines; index++) {
amx_AlignCell(&amxdbg->linetbl[index].address);
amx_Align32((uint32_t*)&amxdbg->linetbl[index].line);
dbg_AlignCell(&amxdbg->linetbl[index].address);
dbg_Align32((uint32_t*)&amxdbg->linetbl[index].line);
} /* for */
#endif
ptr += (uint16_t)dbghdr.lines * sizeof(AMX_DBG_LINE);
@ -158,8 +275,8 @@ int AMXAPI dbg_LoadInfo(AMX_DBG *amxdbg, FILE *fp)
&& (cell)line->address > (cell)(line - 1)->address) {
#if BYTE_ORDER==BIG_ENDIAN
for (index = 0; index <= (uint32_t)(1u << 16) - 1; index++) {
amx_AlignCell(&linetbl[index].address);
amx_Align32((uint32_t*)&linetbl[index].line);
dbg_AlignCell(&linetbl[index].address);
dbg_Align32((uint32_t*)&linetbl[index].line);
line++;
} /* for */
#endif
@ -171,19 +288,19 @@ int AMXAPI dbg_LoadInfo(AMX_DBG *amxdbg, FILE *fp)
assert(amxdbg->symboltbl != NULL);
amxdbg->symboltbl[index] = (AMX_DBG_SYMBOL *)ptr;
#if BYTE_ORDER==BIG_ENDIAN
amx_AlignCell(&amxdbg->symboltbl[index]->address);
amx_Align16((uint16_t*)&amxdbg->symboltbl[index]->tag);
amx_AlignCell(&amxdbg->symboltbl[index]->codestart);
amx_AlignCell(&amxdbg->symboltbl[index]->codeend);
amx_Align16((uint16_t*)&amxdbg->symboltbl[index]->dim);
dbg_AlignCell(&amxdbg->symboltbl[index]->address);
dbg_Align16((uint16_t*)&amxdbg->symboltbl[index]->tag);
dbg_AlignCell(&amxdbg->symboltbl[index]->codestart);
dbg_AlignCell(&amxdbg->symboltbl[index]->codeend);
dbg_Align16((uint16_t*)&amxdbg->symboltbl[index]->dim);
#endif
for (ptr = ptr + sizeof(AMX_DBG_SYMBOL); *ptr != '\0'; ptr++)
/* nothing */;
ptr++; /* skip '\0' too */
for (dim = 0; dim < amxdbg->symboltbl[index]->dim; dim++) {
symdim = (AMX_DBG_SYMDIM *)ptr;
amx_Align16((uint16_t*)&symdim->tag);
amx_AlignCell(&symdim->size);
dbg_Align16((uint16_t*)&symdim->tag);
dbg_AlignCell(&symdim->size);
ptr += sizeof(AMX_DBG_SYMDIM);
} /* for */
} /* for */
@ -193,7 +310,7 @@ int AMXAPI dbg_LoadInfo(AMX_DBG *amxdbg, FILE *fp)
assert(amxdbg->tagtbl != NULL);
amxdbg->tagtbl[index] = (AMX_DBG_TAG *)ptr;
#if BYTE_ORDER==BIG_ENDIAN
amx_Align16(&amxdbg->tagtbl[index]->tag);
dbg_Align16(&amxdbg->tagtbl[index]->tag);
#endif
for (ptr = ptr + sizeof(AMX_DBG_TAG) - 1; *ptr != '\0'; ptr++)
/* nothing */;
@ -205,8 +322,8 @@ int AMXAPI dbg_LoadInfo(AMX_DBG *amxdbg, FILE *fp)
assert(amxdbg->automatontbl != NULL);
amxdbg->automatontbl[index] = (AMX_DBG_MACHINE *)ptr;
#if BYTE_ORDER==BIG_ENDIAN
amx_Align16(&amxdbg->automatontbl[index]->automaton);
amx_AlignCell(&amxdbg->automatontbl[index]->address);
dbg_Align16(&amxdbg->automatontbl[index]->automaton);
dbg_AlignCell(&amxdbg->automatontbl[index]->address);
#endif
for (ptr = ptr + sizeof(AMX_DBG_MACHINE) - 1; *ptr != '\0'; ptr++)
/* nothing */;
@ -218,8 +335,8 @@ int AMXAPI dbg_LoadInfo(AMX_DBG *amxdbg, FILE *fp)
assert(amxdbg->statetbl != NULL);
amxdbg->statetbl[index] = (AMX_DBG_STATE *)ptr;
#if BYTE_ORDER==BIG_ENDIAN
amx_Align16(&amxdbg->statetbl[index]->state);
amx_Align16(&amxdbg->automatontbl[index]->automaton);
dbg_Align16(&amxdbg->statetbl[index]->state);
dbg_Align16(&amxdbg->automatontbl[index]->automaton);
#endif
for (ptr = ptr + sizeof(AMX_DBG_STATE) - 1; *ptr != '\0'; ptr++)
/* nothing */;

1
source/compiler/CMakeLists.txt
View File

@ -135,7 +135,6 @@ target_link_libraries(pawncc pawnc)
set(PAWNDISASM_SRCS
pawndisasm.c
../amx/amxdbg.c
../amx/amx.c
)
add_executable(pawndisasm ${PAWNDISASM_SRCS})
if(UNIX)