Commit graph

12237 commits

Author SHA1 Message Date
Bill Currie
284fcd312d [qfcc] Rewrite assignment destination addressing
It now addressing_mode cleaning up store instructions to use ptr+offset
instead of lea;store ptr...

Entity.field addressing has been impelmented as well.

Move instructions still generate sub-optimal code in that they use an
add instruction instead of lea.
2022-01-28 15:50:46 +09:00
Bill Currie
d3764c108a [qfcc] Rewrite expr_deref to use addressing_mode
This cleans up the generation of load instructions such that they use
ptr+offset addressing instead of lea;load ptr.
2022-01-28 15:42:06 +09:00
Bill Currie
e298f0d993 [qfcc] Break out pointer addressing
This allows the code handling simple pointer dereferences to recurse
along an alias chain that resulted from casting between different
pointer types (such chains could probably be eliminated by replacing the
type in the original pointer expression, but it wasn't worth it at this
stage).
2022-01-28 15:37:08 +09:00
Bill Currie
d28507eacf [qfcc] Reduce some alias chaining
Aliasing an alias expression to the same type as the original aliased
expression is a no-op, so drop the alias entirely in order to simplify
code generation.
2022-01-28 15:29:40 +09:00
Bill Currie
ec9fa3fee8 [qfcc] Clean up an unnecessary use of array_expr
Simply dereferencing a pointer does not need to go through array_expr
and thus collect a 0 offset that will only be constant-folded out again.
Really just a minor optimization in qfcc, but at one stage in today's
modification, it resulted in some unwanted aliasing chains.
2022-01-28 15:26:47 +09:00
Bill Currie
8d873a891f [qfcc] Make struct ptr access consistent with class ivar access
While this does make the generated code a little worse, load is behaving
nicely), the two are at least consistent with each other and when I fix
one, I'll fix both. I missed this change the other day when I did the
address_expr cleanup. Yay near-duplicate code :P
2022-01-28 09:25:53 +09:00
Bill Currie
7877168e93 [qfcc] Make a field name more clear
Just "type" isn't very informative, but "result_type" is at least a fair
bit better.
2022-01-27 23:29:32 +09:00
Bill Currie
f57aa82c4b [qfcc] Use an alias op for return_operand
This is what using new_ret_expr would result in, but new_ret_expr is no
longer used for referencing .return (except in pascal, but I haven't
gotten around to sorting that out) due to the recent changes for Ruamoko
progs. Fixes an ICE when compiling (with optimization) something like
the following (dir is a vector):

    dir /= sqrt (dir * dir);
    return dir * speed;
2022-01-27 23:24:43 +09:00
Bill Currie
82166406df [qfcc] Remove the def sorting (reverts 9a08a51ebd)
It turns out the sorting wasn't working properly and I've decided that
anything that actually needs the defs to be sorted by address (such as a
debugger searching for defs by address) can do the sorting itself. Fixes
a weird swapping of def names.
2022-01-27 16:43:43 +09:00
Bill Currie
5c22253095 [gamecode] Use the stack frame to find local defs
Of course, only in Ruamoko progs, but it works quite nicely.
global_string is now passed the absolute address of the referenced
operand. With a little groveling through the progs stack, it should be
possible to resolve pointers to locals in functions further up the
stack.
2022-01-27 14:20:09 +09:00
Bill Currie
de974fdd3f [gamecode] Add format for addressing modes and use in return
This fixes Ruamoko's return format string. It looks like it's producing
the correct address (but doesn't show all the information it should),
but the rest of the debug code needs work locals.
2022-01-27 13:29:38 +09:00
Bill Currie
4b4cb60c65 [qfcc] Check qfo target matches compile target
Linking mixed target VMs is unlikely to end well.
2022-01-27 13:24:21 +09:00
Bill Currie
0123e12304 [qfcc] Use locals and params_start to describe stack frame
This is necessary to get statement disassembly working, and likely
debugging in general. locals is the total size of the stack frame and
thus reaches above the function-entry stack pointer, and params_start is
the local space relative start of the parameters. Thus, knowing the
function-entry stack pointer, the bottom of the locals space can be
found by subtracting params_start, and the top of the locals space by
adding (locals - params_start).
2022-01-27 11:37:37 +09:00
Bill Currie
42db8514ae [gamecode] Use version instead of locals count
It turned out I need locals count and params_start for debugging, so use
the progs version instead to bail early from PR_EnterFunction and
PR_LeaveFunction (which I had forgotten anyway, oops).
2022-01-27 11:24:00 +09:00
Bill Currie
a0d9cf8d8e [gamecode] Improve verbose statement prints for Ruamoko
They now include base register index and effective address of the
operands (though it may be wrong for instructions that don't use a base
register for that operand).
2022-01-27 10:57:31 +09:00
Bill Currie
59ee723201 [gamecode] Rename parm to param
That misspelling bothered me from the very beginning, I'd always have
trouble getting the name right when trying to access one of those fields.
2022-01-27 10:55:06 +09:00
Bill Currie
e9dff4ff9c [gamecode] Correct types and widths for bitnot
bitnot is the only unary operator in the bitops group and thus needs
special handling.
2022-01-27 10:21:48 +09:00
Bill Currie
169b8cc398 [qfcc] Rewrite qfo_to_progs offset/size calculation
This gets all the sections of the progs file nicely aligned and the code
easier to read with the offset and size calculations not being spread
through the function. ivar-struct-return now works when compiled for
Ruamoko.
2022-01-26 23:18:15 +09:00
Bill Currie
faa98d8198 [gamecode] Use a struct for offset/count pairs
This cleans up dprograms_t, making it easier to read and see what chunks
are in it (I was surprised to see only 6, the explicit pairs made it
seem to have more).
2022-01-26 19:30:25 +09:00
Bill Currie
a2fd42f174 [qfcc] Align progs memory to 32 bytes in the test harness
This ensures the engine can align everything to 32 bytes.
2022-01-26 16:57:34 +09:00
Bill Currie
a2f4522e76 [gamecode] Align Ruamoko progs to 32 bytes.
Intel hardware requires 32-byte alignment for lvec4 and dvec4.
Unfortunately, it turns out that my attempts to align progs data in qfcc
went awry do to the order block sizes are calculated when writing the
progs.
2022-01-26 16:55:14 +09:00
Bill Currie
90b40e7e52 [qfcc] Ensure adjstk and with always come first
While I think the reason the dags code moved an instruction before
adjstk and with was they shared a constant with that instruction (which
is a different bug), this ensures other instructions cannot get
reordered in front of adjstk and with, as doing so would cause any such
instructions to access incorrect data.
2022-01-26 15:50:04 +09:00
Bill Currie
0b9b6955aa [qfcc] Implement addressing modes for return
There's still entity.field to go, but basic def and ptr + const offset
seem to work.
2022-01-26 15:48:08 +09:00
Bill Currie
982a090143 [qfcc] Mask off base register bits when printing statements
Fixes a segfault when compiling Ruamoko progs with debug output.
2022-01-26 12:26:50 +09:00
Bill Currie
ee4eecc741 [gamecode] Correct types and opname for memset and move 2022-01-26 12:26:12 +09:00
Bill Currie
6bc6db471d [gamecode] Make return use same addressing as other ops
This makes return consistent with load, store, etc, though its
addressing mode is encoded in bits 5 and 6 of c rather than the opcode.
It turns out I had no tests for any of return's addressing modes other
than basic def references, so no tests needed changing.
2022-01-26 09:51:11 +09:00
Bill Currie
06d70a32db [qfcc] Rework the functionality of address expressions
The goal was to get lea being used for locals in ruamoko progs because
lea takes the base registers into account while the constant pointer
defs used by v6p cannot. Pointer defs are still used for gobals as they
may be out of reach of 16-bit addressing.

address_expr() has been simplified in that it no longer takes an offset:
the vast majority of the callers never passed one, and the few that did
have been reworked to use other mechanisms. In particular,
offset_pointer_expr does the manipulations needed to add an offset
(unscaled by type size) to a pointer. High-level pointer offsets still
apply a scale, though.

Alias expressions now do a better job of hanling aliasing of aliases by
simply replacing the target type when possible.
2022-01-25 23:39:17 +09:00
Bill Currie
e4bb5c8048 [qfcc] Add pragma to control warning promotion
This allows me to disable -Werror in the Makefile but still have the
build tests work properly and not fail when they shouldn't.
2022-01-25 22:15:28 +09:00
Bill Currie
40f5b8a482 [qfcc] Allow short constants in expr_int
No point in generating an internal error when the value can be converted
to an int.
2022-01-25 12:47:12 +09:00
Bill Currie
8d435040e6 [qfcc] Clean up some type checkes
Using the functions keeps the code a little easier to read.
2022-01-25 12:46:14 +09:00
Bill Currie
a1acdb8951 [qfcc] Print children of uexpr and return expressions
It's possible I lost the child printing when creating the return
expressions, but dot diagrams are much more useful when they don't have
nodes with just pointer values.
2022-01-25 12:29:15 +09:00
Bill Currie
fc73cfc1e0 [qfcc] Rename pointer_expr to deref_pointer_expr
This reflects what it actually does (usually, "pointer_expr" type naming
is creating an expression that represents a pointer).
2022-01-25 12:28:53 +09:00
Bill Currie
37f08f9d4f [qfcc] Build the Ruamoko function parameters
The parameter defs are allocated from the parameter space using a
minimum alignment of 4, and varargs functions get a va_list struct in
place of the ...

An "args" expression is unconditionally injected into the call arguments
list at the place where ... is in the list, with arguments passed
through ... coming after the ...

Arguments get through to functions now, but there's problems with taking
the address of local variables: currently done using constant pointer
defs, which can't work for the base register addressing used in Ruamoko
progs.

With the update to test-bi's printf (and a hack to qfcc for lea),
triangle.r actually works, printing the expected results (but -1 instead
of 1 for equality, though that too is actually expected). qfcc will take
a bit longer because it seems there are some design issues in address
expressions (ambiguity, and a few other things) that have pretty much
always been there.
2022-01-24 23:44:48 +09:00
Bill Currie
7e147e703c [qfcc] Copy def reg into alias def
This fixes incorrect local struct member access in Ruamoko progs.
2022-01-24 18:31:53 +09:00
Bill Currie
5cf7924352 [qfcc] Improve dags handling of auxiliary use ops
The aux use ops need to be counted and given nodes explicitly as they
may refer to defs that are not accessed by other statements other than
by aliases, and those aliases need to be marked live as well as the used
def.
2022-01-24 16:55:55 +09:00
Bill Currie
b663fecd4e [gamecode] Use PR_SetupParameters for rua called builtins
It's a bit heavy-handed as it sets all the param pointers, but simple
(no varargs) functions are working nicely in Ruamoko.
2022-01-24 16:46:49 +09:00
Bill Currie
9fc8f14be6 [qfcc] Put the stack frame exprs into the statements block
dot_expr doesn't follow an expression's next pointer on its own.
make_statements was fine, which is why I didn't notice the mistake until
now.
2022-01-24 16:44:48 +09:00
Bill Currie
739c98fe21 [qfcc] Add adjstk and with to dot_expr
And be more informative with "bad" expression types (print the name if
it's just that I haven't added a printer for a valid type).
2022-01-24 16:42:13 +09:00
Bill Currie
00b7bced7f [gamecode] Rework PR_RESET_PARAMS to use PR_SetupParams
PR_SetupParams is new and sets up the parameter pointers so older code
that expects only up to 8 parameter will work with both v6p and Ruamoko
progs without having to check what progs are running. PR_SetupParams is
useful even when Ruamoko progs are expected as it reserves the required
space (respecting alignment) on the stack and returns a pointer to the
top (bottom? confusing) of the stack. PR_PushFrame and PR_PopFrame
need to be used around PR_SetupParams, regardless of using temp strings,
to avoid a stack leak (need to do an audit).
2022-01-24 12:50:15 +09:00
Bill Currie
1f802716e1 [qfcc] Pass initialize_def the symtab to use as a parameter
This takes care of an old FIXME.
2022-01-24 12:48:02 +09:00
Bill Currie
9c51c3d2e1 [gamecode] Add a data pointer passed to builtin functions
This is part of the work for #26 (Record resource pointer with builtin
function data). Currently, the data pointer gets as far as the
per-instance VM function table (I don't feel like tackling the job of
converting all the builtin functions tonight). All the builtin modules
that register a resources data block pass that block on to
PR_RegisterBuiltins.
2022-01-24 00:20:05 +09:00
Bill Currie
a818fa4b8e [gamecode] Rearrange bfunction_t in preparation for param offsets
The builtin and progs function data is overlaid so the extra data
doesn't cause too much memory to be used (it's actually 8 bytes smaller
now).  The plan is to pre-compute the offsets based on the parameter
size and alignment data.
2022-01-24 00:19:13 +09:00
Bill Currie
a6b932025c [gamecode] Provide builtins with information about their parameters
This will make it possible for the engine to set up their parameter
pointers when running Ruamoko progs. At this stage, it doesn't matter
*too* much, except for varargs functions, because no builtin yet takes
anything larger than a float quaternion, but it will be critical when
double or long vec3 and vec4 values are passed.
2022-01-23 22:27:27 +09:00
Bill Currie
e746e39738 [gamecode] Create macros for progs sizeof and alignof
I wound up needing the idioms in too many places.
2022-01-23 14:29:33 +09:00
Bill Currie
3c86660d4a [gamecode] Rename MAX_PARMS to PR_MAXPARAMS 2022-01-23 14:17:25 +09:00
Bill Currie
cfaf158ebc [math] Add some bit-op functions
Just 32-bit rounding to next higher power of two, and base 2 logarithm.
Most importantly, they are suitable for use in initializers as they are
constant in, constant out.
2022-01-23 13:47:14 +09:00
Bill Currie
f72e8ef551 [qwaq] Fix a couple of errors in debug
Update qdb_get_string's mangling for qfcc's new unsigned int support and
fix an incorrect cast of the param pointer passed by prd_runerror that
caused a segfault when trying to use the string. Attempting to use
qwaq-app (ie, the qc debugger) on Ruamoko ISA progs mostly works, but
the defs are decidedly unhappy (due to the base registers).
2022-01-23 02:04:28 +09:00
Bill Currie
adf672e7b1 [qfcc] Mark the correct operand as used in stores
This fixes the lost-use test, and windows not dragging properly in
qwaq-curses. Another single-character bug-fix :P
2022-01-23 01:37:57 +09:00
Bill Currie
b6093e0728 [qfcc] Add failing test for lost var use
Storing a variable into a dereference pointer (*p = x) is not marking
the variable as used (due to a mistake while converting to Ruamoko
statement format) resulting in assignments to that variable being
dropped due to it being a dead assignment as the assignment to the
variable and the storing need to be in separate basic blocks (thus the
call in the test, though an if would have worked, I think) for the bug
to trigger.
2022-01-23 01:31:50 +09:00
Bill Currie
ec5830f70b [qfcc] "Use" the correct operands
The problem was a missed change when switching the internal statement
format to Ruamoko: I "used" the statement's operands directly rather
than the rotated ones when emitting v6p progs. Fixes a compile segfault
when NOT optimizing.
2022-01-23 00:59:38 +09:00