ioquake/ioq3
0
0
Fork 0
mirror of https://github.com/ioquake/ioq3.git synced 2024-11-10 15:21:35 +00:00
Code Issues Projects Releases Packages Wiki Activity
ioq3/code/tools/asm/q3asm.c

1647 lines
34 KiB
C
Raw Blame History

/*
===========================================================================
Copyright (C) 1999-2005 Id Software, Inc.
This file is part of Quake III Arena source code.
Quake III Arena source code is free software; you can redistribute it
and/or modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of the License,
or (at your option) any later version.
Quake III Arena source code is distributed in the hope that it will be
useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with Quake III Arena source code; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
===========================================================================
*/
#include "../../qcommon/q_platform.h"
#include "cmdlib.h"
#include "mathlib.h"
#include "../../qcommon/qfiles.h"
/* 19079 total symbols in FI, 2002 Jan 23 */
#define DEFAULT_HASHTABLE_SIZE 2048
char outputFilename[MAX_OS_PATH];
// the zero page size is just used for detecting run time faults
#define ZERO_PAGE_SIZE 0 // 256
typedef enum {
OP_UNDEF,
OP_IGNORE,
OP_BREAK,
OP_ENTER,
OP_LEAVE,
OP_CALL,
OP_PUSH,
OP_POP,
OP_CONST,
OP_LOCAL,
OP_JUMP,
//-------------------
OP_EQ,
OP_NE,
OP_LTI,
OP_LEI,
OP_GTI,
OP_GEI,
OP_LTU,
OP_LEU,
OP_GTU,
OP_GEU,
OP_EQF,
OP_NEF,
OP_LTF,
OP_LEF,
OP_GTF,
OP_GEF,
//-------------------
OP_LOAD1,
OP_LOAD2,
OP_LOAD4,
OP_STORE1,
OP_STORE2,
OP_STORE4, // *(stack[top-1]) = stack[yop
OP_ARG,
OP_BLOCK_COPY,
//-------------------
OP_SEX8,
OP_SEX16,
OP_NEGI,
OP_ADD,
OP_SUB,
OP_DIVI,
OP_DIVU,
OP_MODI,
OP_MODU,
OP_MULI,
OP_MULU,
OP_BAND,
OP_BOR,
OP_BXOR,
OP_BCOM,
OP_LSH,
OP_RSHI,
OP_RSHU,
OP_NEGF,
OP_ADDF,
OP_SUBF,
OP_DIVF,
OP_MULF,
OP_CVIF,
OP_CVFI
} opcode_t;
typedef struct {
int imageBytes; // after decompression
int entryPoint;
int stackBase;
int stackSize;
} executableHeader_t;
typedef enum {
CODESEG,
DATASEG, // initialized 32 bit data, will be byte swapped
LITSEG, // strings
BSSSEG, // 0 filled
JTRGSEG, // pseudo-segment that contains only jump table targets
NUM_SEGMENTS
} segmentName_t;
#define MAX_IMAGE 0x400000
typedef struct {
byte image[MAX_IMAGE];
int imageUsed;
int segmentBase; // only valid on second pass
} segment_t;
typedef struct symbol_s {
struct symbol_s *next;
int hash;
segment_t *segment;
char *name;
int value;
} symbol_t;
typedef struct hashchain_s {
void *data;
struct hashchain_s *next;
} hashchain_t;
typedef struct hashtable_s {
int buckets;
hashchain_t **table;
} hashtable_t;
int symtablelen = DEFAULT_HASHTABLE_SIZE;
hashtable_t *symtable;
hashtable_t *optable;
segment_t segment[NUM_SEGMENTS];
segment_t *currentSegment;
int passNumber;
int numSymbols;
int errorCount;
typedef struct options_s {
qboolean verbose;
qboolean writeMapFile;
qboolean vanillaQ3Compatibility;
} options_t;
options_t options = { 0 };
symbol_t *symbols;
symbol_t *lastSymbol = 0; /* Most recent symbol defined. */
#define MAX_ASM_FILES 256
int numAsmFiles;
char *asmFiles[MAX_ASM_FILES];
char *asmFileNames[MAX_ASM_FILES];
int currentFileIndex;
char *currentFileName;
int currentFileLine;
//int stackSize = 16384;
int stackSize = 0x10000;
// we need to convert arg and ret instructions to
// stores to the local stack frame, so we need to track the
// characteristics of the current functions stack frame
int currentLocals; // bytes of locals needed by this function
int currentArgs; // bytes of largest argument list called from this function
int currentArgOffset; // byte offset in currentArgs to store next arg, reset each call
#define MAX_LINE_LENGTH 1024
char lineBuffer[MAX_LINE_LENGTH];
int lineParseOffset;
char token[MAX_LINE_LENGTH];
int instructionCount;
typedef struct {
char *name;
int opcode;
} sourceOps_t;
sourceOps_t sourceOps[] = {
#include "opstrings.h"
};
#define NUM_SOURCE_OPS ( sizeof( sourceOps ) / sizeof( sourceOps[0] ) )
int opcodesHash[ NUM_SOURCE_OPS ];
static int vreport (const char* fmt, va_list vp)
{
if (options.verbose != qtrue)
return 0;
return vprintf(fmt, vp);
}
static int report (const char *fmt, ...)
{
va_list va;
int retval;
va_start(va, fmt);
retval = vreport(fmt, va);
va_end(va);
return retval;
}
/* The chain-and-bucket hash table. -PH */
static void hashtable_init (hashtable_t *H, int buckets)
{
H->buckets = buckets;
H->table = calloc(H->buckets, sizeof(*(H->table)));
}
static hashtable_t *hashtable_new (int buckets)
{
hashtable_t *H;
H = malloc(sizeof(hashtable_t));
hashtable_init(H, buckets);
return H;
}
/* No destroy/destructor. No need. */
static void hashtable_add (hashtable_t *H, int hashvalue, void *datum)
{
hashchain_t *hc, **hb;
hashvalue = (abs(hashvalue) % H->buckets);
hb = &(H->table[hashvalue]);
if (*hb == 0)
{
/* Empty bucket. Create new one. */
*hb = calloc(1, sizeof(**hb));
hc = *hb;
}
else
{
/* Get hc to point to last node in chain. */
for (hc = *hb; hc && hc->next; hc = hc->next);
hc->next = calloc(1, sizeof(*hc));
hc = hc->next;
}
hc->data = datum;
hc->next = 0;
}
static hashchain_t *hashtable_get (hashtable_t *H, int hashvalue)
{
hashvalue = (abs(hashvalue) % H->buckets);
return (H->table[hashvalue]);
}
static void hashtable_stats (hashtable_t *H)
{
int len, empties, longest, nodes;
int i;
float meanlen;
hashchain_t *hc;
report("Stats for hashtable %08X", H);
empties = 0;
longest = 0;
nodes = 0;
for (i = 0; i < H->buckets; i++)
{
if (H->table[i] == 0)
{ empties++; continue; }
for (hc = H->table[i], len = 0; hc; hc = hc->next, len++);
if (len > longest) { longest = len; }
nodes += len;
}
meanlen = (float)(nodes) / (H->buckets - empties);
#if 0
/* Long stats display */
report(" Total buckets: %d\n", H->buckets);
report(" Total stored nodes: %d\n", nodes);
report(" Longest chain: %d\n", longest);
report(" Empty chains: %d\n", empties);
report(" Mean non-empty chain length: %f\n", meanlen);
#else //0
/* Short stats display */
report(", %d buckets, %d nodes", H->buckets, nodes);
report("\n");
report(" Longest chain: %d, empty chains: %d, mean non-empty: %f", longest, empties, meanlen);
#endif //0
report("\n");
}
/* Kludge. */
/* Check if symbol already exists. */
/* Returns 0 if symbol does NOT already exist, non-zero otherwise. */
static int hashtable_symbol_exists (hashtable_t *H, int hash, char *sym)
{
hashchain_t *hc;
symbol_t *s;
hash = (abs(hash) % H->buckets);
hc = H->table[hash];
if (hc == 0)
{
/* Empty chain means this symbol has not yet been defined. */
return 0;
}
for (; hc; hc = hc->next)
{
s = (symbol_t*)hc->data;
// if ((hash == s->hash) && (strcmp(sym, s->name) == 0))
/* We _already_ know the hash is the same. That's why we're probing! */
if (strcmp(sym, s->name) == 0)
{
/* Symbol collisions -- symbol already exists. */
return 1;
}
}
return 0; /* Can't find collision. */
}
/* Comparator function for quicksorting. */
static int symlist_cmp (const void *e1, const void *e2)
{
const symbol_t *a, *b;
a = *(const symbol_t **)e1;
b = *(const symbol_t **)e2;
//crumb("Symbol comparison (1) %d to (2) %d\n", a->value, b->value);
return ( a->value - b->value);
}
/*
Sort the symbols list by using QuickSort (qsort()).
This may take a LOT of memory (a few megabytes?), but memory is cheap these days.
However, qsort(3) already exists, and I'm really lazy.
-PH
*/
static void sort_symbols ()
{
int i, elems;
symbol_t *s;
symbol_t **symlist;
if(!symbols)
return;
//crumb("sort_symbols: Constructing symlist array\n");
for (elems = 0, s = symbols; s; s = s->next, elems++) /* nop */ ;
symlist = malloc(elems * sizeof(symbol_t*));
for (i = 0, s = symbols; s; s = s->next, i++)
{
symlist[i] = s;
}
//crumbf("sort_symbols: Quick-sorting %d symbols\n", elems);
qsort(symlist, elems, sizeof(symbol_t*), symlist_cmp);
//crumbf("sort_symbols: Reconstructing symbols list\n");
s = symbols = symlist[0];
for (i = 1; i < elems; i++)
{
s->next = symlist[i];
s = s->next;
}
lastSymbol = s;
s->next = 0;
//crumbf("sort_symbols: verifying..."); fflush(stdout);
for (i = 0, s = symbols; s; s = s->next, i++) /*nop*/ ;
//crumbf(" %d elements\n", i);
free(symlist); /* d'oh. no gc. */
}
#ifdef _MSC_VER
#define INT64 __int64
#define atoi64 _atoi64
#else
#define INT64 long long int
#define atoi64 atoll
#endif
/*
Problem:
BYTE values are specified as signed decimal string. A properly functional
atoip() will cap large signed values at 0x7FFFFFFF. Negative word values are
often specified as very large decimal values by lcc. Therefore, values that
should be between 0x7FFFFFFF and 0xFFFFFFFF come out as 0x7FFFFFFF when using
atoi(). Bad.
This function is one big evil hack to work around this problem.
*/
static int atoiNoCap (const char *s)
{
INT64 l;
union {
unsigned int u;
signed int i;
} retval;
l = atoi64(s);
/* Now smash to signed 32 bits accordingly. */
if (l < 0) {
retval.i = (int)l;
} else {
retval.u = (unsigned int)l;
}
return retval.i; /* <- union hackage. I feel dirty with this. -PH */
}
/*
=============
HashString
=============
*/
/* Default hash function of Kazlib 1.19, slightly modified. */
static unsigned int HashString (const char *key)
{
static unsigned long randbox[] = {
0x49848f1bU, 0xe6255dbaU, 0x36da5bdcU, 0x47bf94e9U,
0x8cbcce22U, 0x559fc06aU, 0xd268f536U, 0xe10af79aU,
0xc1af4d69U, 0x1d2917b5U, 0xec4c304dU, 0x9ee5016cU,
0x69232f74U, 0xfead7bb3U, 0xe9089ab6U, 0xf012f6aeU,
};
const char *str = key;
unsigned int acc = 0;
while (*str) {
acc ^= randbox[(*str + acc) & 0xf];
acc = (acc << 1) | (acc >> 31);
acc &= 0xffffffffU;
acc ^= randbox[((*str++ >> 4) + acc) & 0xf];
acc = (acc << 2) | (acc >> 30);
acc &= 0xffffffffU;
}
return acc;
}
/*
============
CodeError
============
*/
static void CodeError( char *fmt, ... ) {
va_list argptr;
errorCount++;
fprintf( stderr, "%s:%i ", currentFileName, currentFileLine );
va_start( argptr,fmt );
vfprintf( stderr, fmt, argptr );
va_end( argptr );
}
/*
============
EmitByte
============
*/
static void EmitByte( segment_t *seg, int v ) {
if ( seg->imageUsed >= MAX_IMAGE ) {
Error( "MAX_IMAGE" );
}
seg->image[ seg->imageUsed ] = v;
seg->imageUsed++;
}
/*
============
EmitInt
============
*/
static void EmitInt( segment_t *seg, int v ) {
if ( seg->imageUsed >= MAX_IMAGE - 4) {
Error( "MAX_IMAGE" );
}
seg->image[ seg->imageUsed ] = v & 255;
seg->image[ seg->imageUsed + 1 ] = ( v >> 8 ) & 255;
seg->image[ seg->imageUsed + 2 ] = ( v >> 16 ) & 255;
seg->image[ seg->imageUsed + 3 ] = ( v >> 24 ) & 255;
seg->imageUsed += 4;
}
/*
============
DefineSymbol
Symbols can only be defined on pass 0
============
*/
static void DefineSymbol( char *sym, int value ) {
/* Hand optimization by PhaethonH */
symbol_t *s;
char expanded[MAX_LINE_LENGTH];
int hash;
if ( passNumber == 1 ) {
return;
}
// add the file prefix to local symbols to guarantee unique
if ( sym[0] == '$' ) {
sprintf( expanded, "%s_%i", sym, currentFileIndex );
sym = expanded;
}
hash = HashString( sym );
if (hashtable_symbol_exists(symtable, hash, sym)) {
CodeError( "Multiple definitions for %s\n", sym );
return;
}
s = malloc( sizeof( *s ) );
s->next = NULL;
s->name = copystring( sym );
s->hash = hash;
s->value = value;
s->segment = currentSegment;
hashtable_add(symtable, hash, s);
/*
Hash table lookup already speeds up symbol lookup enormously.
We postpone sorting until end of pass 0.
Since we're not doing the insertion sort, lastSymbol should always
wind up pointing to the end of list.
This allows constant time for adding to the list.
-PH
*/
if (symbols == 0) {
lastSymbol = symbols = s;
} else {
lastSymbol->next = s;
lastSymbol = s;
}
}
/*
============
LookupSymbol
Symbols can only be evaluated on pass 1
============
*/
static int LookupSymbol( char *sym ) {
symbol_t *s;
char expanded[MAX_LINE_LENGTH];
int hash;
hashchain_t *hc;
if ( passNumber == 0 ) {
return 0;
}
// add the file prefix to local symbols to guarantee unique
if ( sym[0] == '$' ) {
sprintf( expanded, "%s_%i", sym, currentFileIndex );
sym = expanded;
}
hash = HashString( sym );
/*
Hand optimization by PhaethonH
Using a hash table with chain/bucket for lookups alone sped up q3asm by almost 3x for me.
-PH
*/
for (hc = hashtable_get(symtable, hash); hc; hc = hc->next) {
s = (symbol_t*)hc->data; /* ugly typecasting, but it's fast! */
if ( (hash == s->hash) && !strcmp(sym, s->name) ) {
return s->segment->segmentBase + s->value;
}
}
CodeError( "error: symbol %s undefined\n", sym );
passNumber = 0;
DefineSymbol( sym, 0 ); // so more errors aren't printed
passNumber = 1;
return 0;
}
/*
==============
ExtractLine
Extracts the next line from the given text block.
If a full line isn't parsed, returns NULL
Otherwise returns the updated parse pointer
===============
*/
static char *ExtractLine( char *data ) {
/* Goal:
Given a string `data', extract one text line into buffer `lineBuffer' that
is no longer than MAX_LINE_LENGTH characters long. Return value is
remainder of `data' that isn't part of `lineBuffer'.
-PH
*/
/* Hand-optimized by PhaethonH */
char *p, *q;
currentFileLine++;
lineParseOffset = 0;
token[0] = 0;
*lineBuffer = 0;
p = q = data;
if (!*q) {
return NULL;
}
for ( ; !((*p == 0) || (*p == '\n')); p++) /* nop */ ;
if ((p - q) >= MAX_LINE_LENGTH) {
CodeError( "MAX_LINE_LENGTH" );
return data;
}
memcpy( lineBuffer, data, (p - data) );
lineBuffer[(p - data)] = 0;
p += (*p == '\n') ? 1 : 0; /* Skip over final newline. */
return p;
}
/*
==============
Parse
Parse a token out of linebuffer
==============
*/
static qboolean Parse( void ) {
/* Hand-optimized by PhaethonH */
const char *p, *q;
/* Because lineParseOffset is only updated just before exit, this makes this code version somewhat harder to debug under a symbolic debugger. */
*token = 0; /* Clear token. */
// skip whitespace
for (p = lineBuffer + lineParseOffset; *p && (*p <= ' '); p++) /* nop */ ;
// skip ; comments
/* die on end-of-string */
if ((*p == ';') || (*p == 0)) {
lineParseOffset = p - lineBuffer;
return qfalse;
}
q = p; /* Mark the start of token. */
/* Find separator first. */
for ( ; *p > 32; p++) /* nop */ ; /* XXX: unsafe assumptions. */
/* *p now sits on separator. Mangle other values accordingly. */
strncpy(token, q, p - q);
token[p - q] = 0;
lineParseOffset = p - lineBuffer;
return qtrue;
}
/*
==============
ParseValue
==============
*/
static int ParseValue( void ) {
Parse();
return atoiNoCap( token );
}
/*
==============
ParseExpression
==============
*/
static int ParseExpression(void) {
/* Hand optimization, PhaethonH */
int i, j;
char sym[MAX_LINE_LENGTH];
int v;
/* Skip over a leading minus. */
for ( i = ((token[0] == '-') ? 1 : 0) ; i < MAX_LINE_LENGTH ; i++ ) {
if ( token[i] == '+' || token[i] == '-' || token[i] == 0 ) {
break;
}
}
memcpy( sym, token, i );
sym[i] = 0;
switch (*sym) { /* Resolve depending on first character. */
/* Optimizing compilers can convert cases into "calculated jumps". I think these are faster. -PH */
case '-':
case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
v = atoiNoCap(sym);
break;
default:
v = LookupSymbol(sym);
break;
}
// parse add / subtract offsets
while ( token[i] != 0 ) {
for ( j = i + 1 ; j < MAX_LINE_LENGTH ; j++ ) {
if ( token[j] == '+' || token[j] == '-' || token[j] == 0 ) {
break;
}
}
memcpy( sym, token+i+1, j-i-1 );
sym[j-i-1] = 0;
switch (token[i]) {
case '+':
v += atoiNoCap(sym);
break;
case '-':
v -= atoiNoCap(sym);
break;
}
i = j;
}
return v;
}
/*
==============
HackToSegment
BIG HACK: I want to put all 32 bit values in the data
segment so they can be byte swapped, and all char data in the lit
segment, but switch jump tables are emited in the lit segment and
initialized strng variables are put in the data segment.
I can change segments here, but I also need to fixup the
label that was just defined
Note that the lit segment is read-write in the VM, so strings
aren't read only as in some architectures.
==============
*/
static void HackToSegment( segmentName_t seg ) {
if ( currentSegment == &segment[seg] ) {
return;
}
currentSegment = &segment[seg];
if ( passNumber == 0 ) {
lastSymbol->segment = currentSegment;
lastSymbol->value = currentSegment->imageUsed;
}
}
//#define STAT(L) report("STAT " L "\n");
#define STAT(L)
#define ASM(O) int TryAssemble##O ()
/*
These clauses were moved out from AssembleLine() to allow reordering of if's.
An optimizing compiler should reconstruct these back into inline code.
-PH
*/
// call instructions reset currentArgOffset
ASM(CALL)
{
if ( !strncmp( token, "CALL", 4 ) ) {
STAT("CALL");
EmitByte( &segment[CODESEG], OP_CALL );
instructionCount++;
currentArgOffset = 0;
return 1;
}
return 0;
}
// arg is converted to a reversed store
ASM(ARG)
{
if ( !strncmp( token, "ARG", 3 ) ) {
STAT("ARG");
EmitByte( &segment[CODESEG], OP_ARG );
instructionCount++;
if ( 8 + currentArgOffset >= 256 ) {
CodeError( "currentArgOffset >= 256" );
return 1;
}
EmitByte( &segment[CODESEG], 8 + currentArgOffset );
currentArgOffset += 4;
return 1;
}
return 0;
}
// ret just leaves something on the op stack
ASM(RET)
{
if ( !strncmp( token, "RET", 3 ) ) {
STAT("RET");
EmitByte( &segment[CODESEG], OP_LEAVE );
instructionCount++;
EmitInt( &segment[CODESEG], 8 + currentLocals + currentArgs );
return 1;
}
return 0;
}
// pop is needed to discard the return value of
// a function
ASM(POP)
{
if ( !strncmp( token, "pop", 3 ) ) {
STAT("POP");
EmitByte( &segment[CODESEG], OP_POP );
instructionCount++;
return 1;
}
return 0;
}
// address of a parameter is converted to OP_LOCAL
ASM(ADDRF)
{
int v;
if ( !strncmp( token, "ADDRF", 5 ) ) {
STAT("ADDRF");
instructionCount++;
Parse();
v = ParseExpression();
v = 16 + currentArgs + currentLocals + v;
EmitByte( &segment[CODESEG], OP_LOCAL );
EmitInt( &segment[CODESEG], v );
return 1;
}
return 0;
}
// address of a local is converted to OP_LOCAL
ASM(ADDRL)
{
int v;
if ( !strncmp( token, "ADDRL", 5 ) ) {
STAT("ADDRL");
instructionCount++;
Parse();
v = ParseExpression();
v = 8 + currentArgs + v;
EmitByte( &segment[CODESEG], OP_LOCAL );
EmitInt( &segment[CODESEG], v );
return 1;
}
return 0;
}
ASM(PROC)
{
char name[1024];
if ( !strcmp( token, "proc" ) ) {
STAT("PROC");
Parse(); // function name
strcpy( name, token );
DefineSymbol( token, instructionCount ); // segment[CODESEG].imageUsed );
currentLocals = ParseValue(); // locals
currentLocals = ( currentLocals + 3 ) & ~3;
currentArgs = ParseValue(); // arg marshalling
currentArgs = ( currentArgs + 3 ) & ~3;
if ( 8 + currentLocals + currentArgs >= 32767 ) {
CodeError( "Locals > 32k in %s\n", name );
}
instructionCount++;
EmitByte( &segment[CODESEG], OP_ENTER );
EmitInt( &segment[CODESEG], 8 + currentLocals + currentArgs );
return 1;
}
return 0;
}
ASM(ENDPROC)
{
if ( !strcmp( token, "endproc" ) ) {
STAT("ENDPROC");
Parse(); // skip the function name
ParseValue(); // locals
ParseValue(); // arg marshalling
// all functions must leave something on the opstack
instructionCount++;
EmitByte( &segment[CODESEG], OP_PUSH );
instructionCount++;
EmitByte( &segment[CODESEG], OP_LEAVE );
EmitInt( &segment[CODESEG], 8 + currentLocals + currentArgs );
return 1;
}
return 0;
}
ASM(ADDRESS)
{
int v;
if ( !strcmp( token, "address" ) ) {
STAT("ADDRESS");
Parse();
v = ParseExpression();
/* Addresses are 32 bits wide, and therefore go into data segment. */
HackToSegment( DATASEG );
EmitInt( currentSegment, v );
if( passNumber == 1 && token[ 0 ] == '$' ) // crude test for labels
EmitInt( &segment[ JTRGSEG ], v );
return 1;
}
return 0;
}
ASM(EXPORT)
{
if ( !strcmp( token, "export" ) ) {
STAT("EXPORT");
return 1;
}
return 0;
}
ASM(IMPORT)
{
if ( !strcmp( token, "import" ) ) {
STAT("IMPORT");
return 1;
}
return 0;
}
ASM(CODE)
{
if ( !strcmp( token, "code" ) ) {
STAT("CODE");
currentSegment = &segment[CODESEG];
return 1;
}
return 0;
}
ASM(BSS)
{
if ( !strcmp( token, "bss" ) ) {
STAT("BSS");
currentSegment = &segment[BSSSEG];
return 1;
}
return 0;
}
ASM(DATA)
{
if ( !strcmp( token, "data" ) ) {
STAT("DATA");
currentSegment = &segment[DATASEG];
return 1;
}
return 0;
}
ASM(LIT)
{
if ( !strcmp( token, "lit" ) ) {
STAT("LIT");
currentSegment = &segment[LITSEG];
return 1;
}
return 0;
}
ASM(LINE)
{
if ( !strcmp( token, "line" ) ) {
STAT("LINE");
return 1;
}
return 0;
}
ASM(FILE)
{
if ( !strcmp( token, "file" ) ) {
STAT("FILE");
return 1;
}
return 0;
}
ASM(EQU)
{
char name[1024];
if ( !strcmp( token, "equ" ) ) {
STAT("EQU");
Parse();
strcpy( name, token );
Parse();
DefineSymbol( name, atoiNoCap(token) );
return 1;
}
return 0;
}
ASM(ALIGN)
{
int v;
if ( !strcmp( token, "align" ) ) {
STAT("ALIGN");
v = ParseValue();
currentSegment->imageUsed = (currentSegment->imageUsed + v - 1 ) & ~( v - 1 );
return 1;
}
return 0;
}
ASM(SKIP)
{
int v;
if ( !strcmp( token, "skip" ) ) {
STAT("SKIP");
v = ParseValue();
currentSegment->imageUsed += v;
return 1;
}
return 0;
}
ASM(BYTE)
{
int i, v, v2;
if ( !strcmp( token, "byte" ) ) {
STAT("BYTE");
v = ParseValue();
v2 = ParseValue();
if ( v == 1 ) {
/* Character (1-byte) values go into lit(eral) segment. */
HackToSegment( LITSEG );
} else if ( v == 4 ) {
/* 32-bit (4-byte) values go into data segment. */
HackToSegment( DATASEG );
} else if ( v == 2 ) {
/* and 16-bit (2-byte) values will cause q3asm to barf. */
CodeError( "16 bit initialized data not supported" );
}
// emit little endien
for ( i = 0 ; i < v ; i++ ) {
EmitByte( currentSegment, (v2 & 0xFF) ); /* paranoid ANDing -PH */
v2 >>= 8;
}
return 1;
}
return 0;
}
// code labels are emited as instruction counts, not byte offsets,
// because the physical size of the code will change with
// different run time compilers and we want to minimize the
// size of the required translation table
ASM(LABEL)
{
if ( !strncmp( token, "LABEL", 5 ) ) {
STAT("LABEL");
Parse();
if ( currentSegment == &segment[CODESEG] ) {
DefineSymbol( token, instructionCount );
} else {
DefineSymbol( token, currentSegment->imageUsed );
}
return 1;
}
return 0;
}
/*
==============
AssembleLine
==============
*/
static void AssembleLine( void ) {
hashchain_t *hc;
sourceOps_t *op;
int i;
int hash;
Parse();
if ( !token[0] ) {
return;
}
hash = HashString( token );
/*
Opcode search using hash table.
Since the opcodes stays mostly fixed, this may benefit even more from a tree.
Always with the tree :)
-PH
*/
for (hc = hashtable_get(optable, hash); hc; hc = hc->next) {
op = (sourceOps_t*)(hc->data);
i = op - sourceOps;
if ((hash == opcodesHash[i]) && (!strcmp(token, op->name))) {
int opcode;
int expression;
if ( op->opcode == OP_UNDEF ) {
CodeError( "Undefined opcode: %s\n", token );
}
if ( op->opcode == OP_IGNORE ) {
return; // we ignore most conversions
}
// sign extensions need to check next parm
opcode = op->opcode;
if ( opcode == OP_SEX8 ) {
Parse();
if ( token[0] == '1' ) {
opcode = OP_SEX8;
} else if ( token[0] == '2' ) {
opcode = OP_SEX16;
} else {
CodeError( "Bad sign extension: %s\n", token );
return;
}
}
// check for expression
Parse();
if ( token[0] && op->opcode != OP_CVIF
&& op->opcode != OP_CVFI ) {
expression = ParseExpression();
// code like this can generate non-dword block copies:
// auto char buf[2] = " ";
// we are just going to round up. This might conceivably
// be incorrect if other initialized chars follow.
if ( opcode == OP_BLOCK_COPY ) {
expression = ( expression + 3 ) & ~3;
}
EmitByte( &segment[CODESEG], opcode );
EmitInt( &segment[CODESEG], expression );
} else {
EmitByte( &segment[CODESEG], opcode );
}
instructionCount++;
return;
}
}
/* This falls through if an assembly opcode is not found. -PH */
/* The following should be sorted in sequence of statistical frequency, most frequent first. -PH */
/*
Empirical frequency statistics from FI 2001.01.23:
109892 STAT ADDRL
72188 STAT BYTE
51150 STAT LINE
50906 STAT ARG
43704 STAT IMPORT
34902 STAT LABEL
32066 STAT ADDRF
23704 STAT CALL
7720 STAT POP
7256 STAT RET
5198 STAT ALIGN
3292 STAT EXPORT
2878 STAT PROC
2878 STAT ENDPROC
2812 STAT ADDRESS
738 STAT SKIP
374 STAT EQU
280 STAT CODE
176 STAT LIT
102 STAT FILE
100 STAT BSS
68 STAT DATA
-PH
*/
#undef ASM
#define ASM(O) if (TryAssemble##O ()) return;
ASM(ADDRL)
ASM(BYTE)
ASM(LINE)
ASM(ARG)
ASM(IMPORT)
ASM(LABEL)
ASM(ADDRF)
ASM(CALL)
ASM(POP)
ASM(RET)
ASM(ALIGN)
ASM(EXPORT)
ASM(PROC)
ASM(ENDPROC)
ASM(ADDRESS)
ASM(SKIP)
ASM(EQU)
ASM(CODE)
ASM(LIT)
ASM(FILE)
ASM(BSS)
ASM(DATA)
CodeError( "Unknown token: %s\n", token );
}
/*
==============
InitTables
==============
*/
void InitTables( void ) {
int i;
symtable = hashtable_new(symtablelen);
optable = hashtable_new(100); /* There's hardly 100 opcodes anyway. */
for ( i = 0 ; i < NUM_SOURCE_OPS ; i++ ) {
opcodesHash[i] = HashString( sourceOps[i].name );
hashtable_add(optable, opcodesHash[i], sourceOps + i);
}
}
/*
==============
WriteMapFile
==============
*/
static void WriteMapFile( void ) {
FILE *f;
symbol_t *s;
char imageName[MAX_OS_PATH];
int seg;
strcpy( imageName, outputFilename );
StripExtension( imageName );
strcat( imageName, ".map" );
report( "Writing %s...\n", imageName );
f = SafeOpenWrite( imageName );
for ( seg = CODESEG ; seg <= BSSSEG ; seg++ ) {
for ( s = symbols ; s ; s = s->next ) {
if ( s->name[0] == '$' ) {
continue; // skip locals
}
if ( &segment[seg] != s->segment ) {
continue;
}
fprintf( f, "%i %8x %s\n", seg, s->value, s->name );
}
}
fclose( f );
}
/*
===============
WriteVmFile
===============
*/
static void WriteVmFile( void ) {
char imageName[MAX_OS_PATH];
vmHeader_t header;
FILE *f;
int headerSize;
report( "%i total errors\n", errorCount );
strcpy( imageName, outputFilename );
StripExtension( imageName );
strcat( imageName, ".qvm" );
remove( imageName );
report( "code segment: %7i\n", segment[CODESEG].imageUsed );
report( "data segment: %7i\n", segment[DATASEG].imageUsed );
report( "lit segment: %7i\n", segment[LITSEG].imageUsed );
report( "bss segment: %7i\n", segment[BSSSEG].imageUsed );
report( "instruction count: %i\n", instructionCount );
if ( errorCount != 0 ) {
report( "Not writing a file due to errors\n" );
return;
}
if( !options.vanillaQ3Compatibility ) {
header.vmMagic = VM_MAGIC_VER2;
headerSize = sizeof( header );
} else {
header.vmMagic = VM_MAGIC;
// Don't write the VM_MAGIC_VER2 bits when maintaining 1.32b compatibility.
// (I know this isn't strictly correct due to padding, but then platforms
// that pad wouldn't be able to write a correct header anyway). Note: if
// vmHeader_t changes, this needs to be adjusted too.
headerSize = sizeof( header ) - sizeof( header.jtrgLength );
}
header.instructionCount = instructionCount;
header.codeOffset = headerSize;
header.codeLength = segment[CODESEG].imageUsed;
header.dataOffset = header.codeOffset + segment[CODESEG].imageUsed;
header.dataLength = segment[DATASEG].imageUsed;
header.litLength = segment[LITSEG].imageUsed;
header.bssLength = segment[BSSSEG].imageUsed;
header.jtrgLength = segment[JTRGSEG].imageUsed;
report( "Writing to %s\n", imageName );
#ifdef Q3_BIG_ENDIAN
{
int i;
// byte swap the header
for ( i = 0 ; i < sizeof( vmHeader_t ) / 4 ; i++ ) {
((int *)&header)[i] = LittleLong( ((int *)&header)[i] );
}
}
#endif
CreatePath( imageName );
f = SafeOpenWrite( imageName );
SafeWrite( f, &header, headerSize );
SafeWrite( f, &segment[CODESEG].image, segment[CODESEG].imageUsed );
SafeWrite( f, &segment[DATASEG].image, segment[DATASEG].imageUsed );
SafeWrite( f, &segment[LITSEG].image, segment[LITSEG].imageUsed );
if( !options.vanillaQ3Compatibility ) {
SafeWrite( f, &segment[JTRGSEG].image, segment[JTRGSEG].imageUsed );
}
fclose( f );
}
/*
===============
Assemble
===============
*/
static void Assemble( void ) {
int i;
char filename[MAX_OS_PATH];
char *ptr;
report( "outputFilename: %s\n", outputFilename );
for ( i = 0 ; i < numAsmFiles ; i++ ) {
strcpy( filename, asmFileNames[ i ] );
DefaultExtension( filename, ".asm" );
LoadFile( filename, (void **)&asmFiles[i] );
}
// assemble
for ( passNumber = 0 ; passNumber < 2 ; passNumber++ ) {
segment[LITSEG].segmentBase = segment[DATASEG].imageUsed;
segment[BSSSEG].segmentBase = segment[LITSEG].segmentBase + segment[LITSEG].imageUsed;
segment[JTRGSEG].segmentBase = segment[BSSSEG].segmentBase + segment[BSSSEG].imageUsed;
for ( i = 0 ; i < NUM_SEGMENTS ; i++ ) {
segment[i].imageUsed = 0;
}
segment[DATASEG].imageUsed = 4; // skip the 0 byte, so NULL pointers are fixed up properly
instructionCount = 0;
for ( i = 0 ; i < numAsmFiles ; i++ ) {
currentFileIndex = i;
currentFileName = asmFileNames[ i ];
currentFileLine = 0;
report("pass %i: %s\n", passNumber, currentFileName );
fflush( NULL );
ptr = asmFiles[i];
while ( ptr ) {
ptr = ExtractLine( ptr );
AssembleLine();
}
}
// align all segment
for ( i = 0 ; i < NUM_SEGMENTS ; i++ ) {
segment[i].imageUsed = (segment[i].imageUsed + 3) & ~3;
}
if (passNumber == 0) {
sort_symbols();
}
}
// reserve the stack in bss
DefineSymbol( "_stackStart", segment[BSSSEG].imageUsed );
segment[BSSSEG].imageUsed += stackSize;
DefineSymbol( "_stackEnd", segment[BSSSEG].imageUsed );
// write the image
WriteVmFile();
// write the map file even if there were errors
if( options.writeMapFile ) {
WriteMapFile();
}
}
/*
=============
ParseOptionFile
=============
*/
static void ParseOptionFile( const char *filename ) {
char expanded[MAX_OS_PATH];
char *text, *text_p;
strcpy( expanded, filename );
DefaultExtension( expanded, ".q3asm" );
LoadFile( expanded, (void **)&text );
if ( !text ) {
return;
}
text_p = text;
while( ( text_p = COM_Parse( text_p ) ) != 0 ) {
if ( !strcmp( com_token, "-o" ) ) {
// allow output override in option file
text_p = COM_Parse( text_p );
if ( text_p ) {
strcpy( outputFilename, com_token );
}
continue;
}
asmFileNames[ numAsmFiles ] = copystring( com_token );
numAsmFiles++;
}
}
static void ShowHelp( char *argv0 ) {
Error("Usage: %s [OPTION]... [FILES]...\n\
Assemble LCC bytecode assembly to Q3VM bytecode.\n\
\n\
-o OUTPUT Write assembled output to file OUTPUT.qvm\n\
-f LISTFILE Read options and list of files to assemble from LISTFILE.q3asm\n\
-b BUCKETS Set symbol hash table to BUCKETS buckets\n\
-m Generate a mapfile for each OUTPUT.qvm\n\
-v Verbose compilation report\n\
-vq3 Produce a qvm file compatible with Q3 1.32b\n\
-h --help -? Show this help\n\
", argv0);
}
/*
==============
main
==============
*/
int main( int argc, char **argv ) {
int i;
double start, end;
// _chdir( "/quake3/jccode/cgame/lccout" ); // hack for vc profiler
if ( argc < 2 ) {
ShowHelp( argv[0] );
}
start = I_FloatTime ();
// default filename is "q3asm"
strcpy( outputFilename, "q3asm" );
numAsmFiles = 0;
for ( i = 1 ; i < argc ; i++ ) {
if ( argv[i][0] != '-' ) {
break;
}
if( !strcmp( argv[ i ], "-h" ) ||
!strcmp( argv[ i ], "--help" ) ||
!strcmp( argv[ i ], "-?") ) {
ShowHelp( argv[0] );
}
if ( !strcmp( argv[i], "-o" ) ) {
if ( i == argc - 1 ) {
Error( "-o must preceed a filename" );
}
/* Timbo of Tremulous pointed out -o not working; stock ID q3asm folded in the change. Yay. */
strcpy( outputFilename, argv[ i+1 ] );
i++;
continue;
}
if ( !strcmp( argv[i], "-f" ) ) {
if ( i == argc - 1 ) {
Error( "-f must preceed a filename" );
}
ParseOptionFile( argv[ i+1 ] );
i++;
continue;
}
if (!strcmp(argv[i], "-b")) {
if (i == argc - 1) {
Error("-b requires an argument");
}
i++;
symtablelen = atoiNoCap(argv[i]);
continue;
}
if( !strcmp( argv[ i ], "-v" ) ) {
/* Verbosity option added by Timbo, 2002.09.14.
By default (no -v option), q3asm remains silent except for critical errors.
Verbosity turns on all messages, error or not.
Motivation: not wanting to scrollback for pages to find asm error.
*/
options.verbose = qtrue;
continue;
}
if( !strcmp( argv[ i ], "-m" ) ) {
options.writeMapFile = qtrue;
continue;
}
if( !strcmp( argv[ i ], "-vq3" ) ) {
options.vanillaQ3Compatibility = qtrue;
continue;
}
Error( "Unknown option: %s", argv[i] );
}
// the rest of the command line args are asm files
for ( ; i < argc ; i++ ) {
asmFileNames[ numAsmFiles ] = copystring( argv[ i ] );
numAsmFiles++;
}
// In some case it Segfault without this check
if ( numAsmFiles == 0 ) {
Error( "No file to assemble" );
}
InitTables();
Assemble();
{
symbol_t *s;
for ( i = 0, s = symbols ; s ; s = s->next, i++ ) /* nop */ ;
if (options.verbose)
{
report("%d symbols defined\n", i);
hashtable_stats(symtable);
hashtable_stats(optable);
}
}
end = I_FloatTime ();
report ("%5.0f seconds elapsed\n", end-start);
return errorCount;
}
Reference in a new issue View git blame Copy permalink