[insert project logo here (125x200px max)] Navigator Home Downloads Documentation Research News Forums Project Summary CVS repository Mailinglists Help Announcement Developer Please report any errors or ommissions you find to our `Help' mailinglist, or post a message in the Forums. Copyright and Licensing Information Snap is (c) Jonathan T. Moore, 1999-2002 and licensed under the GNU General Public License (GPL). All other parts of Splash are (c) Willem de Bruijn, 2002-2003 and licensed under the BSD Open Source License. All sourcecode is made publicly available. Acknowledgement Splash and the Splash website are hosted by SourceForge.net

Splash - Documentation SNMP Plus a Lightweight API for SNAP Handling             snap-1.1-wjdb/lib/bytecode.h Go to the documentation of this file. /* $Id: bytecode.h,v 1.7 2003/04/02 17:01:14 wdebruij Exp $ */ #include <stdio.h> #include <limits.h> #include "config.h" #include "dyncheck.h" #include "wassert.h" #ifndef _SNAP_BYTECODE_H_ #define _SNAP_BYTECODE_H_ #ifdef CONFIG_IP_SNAP_SMALL_INSTRS #define SMALL_INSTRS #endif #ifdef CONFIG_IP_SNAP_SMALL_VALUES #define SMALL_VALUES #endif #ifdef TAG_CHECK #define DYNCHECK_TAG(v,tag) DYNCHECK(GET_TAG((v)) == (tag)) #else #define DYNCHECK_TAG(v,tag) ((void)0) #endif /* having small representation for instructions requires small values as well */ #ifdef SMALL_INSTRS #ifndef SMALL_VALUES #define SMALL_VALUES #endif #endif /* enumeration of all value types -- these are the tags for the values */ #ifdef SMALL_VALUES #define INTV 0 /* integers (32-bit) */ #define ADDRV 1 /* IPv4 addresses (32-bit) */ #define STRV 2 /* strings/blobs */ #define EXCV 3 /* exceptions */ #define TUPLEV 4 /* tuples */ #define FLOATV 5 /* 32-bit floats */ #define BOGUSV 6 /* for ops that ignore the tag */ #define TAG_T int /* not enough space to put addrs as literals when values are small */ #ifndef ADDR_IN_HEAP #define ADDR_IN_HEAP #endif #else typedef enum { INTV, /* integers (32-bit) */ ADDRV, /* IPv4 addresses (32-bit) */ STRV, /* strings/blobs */ EXCV, /* exceptions */ TUPLEV, /* tuples */ FLOATV /* 32-bit floats */ } value_tag_t; #define TAG_T value_tag_t #endif /* heap objects are strings */ #define LENTYPE unsigned short #define MAX_HEAPOBJ_SZ (1 << ((sizeof(unsigned short) * 8))) typedef struct { LENTYPE len; /* length of string/exc/tuple in bytes */ unsigned short flag; /* legal values 0 : non-ptr-containing object 1 : ptr-containing object 4,8,12,... : forwarding offset */ char s[0]; /* string (maybe not null terminated) */ } heap_obj; /* stack value-- has a type tag plus the value itself */ #ifdef SMALL_VALUES typedef unsigned int value_t; #define ZERO_VALUE_T 0 #ifdef SMALL_INSTRS #define TAGSZ 7 #else #define TAGSZ 3 #endif #define MAX_VINT (1 << ((sizeof(unsigned int) * 8-(TAGSZ+1)))) #define MIN_VINT (- MAX_VINT - 1) #define GET_TAG(v) ((v) >> (sizeof(unsigned int)*8-TAGSZ)) #define SET_TAG(v,t) ((v) = (((v) << TAGSZ) >> TAGSZ) | ((t) << (sizeof(unsigned int)*8-TAGSZ))) #define GET_INT(v) (((int)((v) << TAGSZ)) >> TAGSZ) #define SET_INT(v,i) ((v) = (((v) >> (sizeof(unsigned int)*8-TAGSZ)) << (sizeof(unsigned int)*8-TAGSZ)) | ((((unsigned int)(i)) << TAGSZ) >> TAGSZ)) #define GET_OFFS GET_INT #define SET_OFFS SET_INT #define COPY_VAL(val1,val2) ((val1) = (val2)) #define GET_BOXED(res,heap,v,t) \ { \ heap_obj *ho1 = (heap_obj *)((heap) + GET_OFFS(v)); \ DYNCHECK_ADDR_IN_HEAP(ho1); \ wassert(ho1->len == sizeof(t)); \ (res) = *((t *)ho1->s); \ } #define GET_ADDR(res,h,v) GET_BOXED(res,h,v,uint32_t) #define GET_FLOAT(res,h,v) GET_BOXED(res,h,v,float32) #define GET_ADDR_VAL(h,v) (*((uint32_t *)(((heap_obj *)((h) + GET_OFFS(v)))->s))) #define GET_FLT_VAL(h,v) (*((float32 *)(((heap_obj *)((h) + GET_OFFS(v)))->s))) #define FLTINTPAIR(f) (int)(f),(int)(((f) - (int)(f)) * 1000000) #define SET_ADDR(val,a,p) \ { int hoffset; \ heap_obj *ho; \ if (!heap_alloc((p),sizeof(uint32_t),0,&ho,&hoffset)) { \ *((uint32_t *)ho->s) = (a); \ SET_OFFS(val,hoffset); \ } \ else return -1; \ } #define SET_FLOAT(val,a,p) \ { int hoffset; \ heap_obj *ho; \ if (!heap_alloc((p),sizeof(float32),0,&ho,&hoffset)) {\ *((float32 *)ho->s) = (a); \ SET_OFFS(val,hoffset); \ } \ else return -1; \ } #define IS_HEAP_VAL(v) \ ((GET_TAG(v) == ADDRV) || (GET_TAG(v) == STRV) || \ (GET_TAG(v) == TUPLEV) || (GET_TAG(v) == FLOATV)) #else typedef struct { TAG_T tag; /* type tag */ union { int intval; /* 32-bit integer */ #ifndef ADDR_IN_HEAP uint32_t addrval; /* 32-bit IPv4 address */ float32 floatval; /* 32-bit float */ #endif int hoffset; /* offset for a heap object */ } v; } value_t; #define ZERO_VALUE_T { 0, { 0 } } #define MAX_VINT INT_MAX #define MIN_VINT INT_MIN #define GET_TAG(val) ((val).tag) #define SET_TAG(val,t) ((val).tag = (t)) #define GET_INT(val) ((val).v.intval) #define SET_INT(val,i) ((val).v.intval = (i)) #define GET_OFFS(val) ((val).v.hoffset) #define SET_OFFS(val,o) ((val).v.hoffset = (o)) #ifndef ADDR_IN_HEAP #define GET_ADDR(res,unused,val) ((res) = (val).v.addrval) #define SET_ADDR(val,a,unused) ((val).v.addrval = (a)) #define GET_FLOAT(res,unused,val) ((res) = (val).v.floatval) #define SET_FLOAT(val,a,unused) ((val).v.floatval = (a)) #define IS_HEAP_VAL(v) \ ((GET_TAG(v) == STRV) || (GET_TAG(v) == TUPLEV)) #else #define GET_BOXED(res,heap,v,t) \ { \ heap_obj *ho1 = (heap_obj *)((heap) + GET_OFFS(v)); \ DYNCHECK_ADDR_IN_HEAP(ho1); \ wassert(ho1->len == sizeof(t)); \ (res) = *((t *)ho1->s); \ } #define GET_ADDR(res,h,v) GET_BOXED(res,h,v,uint32_t) #define GET_FLOAT(res,h,v) GET_BOXED(res,h,v,float32) #define GET_ADDR_VAL(h,v) (*((uint32_t *)(((heap_obj *)((h) + GET_OFFS(v)))->s))) #define GET_FLT_VAL(h,v) (*((float32 *)(((heap_obj *)((h) + GET_OFFS(v)))->s))) #define IS_HEAP_VAL(v) \ ((GET_TAG(v) == STRV) || (GET_TAG(v) == TUPLEV) || \ (GET_TAG(v) == ADDRV)) #define FLTINTPAIR(f) (int)(f),(int)(((f) - (int)(f)) * 1000000) #define SET_ADDR(val,a,p) \ { int hoffset; \ heap_obj *ho; \ if (!heap_alloc((p),sizeof(uint32_t),0,&ho,&hoffset)) { \ *((uint32_t *)ho->s) = (a); \ SET_OFFS(val,hoffset); \ } \ else return -1; \ } #define SET_FLOAT(val,a,p) \ { int hoffset; \ heap_obj *ho; \ if (!heap_alloc((p),sizeof(float32),0,&ho,&hoffset)) {\ *((float32 *)ho->s) = (a); \ SET_OFFS(val,hoffset); \ } \ else return -1; \ } #endif #define COPY_VAL(val1,val2) ((val1) = (val2)) #endif /* opcodes */ #ifdef SMALL_INSTRS #define EXIT 0 #define PUSH 1 /* not used */ #define POP 2 #define POPI 3 #define PULL 4 #define STORE 5 #define PAJ 6 #define TPAJ 7 #define JI 8 #define BEZ 9 #define BNE 10 #define MKTUP 11 #define NTH 12 #define LEN 13 #define ISTUP 14 #define EQ 15 #define EQI 16 /* not used */ #define NEQ 17 #define NEQI 18 /* not used */ #define GT 19 #define GTI 20 #define GEQ 21 #define GEQI 22 #define LEQ 23 #define LEQI 24 #define LT 25 #define LTI 26 #define ADD 27 #define ADDI 28 #define SUB 29 #define SUBI 30 #define MULT 31 #define MULTI 32 #define DIV 33 #define DIVI 34 #define MOD 35 #define MODI 36 #define NEG 37 #define NOT 38 #define LNOT 39 #define AND 40 #define ANDI 41 #define OR 42 #define ORI 43 #define LSHL 44 #define LSHLI 45 #define RSHL 46 #define RSHLI 47 #define RSHA 48 #define RSHAI 49 #define XOR 50 #define XORI 51 #define SNET 52 #define SNETI 53 #define BCAST 54 #define BCASTI 55 #define ISX 56 #define GETRB 57 #define GETSRC 58 #define GETDST 60 #define GETSPT 61 #define HERE 62 #define ISHERE 63 #define ROUTE 64 #define RTDEV 65 #define SEND 66 #define HOP 67 /* #define SENDCK 67 */ /* #define HOPCK 68 */ #define FORW 69 #define FORWTO 70 #define DEMUX 71 #define DEMUXI 72 #define PRINT 73 #define PINT 74 #define PADDR 75 #define PTUP 76 #define PEXC 77 #define PSTR 78 #define PFLT 79 #define EQINT 80 #define EQADR 81 #define EQTUP 82 #define EQEXC 83 #define EQSTR 84 #define EQFLT 85 #define NQINT 86 #define NQADR 87 #define NQTUP 88 #define NQEXC 89 #define NQSTR 90 #define NQFLT 91 #define SVCV 92 #define CALLS 93 #define FGTI 94 #define FGEQI 95 #define FLEQI 96 #define FLTI 97 #define FADDI 98 #define FSUBI 99 #define FMULI 100 #define FDIVI 101 #define GETLD 102 #define SETXH 103 #define RAISEX 104 /* willem's additions */ #define DSEND 105 /* direct send (no interpretation on intermediate hops) */ #define DFORW 106 /* idem for forw */ #define DFORWTO 107 /* idem for forwto */ #define STACKEMPTY 108 /* pushes a 1 if the stack is empty, 0 otherwise */ #define STACKCOUNT 109 /* pushes the number of elements on the stack */ #define PULLSTACK 110 /* PULL using top stack element as index (this value is removed */ #define OPCODE_T int /* operations on literals */ /* assumes that TAGSZ is set appropriately above */ #define GET_OP(v) ((v) >> (sizeof(unsigned int)*8-TAGSZ)) #define SET_OP(v,i) ((v) = (((v) << TAGSZ) >> TAGSZ) | ((i) << (sizeof(unsigned int)*8-TAGSZ))) #define GET_LIT(l,t,i) ((l) = (((int)((i) << TAGSZ)) >> TAGSZ)) #define SET_LIT(i,t,l) ((i) = (((i) >> (sizeof(unsigned int)*8-TAGSZ)) << (sizeof(unsigned int)*8-TAGSZ)) | ((((unsigned int)(l)) << TAGSZ) >> TAGSZ)) #define GET_LIT_VAL(i) (((int)((i) << TAGSZ)) >> TAGSZ) #define GET_STR_VAL(h,v) (((heap_obj *)((h) + GET_OFFS(v)))->s) #define NUM_OPS 87 /* total number of (legal) opcodes */ typedef unsigned int instr_t; #else typedef enum { /* stack and flow control */ EXIT, PUSH, /* push a value on the stack */ POP, /* pop the top value off the stack */ POPI, /* pop the top n values off the stack */ PULL, /* push a copy of the nth stack value */ STORE, /* store the top of the stack into the nth stack value (thus store 0 is a no-op) */ PAJ, /* jump by the value on the top of the stack (pop and jump) plus the given immediate value */ TPAJ, /* jump by the 2nd value on the top of the stack, plus the immediate value,if the top value is zero (test, pop, and jump) */ JI, /* jump by the immediate value */ BEZ, /* branch x instrs if the top stack value is equal to zero */ BNE, /* branch x instrs if the top stack value is not zero */ /* heap operations */ MKTUP, /* allocates a tuple that holds n values, where n>0 is an immediate. Must be followed by n-1 (JI 1) instructions */ NTH, /* get's the nTH entry of the tuple on the top of the stack, where n is an immediate > 0 */ LEN, /* returns the length of the tuple, that is, how many values it contains. */ ISTUP, /* is the top value a tuple? */ /* relational operators */ EQ, /* are the top two stack values equal? */ EQI, /* is the top stack value equal to the immediate argument? */ NEQ, /* are the top two stack values not equal? */ NEQI, /* is the top stack value not equal to the immediate argument? */ GT, /* comparing top 2 values: v2 > v1 */ GTI, /* top > immediate */ GEQ, /* comparing top 2 values: v2 >= v1 */ GEQI, /* top >= immediate */ LEQ, /* comparing top 2 values: v2 <= v1 */ LEQI, /* top <= immediate */ LT, /* comparing top 2 values: v2 < v1 */ LTI, /* top < immediate */ /* arithmetic */ ADD, /* integer addition */ ADDI, /* integer addition with immediate */ SUB, /* integer subtraction */ SUBI, /* integer subtraction with immediate */ MULT, /* integer multiplication */ MULTI, /* integer multiplication with immediate*/ DIV, /* integer division */ DIVI, /* integer division with immediate */ MOD, /* integer modulus */ MODI, /* integer modulus with immediate */ NEG, /* integer arithmetic negation */ NOT, /* integer boolean negation */ LNOT, /* integer logical negation */ AND, /* integer logical and */ ANDI, /* integer logical and with immediate */ OR, /* integer logical or */ ORI, /* integer logical or with immediate */ LSHL, /* integer left shift logical */ LSHLI, /* integer left shift logical with immediate */ RSHL, /* integer right shift logical */ RSHLI, /* integer right shift logical with immediate */ RSHA, /* integer right shift arithmetic */ RSHAI, /* integer right shift arithmetic with immediate */ XOR, /* integer logical xor */ XORI, /* integer logical xor with immediate */ /* operations on addresses */ SNET, /* given an address and a subnet mask, give the subnet address */ SNETI, /* subnet with immediate mask */ BCAST, /* given an address and a subnet mask, give the broadcast address */ BCASTI, /* broadcast address with immed. mask */ /* operations on exceptions */ ISX, /* is the top value an exception? */ /* core services */ GETRB, /* get the resource bound field */ GETSRC, /* get the source field */ GETDST, /* get the destination field */ GETSPT, /* get the flow id */ HERE, /* push an address of the current host */ ISHERE, /* does the address on top of the stack belong to the current host? */ ROUTE, /* determine the next hop to send to */ RTDEV, /* next hop and outgoing interface */ SEND, /* OnRemote w/ literal: args are: entry point, how many values of stack to take, how much resource bound, destination. side effects the header dest and source fields of outgoing packet */ HOP, /* OnNeighbor w/ literal: args are: entry point, stack amount, resource bound, neighbor */ /* SENDCK, */ /* OnRemote: same as SEND, except (entrypoint,how much stack) args replaced with a chunk. */ /* HOPCK, */ /* OnNeighbor: same as HOP, except (entrypoint,how much stack) args replaced with a chunk. */ FORW, /* if at destination, do nothing. else forward packet towards destination and exit */ FORWTO, /* arg is final destination. if there, do nothing. else set header's src and dst appropriately and forward */ DEMUX, /* application delivery: args are: UDP port, string */ DEMUXI, /* same, but port num is immediate */ PRINT, /* print value to console */ /* general services */ SVCV, /* returns (non-function) value with given name from the service symtab */ CALLS, /* invokes service routine with given string */ /* willem's additions */ , DSEND, /* direct send (no interpretation on intermediate hops) */ DFORW, /* idem for forw */ DFORWTO, /* idem for forwto */ STACKEMPTY, /* pushes a 1 if the stack is empty, 0 otherwise */ STACKCOUNT, /* pushes the number of elements on the stack */ PULLSTACK /* PULL using top stack element as index (this value is removed */ } opcode_t; #define OPCODE_T opcode_t /* operations on literals */ #define GET_LIT(l,t,i) \ DYNCHECK_TAG((i).arg,t); \ (l) = GET_INT((i).arg); /* assumes this is the same as GET_OFFS */ #define SET_LIT(i,t,l) \ SET_INT((i).arg,(l)); /* all ints anyway */ \ SET_TAG((i).arg,(t)); #define GET_OP(i) ((i).op) #define SET_OP(i,t) ((i).op = (t)) #define NUM_OPS 73 /* total number of opcodes */ /* instructions are an opcode with an (optional) argument */ typedef struct { OPCODE_T op; value_t arg; } instr_t; #endif #define COPY_LIT(d,t,s) \ { int _lit; \ GET_LIT(_lit,t,(s)); \ SET_INT((d),_lit); \ SET_TAG((d),t); \ } #endif /* _SNAP_BYTECODE_H_ */