diff options
Diffstat (limited to 'Build/source/utils/xml2pmx/xml2pmx-src/obx.h')
-rw-r--r-- | Build/source/utils/xml2pmx/xml2pmx-src/obx.h | 361 |
1 files changed, 361 insertions, 0 deletions
diff --git a/Build/source/utils/xml2pmx/xml2pmx-src/obx.h b/Build/source/utils/xml2pmx/xml2pmx-src/obx.h new file mode 100644 index 00000000000..7af9058f495 --- /dev/null +++ b/Build/source/utils/xml2pmx/xml2pmx-src/obx.h @@ -0,0 +1,361 @@ +/* + * obx.h + * + * This file is part of the Oxford Oberon-2 compiler + * Copyright (c) 2006--2016 J. M. Spivey + * 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. + */ + +#ifndef _OBX_H +#define _OBX_H 1 + +#ifdef TRACE +#define DEBUG 1 +#endif + +#include "config.h" +#include <stdio.h> +#include "obcommon.h" + +#define SLIMIT 256 /* Min stack space space left (bytes) */ + +typedef union value value; + +typedef value *primitive(value *sp); + +typedef uint32_t word; +typedef uintptr_t ptrtype; + +union value { + int i; + float f; + word a; +}; + +#define valptr(v) ptrcast(value, (v).a) +#define pointer(v) ptrcast(void, (v).a) + +#ifdef SEGMEM + +#define SEGBITS 20 +#define SEGMENT (1 << SEGBITS) +#define SEGMASK ((1 << SEGBITS)-1) +#define NSEGMENTS 4096 + +#define stkaddr(p) (stack_vbase + ((uchar *) (p) - stack)) +#define dsegaddr(p) (data_vbase + ((uchar *) (p) - dmem)) +#define ptrcast(t, a) ((t *) physmap(a)) + +extern void *segmap[]; +EXTERN word stack_vbase, data_vbase; + +#define physmap(a) \ + ((void *) ((char *) segmap[(a) >> SEGBITS] + ((a) & SEGMASK))) + +/* +static inline void *physmap(unsigned a) { + return (char *) segmap[a >> SEGBITS] + (a & SEGMASK); +} +*/ + +#else + +#define pun_memory(p) ((word) (ptrtype) (p)) +#define stkaddr(p) pun_memory(p) +#define dsegaddr(p) pun_memory(p) +#define ptrcast(t, a) ((t *) (ptrtype) (a)) + +#endif + +#define codeaddr(p) ((p) - imem) +#define codeptr(v) (imem + (v)) + +typedef struct _proc *proc; +typedef struct _module *module; +typedef struct _arc *arc; + +#ifdef PROFILE +typedef uint64_t counter; +#endif + +struct _proc { + const char *p_name; /* Procedure name */ + word p_addr; /* Address of descriptor in data space */ +#ifdef PROFILE + int p_index; /* Position in listing */ + unsigned p_calls; /* Call count */ + unsigned p_rec; /* Call count for recursion */ + counter p_self; /* Tick count for self */ + counter p_child; /* Tick count for children */ + arc p_parents; /* List of callers */ + arc p_children; /* List of procs we call */ +#endif +}; + +struct _module { + char *m_name; /* Layout must match proc */ + word m_addr; + int m_length; +#ifdef PROFILE + int m_nlines; + unsigned *m_lcount; +#endif +}; + + +/* Global variables */ +EXTERN uchar *imem, *dmem; /* Instruction and data memory arrays */ +EXTERN uchar *stack; /* Program stack */ +EXTERN int code_size; /* Size of program code */ +EXTERN int stack_size; /* Size of main stack */ +EXTERN char *libpath; /* Path to dynamic library */ +EXTERN value *entry; /* Program entry point */ +EXTERN value *gcmap; /* Global pointer map */ +EXTERN word interpreter, dyntrap; +#ifdef USE_FFI +EXTERN word dynstub; +#endif + +#define interpreted(p) ((p)[CP_PRIM].a == interpreter) + +#ifndef M64X32 +#define primcall(p, sp) ((primitive *) p[CP_PRIM].a)(sp) +#else +#ifdef JIT +#define primcall(p, sp) (ptrcast(primitive, p[CP_PRIM].a))(sp) +#else +#define primcall(p, sp) (*ptrcast(primitive *, p[CP_PRIM].a))(sp) +#endif +#endif + +#define get1(p) ((int) ((signed char) (p)[0])) +#define get2(p) ((int) ((short) (((p)[1]<<8) + (p)[0]))) + +EXTERN int nmods, nprocs, nsyms; +EXTERN module *modtab; +EXTERN proc *proctab; + +extern struct primdef { + char *p_name; + primitive *p_prim; +} primtab[]; + +EXTERN int level; /* Recursion level in bytecode interp. */ +#ifdef OBXDEB +EXTERN value *prim_bp; /* Base pointer during primitive call */ +#endif + +EXTERN int dflag; +EXTERN mybool gflag; +#ifdef PROFILE +EXTERN mybool lflag; +#endif +#ifdef TRACE +EXTERN int qflag; +#endif +#ifdef OBXDEB +EXTERN char *debug_socket; +#endif + + +/* profile.c */ +#ifdef PROFILE +void prof_enter(word p, counter ticks, int why); +void prof_exit(word p, counter ticks); +void prof_init(void); +void prof_reset(proc p); +void profile(FILE *fp); + +#define PROF_CALL 1 +#define PROF_TAIL 2 +#define PROF_PRIM 3 +#endif + +/* interp.c */ +primitive interp, dltrap, dlstub; + +/* xmain.c */ +EXTERN int saved_argc; +EXTERN char **saved_argv; + +void xmain_exit(int status); +void error_exit(int status); + +/* support.c */ +int ob_div(int a, int b); +int ob_mod(int a, int b); + +void int_div(value *sp); +void int_mod(value *sp); + +void long_add(value *sp); +void long_sub(value *sp); +void long_mul(value *sp); +void long_div(value *sp); +void long_mod(value *sp); +void long_neg(value *sp); +void long_cmp(value *sp); +void long_flo(value *sp); +void long_ext(value *sp); +void long_zcheck(value *sp); + +void flo_add(value *sp); +void flo_sub(value *sp); +void flo_mul(value *sp); +void flo_div(value *sp); +void flo_neg(value *sp); +void flo_float(value *sp); +void flo_fix(value *sp); +void flo_cmpl(value *sp); +void flo_cmpg(value *sp); +void flo_trunc(value *sp); +void dbl_add(value *sp); +void dbl_sub(value *sp); +void dbl_mul(value *sp); +void dbl_div(value *sp); +void dbl_neg(value *sp); +void dbl_float(value *sp); +void dbl_fix(value *sp); +void dbl_cmpl(value *sp); +void dbl_cmpg(value *sp); +void dbl_widen(value *sp); +void flo_zcheck(value *sp); +void dbl_zcheck(value *sp); + +word wrap_prim(primitive *prim); + +/* load_file -- load a file of object code */ +void load_file(FILE *bfp); +void load_image(void); + +void make_module(char *name, word addr, int chsum, int nlines); +void make_proc(char *name, word addr); +void make_symbol(const char *kind, char *name, word addr); +void fix_sizes(int dseg); + +void panic(const char *, ...); +void obcopy(char *dst, int dlen, const char *src, int slen, value *bp); + +void error_stop(const char *msg, int val, int line, value *bp, uchar *pc); +void runtime_error(int num, int line, value *bp, uchar *pc); +void rterror(int num, int line, value *bp); +void stkoflo(value *bp); +#define liberror(msg) error_stop(msg, 0, 0, bp, NULL) + +proc find_symbol(word p, proc *table, int nelem); +#define find_proc(cp) find_symbol(cp, proctab, nprocs) +#define find_module(cp) ((module) find_symbol(cp, (proc *) modtab, nmods)) + +#ifdef TRACE +char *fmt_inst(uchar *pc); +void dump(void); +const char *prim_name(value *p); +#endif + +#ifdef UNALIGNED_MEM +#define get_double(v) (* (double *) (v)) +#define put_double(v, x) (* (double *) (v) = (x)) +#define get_long(v) (* (longint *) (v)) +#define put_long(v, x) (* (longint *) (v) = (x)) +#else +double get_double(value *v); +void put_double(value *v, double x); +longint get_long(value *v); +void put_long(value *v, longint w); +#endif + +double flo_conv(int); +double flo_convq(longint); + + +/* gc.c */ + +/* scratch_alloc -- allocate memory that will not be freed */ +void *scratch_alloc(unsigned bytes); + +#ifdef USE_BOEHM +/* scratch_alloc_atomic -- allocate memory that will not contain pointers */ +void *scratch_alloc_atomic(unsigned bytes); +#else +#define scratch_alloc_atomic(bytes) scratch_alloc(bytes) +#endif + +#ifdef SEGMEM + +word virtual_alloc(unsigned bytes); +word map_segment(void *base, unsigned length); +#define virtual_alloc_atomic(bytes) virtual_alloc(bytes) + +#else + +#define virtual_alloc(bytes) pun_memory(scratch_alloc(bytes)) +#define virtual_alloc_atomic(bytes) pun_memory(scratch_alloc_atomic(bytes)) + +#endif + +/* gc_alloc -- allocate an object on the managed heap */ +word gc_alloc(unsigned size, value *sp); + +/* gc_collect -- run the garbage collector */ +value *gc_collect(value *sp); + +/* gc_heap_size -- return size of heap */ +int gc_heap_size(void); + +extern mybool gcflag; +void gc_init(void); +void gc_dump(void); + +/* debug.c */ +#ifdef OBXDEB +extern mybool one_shot; +extern mybool intflag; + +void debug_init(void); +void debug_message(char *fmt, ...); +void debug_break(value *cp, value *bp, uchar *pc, char *fmt, ...); +#endif + +/* jit.c */ +#ifdef JIT +void jit_compile(value *cp); +value *jit_trap(value *cp); +#endif + +#ifdef __cplusplus +#define PRIMDEF extern "C" +#else +#define PRIMDEF +#endif + +#ifdef NEED_FPINIT +/* On x86, each primitive re-initialises the FP unit, so that values + left behind in registers by the caller do not cause stack overflow. */ +#define FPINIT asm ("fninit") +#else +#define FPINIT +#endif + +#endif |