void r_astnode_cleanup(robject_t *obj)
{
- rastnode_t *node = (rastnode_t*)obj;
-
-// if (node->props)
-// r_object_destroy((robject_t*)node->props);
r_object_cleanup(obj);
}
start = rvm_codegen_addins(cg, rvm_asm(RVM_PUSHM, DA, XX, XX, BIT(FP)|BIT(SP)|BIT(LR)));
rvm_codegen_addins(cg, rvm_asm(RVM_MOV, FP, SP, XX, 0));
rvm_codegen_addins(cg, rvm_asm(RVM_ADD, SP, SP, DA, args));
- rvm_codemap_add(cg->codemap, name, namesize, start);
+ rvm_codemap_addindex(cg->codemap, name, namesize, start);
return start;
}
start = rvm_codegen_addins(cg, rvm_asm(RVM_PUSHM, DA, XX, XX, BIT(FP)|BIT(SP)|BIT(LR)));
rvm_codegen_addins(cg, rvm_asm(RVM_MOV, FP, SP, XX, 0));
rvm_codegen_addins(cg, rvm_asm(RVM_ADD, SP, SP, R0, 0));
- rvm_codemap_add(cg->codemap, name, namesize, start);
+ rvm_codemap_addindex(cg->codemap, name, namesize, start);
return start;
}
}
-
-rvm_codelabel_t *rvm_codemap_add(rvm_codemap_t *codemap, const rchar *name, ruint namesize, rulong index)
+static rvm_codelabel_t *rvm_codemap_add(rvm_codemap_t *codemap, const rchar *name, ruint namesize)
{
rvm_codelabel_t *label;
label = rvm_codemap_dolookup(codemap, name, namesize);
if (!label) {
- label = r_malloc(sizeof(*label));
+ label = r_zmalloc(sizeof(*label));
label->name = r_rstrdup(name, namesize);
r_hash_insert(codemap->hash, label->name, label);
r_array_add(codemap->labels, &label);
}
- label->index = index;
return label;
}
-rvm_codelabel_t *rvm_codemap_add_s(rvm_codemap_t *codemap, const rchar *name, rulong index)
+
+rvm_codelabel_t *rvm_codemap_addindex(rvm_codemap_t *codemap, const rchar *name, ruint namesize, rulong index)
+{
+ rvm_codelabel_t *label = rvm_codemap_add(codemap, name, namesize);
+
+ if (label) {
+ label->loc.index = index;
+ label->type = RVM_CODELABEL_INDEX;
+ }
+ return label;
+}
+
+
+rvm_codelabel_t *rvm_codemap_addindex_s(rvm_codemap_t *codemap, const rchar *name, rulong index)
{
- return rvm_codemap_add(codemap, name, r_strlen(name), index);
+ return rvm_codemap_addindex(codemap, name, r_strlen(name), index);
+}
+
+
+rvm_codelabel_t *rvm_codemap_addpointer(rvm_codemap_t *codemap, const rchar *name, ruint namesize, rvm_asmins_t *ptr)
+{
+ rvm_codelabel_t *label = rvm_codemap_add(codemap, name, namesize);
+
+ if (label) {
+ label->loc.ptr = ptr;
+ label->type = RVM_CODELABEL_POINTER;
+ }
+ return label;
+}
+
+
+rvm_codelabel_t *rvm_codemap_addpointer_s(rvm_codemap_t *codemap, const rchar *name, rvm_asmins_t *ptr)
+{
+ return rvm_codemap_addpointer(codemap, name, r_strlen(name), ptr);
}
rvm_codelabel_t *rvm_codemap_invalid_add(rvm_codemap_t *codemap, const rchar *name, ruint namesize)
{
- return rvm_codemap_add(codemap, name, namesize, RVM_CODELABEL_INVALID);
+ rvm_codelabel_t *label = rvm_codemap_add(codemap, name, namesize);
+
+ if (label) {
+ label->type = RVM_CODELABEL_INVALID;
+ }
+ return label;
}
extern "C" {
#endif
-#define RVM_CODELABEL_INVALID ((rulong)-1)
-
-typedef struct rvm_codelabel_s {
- rstr_t *name;
- rulong index;
- rulong size; // Optional, used for function declarations
-} rvm_codelabel_t;
-
-
typedef struct rvm_loopblock_s {
rulong begin;
rulong size;
void rvm_codemap_clear(rvm_codemap_t *codemap);
rvm_codelabel_t *rvm_codemap_invalid_add(rvm_codemap_t *codemap, const rchar *name, ruint namesize);
rvm_codelabel_t *rvm_codemap_invalid_add_s(rvm_codemap_t *codemap, const rchar *name);
-rvm_codelabel_t *rvm_codemap_add(rvm_codemap_t *codemap, const rchar *name, ruint namesize, rulong index);
-rvm_codelabel_t *rvm_codemap_add_s(rvm_codemap_t *codemap, const rchar *name, rulong index);
+rvm_codelabel_t *rvm_codemap_addindex(rvm_codemap_t *codemap, const rchar *name, ruint namesize, rulong index);
+rvm_codelabel_t *rvm_codemap_addindex_s(rvm_codemap_t *codemap, const rchar *name, rulong index);
+rvm_codelabel_t *rvm_codemap_addpointer(rvm_codemap_t *codemap, const rchar *name, ruint namesize, rvm_asmins_t *ptr);
+rvm_codelabel_t *rvm_codemap_addpointer_s(rvm_codemap_t *codemap, const rchar *name, rvm_asmins_t *ptr);
rvm_codelabel_t *rvm_codemap_lookup(rvm_codemap_t *codemap, const rchar *name, ruint namesize);
rvm_codelabel_t *rvm_codemap_lookup_s(rvm_codemap_t *codemap, const rchar *name);
rvm_codelabel_t *rvm_codemap_lastlabel(rvm_codemap_t *codemap);
#include "rvmoperatorcast.h"
#include "rvmoperatornot.h"
#include "rvmoperatorlogicnot.h"
+#include "rvmcodemap.h"
#include "rmem.h"
#include "rstring.h"
#include "rvmreg.h"
}
-
-rvm_asmins_t rvm_asmr(rword opcode, rword op1, rword op2, rword op3, rpointer pReloc)
-{
- rvm_asmins_t a;
-
- r_memset(&a, 0, sizeof(a));
- a.opcode = (ruint32) RVM_ASMINS_OPCODE(opcode);
- a.swi = (ruint32) RVM_ASMINS_SWI(opcode);
- a.op1 = (ruint8)op1;
- a.op2 = (ruint8)op2;
- a.op3 = (ruint8)op3;
- a.data.u = (rword)pReloc;
- a.flags = RVM_ASMINS_RELOC | RVM_ASMINS_RELOCPTR;
- a.da = 1;
-
- return a;
-}
-
-
rvm_asmins_t rvm_asmx(rword opcode, rword op1, rword op2, rword op3, rpointer pReloc)
{
rvm_asmins_t a;
return a;
}
+/*
+ * On success return NULL, otherwise
+ * return a pointer to undefined label
+ */
-void rvm_relocate(rvm_asmins_t *code, rsize_t size)
+rvm_codelabel_t *rvm_relocate(rvm_asmins_t *code, rsize_t size)
{
+ rvm_codelabel_t *label;
rvm_asmins_t *reloc;
rulong relocindex;
rulong off;
+// code->data.u = reloc - code;
+
for (off = 0; off < size; off++, code++) {
if (code->flags & RVM_ASMINS_RELOC) {
- if (code->flags & RVM_ASMINS_RELOCPTR) {
- reloc = *((rvm_asmins_t **)code->data.u);
+ label = (rvm_codelabel_t *)code->data.u;
+ if (label->type == RVM_CODELABEL_INDEX) {
+ relocindex = label->loc.index;
+ code->data.u = relocindex - off;
+ code->flags &= ~RVM_ASMINS_RELOC;
+ } else if (label->type == RVM_CODELABEL_POINTER) {
+ reloc = label->loc.ptr;
code->data.u = reloc - code;
+ code->flags &= ~RVM_ASMINS_RELOC;
} else {
- relocindex = *((rulong *)code->data.u);
- code->data.u = relocindex - off;
+ return label;
}
- code->flags &= ~(RVM_ASMINS_RELOCPTR | RVM_ASMINS_RELOC);
}
}
+ return NULL;
}
#define RVM_ASMINS_RELOC (1 << 0)
-#define RVM_ASMINS_RELOCPTR (1 << 1)
struct rvm_asmins_s {
union {
ruint32 flags:3;
};
+
+typedef struct rvm_codelabel_s {
+ enum {
+ RVM_CODELABEL_INDEX = 0,
+ RVM_CODELABEL_POINTER,
+ RVM_CODELABEL_INVALID,
+ } type;
+ union {
+ rulong index;
+ rvm_asmins_t *ptr;
+ } loc;
+ rstr_t *name;
+ rulong size; // Optional, used for function declarations
+} rvm_codelabel_t;
+
+
struct rvm_opmap_s;
struct rvmcpu_s {
rint rvm_cpu_exec_debug(rvmcpu_t *cpu, rvm_asmins_t *prog, rword off);
rint rvm_cpu_getswi(rvmcpu_t *cpu, const rchar *swiname, rsize_t size);
rint rvm_cpu_getswi_s(rvmcpu_t *cpu, const rchar *swiname);
-void rvm_relocate(rvm_asmins_t *code, rsize_t size);
+rvm_codelabel_t *rvm_relocate(rvm_asmins_t *code, rsize_t size);
rvmreg_t *rvm_cpu_alloc_global(rvmcpu_t *cpu);
int rvm_cpu_setreg(rvmcpu_t *cpu, rword regnum, const rvmreg_t *src);
rvmreg_t * rvm_cpu_getreg(rvmcpu_t *cpu, rword regnum);
#include <stdio.h>
#include "common.h"
+#include "rvmcodemap.h"
{
ruint ret = 0;
ruint off = 0;
- rvm_asmins_t *l_add2 = NULL, *l_add3 = NULL, *l_main = NULL;
+ rvm_codelabel_t l_add2 = {RVM_CODELABEL_POINTER};
+ rvm_codelabel_t l_add3 = {RVM_CODELABEL_POINTER};
rvm_asmins_t vmcode[256];
rvmcpu_t *vm = rvm_cpu_create_default();
-
+ rvm_codemap_t *codemap = rvm_codemap_create();
+
rvm_cpu_addswitable(vm, common_calltable);
- vmcode[off++] = rvm_asmr(RVM_B, DA, XX, XX, &l_main);
+ vmcode[off++] = rvm_asmx(RVM_B, DA, XX, XX, rvm_codemap_lookup_s(codemap, "l_main"));
/*
* R0 = R0 + R1
*/
- l_add2 = &vmcode[off];
+ l_add2.loc.ptr = &vmcode[off];
vmcode[off++] = rvm_asm(RVM_ADD, R0, R0, R1, 0);
vmcode[off++] = rvm_asm(RVM_RET, XX, XX, XX, 0);
/*
* R0 = R0 + R1 + R2
*/
- l_add3 = &vmcode[off];
+ l_add3.loc.ptr = &vmcode[off];
vmcode[off++] = rvm_asm(RVM_PUSHM,DA, XX, XX, BIT(R7)|BIT(R8)|BIT(SP)|BIT(LR));
vmcode[off++] = rvm_asm(RVM_PUSH, R2, XX, XX, 0);
- vmcode[off++] = rvm_asmr(RVM_BL, DA, XX, XX, &l_add2);
+ vmcode[off++] = rvm_asmx(RVM_BL, DA, XX, XX, &l_add2);
vmcode[off++] = rvm_asm(RVM_POP, R1, XX, XX, 0);
- vmcode[off++] = rvm_asmr(RVM_BL, DA, XX, XX, &l_add2);
+ vmcode[off++] = rvm_asmx(RVM_BL, DA, XX, XX, &l_add2);
vmcode[off++] = rvm_asm(RVM_POPM, DA, XX, XX, BIT(R7)|BIT(R8)|BIT(SP)|BIT(LR));
vmcode[off++] = rvm_asm(RVM_RET, XX, XX, XX, 0);
/*
*
*/
-
- l_main = &vmcode[off];
+ rvm_codemap_addpointer_s(codemap, "l_main", &vmcode[off]);
vmcode[off++] = rvm_asm(RVM_MOV, R0, DA, XX, 1);
vmcode[off++] = rvm_asm(RVM_MOV, R1, DA, XX, 2);
- vmcode[off++] = rvm_asmr(RVM_BL, DA, XX, XX, &l_add2);
+ vmcode[off++] = rvm_asmx(RVM_BL, DA, XX, XX, &l_add2);
VMTEST_REG(vmcode, off, 0, 3, "BL/RET");
vmcode[off++] = rvm_asm(RVM_MOV, R0, DA, XX, 1);
vmcode[off++] = rvm_asm(RVM_MOV, R1, DA, XX, 2);
vmcode[off++] = rvm_asm(RVM_MOV, R2, DA, XX, 4);
- vmcode[off++] = rvm_asmr(RVM_BL, DA, XX, XX, &l_add3);
+ vmcode[off++] = rvm_asmx(RVM_BL, DA, XX, XX, &l_add3);
VMTEST_REG(vmcode, off, 0, 7, "BL/RET");
vmcode[off++] = rvm_asm(RVM_EXT, R0, XX, XX, 0);
-
rvm_relocate(vmcode, off);
#ifdef EXECDEBUG
ret = rvm_cpu_exec_debug(vm, vmcode, 0);
ret = rvm_cpu_exec(vm, vmcode, 0);
#endif
rvm_cpu_destroy(vm);
+ rvm_codemap_destroy(codemap);
return 0;
}
rvm_codegen_addins(cg, rvm_asm(RVM_MOV, R0, DA, XX, 9));
rvm_codegen_addins(cg, rvm_asm(RVM_STS, R0, SP, DA, 3 + RVM_CODEGEN_FUNCINITOFFSET));
rvm_codegen_addins(cg, rvm_asm(RVM_MOV, R0, DA, XX, 3));
- rvm_codegen_addins(cg, rvm_asmx(RVM_BL, DA, XX, XX, &rvm_codemap_lookup_s(cg->codemap, "add3")->index));
+ rvm_codegen_addins(cg, rvm_asmx(RVM_BL, DA, XX, XX, rvm_codemap_lookup_s(cg->codemap, "add3")));
rvm_codegen_addins(cg, rvm_asm(RVM_OPSWI(RVM_SWI_ID(ntable, 0)), R0, XX, XX, 0));
rvm_codegen_addins(cg, rvm_asm(RVM_MOV, R0, DA, XX, 4));
rvm_codegen_addins(cg, rvm_asm(RVM_STS, R0, SP, DA, 4 + RVM_CODEGEN_FUNCINITOFFSET));
rvm_codegen_addins(cg, rvm_asm(RVM_MOV, R0, DA, XX, 4));
- rvm_codegen_addins(cg, rvm_asmx(RVM_BL, DA, XX, XX, &rvm_codemap_lookup_s(cg->codemap, "varadd")->index));
+ rvm_codegen_addins(cg, rvm_asmx(RVM_BL, DA, XX, XX, rvm_codemap_lookup_s(cg->codemap, "varadd")));
rvm_codegen_addins(cg, rvm_asm(RVM_OPSWI(RVM_SWI_ID(ntable, 0)), R0, XX, XX, 0));
rvm_codegen_addins(cg, rvm_asm(RVM_STS, R0, SP, DA, 1 + RVM_CODEGEN_FUNCINITOFFSET));
rvm_codegen_addins(cg, rvm_asm(RVM_STS, R1, SP, DA, 2 + RVM_CODEGEN_FUNCINITOFFSET));
rvm_codegen_addins(cg, rvm_asm(RVM_MOV, R0, DA, XX, 2));
- rvm_codegen_addins(cg, rvm_asmx(RVM_BL, DA, XX, XX, &rvm_codemap_lookup_s(cg->codemap, "add2")->index));
+ rvm_codegen_addins(cg, rvm_asmx(RVM_BL, DA, XX, XX, rvm_codemap_lookup_s(cg->codemap, "add2")));
rvm_codegen_addins(cg, rvm_asm(RVM_LDS, R1, FP, DA, 3));
rvm_codegen_addins(cg, rvm_asm(RVM_STS, R0, SP, DA, 1 + RVM_CODEGEN_FUNCINITOFFSET));
rvm_codegen_addins(cg, rvm_asm(RVM_STS, R1, SP, DA, 2 + RVM_CODEGEN_FUNCINITOFFSET));
rvm_codegen_addins(cg, rvm_asm(RVM_MOV, R0, DA, XX, 2));
- rvm_codegen_addins(cg, rvm_asmx(RVM_BL, DA, XX, XX, &rvm_codemap_lookup_s(cg->codemap, "add2")->index));
+ rvm_codegen_addins(cg, rvm_asmx(RVM_BL, DA, XX, XX, rvm_codemap_lookup_s(cg->codemap, "add2")));
rvm_codegen_funcend(cg);
rvm_codegen_vargs_funcstart_s(cg, "varadd");
if (!label)
fprintf(stdout, "%s (not found)\n", name);
else
- fprintf(stdout, "%s, asmins: 0x%d\n", label->name->str, (ruint)label->index);
+ fprintf(stdout, "%s, asmins: 0x%d\n", label->name->str, (ruint)label->loc.index);
}
{
rvm_codemap_t *codemap = rvm_codemap_create();
- rvm_codemap_add_s(codemap, "add2", 0);
- rvm_codemap_add_s(codemap, "add3", 3);
- rvm_codemap_add_s(codemap, "sub2", 7);
+ rvm_codemap_addindex_s(codemap, "add2", 0);
+ rvm_codemap_addindex_s(codemap, "add3", 3);
+ rvm_codemap_addindex_s(codemap, "sub2", 7);
codelabel_print_info(codemap, "add2");
codelabel_print_info(codemap, "add7");
rvm_codegen_addins(cg, rvm_asm(RVM_STS, R0, SP, DA, 1 + RVM_CODEGEN_FUNCINITOFFSET));
rvm_codegen_addins(cg, rvm_asm(RVM_MOV, R0, DA, XX, 8));
rvm_codegen_addins(cg, rvm_asm(RVM_STS, R0, SP, DA, 2 + RVM_CODEGEN_FUNCINITOFFSET));
- rvm_codegen_addins(cg, rvm_asmx(RVM_BL, DA, XX, XX, &rvm_codemap_lookup_s(cg->codemap, "add2")->index));
+ rvm_codegen_addins(cg, rvm_asmx(RVM_BL, DA, XX, XX, rvm_codemap_lookup_s(cg->codemap, "add2")));
rvm_codegen_addins(cg, rvm_asm(RVM_OPSWI(rvm_cpu_getswi_s(cpu, "print")), R0, XX, XX, 0));
rvm_codegen_addins(cg, rvm_asm(RVM_EXT, XX, XX, XX, 0));
int r_astcompiler_dumpnotification(rpa_stat_handle stat, const char *name, void *userdata, const char *input, unsigned int size, unsigned int reason)
{
- rastcompiler_t *aco = (rastcompiler_t *)userdata;
-
if (reason & RPA_REASON_START)
fprintf(stdout, "START ");
if (reason & RPA_REASON_MATCHED)
int res, i;
rstr_t *script = NULL, *unmapscript = NULL;
rastcompiler_t *aco = r_astcompiler_create();
- rastnode_t *node;
-
aco->dbex = rpa_dbex_create();
rvm_codegen_addins(co->cg, rvm_asm(RVM_STRR, R0, R1, XX, 0));
l2 = rvm_codegen_getcodesize(co->cg);
rvm_codegen_addins(co->cg, rvm_asm(RVM_B, DA, XX, XX, 0)); /* Will be re-written later */
+ rvm_codemap_addindex_s(co->cg->codemap, "rpa_match", rvm_codegen_getcodesize(co->cg));
rvm_codegen_addins(co->cg, rvm_asm(RVM_PUSHM, DA, XX, XX, BIT(TP)|BIT(FP)|BIT(SP)|BIT(LR)));
rvm_codegen_addins(co->cg, rvm_asm(RVM_MOV, FP, SP, XX, 0));
rvm_codegen_addins(co->cg, rvm_asm(RVM_BXL, R0, XX, XX, 0));
int main(int argc, char *argv[])
{
rvmcpu_t *cpu;
+ rvm_codelabel_t *unresolved;
rpa_compiler_t *co;
rint i;
rvm_codegen_addins(co->cg, rvm_asm(RVM_LDS, R4, DA, XX, rvm_scope_lookup_s(co->scope, "rpa_match")->data.offset));
rvm_codegen_addins(co->cg, rvm_asm(RVM_LDS, R0, DA, XX, rvm_scope_lookup_s(co->scope, "rpa_match_abc")->data.offset));
- rvm_codegen_addins(co->cg, rvm_asm(RVM_BXL, R4, XX, XX, 0));
+// rvm_codegen_addins(co->cg, rvm_asm(RVM_BXL, R4, XX, XX, 0));
+ rvm_codegen_addins(co->cg, rvm_asmx(RVM_BL, DA, XX, XX, rvm_codemap_lookup_s(co->cg->codemap, "rpa_match")));
+
rvm_codegen_addins(co->cg, rvm_asm(RVM_NOP, XX, XX, XX, 0xabc));
rvm_codegen_addins(co->cg, rvm_asm(RVM_EXT, XX, XX, XX, 0));
+ unresolved = rvm_relocate(rvm_codegen_getcode(co->cg, 0), rvm_codegen_getcodesize(co->cg));
+ if (unresolved) {
+ fprintf(stderr, "ERROR: Undefined reference to: %s\n", unresolved->name->str);
+ goto end;
+ }
if (debuginfo) {
fprintf(stdout, "\nGenerated Code:\n");
rvm_cpu_exec(cpu, rvm_codegen_getcode(co->cg, 0), 0);
}
-
+end:
rpa_stat_destroy((rpastat_t *)cpu->userdata1);
rvm_cpu_destroy(cpu);
rvm_codegen_addins(cg, rvm_asm(RVM_STS, R0, SP, DA, 1 + RVM_CODEGEN_FUNCINITOFFSET));
rvm_codegen_addins(cg, rvm_asml(RVM_MOV, R0, DA, XX, r_strlen(hello)));
rvm_codegen_addins(cg, rvm_asm(RVM_STS, R0, SP, DA, 2 + RVM_CODEGEN_FUNCINITOFFSET));
- rvm_codegen_addins(cg, rvm_asmx(RVM_BL, DA, XX, XX, &rvm_codemap_lookup_s(cg->codemap, "str_init")->index));
+ rvm_codegen_addins(cg, rvm_asmx(RVM_BL, DA, XX, XX, rvm_codemap_lookup_s(cg->codemap, "str_init")));
rvm_codegen_addins(cg, rvm_asmp(RVM_MOV, R7, R0, XX, 0));
rvm_codegen_addins(cg, rvm_asmp(RVM_MOV, R0, DA, XX, there));
rvm_codegen_addins(cg, rvm_asm(RVM_STS, R0, SP, DA, 1 + RVM_CODEGEN_FUNCINITOFFSET));
rvm_codegen_addins(cg, rvm_asml(RVM_MOV, R0, DA, XX, r_strlen(there)));
rvm_codegen_addins(cg, rvm_asm(RVM_STS, R0, SP, DA, 2 + RVM_CODEGEN_FUNCINITOFFSET));
- rvm_codegen_addins(cg, rvm_asmx(RVM_BL, DA, XX, XX, &rvm_codemap_lookup_s(cg->codemap, "str_init")->index));
+ rvm_codegen_addins(cg, rvm_asmx(RVM_BL, DA, XX, XX, rvm_codemap_lookup_s(cg->codemap, "str_init")));
rvm_codegen_addins(cg, rvm_asmp(RVM_MOV, R8, R0, XX, 0));
rvm_codegen_addins(cg, rvm_asmp(RVM_MOV, R0, R7, XX, 0));