Open-Argon/Chloride
1
1
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

change to dispatch table to hopefully improve speed

Browse Source
This commit is contained in:
William Bell
2025-08-29 12:22:35 +01:00
parent f598c215e7
commit 0f0a3f5d31
2 changed files with 188 additions and 171 deletions
Download Patch File Download Diff File Expand all files Collapse all files

168
src/runtime/runtime.c
View File

@@ -10,9 +10,9 @@
#include "../parser/number/number.h" #include "../parser/number/number.h"
#include "../translator/translator.h" #include "../translator/translator.h"
#include "access/access.h" #include "access/access.h"
#include "assignment/assignment.h"
#include "call/call.h" #include "call/call.h"
#include "declaration/declaration.h" #include "declaration/declaration.h"
#include "assignment/assignment.h"
#include "internals/hashmap/hashmap.h" #include "internals/hashmap/hashmap.h"
#include "objects/functions/functions.h" #include "objects/functions/functions.h"
#include "objects/literals/literals.h" #include "objects/literals/literals.h"
@@ -70,7 +70,8 @@ ArgonObject *ARGON_ADDITION_FUNCTION(size_t argc, ArgonObject **argv,
ArgonObject *ARGON_SUBTRACTION_FUNCTION(size_t argc, ArgonObject **argv, ArgonObject *ARGON_SUBTRACTION_FUNCTION(size_t argc, ArgonObject **argv,
ArErr *err, RuntimeState *state) { ArErr *err, RuntimeState *state) {
if (argc < 1) { if (argc < 1) {
*err = create_err(0, 0, 0, "", "Runtime Error", *err =
create_err(0, 0, 0, "", "Runtime Error",
"subtract expects at least 1 argument, got %" PRIu64, argc); "subtract expects at least 1 argument, got %" PRIu64, argc);
return ARGON_NULL; return ARGON_NULL;
} }
@@ -95,7 +96,8 @@ ArgonObject *ARGON_SUBTRACTION_FUNCTION(size_t argc, ArgonObject **argv,
ArgonObject *ARGON_MULTIPLY_FUNCTION(size_t argc, ArgonObject **argv, ArgonObject *ARGON_MULTIPLY_FUNCTION(size_t argc, ArgonObject **argv,
ArErr *err, RuntimeState *state) { ArErr *err, RuntimeState *state) {
if (argc < 1) { if (argc < 1) {
*err = create_err(0, 0, 0, "", "Runtime Error", *err =
create_err(0, 0, 0, "", "Runtime Error",
"multiply expects at least 1 argument, got %" PRIu64, argc); "multiply expects at least 1 argument, got %" PRIu64, argc);
return ARGON_NULL; return ARGON_NULL;
} }
@@ -120,7 +122,8 @@ ArgonObject *ARGON_MULTIPLY_FUNCTION(size_t argc, ArgonObject **argv,
ArgonObject *ARGON_DIVISION_FUNCTION(size_t argc, ArgonObject **argv, ArgonObject *ARGON_DIVISION_FUNCTION(size_t argc, ArgonObject **argv,
ArErr *err, RuntimeState *state) { ArErr *err, RuntimeState *state) {
if (argc < 1) { if (argc < 1) {
*err = create_err(0, 0, 0, "", "Runtime Error", *err =
create_err(0, 0, 0, "", "Runtime Error",
"division expects at least 1 argument, got %" PRIu64, argc); "division expects at least 1 argument, got %" PRIu64, argc);
return ARGON_NULL; return ARGON_NULL;
} }
@@ -337,17 +340,18 @@ ArgonObject *ARGON_STRING_TYPE___add__(size_t argc, ArgonObject **argv,
if (argv[1]->type != TYPE_STRING) { if (argv[1]->type != TYPE_STRING) {
ArgonObject *type_name = get_field_for_class( ArgonObject *type_name = get_field_for_class(
get_field(argv[1], "__class__", false, false), "__name__", argv[1]); get_field(argv[1], "__class__", false, false), "__name__", argv[1]);
*err = create_err(0, 0, 0, "", "Runtime Error", *err = create_err(
0, 0, 0, "", "Runtime Error",
"__add__ cannot perform concatenation between a string and %.*s", "__add__ cannot perform concatenation between a string and %.*s",
type_name->value.as_str.length, type_name->value.as_str.length, type_name->value.as_str.data);
type_name->value.as_str.data);
return ARGON_NULL; return ARGON_NULL;
} }
size_t length = argv[0]->value.as_str.length+argv[1]->value.as_str.length; size_t length = argv[0]->value.as_str.length + argv[1]->value.as_str.length;
char*concat = malloc(length); char *concat = malloc(length);
memcpy(concat,argv[0]->value.as_str.data, argv[0]->value.as_str.length); memcpy(concat, argv[0]->value.as_str.data, argv[0]->value.as_str.length);
memcpy(concat+argv[0]->value.as_str.length,argv[1]->value.as_str.data, argv[1]->value.as_str.length); memcpy(concat + argv[0]->value.as_str.length, argv[1]->value.as_str.data,
ArgonObject* object = new_string_object(concat, length); argv[1]->value.as_str.length);
ArgonObject *object = new_string_object(concat, length);
free(concat); free(concat);
return object; return object;
} }
@@ -519,8 +523,7 @@ void bootstrap_types() {
add_field( add_field(
ARGON_STRING_TYPE, "__init__", ARGON_STRING_TYPE, "__init__",
create_argon_native_function("__init__", ARGON_STRING_TYPE___init__)); create_argon_native_function("__init__", ARGON_STRING_TYPE___init__));
add_field( add_field(ARGON_STRING_TYPE, "__add__",
ARGON_STRING_TYPE, "__add__",
create_argon_native_function("__add__", ARGON_STRING_TYPE___add__)); create_argon_native_function("__add__", ARGON_STRING_TYPE___add__));
add_field( add_field(
ARGON_STRING_TYPE, "__number__", ARGON_STRING_TYPE, "__number__",
@@ -597,19 +600,7 @@ int compare_by_order(const void *a, const void *b) {
return itemA->order - itemB->order; return itemA->order - itemB->order;
} }
uint8_t pop_byte(Translated *translated, RuntimeState *state) { static inline void load_const(Translated *translated, RuntimeState *state) {
return *((uint8_t *)darray_get(&translated->bytecode, state->head++));
}
uint64_t pop_bytecode(Translated *translated, RuntimeState *state) {
uint64_t value = 0;
for (int i = 0; i < 8; i++) {
value |= ((uint64_t)pop_byte(translated, state)) << (i * 8);
}
return value;
}
void load_const(Translated *translated, RuntimeState *state) {
uint64_t to_register = pop_byte(translated, state); uint64_t to_register = pop_byte(translated, state);
size_t length = pop_bytecode(translated, state); size_t length = pop_bytecode(translated, state);
uint64_t offset = pop_bytecode(translated, state); uint64_t offset = pop_bytecode(translated, state);
@@ -636,7 +627,7 @@ uint64_t runtime_hash(const void *data, size_t len, uint64_t prehash) {
return hash; return hash;
} }
ArErr load_variable(Translated *translated, RuntimeState *state, static inline ArErr load_variable(Translated *translated, RuntimeState *state,
struct Stack *stack) { struct Stack *stack) {
int64_t length = pop_bytecode(translated, state); int64_t length = pop_bytecode(translated, state);
int64_t offset = pop_bytecode(translated, state); int64_t offset = pop_bytecode(translated, state);
@@ -660,49 +651,70 @@ ArErr load_variable(Translated *translated, RuntimeState *state,
return err; return err;
} }
ArErr run_instruction(Translated *translated, RuntimeState *state, static inline ArErr run_instruction(Translated *translated, RuntimeState *state,
struct Stack **stack) { struct Stack **stack) {
OperationType opcode = pop_byte(translated, state); static void *dispatch_table[] = {
switch (opcode) { [OP_LOAD_STRING] = &&DO_LOAD_STRING,
case OP_LOAD_NULL: [OP_DECLARE] = &&DO_DECLARE,
[OP_LOAD_NULL] = &&DO_LOAD_NULL,
[OP_LOAD_FUNCTION] = &&DO_LOAD_FUNCTION,
[OP_IDENTIFIER] = &&DO_IDENTIFIER,
[OP_BOOL] = &&DO_BOOL,
[OP_JUMP_IF_FALSE] = &&DO_JUMP_IF_FALSE,
[OP_JUMP] = &&DO_JUMP,
[OP_NEW_SCOPE] = &&DO_NEW_SCOPE,
[OP_POP_SCOPE] = &&DO_POP_SCOPE,
[OP_INIT_CALL] = &&DO_INIT_CALL,
[OP_INSERT_ARG] = &&DO_INSERT_ARG,
[OP_CALL] = &&DO_CALL,
[OP_SOURCE_LOCATION] = &&DO_SOURCE_LOCATION,
[OP_LOAD_ACCESS_FUNCTION] = &&DO_LOAD_ACCESS_FUNCTION,
[OP_LOAD_BOOL] = &&DO_LOAD_BOOL,
[OP_LOAD_NUMBER] = &&DO_LOAD_NUMBER,
[OP_LOAD_ADDITION_FUNCTION] = &&DO_LOAD_ADDITION_FUNCTION,
[OP_LOAD_SUBTRACTION_FUNCTION] = &&DO_LOAD_SUBTRACTION_FUNCTION,
[OP_LOAD_MULTIPLY_FUNCTION] = &&DO_LOAD_MULTIPLY_FUNCTION,
[OP_LOAD_DIVISION_FUNCTION] = &&DO_LOAD_DIVISION_FUNCTION,
[OP_ASSIGN] = &&DO_ASSIGN};
goto *dispatch_table[pop_byte(translated, state)];
DO_LOAD_NULL:
state->registers[pop_byte(translated, state)] = ARGON_NULL; state->registers[pop_byte(translated, state)] = ARGON_NULL;
break; goto BREAK;
case OP_LOAD_STRING: DO_LOAD_STRING:
load_const(translated, state); load_const(translated, state);
break; goto BREAK;
case OP_LOAD_NUMBER: DO_LOAD_NUMBER:
load_number(translated, state); load_number(translated, state);
break; goto BREAK;
case OP_LOAD_FUNCTION: DO_LOAD_FUNCTION:
load_argon_function(translated, state, *stack); load_argon_function(translated, state, *stack);
break; goto BREAK;
case OP_IDENTIFIER: DO_IDENTIFIER:
return load_variable(translated, state, *stack); return load_variable(translated, state, *stack);
case OP_DECLARE: DO_DECLARE:
return runtime_declaration(translated, state, *stack); return runtime_declaration(translated, state, *stack);
case OP_ASSIGN: DO_ASSIGN:
return runtime_assignment(translated, state, *stack); return runtime_assignment(translated, state, *stack);
case OP_BOOL:; DO_BOOL:;
ArErr err = no_err; ArErr err = no_err;
uint8_t to_register = pop_byte(translated, state); uint8_t to_register = pop_byte(translated, state);
ArgonObject *args[] = {ARGON_BOOL_TYPE, state->registers[0]}; ArgonObject *args[] = {ARGON_BOOL_TYPE, state->registers[0]};
state->registers[to_register] = state->registers[to_register] = ARGON_BOOL_TYPE___new__(2, args, &err, state);
ARGON_BOOL_TYPE___new__(2, args, &err, state);
return err; return err;
case OP_JUMP_IF_FALSE:; DO_JUMP_IF_FALSE:;
uint8_t from_register = pop_byte(translated, state); uint8_t from_register = pop_byte(translated, state);
uint64_t to = pop_bytecode(translated, state); uint64_t to = pop_bytecode(translated, state);
if (state->registers[from_register] == ARGON_FALSE) { if (state->registers[from_register] == ARGON_FALSE) {
state->head = to; state->head = to;
} }
break; goto BREAK;
case OP_JUMP: DO_JUMP:
state->head = pop_bytecode(translated, state); state->head = pop_bytecode(translated, state);
break; goto BREAK;
case OP_NEW_SCOPE: DO_NEW_SCOPE:
*stack = create_scope(*stack); *stack = create_scope(*stack);
break; goto BREAK;
case OP_POP_SCOPE:; DO_POP_SCOPE:;
// struct node_GC *array = // struct node_GC *array =
// checked_malloc(sizeof(struct node_GC) * (*stack)->scope->count); // checked_malloc(sizeof(struct node_GC) * (*stack)->scope->count);
// size_t j = 0; // size_t j = 0;
@@ -725,22 +737,22 @@ ArErr run_instruction(Translated *translated, RuntimeState *state,
// } // }
// free(array); // free(array);
*stack = (*stack)->prev; *stack = (*stack)->prev;
break; goto BREAK;
case OP_INIT_CALL:; DO_INIT_CALL:;
size_t length = pop_bytecode(translated, state); size_t length = pop_bytecode(translated, state);
call_instance call_instance = {state->call_instance, state->registers[0], call_instance call_instance = {state->call_instance, state->registers[0],
ar_alloc(length * sizeof(ArgonObject *)), ar_alloc(length * sizeof(ArgonObject *)),
length}; length};
state->call_instance = ar_alloc(sizeof(call_instance)); state->call_instance = ar_alloc(sizeof(call_instance));
*state->call_instance = call_instance; *state->call_instance = call_instance;
break; goto BREAK;
case OP_INSERT_ARG:; DO_INSERT_ARG:;
size_t index = pop_bytecode(translated, state); size_t index = pop_bytecode(translated, state);
(state->call_instance->args)[index] = state->registers[0]; (state->call_instance->args)[index] = state->registers[0];
break; goto BREAK;
case OP_CALL:; DO_CALL:;
err = run_call(state->call_instance->to_call, err =
state->call_instance->args_length, run_call(state->call_instance->to_call, state->call_instance->args_length,
state->call_instance->args, state, false); state->call_instance->args, state, false);
state->call_instance = (*state->call_instance).previous; state->call_instance = (*state->call_instance).previous;
return err; return err;
@@ -763,34 +775,30 @@ ArErr run_instruction(Translated *translated, RuntimeState *state,
// (int)class_name->value.as_str.length, class_name->value.as_str.data, // (int)class_name->value.as_str.length, class_name->value.as_str.data,
// object); // object);
// } // }
case OP_SOURCE_LOCATION: DO_SOURCE_LOCATION:
state->source_location = (SourceLocation){pop_bytecode(translated, state), state->source_location = (SourceLocation){pop_bytecode(translated, state),
pop_bytecode(translated, state), pop_bytecode(translated, state),
pop_bytecode(translated, state)}; pop_bytecode(translated, state)};
break; goto BREAK;
case OP_LOAD_BOOL: DO_LOAD_BOOL:
state->registers[0] = state->registers[0] = pop_byte(translated, state) ? ARGON_TRUE : ARGON_FALSE;
pop_byte(translated, state) ? ARGON_TRUE : ARGON_FALSE; goto BREAK;
break; DO_LOAD_ACCESS_FUNCTION:
case OP_LOAD_ACCESS_FUNCTION:
state->registers[0] = ACCESS_FUNCTION; state->registers[0] = ACCESS_FUNCTION;
break; goto BREAK;
case OP_LOAD_ADDITION_FUNCTION: DO_LOAD_ADDITION_FUNCTION:
state->registers[0] = ADDITION_FUNCTION; state->registers[0] = ADDITION_FUNCTION;
break; goto BREAK;
case OP_LOAD_SUBTRACTION_FUNCTION: DO_LOAD_SUBTRACTION_FUNCTION:
state->registers[0] = SUBTRACTION_FUNCTION; state->registers[0] = SUBTRACTION_FUNCTION;
break; goto BREAK;
case OP_LOAD_MULTIPLY_FUNCTION: DO_LOAD_MULTIPLY_FUNCTION:
state->registers[0] = MULTIPLY_FUNCTION; state->registers[0] = MULTIPLY_FUNCTION;
break; goto BREAK;
case OP_LOAD_DIVISION_FUNCTION: DO_LOAD_DIVISION_FUNCTION:
state->registers[0] = DIVISION_FUNCTION; state->registers[0] = DIVISION_FUNCTION;
break; goto BREAK;
default: BREAK:
return create_err(0, 0, 0, NULL, "Runtime Error", "Invalid Opcode %#x",
opcode);
}
return no_err; return no_err;
} }

15
src/runtime/runtime.h
View File

@@ -64,11 +64,20 @@ uint64_t runtime_hash(const void *data, size_t len, uint64_t prehash);
void bootstrap_globals(); void bootstrap_globals();
uint8_t pop_byte(Translated *translated, RuntimeState *state); static inline uint8_t pop_byte(Translated *translated, RuntimeState *state) {
return *((uint8_t *)darray_get(&translated->bytecode, state->head++));
}
uint64_t pop_bytecode(Translated *translated, RuntimeState *state); static inline uint64_t pop_bytecode(Translated *translated,
RuntimeState *state) {
uint64_t value = 0;
for (int i = 0; i < 8; i++) {
value |= ((uint64_t)pop_byte(translated, state)) << (i * 8);
}
return value;
}
ArErr run_instruction(Translated *translated, RuntimeState *state, static inline ArErr run_instruction(Translated *translated, RuntimeState *state,
struct Stack **stack); struct Stack **stack);
RuntimeState init_runtime_state(Translated translated, char *path); RuntimeState init_runtime_state(Translated translated, char *path);