CPunch
/
Cosmo
mirror of https://github.com/CPunch/Cosmo.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

implemented jump table dispatch 

- currently only enabled on supported platforms (GNU C Compiler + Clang)
- when enabled, sped up examples/fibtest.cosmo by about 20% (avg of 11.179s prior and 8.799 after)

NOTE: malicious dumps can trivially cause crashes now by having junk function chunks
This commit is contained in:
CPunch 2023-06-03 01:17:28 -05:00 committed by cpunch
parent 7bca6927a9
commit 2b3825d258
4 changed files with 647 additions and 589 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/coperators.h
View File

@ -64,7 +64,7 @@ typedef enum
OP_FALSE,
OP_NIL,
OP_RETURN
OP_RETURN,
} COPCODE; // there can be a max of 256 instructions
#endif

10
src/cosmo.h
View File

@ -14,7 +14,15 @@
performance, however this will produce undefined behavior as you reach the stack limit (and may
cause a seg fault!). It is recommended to keep this enabled.
*/
#define SAFE_STACK
// #define SAFE_STACK
/*
NAN_BOXXED:
if undefined, the interpreter will use a tagged union to store values. This is the default.
Note that even though the sizeof(CValue) is 8 bytes for NAN_BOXXED (as opposed to 16 bytes for
the tagged union) no performance benefits were measured. I recommend keeping this undefined for
now.
*/
// #define NAN_BOXXED
// forward declare *most* stuff so our headers are cleaner

391
src/cvm.c
View File

@ -672,15 +672,62 @@ int _tbl__next(CState *state, int nargs, CValue *args)
return -1; \
}
static inline uint8_t READBYTE(CCallFrame *frame)
{
return *frame->pc++;
}
static inline uint16_t READUINT(CCallFrame *frame)
{
frame->pc += 2;
return *(uint16_t *)(&frame->pc[-2]);
}
#ifdef VM_JUMPTABLE
# define DISPATCH goto *cosmoV_dispatchTable[READBYTE(frame)]
# define CASE(op) \
DISPATCH; \
JMP_##op
# define JMPLABEL(op) &&JMP_##op
# define SWITCH \
static void *cosmoV_dispatchTable[] = { \
JMPLABEL(OP_LOADCONST), JMPLABEL(OP_SETGLOBAL), JMPLABEL(OP_GETGLOBAL), \
JMPLABEL(OP_SETLOCAL), JMPLABEL(OP_GETLOCAL), JMPLABEL(OP_GETUPVAL), \
JMPLABEL(OP_SETUPVAL), JMPLABEL(OP_PEJMP), JMPLABEL(OP_EJMP), \
JMPLABEL(OP_JMP), JMPLABEL(OP_JMPBACK), JMPLABEL(OP_POP), \
JMPLABEL(OP_CALL), JMPLABEL(OP_CLOSURE), JMPLABEL(OP_CLOSE), \
JMPLABEL(OP_NEWTABLE), JMPLABEL(OP_NEWARRAY), JMPLABEL(OP_INDEX), \
JMPLABEL(OP_NEWINDEX), JMPLABEL(OP_NEWOBJECT), JMPLABEL(OP_SETOBJECT), \
JMPLABEL(OP_GETOBJECT), JMPLABEL(OP_GETMETHOD), JMPLABEL(OP_INVOKE), \
JMPLABEL(OP_ITER), JMPLABEL(OP_NEXT), JMPLABEL(OP_ADD), \
JMPLABEL(OP_SUB), JMPLABEL(OP_MULT), JMPLABEL(OP_DIV), \
JMPLABEL(OP_MOD), JMPLABEL(OP_POW), JMPLABEL(OP_NOT), \
JMPLABEL(OP_NEGATE), JMPLABEL(OP_COUNT), JMPLABEL(OP_CONCAT), \
JMPLABEL(OP_INCLOCAL), JMPLABEL(OP_INCGLOBAL), JMPLABEL(OP_INCUPVAL), \
JMPLABEL(OP_INCINDEX), JMPLABEL(OP_INCOBJECT), JMPLABEL(OP_EQUAL), \
JMPLABEL(OP_LESS), JMPLABEL(OP_GREATER), JMPLABEL(OP_LESS_EQUAL), \
JMPLABEL(OP_GREATER_EQUAL), JMPLABEL(OP_TRUE), JMPLABEL(OP_FALSE), \
JMPLABEL(OP_NIL), JMPLABEL(OP_RETURN), \
}; \
DISPATCH;
# define DEFAULT DISPATCH /* no-op */
#else
# define CASE(op) \
continue; \
case op
# define SWITCH switch (READBYTE(frame))
# define DEFAULT \
default: \
CERROR("unknown opcode!"); \
exit(0)
#endif
// returns -1 if panic
int cosmoV_execute(CState *state)
{
CCallFrame *frame = &state->callFrame[state->frameCount - 1]; // grabs the current frame
CValue *constants = frame->closure->function->chunk.constants.values; // cache the pointer :)
#define READBYTE() *frame->pc++
#define READUINT() (frame->pc += 2, *(uint16_t *)(&frame->pc[-2]))
while (!state->panic) {
#ifdef VM_DEBUG
cosmoV_printStack(state);
@ -688,95 +735,98 @@ int cosmoV_execute(CState *state)
frame->pc - frame->closure->function->chunk.buf, state->frameCount - 1);
printf("\n");
#endif
switch (READBYTE()) {
case OP_LOADCONST: { // push const[uint] to stack
uint16_t indx = READUINT();
SWITCH
{
CASE(OP_LOADCONST) :
{ // push const[uint] to stack
uint16_t indx = READUINT(frame);
cosmoV_pushValue(state, constants[indx]);
continue;
}
case OP_SETGLOBAL: {
uint16_t indx = READUINT();
CASE(OP_SETGLOBAL) :
{
uint16_t indx = READUINT(frame);
CValue ident = constants[indx]; // grabs identifier
CValue *val = cosmoT_insert(state, &state->globals->tbl, ident);
*val = *cosmoV_pop(state); // sets the value in the hash table
continue;
}
case OP_GETGLOBAL: {
uint16_t indx = READUINT();
CASE(OP_GETGLOBAL) :
{
uint16_t indx = READUINT(frame);
CValue ident = constants[indx]; // grabs identifier
CValue val; // to hold our value
cosmoT_get(state, &state->globals->tbl, ident, &val);
cosmoV_pushValue(state, val); // pushes the value to the stack
continue;
}
case OP_SETLOCAL: {
uint8_t indx = READBYTE();
CASE(OP_SETLOCAL) :
{
uint8_t indx = READBYTE(frame);
// set base to top of stack & pop
frame->base[indx] = *cosmoV_pop(state);
continue;
}
case OP_GETLOCAL: {
uint8_t indx = READBYTE();
CASE(OP_GETLOCAL) :
{
uint8_t indx = READBYTE(frame);
cosmoV_pushValue(state, frame->base[indx]);
continue;
}
case OP_GETUPVAL: {
uint8_t indx = READBYTE();
CASE(OP_GETUPVAL) :
{
uint8_t indx = READBYTE(frame);
cosmoV_pushValue(state, *frame->closure->upvalues[indx]->val);
continue;
}
case OP_SETUPVAL: {
uint8_t indx = READBYTE();
CASE(OP_SETUPVAL) :
{
uint8_t indx = READBYTE(frame);
*frame->closure->upvalues[indx]->val = *cosmoV_pop(state);
continue;
}
case OP_PEJMP: { // pop equality jump
uint16_t offset = READUINT();
CASE(OP_PEJMP) :
{ // pop equality jump
uint16_t offset = READUINT(frame);
if (isFalsey(cosmoV_pop(state))) { // pop, if the condition is false, jump!
frame->pc += offset;
}
continue;
}
case OP_EJMP: { // equality jump
uint16_t offset = READUINT();
CASE(OP_EJMP) :
{ // equality jump
uint16_t offset = READUINT(frame);
if (isFalsey(cosmoV_getTop(state, 0))) { // if the condition is false, jump!
frame->pc += offset;
}
continue;
}
case OP_JMP: { // jump
uint16_t offset = READUINT();
CASE(OP_JMP) :
{ // jump
uint16_t offset = READUINT(frame);
frame->pc += offset;
continue;
}
case OP_JMPBACK: {
uint16_t offset = READUINT();
CASE(OP_JMPBACK) :
{
uint16_t offset = READUINT(frame);
frame->pc -= offset;
continue;
}
case OP_POP: { // pops value off the stack
cosmoV_setTop(state, READBYTE());
continue;
CASE(OP_POP) :
{ // pops value off the stack
cosmoV_setTop(state, READBYTE(frame));
}
case OP_CALL: {
uint8_t args = READBYTE();
uint8_t nres = READBYTE();
CASE(OP_CALL) :
{
uint8_t args = READBYTE(frame);
uint8_t nres = READBYTE(frame);
if (cosmoV_call(state, args, nres) != COSMOVM_OK) {
return -1;
}
continue;
}
case OP_CLOSURE: {
uint16_t index = READUINT();
CASE(OP_CLOSURE) :
{
uint16_t index = READUINT(frame);
CObjFunction *func = cosmoV_readFunction(constants[index]);
CObjClosure *closure = cosmoO_newClosure(state, func);
cosmoV_pushRef(state, (CObj *)closure);
for (int i = 0; i < closure->upvalueCount; i++) {
uint8_t encoding = READBYTE();
uint8_t index = READBYTE();
uint8_t encoding = READBYTE(frame);
uint8_t index = READBYTE(frame);
if (encoding == OP_GETUPVAL) {
// capture upvalue from current frame's closure
closure->upvalues[i] = frame->closure->upvalues[index];
@ -785,21 +835,20 @@ int cosmoV_execute(CState *state)
closure->upvalues[i] = captureUpvalue(state, frame->base + index);
}
}
continue;
}
case OP_CLOSE: {
CASE(OP_CLOSE) :
{
closeUpvalues(state, state->top - 1);
cosmoV_pop(state);
continue;
}
case OP_NEWTABLE: {
uint16_t pairs = READUINT();
CASE(OP_NEWTABLE) :
{
uint16_t pairs = READUINT(frame);
cosmoV_makeTable(state, pairs);
continue;
}
case OP_NEWARRAY: {
uint16_t pairs = READUINT();
CASE(OP_NEWARRAY) :
{
uint16_t pairs = READUINT(frame);
StkPtr val;
CObjTable *newObj = cosmoO_newTable(state);
cosmoV_pushRef(state, (CObj *)newObj); // so our GC doesn't free our new table
@ -816,9 +865,9 @@ int cosmoV_execute(CState *state)
// once done, pop everything off the stack + push new table
cosmoV_setTop(state, pairs + 1); // + 1 for our table
cosmoV_pushRef(state, (CObj *)newObj);
continue;
}
case OP_INDEX: {
CASE(OP_INDEX) :
{
StkPtr key = cosmoV_getTop(state, 0); // key should be the top of the stack
StkPtr temp = cosmoV_getTop(state, 1); // after that should be the table
@ -849,9 +898,9 @@ int cosmoV_execute(CState *state)
cosmoV_setTop(state, 2); // pops the table & the key
cosmoV_pushValue(state, val); // pushes the field result
continue;
}
case OP_NEWINDEX: {
CASE(OP_NEWINDEX) :
{
StkPtr value = cosmoV_getTop(state, 0); // value is at the top of the stack
StkPtr key = cosmoV_getTop(state, 1);
StkPtr temp = cosmoV_getTop(state, 2); // table is after the key
@ -866,7 +915,8 @@ int cosmoV_execute(CState *state)
CObjObject *proto = cosmoO_grabProto(obj);
if (proto != NULL) {
if (!cosmoO_newIndexObject(state, proto, *key,
if (!cosmoO_newIndexObject(
state, proto, *key,
*value)) // if it returns false, cosmoV_error was called
return -1;
} else if (obj->type == COBJ_TABLE) {
@ -882,17 +932,17 @@ int cosmoV_execute(CState *state)
// pop everything off the stack
cosmoV_setTop(state, 3);
continue;
}
case OP_NEWOBJECT: {
uint16_t pairs = READUINT();
CASE(OP_NEWOBJECT) :
{
uint16_t pairs = READUINT(frame);
cosmoV_makeObject(state, pairs);
continue;
}
case OP_SETOBJECT: {
CASE(OP_SETOBJECT) :
{
StkPtr value = cosmoV_getTop(state, 0); // value is at the top of the stack
StkPtr temp = cosmoV_getTop(state, 1); // object is after the value
uint16_t ident = READUINT(); // use for the key
uint16_t ident = READUINT(frame); // use for the key
// sanity check
if (IS_REF(*temp)) {
@ -907,12 +957,12 @@ int cosmoV_execute(CState *state)
// pop everything off the stack
cosmoV_setTop(state, 2);
continue;
}
case OP_GETOBJECT: {
CASE(OP_GETOBJECT) :
{
CValue val; // to hold our value
StkPtr temp = cosmoV_getTop(state, 0); // that should be the object
uint16_t ident = READUINT(); // use for the key
uint16_t ident = READUINT(frame); // use for the key
// sanity check
if (IS_REF(*temp)) {
@ -927,15 +977,15 @@ int cosmoV_execute(CState *state)
cosmoV_setTop(state, 1); // pops the object
cosmoV_pushValue(state, val); // pushes the field result
continue;
}
case OP_GETMETHOD: {
CASE(OP_GETMETHOD) :
{
CValue val; // to hold our value
StkPtr temp = cosmoV_getTop(state, 0); // that should be the object
uint16_t ident = READUINT(); // use for the key
uint16_t ident = READUINT(frame); // use for the key
// this is almost identical to GETOBJECT, however cosmoV_getMethod is used instead of
// just cosmoV_get
// this is almost identical to GETOBJECT, however cosmoV_getMethod is used instead
// of just cosmoV_get
if (IS_REF(*temp)) {
if (!cosmoV_getMethod(state, cosmoV_readRef(*temp), constants[ident], &val))
return -1;
@ -948,12 +998,12 @@ int cosmoV_execute(CState *state)
cosmoV_setTop(state, 1); // pops the object
cosmoV_pushValue(state, val); // pushes the field result
continue;
}
case OP_INVOKE: {
uint8_t args = READBYTE();
uint8_t nres = READBYTE();
uint16_t ident = READUINT();
CASE(OP_INVOKE) :
{
uint8_t args = READBYTE(frame);
uint8_t nres = READBYTE(frame);
uint16_t ident = READUINT(frame);
StkPtr temp = cosmoV_getTop(state, args); // grabs object from stack
CValue val; // to hold our value
@ -969,10 +1019,9 @@ int cosmoV_execute(CState *state)
cosmoV_error(state, "Couldn't get from type %s!", cosmoV_typeStr(*temp));
return -1;
}
continue;
}
case OP_ITER: {
CASE(OP_ITER) :
{
StkPtr temp = cosmoV_getTop(state, 0); // should be the object/table
if (!IS_REF(*temp)) {
@ -992,15 +1041,16 @@ int cosmoV_execute(CState *state)
cosmoV_pushValue(state, val);
cosmoV_pushRef(state, (CObj *)obj);
if (cosmoV_call(state, 1, 1) !=
COSMOVM_OK) // we expect 1 return value on the stack, the iterable object
COSMOVM_OK) // we expect 1 return value on the stack, the iterable
// object
return -1;
StkPtr iObj = cosmoV_getTop(state, 0);
if (!IS_OBJECT(*iObj)) {
cosmoV_error(
state,
"Expected iterable object! '__iter' returned %s, expected <object>!",
cosmoV_error(state,
"Expected iterable object! '__iter' returned %s, expected "
"<object>!",
cosmoV_typeStr(*iObj));
return -1;
}
@ -1022,11 +1072,13 @@ int cosmoV_execute(CState *state)
CObjCFunction *tbl_next = cosmoO_newCFunction(state, _tbl__next);
cosmoV_pushRef(state, (CObj *)tbl_next); // value
CObjObject *obj = cosmoV_makeObject(state, 2); // pushes the new object to the stack
CObjObject *obj =
cosmoV_makeObject(state, 2); // pushes the new object to the stack
cosmoO_setUserI(obj, 0); // increment for iterator
// make our CObjMethod for OP_NEXT to call
CObjMethod *method = cosmoO_newMethod(state, cosmoV_newRef(tbl_next), (CObj *)obj);
CObjMethod *method =
cosmoO_newMethod(state, cosmoV_newRef(tbl_next), (CObj *)obj);
cosmoV_setTop(state, 2); // pops the object & the tbl
cosmoV_pushRef(state, (CObj *)method); // pushes the method for OP_NEXT
@ -1035,12 +1087,11 @@ int cosmoV_execute(CState *state)
cosmoO_typeStr(obj));
return -1;
}
continue;
}
case OP_NEXT: {
uint8_t nresults = READBYTE();
uint16_t jump = READUINT();
CASE(OP_NEXT) :
{
uint8_t nresults = READBYTE(frame);
uint16_t jump = READUINT(frame);
StkPtr temp = cosmoV_getTop(state, 0); // we don't actually pop this off the stack
if (!IS_METHOD(*temp)) {
@ -1058,25 +1109,29 @@ int cosmoV_execute(CState *state)
cosmoV_setTop(state, nresults); // pop the return values
frame->pc += jump;
}
continue;
}
case OP_ADD: { // pop 2 values off the stack & try to add them together
CASE(OP_ADD) :
{
// pop 2 values off the stack & try to add them together
NUMBEROP(cosmoV_newNumber, +);
continue;
}
case OP_SUB: { // pop 2 values off the stack & try to subtracts them
NUMBEROP(cosmoV_newNumber, -)
continue;
CASE(OP_SUB) :
{
// pop 2 values off the stack & try to subtracts them
NUMBEROP(cosmoV_newNumber, -);
}
case OP_MULT: { // pop 2 values off the stack & try to multiplies them together
NUMBEROP(cosmoV_newNumber, *)
continue;
CASE(OP_MULT) :
{
// pop 2 values off the stack & try to multiplies them together
NUMBEROP(cosmoV_newNumber, *);
}
case OP_DIV: { // pop 2 values off the stack & try to divides them
NUMBEROP(cosmoV_newNumber, /)
continue;
CASE(OP_DIV) :
{
// pop 2 values off the stack & try to divides them
NUMBEROP(cosmoV_newNumber, /);
}
case OP_MOD: {
CASE(OP_MOD) :
{
StkPtr valA = cosmoV_getTop(state, 1);
StkPtr valB = cosmoV_getTop(state, 0);
if (IS_NUMBER(*valA) && IS_NUMBER(*valB)) {
@ -1088,9 +1143,9 @@ int cosmoV_execute(CState *state)
cosmoV_typeStr(*valB));
return -1;
}
continue;
}
case OP_POW: {
CASE(OP_POW) :
{
StkPtr valA = cosmoV_getTop(state, 1);
StkPtr valB = cosmoV_getTop(state, 0);
if (IS_NUMBER(*valA) && IS_NUMBER(*valB)) {
@ -1102,13 +1157,13 @@ int cosmoV_execute(CState *state)
cosmoV_typeStr(*valB));
return -1;
}
continue;
}
case OP_NOT: {
CASE(OP_NOT) :
{
cosmoV_pushBoolean(state, isFalsey(cosmoV_pop(state)));
continue;
}
case OP_NEGATE: { // pop 1 value off the stack & try to negate
CASE(OP_NEGATE) :
{ // pop 1 value off the stack & try to negate
StkPtr val = cosmoV_getTop(state, 0);
if (IS_NUMBER(*val)) {
@ -1118,9 +1173,9 @@ int cosmoV_execute(CState *state)
cosmoV_error(state, "Expected number, got %s!", cosmoV_typeStr(*val));
return -1;
}
continue;
}
case OP_COUNT: {
CASE(OP_COUNT) :
{
StkPtr temp = cosmoV_getTop(state, 0);
if (!IS_REF(*temp)) {
@ -1132,16 +1187,16 @@ int cosmoV_execute(CState *state)
cosmoV_pop(state);
cosmoV_pushNumber(state, count); // pushes the count onto the stack
continue;
}
case OP_CONCAT: {
uint8_t vals = READBYTE();
CASE(OP_CONCAT) :
{
uint8_t vals = READBYTE(frame);
cosmoV_concat(state, vals);
continue;
}
case OP_INCLOCAL: { // this leaves the value on the stack
int8_t inc = READBYTE() - 128; // amount we're incrementing by
uint8_t indx = READBYTE();
CASE(OP_INCLOCAL) :
{ // this leaves the value on the stack
int8_t inc = READBYTE(frame) - 128; // amount we're incrementing by
uint8_t indx = READBYTE(frame);
StkPtr val = &frame->base[indx];
// check that it's a number value
@ -1152,12 +1207,11 @@ int cosmoV_execute(CState *state)
cosmoV_error(state, "Expected number, got %s!", cosmoV_typeStr(*val));
return -1;
}
continue;
}
case OP_INCGLOBAL: {
int8_t inc = READBYTE() - 128; // amount we're incrementing by
uint16_t indx = READUINT();
CASE(OP_INCGLOBAL) :
{
int8_t inc = READBYTE(frame) - 128; // amount we're incrementing by
uint16_t indx = READUINT(frame);
CValue ident = constants[indx]; // grabs identifier
CValue *val = cosmoT_insert(state, &state->globals->tbl, ident);
@ -1169,12 +1223,11 @@ int cosmoV_execute(CState *state)
cosmoV_error(state, "Expected number, got %s!", cosmoV_typeStr(*val));
return -1;
}
continue;
}
case OP_INCUPVAL: {
int8_t inc = READBYTE() - 128; // amount we're incrementing by
uint8_t indx = READBYTE();
CASE(OP_INCUPVAL) :
{
int8_t inc = READBYTE(frame) - 128; // amount we're incrementing by
uint8_t indx = READBYTE(frame);
CValue *val = frame->closure->upvalues[indx]->val;
// check that it's a number value
@ -1185,16 +1238,16 @@ int cosmoV_execute(CState *state)
cosmoV_error(state, "Expected number, got %s!", cosmoV_typeStr(*val));
return -1;
}
continue;
}
case OP_INCINDEX: {
int8_t inc = READBYTE() - 128; // amount we're incrementing by
CASE(OP_INCINDEX) :
{
int8_t inc = READBYTE(frame) - 128; // amount we're incrementing by
StkPtr temp = cosmoV_getTop(state, 1); // object should be above the key
StkPtr key = cosmoV_getTop(state, 0); // grabs key
if (!IS_REF(*temp)) {
cosmoV_error(state, "Couldn't index non-indexable type %s!", cosmoV_typeStr(*temp));
cosmoV_error(state, "Couldn't index non-indexable type %s!",
cosmoV_typeStr(*temp));
return -1;
}
@ -1236,12 +1289,11 @@ int cosmoV_execute(CState *state)
cosmoV_typeStr(*temp));
return -1;
}
continue;
}
case OP_INCOBJECT: {
int8_t inc = READBYTE() - 128; // amount we're incrementing by
uint16_t indx = READUINT();
CASE(OP_INCOBJECT) :
{
int8_t inc = READBYTE(frame) - 128; // amount we're incrementing by
uint16_t indx = READUINT(frame);
StkPtr temp = cosmoV_getTop(state, 0); // object should be at the top of the stack
CValue ident = constants[indx]; // grabs identifier
@ -1270,57 +1322,42 @@ int cosmoV_execute(CState *state)
cosmoV_error(state, "Couldn't set a field on type %s!", cosmoV_typeStr(*temp));
return -1;
}
continue;
}
case OP_EQUAL: {
CASE(OP_EQUAL) :
{
// pop vals
StkPtr valB = cosmoV_pop(state);
StkPtr valA = cosmoV_pop(state);
// compare & push
cosmoV_pushBoolean(state, cosmoV_equal(state, *valA, *valB));
continue;
}
case OP_GREATER: {
NUMBEROP(cosmoV_newBoolean, >)
continue;
CASE(OP_GREATER) :
{
NUMBEROP(cosmoV_newBoolean, >);
}
case OP_LESS: {
NUMBEROP(cosmoV_newBoolean, <)
continue;
CASE(OP_LESS) :
{
NUMBEROP(cosmoV_newBoolean, <);
}
case OP_GREATER_EQUAL: {
NUMBEROP(cosmoV_newBoolean, >=)
continue;
CASE(OP_GREATER_EQUAL) :
{
NUMBEROP(cosmoV_newBoolean, >=);
}
case OP_LESS_EQUAL: {
NUMBEROP(cosmoV_newBoolean, <=)
continue;
}
case OP_TRUE:
cosmoV_pushBoolean(state, true);
continue;
case OP_FALSE:
cosmoV_pushBoolean(state, false);
continue;
case OP_NIL:
cosmoV_pushValue(state, cosmoV_newNil());
continue;
case OP_RETURN: {
uint8_t res = READBYTE();
CASE(OP_LESS_EQUAL)
: {NUMBEROP(cosmoV_newBoolean, <=)} CASE(OP_TRUE) : cosmoV_pushBoolean(state, true);
CASE(OP_FALSE) : cosmoV_pushBoolean(state, false);
CASE(OP_NIL) : cosmoV_pushValue(state, cosmoV_newNil());
CASE(OP_RETURN) :
{
uint8_t res = READBYTE(frame);
return res;
}
default:
CERROR("unknown opcode!");
exit(0);
DEFAULT;
}
}
#undef READBYTE
#undef READUINT
// we'll only reach this is state->panic is true
// we'll only reach this if state->panic is true
return -1;
}

13
src/cvm.h
View File

@ -8,6 +8,19 @@
// #define VM_DEBUG
/*
if we're using GNUC or clang, we can use computed gotos which speeds up
cosmoV_execute by about 20% from benchmarking. of course, if you know
your compiler supports computed gotos, you can define VM_JUMPTABLE
BTW: be weary of maliciously crafted cosmo dumps!! it's very easy to crash
cosmo with this enabled and reading invalid opcodes due to us just using the
opcode as an index into the jump table
*/
#if defined(__GNUC__) || defined(__clang__)
# define VM_JUMPTABLE
#endif
typedef enum
{
COSMOVM_OK,