Advertisement
Not a member of Pastebin yet?
Sign Up,
it unlocks many cool features!
- architecture yafn {
- registers:
- storage sys_reg[96];
- view ssz = sys_reg[0..32]; /* stack size */
- view spn = sys_reg[32..64]; /* pointer to stack's beginning */
- view err = sys_reg[64..96]; /* error register */
- memory:
- /* 0xFFFFFFFF because we use 32-bit integers, so it will just fit */
- range __constants [0x0..0xFFFFFFFF] {
- cell = 8;
- endianess = little-endian;
- granularity = 0;
- }
- range __data [0x0..0xFFFFFFFF] {
- cell = 8;
- endianess = little-endian;
- granularity = 0;
- }
- range __stack [0x0..0xFFFFFFFF] {
- cell = 8;
- endianess = little-endian;
- granularity = 0;
- }
- range __code [0x0..0xFFFFFFFF] {
- cell = 8;
- endianess = little-endian;
- granularity = 0;
- }
- instructions: /* encodings */
- encode __dat field = immediate[32] data; /* some integer */
- encode __off field = immediate[32] offset; /* offset in memory */
- encode __lbl field = immediate[32] offset; /* pointer to instruction */
- encode __reg field = register {
- ssz = 00,
- spn = 01,
- err = 10
- };
- instructions: /* base */
- instruction emp = { 0000 0000 }; /* do nothing */
- instruction hlt = { 0000 0001 }; /* exits program */
- instruction brp = { 0000 0010 }; /* breakpoint */
- instruction wrt = { 0000 0011 }; /* outouts int from stack to console */
- instruction srt = { 0000 0100 }; /* sorts last N elements of stack */
- instructions: /* stack instructions */
- instruction epush = { 0001 0001 }; /* pushes error register to stack */
- instruction ipush = { 0001 0010, __dat as dat }; /* pushes integer to stack */
- instruction mpush = { 0001 0011, __off as off }; /* pushes from mem storage to stack */
- instruction cpush = { 0001 0100, __off as off }; /* pushes from constants storage to stack */
- /* pop instructions */
- instruction pop = { 0001 0101 }; /* discards top value from stack */
- instruction dpl = { 0001 0110 }; /* duplicates last element from stack */
- instruction sav = { 0001 0111, __off as off }; /* pops data from stack and stores it in memory */
- instruction swp = { 0001 1000 }; /* swaps top two values */
- instruction svs = { 0001 1001 }; /* pops data and place in memory to save */
- instruction rnd = { 0001 1010 }; /* pushes to stack random int */
- instruction smpsh = { 0001 1011 }; /* gets mem_ptr from stack to push fom mem */
- instruction scpsh = { 0001 1100 }; /* gets const_ptr from stack to push fom mem */
- /* all operations automatically pops top elements, so it's necessary to use `dpl` */
- instructions: /* arithmetics */
- instruction add = { 0010 0000 }; /* adds two top values on stack */
- instruction sub = { 0010 0001 }; /* substracts two top values of stack */
- instruction mul = { 0010 0010 }; /* multiplies two top values of stack */
- instruction div = { 0010 0011 }; /* dividies two top values of stack and pushes to
- stack result integer division and remainder */
- instruction neg = { 0010 0100 }; /* negatives top element of stack */
- instruction inc = { 0010 0101 }; /* increments top element of stack */
- instruction dec = { 0010 0110 }; /* decrements top element of stack */
- instructions: /* bitwise ops */
- instruction bor = { 0011 0000 }; /* bitwise or */
- instruction band = { 0011 0001 }; /* bitwise and */
- instruction and1 = { 0011 0100 }; /* bitwise and of top element and 1 */
- instruction and2 = { 0011 0101 }; /* bitwise and of top element and 2 */
- instruction and3 = { 0011 0110 }; /* bitwise and of top element and 4 */
- instruction and4 = { 0011 0111 }; /* bitwise and of top element and 8 */
- instruction lsh = { 0011 0010 }; /* left shift */
- instruction lsh1 = { 0011 1000 }; /* shifts top element left on 1 */
- instruction lsh2 = { 0011 1001 }; /* shifts top element left on 2 */
- instruction rsh = { 0011 0011 }; /* right shift */
- instruction rsh1 = { 0011 1100 }; /* shifts top element right on 1 */
- instruction rsh2 = { 0011 1101 }; /* shifts top element right on 2 */
- instruction bxor = { 0011 1111 }; /* bitwise xor */
- instructions: /* conditions and jumps */
- instruction cmp = { 0100 0000 }; /* compares two elements
- ---------------------
- | state | pushes |
- ---------------------
- | == | 001 |
- | >= | 011 |
- | <= | 101 |
- | > | 010 |
- | < | 100 |
- ---------------------
- So, the first bit for equality,
- second one for greatness and
- third one for less */
- instruction eq = { 0100 0001 }; /* pushes 1 if top values equal, else 0 */
- instruction jmp = { 0100 0100, __lbl as lbl }; /* jumps to instruction */
- instruction jez = { 0100 0101, __lbl as lbl }; /* jmps to instructions if 0 on stack top */
- instruction jnz = { 0100 0110, __lbl as lbl }; /* jmps to instructions if on stack top not 0 */
- instruction call = { 0100 0111, __lbl as lbl }; /* jmps to instructions and pushes current cursor to stack */
- instruction ret = { 0100 1000 }; /* jps to address at stack top and pops */
- instruction cmp0 = { 0100 1001 }; /* compares with 0 */
- mnemonics: /* formats */
- format plain1 is "{1}"; /* for numbers */
- format mem_ptr is "*{1}"; /* for memory pointers */
- format const_ptr is "#{1}"; /* for constants pointers */
- mnemonics: /* base */
- mnemonic emp();
- mnemonic hlt();
- mnemonic brp();
- mnemonic wrt();
- mnemonic srt();
- mnemonics: /* stack instructions */
- mnemonic epush();
- mnemonic push for ipush(dat) plain1;
- mnemonic push for cpush(off) const_ptr;
- mnemonic push for mpush(off) mem_ptr;
- mnemonic pop();
- mnemonic dpl();
- mnemonic sav for sav(off) mem_ptr;
- mnemonic swp();
- mnemonic sav for svs();
- mnemonic rnd();
- mnemonic smpsh();
- mnemonic scpsh();
- mnemonics: /* arithmetics instructions */
- mnemonic add();
- mnemonic sub();
- mnemonic mul();
- mnemonic div();
- mnemonic neg();
- mnemonic inc();
- mnemonic dec();
- mnemonics: /* bitwise instructions */
- mnemonic bor();
- mnemonic band();
- mnemonic and1();
- mnemonic and2();
- mnemonic and3();
- mnemonic and4();
- mnemonic lsh();
- mnemonic lsh1();
- mnemonic lsh2();
- mnemonic rsh();
- mnemonic rsh1();
- mnemonic rsh2();
- mnemonic bxor();
- mnemonics: /* conditions */
- mnemonic cmp();
- mnemonic eq();
- mnemonic jmp for jmp(lbl) plain1;
- mnemonic jez for jez(lbl) plain1;
- mnemonic jnz for jnz(lbl) plain1;
- mnemonic call for call(lbl) plain1;
- mnemonic ret();
- mnemonic cmp0();
- }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement