zdoom/qzdoom
0
0
Fork 0
mirror of https://github.com/ZDoom/qzdoom.git synced 2025-01-07 02:00:49 +00:00
Code Issues Projects Releases Packages Wiki Activity
qzdoom/src/scripting/vm/vmexec.cpp

240 lines
6.6 KiB
C++
Raw Normal View History

- added copyright headers to scripting files.
2016-10-08 06:35:16 +00:00
/*
** vmexec.cpp
**
**---------------------------------------------------------------------------
** Copyright -2016 Randy Heit
** All rights reserved.
**
** Redistribution and use in source and binary forms, with or without
** modification, are permitted provided that the following conditions
** are met:
**
** 1. Redistributions of source code must retain the above copyright
** notice, this list of conditions and the following disclaimer.
** 2. Redistributions in binary form must reproduce the above copyright
** notice, this list of conditions and the following disclaimer in the
** documentation and/or other materials provided with the distribution.
** 3. The name of the author may not be used to endorse or promote products
** derived from this software without specific prior written permission.
**
** THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
** IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
** OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
** IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
** INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
** NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
** THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
**---------------------------------------------------------------------------
**
*/
Normalize line endings
2016-03-01 15:47:10 +00:00
#include <math.h>
- changed order of script files to match the old DECORATE list for easy comparison of the disassembly. - added a descriptive name to all types for error messages. - added a generic type cast node to the code generator. - added a few more cast operations to the 'cast' VM instruction. - extended FxClassTypeCast to handle all possible input that can be cast to a class pointer, not just names.
2016-10-16 17:42:22 +00:00
#include <v_video.h>
#include <s_sound.h>
- reverted most of the last commit after realizing that trying to manage constructing/destructing per variable is not going to work because it'd require some extensive exception management in the compiled VM code. - instead add a list of SpecialInits to VMScriptFunction so this can be done transparently when setting up and popping the stack frame. The only drawback is that this requires permanent allocation of stack objects for the entire lifetime of a function but this is a relatively small tradeoff for significantly reduced maintenance work throughout. - removed most #include "vm.h", because nearly all files already pull this in through dobject.h.
2016-11-17 12:10:19 +00:00
#include "dobject.h"
Normalize line endings
2016-03-01 15:47:10 +00:00
#include "xs_Float.h"
- added two new integral types SpriteID and TextureID, both are needed to allow proper serialization as they require something different to be written out than a regular integer.
2016-11-21 12:45:33 +00:00
#include "r_state.h"
#include "textures/textures.h"
- added custom math routines for reliability.
2016-03-11 14:45:47 +00:00
#include "math/cmath.h"
- added some profiling code to the VM.
2016-12-31 16:59:48 +00:00
#include "stats.h"
extern cycle_t VMCycles[10];
extern int VMCalls[10];
Normalize line endings
2016-03-01 15:47:10 +00:00
redid the exception mechanism for script-side access violations to be of more use for diagnosing problems. The original implementation just printed a mostly information-free message and then went on as if nothing has happened, making it ridiculously easy to write broken code and release it. Changed it to: * Any VMAbortException will now terminate the game session and go back to the console. * It will also print a VM stack trace with all open functions, including source file and line numbers pointing to the problem spots. For this the relevant information had to be added to the VMScriptFunction class. An interesting effect here was that just throwing the exception object increased the VM's Exec function's stack size from 900 bytes to 70kb, because the compiler allocates a separate local buffer for every single instance of the exception object. The obvious solution was to put this part into a subfunction so that it won't pollute the Exec function's own stack frame. Interesting side effect of this: Exec's stack requirement went down from 900 bytes to 600 bytes. This is still on the high side but already a lot better.
2016-12-03 11:23:13 +00:00
// This must be a separate function because the VC compiler would otherwise allocate memory on the stack for every separate instance of the exception object that may get thrown.
void ThrowAbortException(EVMAbortException reason, const char *moreinfo, ...);
// intentionally implemented in a different source file tp prevent inlining.
void ThrowVMException(VMException *x);
Normalize line endings
2016-03-01 15:47:10 +00:00
#define IMPLEMENT_VMEXEC
#if !defined(COMPGOTO) && defined(__GNUC__)
#define COMPGOTO 1
#endif
#if COMPGOTO
#define OP(x) x
Change VM to increment PC after each instruction rather than before - VC++ generated horribly stupid code for x64 when incrementing pc at the beginning of each instruction by storing hundreds of copies of it for every opcode executed. Incrementing pc at the end avoids this madness. - It is possible I messed something up with this change. Hopefully not.
2016-10-22 03:08:12 +00:00
#define NEXTOP do { pc++; unsigned op = pc->op; a = pc->a; goto *ops[op]; } while(0)
Normalize line endings
2016-03-01 15:47:10 +00:00
#else
#define OP(x) case OP_##x
Change VM to increment PC after each instruction rather than before - VC++ generated horribly stupid code for x64 when incrementing pc at the beginning of each instruction by storing hundreds of copies of it for every opcode executed. Incrementing pc at the end avoids this madness. - It is possible I messed something up with this change. Hopefully not.
2016-10-22 03:08:12 +00:00
#define NEXTOP pc++; break
Normalize line endings
2016-03-01 15:47:10 +00:00
#endif
#define luai_nummod(a,b) ((a) - floor((a)/(b))*(b))
Change VM to increment PC after each instruction rather than before - VC++ generated horribly stupid code for x64 when incrementing pc at the beginning of each instruction by storing hundreds of copies of it for every opcode executed. Incrementing pc at the end avoids this madness. - It is possible I messed something up with this change. Hopefully not.
2016-10-22 03:08:12 +00:00
#define A (pc[0].a)
#define B (pc[0].b)
#define C (pc[0].c)
#define Cs (pc[0].cs)
#define BC (pc[0].i16u)
#define BCs (pc[0].i16)
#define ABCs (pc[0].i24)
Normalize line endings
2016-03-01 15:47:10 +00:00
#define JMPOFS(x) ((x)->i24)
#define KC (konstd[C])
#define RC (reg.d[C])
#define PA (reg.a[A])
#define PB (reg.a[B])
#define ASSERTD(x) assert((unsigned)(x) < f->NumRegD)
#define ASSERTF(x) assert((unsigned)(x) < f->NumRegF)
#define ASSERTA(x) assert((unsigned)(x) < f->NumRegA)
#define ASSERTS(x) assert((unsigned)(x) < f->NumRegS)
- scriptified Heretic's blaster. - scriptified all Effect functions of Fastprojectile's children - implemented access to class meta data. - added a VM instruction to retrieve the class metadata, to eliminate the overhead of the function call that would otherwise be needed. - made GetClass() a builtin so that it can use the new instruction Important note about this commit: Scriptifying CFlameMissile::Effect revealed a problem with the virtual function interface: In order to work, this needs to be explicitly enabled for each single native class that may be used as a base for a scripted class. Needless to say, this will end up way too much work, as there are over 100 native classes, excluding those which will be scriptified. But in order to fix the problem this partially broken state needs to be committed first.
2016-11-24 19:02:44 +00:00
#define ASSERTO(x) assert((unsigned)(x) < f->NumRegA && reg.atag[x] == ATAG_OBJECT)
Normalize line endings
2016-03-01 15:47:10 +00:00
#define ASSERTKD(x) assert(sfunc != NULL && (unsigned)(x) < sfunc->NumKonstD)
#define ASSERTKF(x) assert(sfunc != NULL && (unsigned)(x) < sfunc->NumKonstF)
#define ASSERTKA(x) assert(sfunc != NULL && (unsigned)(x) < sfunc->NumKonstA)
#define ASSERTKS(x) assert(sfunc != NULL && (unsigned)(x) < sfunc->NumKonstS)
#define CMPJMP(test) \
SHA-1: 8852bc7278d033bbed66c51bf23aee841ee977a9 * Revert "Modify CMPJMP to produce more compact code (as far as VC++ is concerned, anyway)" This reverts commit 6ff973a06bd97dfd1c2c5191b508fdbd98f62063. This modification did not work and broke the comparisons. Actually this had three problems: * the asserts checked the wrong instruction * the mask was not applied to regular comparisons. * incrementing PC before testing does not work because 'test' references the PC.
2016-11-02 09:52:14 +00:00
if ((test) == (a & CMP_CHECK)) { \
Change VM to increment PC after each instruction rather than before - VC++ generated horribly stupid code for x64 when incrementing pc at the beginning of each instruction by storing hundreds of copies of it for every opcode executed. Incrementing pc at the end avoids this madness. - It is possible I messed something up with this change. Hopefully not.
2016-10-22 03:08:12 +00:00
assert(pc[1].op == OP_JMP); \
SHA-1: 8852bc7278d033bbed66c51bf23aee841ee977a9 * Revert "Modify CMPJMP to produce more compact code (as far as VC++ is concerned, anyway)" This reverts commit 6ff973a06bd97dfd1c2c5191b508fdbd98f62063. This modification did not work and broke the comparisons. Actually this had three problems: * the asserts checked the wrong instruction * the mask was not applied to regular comparisons. * incrementing PC before testing does not work because 'test' references the PC.
2016-11-02 09:52:14 +00:00
pc += 1 + JMPOFS(pc+1); \
} else { \
pc += 1; \
Normalize line endings
2016-03-01 15:47:10 +00:00
}
#define GETADDR(a,o,x) \
redid the exception mechanism for script-side access violations to be of more use for diagnosing problems. The original implementation just printed a mostly information-free message and then went on as if nothing has happened, making it ridiculously easy to write broken code and release it. Changed it to: * Any VMAbortException will now terminate the game session and go back to the console. * It will also print a VM stack trace with all open functions, including source file and line numbers pointing to the problem spots. For this the relevant information had to be added to the VMScriptFunction class. An interesting effect here was that just throwing the exception object increased the VM's Exec function's stack size from 900 bytes to 70kb, because the compiler allocates a separate local buffer for every single instance of the exception object. The obvious solution was to put this part into a subfunction so that it won't pollute the Exec function's own stack frame. Interesting side effect of this: Exec's stack requirement went down from 900 bytes to 600 bytes. This is still on the high side but already a lot better.
2016-12-03 11:23:13 +00:00
if (a == NULL) { ThrowAbortException(x, nullptr); } \
Normalize line endings
2016-03-01 15:47:10 +00:00
ptr = (VM_SBYTE *)a + o
static const VM_UWORD ZapTable[16] =
{
0x00000000, 0x000000FF, 0x0000FF00, 0x0000FFFF,
0x00FF0000, 0x00FF00FF, 0x00FFFF00, 0x00FFFFFF,
0xFF000000, 0xFF0000FF, 0xFF00FF00, 0xFF00FFFF,
0xFFFF0000, 0xFFFF00FF, 0xFFFFFF00, 0xFFFFFFFF
};
#ifdef NDEBUG
#define WAS_NDEBUG 1
#else
#define WAS_NDEBUG 0
#endif
#if WAS_NDEBUG
#undef NDEBUG
#endif
#undef assert
#include <assert.h>
struct VMExec_Checked
{
#include "vmexec.h"
};
#if WAS_NDEBUG
#define NDEBUG
#endif
#if !WAS_NDEBUG
#define NDEBUG
#endif
#undef assert
#include <assert.h>
struct VMExec_Unchecked
{
#include "vmexec.h"
};
#if !WAS_NDEBUG
#undef NDEBUG
#endif
#undef assert
#include <assert.h>
int (*VMExec)(VMFrameStack *stack, const VMOP *pc, VMReturn *ret, int numret) =
#ifdef NDEBUG
VMExec_Unchecked::Exec
#else
VMExec_Checked::Exec
#endif
;
- allow the VM to run on one global stack per thread. It is utterly pointless to require every function that wants to make a VM call to allocate a new stack first. The allocation overhead doubles the time to set up the call. With one stack, previously allocated memory can be reused. The only important thing is, if this ever gets used in a multithreaded environment to have the stack being declared as thread_local, although for ZDoom this is of no consequence. - eliminated all cases where native code was calling other native code through the VM interface. After scriptifying the game code, only 5 places were left which were quickly eliminated. This was mostly to ensure that the native VM function parameters do not need to be propagated further than absolutely necessary.
2016-11-30 16:15:01 +00:00
// Note: If the VM is being used in multiple threads, this should be declared as thread_local.
// ZDoom doesn't need this at the moment so this is disabled.
thread_local VMFrameStack GlobalVMStack;
Normalize line endings
2016-03-01 15:47:10 +00:00
//===========================================================================
//
// VMSelectEngine
//
// Selects the VM engine, either checked or unchecked. Default will decide
// based on the NDEBUG preprocessor definition.
//
//===========================================================================
void VMSelectEngine(EVMEngine engine)
{
switch (engine)
{
case VMEngine_Default:
#ifdef NDEBUG
VMExec = VMExec_Unchecked::Exec;
#else
#endif
VMExec = VMExec_Checked::Exec;
break;
case VMEngine_Unchecked:
VMExec = VMExec_Unchecked::Exec;
break;
case VMEngine_Checked:
VMExec = VMExec_Checked::Exec;
break;
}
}
//===========================================================================
//
// VMFillParams
//
// Takes parameters from the parameter stack and stores them in the callee's
// registers.
//
//===========================================================================
void VMFillParams(VMValue *params, VMFrame *callee, int numparam)
{
unsigned int regd, regf, regs, rega;
VMScriptFunction *calleefunc = static_cast<VMScriptFunction *>(callee->Func);
const VMRegisters calleereg(callee);
assert(calleefunc != NULL && !calleefunc->Native);
- fixed: A VM function's NumArgs value needs to count stack arguments, not logical ones, meaning that for vectors each element needs to count separately. - renamed VMFunction::Defaults to DefaultArgs to make searching easier. - let ZCCCompiler process vector defaults for function parameters.
2016-10-30 08:05:42 +00:00
assert(numparam == calleefunc->NumArgs || ((int)calleefunc->DefaultArgs.Size() == calleefunc->NumArgs));
Normalize line endings
2016-03-01 15:47:10 +00:00
assert(REGT_INT == 0 && REGT_FLOAT == 1 && REGT_STRING == 2 && REGT_POINTER == 3);
regd = regf = regs = rega = 0;
- actually evaluate the default parameters and store them in the VMFunction. - disabled the assert in PType::GetRegType. This assert blocks any use to check for types that are incompatible with function parameters. - pass the default parameter constants to the native functions. At the moment this is not used yet. - use the function defaults to complete argument lists to script functions. - fixed all default values that got flagged by the expression evaluator as non-constant. Most were state labels and colors which were defaulted to "". The proper value is null for states and 0 for colors. - also replaced all "" defaults for names with "none".
2016-10-26 23:30:34 +00:00
for (int i = 0; i < calleefunc->NumArgs; ++i)
Normalize line endings
2016-03-01 15:47:10 +00:00
{
- actually evaluate the default parameters and store them in the VMFunction. - disabled the assert in PType::GetRegType. This assert blocks any use to check for types that are incompatible with function parameters. - pass the default parameter constants to the native functions. At the moment this is not used yet. - use the function defaults to complete argument lists to script functions. - fixed all default values that got flagged by the expression evaluator as non-constant. Most were state labels and colors which were defaulted to "". The proper value is null for states and 0 for colors. - also replaced all "" defaults for names with "none".
2016-10-26 23:30:34 +00:00
// get all actual parameters and fill the rest from the defaults.
- fixed: A VM function's NumArgs value needs to count stack arguments, not logical ones, meaning that for vectors each element needs to count separately. - renamed VMFunction::Defaults to DefaultArgs to make searching easier. - let ZCCCompiler process vector defaults for function parameters.
2016-10-30 08:05:42 +00:00
VMValue &p = i < numparam? params[i] : calleefunc->DefaultArgs[i];
Normalize line endings
2016-03-01 15:47:10 +00:00
if (p.Type < REGT_STRING)
{
if (p.Type == REGT_INT)
{
calleereg.d[regd++] = p.i;
}
else // p.Type == REGT_FLOAT
{
calleereg.f[regf++] = p.f;
}
}
else if (p.Type == REGT_STRING)
{
calleereg.s[regs++] = p.s();
}
else
{
assert(p.Type == REGT_POINTER);
calleereg.a[rega] = p.a;
calleereg.atag[rega++] = p.atag;
}
}
}
- added null pointer validation to any relevant exported function. In most cases null pointers were already being treated as 'do nothing', but there's several places where this can make the code silently fail so in these cases a VM exception will be raised, once the VM's exception handling has been repaired to provide useful diagnostics. (Right now all it does is catch the exception, print a useless message and return to the caller as if nothing has happened.)
2016-12-02 11:06:49 +00:00
- record all line numbers during function generation. This is useful for error reporting and eventually debugging. - throw a useful exception when a VM abort occurs, the simple enum was incapable of reporting anything more than the barest minimum, which at least for array index out of bounds errors was insufficient. The current exception mechanism is still insufficient. It really has to report a proper crash location and print a stack trace to the maximum extent possible. Instead it just prints a message and happily goes on. This is not a good solution.
2016-12-02 16:36:29 +00:00
Reference in a new issue Copy permalink