/* * Optimized `switch' instruction dispatcher. * Copyright (c) 1998 New Generation Software (NGS) Oy * * Author: Markku Rossi <mtr@ngs.fi> */ /* * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Library General Public * License as published by the Free Software Foundation; either * version 2 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Library General Public License for more details. * * You should have received a copy of the GNU Library General Public * License along with this library; if not, write to the Free * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, * MA 02111-1307, USA */ /* * $Source: /tmp/cvsroot-15-2-2007/clamav-devel/libclamav/js/vmswitch.c,v $ * $Id: vmswitch.c,v 1.2 2006/10/28 11:27:44 njh Exp $ */ #if HAVE_CONFIG_H #include "clamav-config.h" #endif #ifdef CL_EXPERIMENTAL #include "jsint.h" /* * Types and definitions. */ #define SAVE_OP(a) \ reloc[cp - fixed_code - 1] = &f->code[cpos]; \ f->code[cpos++].u.op = (a) #define SAVE_INT8(a) f->code[cpos++].u.i8 = (a) #define SAVE_INT16(a) f->code[cpos++].u.i16 = (a) #define SAVE_INT32(a) f->code[cpos++].u.i32 = (a) #define ARG_INT32() f->code[cpos].u.i32 #define READ_INT8(var) (var) = (pc++)->u.i8 #define READ_INT16(var) (var) = (pc++)->u.i16 #define READ_INT32(var) (var) = (pc++)->u.i32 #define SETPC(ofs) pc = (ofs) #define SETPC_RELATIVE(ofs) pc += (ofs) #define CALL_USER_FUNC(f) pc = ((Function *) (f))->code #define DONE() goto done #define ERROR(msg) \ do { \ JS_SAVE_REGS (); \ strcpy (vm->error, (msg)); \ js_vm_error (vm); \ /* NOTREACHED */ \ } while (0) struct compiled_st { union { void *ptr; JSUInt8 op; JSInt8 i8; JSInt16 i16; JSInt32 i32; } u; }; typedef struct compiled_st Compiled; /* Debug information. */ struct debug_info_st { void *pc; unsigned int linenum; }; typedef struct debug_info_st DebugInfo; struct function_st { JSHeapDestroyableCB destroy; char *name; Compiled *code; unsigned int length; struct { char *file; unsigned int num_info; DebugInfo *info; } debug; }; typedef struct function_st Function; /* * Prototypes for static functions. */ static void function_destroy (void *ptr); static Function *link_code (JSVirtualMachine *vm, unsigned char *code, unsigned int code_len, unsigned int consts_offset, unsigned char *debug_info, unsigned int debug_info_len, unsigned int code_offset); static void execute_code (JSVirtualMachine *vm, JSNode *object, Function *f, unsigned int argc, JSNode *argv); /* * Global functions. */ int js_vm_switch_exec (JSVirtualMachine *vm, JSByteCode *bc, JSSymtabEntry *symtab, unsigned int num_symtab_entries, unsigned int consts_offset, unsigned int anonymous_function_offset, unsigned char *debug_info, unsigned int debug_info_len, JSNode *object, JSNode *func, unsigned int argc, JSNode *argv) { int i; unsigned int ui; Function *global_f = NULL; Function *f; unsigned char *code = NULL; char buf[512]; if (bc) { /* Executing byte-code. */ /* Find the code section. */ for (i = 0; i < bc->num_sects; i++) if (bc->sects[i].type == JS_BCST_CODE) code = bc->sects[i].data; assert (code != NULL); /* Enter all functions to the known functions of the VM. */ for (i = 0; i < num_symtab_entries; i++) { /* Link the code to our environment. */ f = link_code (vm, code + symtab[i].offset, symtab[i + 1].offset - symtab[i].offset, consts_offset, debug_info, debug_info_len, symtab[i].offset); f->name = js_strdup (vm, symtab[i].name); if (strcmp (symtab[i].name, JS_GLOBAL_NAME) == 0) global_f = f; else { int is_anonymous = 0; /* Check for the anonymous function. */ if (symtab[i].name[0] == '.' && symtab[i].name[1] == 'F' && symtab[i].name[2] == ':') is_anonymous = 1; if (vm->verbose > 3) { sprintf (buf, "VM: link: %s(): start=%d, length=%d", symtab[i].name, symtab[i].offset, symtab[i + 1].offset - symtab[i].offset); if (is_anonymous) sprintf (buf + strlen (buf), ", relocating with offset %u", anonymous_function_offset); strcat (buf, JS_HOST_LINE_BREAK); js_iostream_write (vm->s_stderr, buf, strlen (buf)); } if (is_anonymous) { sprintf (buf, ".F:%u", (unsigned int) atoi (symtab[i].name + 3) + anonymous_function_offset); ui = js_vm_intern (vm, buf); } else ui = js_vm_intern (vm, symtab[i].name); vm->globals[ui].type = JS_FUNC; vm->globals[ui].u.vfunction = js_vm_make_function (vm, f); } } } else { /* Applying arguments to function. */ if (func->type != JS_FUNC) { sprintf (vm->error, "illegal function in apply"); return 0; } if (vm->verbose > 1) { sprintf (buf, "VM: calling function%s", JS_HOST_LINE_BREAK); js_iostream_write (vm->s_stderr, buf, strlen (buf)); } f = func->u.vfunction->implementation; execute_code (vm, object, f, argc, argv); } if (global_f) { if (vm->verbose > 1) { sprintf (buf, "VM: exec: %s%s", global_f->name, JS_HOST_LINE_BREAK); js_iostream_write (vm->s_stderr, buf, strlen (buf)); } /* Execute. */ execute_code (vm, NULL, global_f, 0, NULL); } return 1; } const char * js_vm_switch_func_name (JSVirtualMachine *vm, void *program_counter) { int i; Function *f; Compiled *pc = program_counter; JSNode *sp = vm->sp; /* Check the globals. */ for (i = 0; i < vm->num_globals; i++) if (vm->globals[i].type == JS_FUNC) { f = (Function *) vm->globals[i].u.vfunction->implementation; if (f->code < pc && pc < f->code + f->length) return f->name; } /* No luck. Let's try the stack. */ for (sp++; sp < vm->stack + vm->stack_size; sp++) if (sp->type == JS_FUNC) { f = (Function *) sp->u.vfunction->implementation; if (f->code < pc && pc < f->code + f->length) return f->name; } /* Still no matches. This shouldn't be reached... ok, who cares? */ return JS_GLOBAL_NAME; } const char * js_vm_switch_debug_position (JSVirtualMachine *vm, unsigned int *linenum_return) { int i; Function *f; void *program_counter = vm->pc; Compiled *pc = vm->pc; JSNode *sp = vm->sp; unsigned int linenum = 0; /* Check the globals. */ for (i = 0; i < vm->num_globals; i++) if (vm->globals[i].type == JS_FUNC) { f = (Function *) vm->globals[i].u.vfunction->implementation; if (f->code < pc && pc < f->code + f->length) { found: /* Ok, found it. */ if (f->debug.file == NULL) /* No debugging information available for this function. */ return NULL; /* Find the correct pc position. */ for (i = 0; i < f->debug.num_info; i++) { if (f->debug.info[i].pc > program_counter) break; linenum = f->debug.info[i].linenum; } *linenum_return = linenum; return f->debug.file; } } /* No luck. Let's try the stack. */ for (sp++; sp < vm->stack + vm->stack_size; sp++) if (sp->type == JS_FUNC) { f = (Function *) sp->u.vfunction->implementation; if (f->code < pc && pc < f->code + f->length) /* Found it. */ goto found; } /* Couldn't find the function we are executing. */ return NULL; } /* * Static functions. */ static void function_destroy (void *ptr) { Function *f = ptr; js_free (f->name); js_free (f->code); if (f->debug.file) js_free (f->debug.file); if (f->debug.info) js_free (f->debug.info); } static Function * link_code (JSVirtualMachine *vm, unsigned char *code, unsigned int code_len, unsigned int consts_offset, unsigned char *debug_info, unsigned int debug_info_len, unsigned int code_offset) { unsigned char *cp, *end; JSInt32 i; Compiled **reloc; unsigned int cpos; Function *f; unsigned char *fixed_code; unsigned int ui; char *debug_filename = "unknown"; char buf[512]; /* Terminate the code with op `done'. */ fixed_code = js_malloc (vm, code_len + 1); memcpy (fixed_code, code, code_len); fixed_code[code_len] = 1; /* op `done' */ cp = fixed_code; end = fixed_code + code_len + 1; /* Alloc function closure. */ f = js_vm_alloc_destroyable (vm, sizeof (*f)); f->destroy = function_destroy; /* Allocate space for our compiled code. <length> is enought. */ f->code = js_malloc (vm, (code_len + 1) * sizeof (Compiled)); reloc = js_calloc (vm, code_len + 1, sizeof (Compiled *)); /* Link phase 1: constants and symbols. */ cpos = 0; while (cp < end) { switch (*cp++) { /* include c1switch.h */ #include "c1switch.h" /* end include c1switch.h */ } } f->length = cpos; /* Link phase 2: relative jumps. */ cp = fixed_code; cpos = 0; while (cp < end) { switch (*cp++) { /* include c2switch.h */ #include "c2switch.h" /* end include c2switch.h */ } } /* Handle debug info. */ if (debug_info) { unsigned int di_start = code_offset; unsigned int di_end = code_offset + code_len; unsigned int ln; for (; debug_info_len > 0;) { switch (*debug_info) { case JS_DI_FILENAME: debug_info++; debug_info_len--; JS_BC_READ_INT32 (debug_info, ui); debug_info += 4; debug_info_len -= 4; f->debug.file = js_malloc (vm, ui + 1); memcpy (f->debug.file, debug_info, ui); f->debug.file[ui] = '\0'; debug_filename = f->debug.file; debug_info += ui; debug_info_len -= ui; break; case JS_DI_LINENUMBER: JS_BC_READ_INT32 (debug_info + 1, ui); if (ui > di_end) goto debug_info_done; /* This belongs to us (maybe). */ debug_info += 5; debug_info_len -= 5; JS_BC_READ_INT32 (debug_info, ln); debug_info += 4; debug_info_len -= 4; if (di_start <= ui && ui <= di_end) { ui -= di_start; f->debug.info = js_realloc (vm, f->debug.info, (f->debug.num_info + 1) * sizeof (DebugInfo)); f->debug.info[f->debug.num_info].pc = reloc[ui]; f->debug.info[f->debug.num_info].linenum = ln; f->debug.num_info++; } break; default: sprintf (buf, "VM: unknown debug information type %d%s", *debug_info, JS_HOST_LINE_BREAK); js_iostream_write (vm->s_stderr, buf, strlen (buf)); js_iostream_flush (vm->s_stderr); abort (); break; } } debug_info_done: if (f->debug.file == NULL) f->debug.file = js_strdup (vm, debug_filename); } js_free (reloc); js_free (fixed_code); return f; } /* * Execute byte code by using the `switch' dispatch technique. */ static void execute_code (JSVirtualMachine *vm, JSNode *object, Function *f, unsigned int argc, JSNode *argv) { JSNode *sp; JSNode *fp; JSNode *function; JSNode builtin_result; Compiled *pc; JSInt32 i, j; JSInt8 i8; char buf[512]; /* Create the initial stack frame by hand. */ sp = vm->sp; /* Protect the function from gc. */ JS_SP0->type = JS_FUNC; JS_SP0->u.vfunction = js_vm_make_function (vm, f); JS_PUSH (); /* Push arguments to the stack. */ i = argc; for (i--; i >= 0; i--) { JS_COPY (JS_SP0, &argv[i]); JS_PUSH (); } /* This pointer. */ if (object) JS_COPY (JS_SP0, object); else JS_SP0->type = JS_NULL; JS_PUSH (); /* Init fp and pc so our SUBROUTINE_CALL will work. */ fp = NULL; pc = NULL; JS_SUBROUTINE_CALL (f); /* Ok, now we are ready to run. */ while (1) { switch ((pc++)->u.op) { /* include eswitch.h */ #include "eswitch.h" /* end include eswitch.h */ default: sprintf (buf, "execute_code: unknown opcode %d%s", (pc - 1)->u.op, JS_HOST_LINE_BREAK); js_iostream_write (vm->s_stderr, buf, strlen (buf)); js_iostream_flush (vm->s_stderr); abort (); break; } } done: /* All done. */ JS_COPY (&vm->exec_result, JS_SP1); } #endif /*CL_EXPERIMENTAL*/