goose.arch

/* 
	<==============================O
	|   GOOSE ARCHITECTURE v4.0    |
	|            __                |
	|          >(' )               |
	|            )/    ~           |
	|           /(____/\           |
	|          /        )          |
	|          \ `  =~~/           |
	|           `-----|            |
	|        - - -  ~~^  - -       |
	+------------------------------+
	|	ARCHITECTURE DEFINITION    |
	+------------------------------+

	Word length: 		16 bits
	Class:				Stack virtual machine
	Memory regions: 	Code, constants, data, stack

	Илья Бураков, вариант 6	
*/

architecture Goose {

	registers:
		storage STACK_STORAGE[32];									/* A little-endian physical storage to serve for stack maintaining purposes: */
																	/* [0 .. SSZ .. 15 ][ 16 .. CSZ .. 31] */

		storage SYSTEM_STORAGE[16];									/* A little-endian physical storage for system essential data: */
																	/* [0 .. IP .. 15] */

		view SSZ = STACK_STORAGE[0..15];							/* A view for the current Stack Size storage */

		view CSZ = STACK_STORAGE[16..31];							/* A view for the subroutine caller's stack Size storage at the entry point */
																	/* For "main" or "root" subroutine it's -1 */

		view IP = SYSTEM_STORAGE[0..15];							/* A view for the current instruction's pointer storage */
		
	memory:
		range mCode[0x0000..0xFFFF] {
			cell = 8;
			endianess = little-endian;
			granularity = 0;
		}

		range mConsts[0x0000..0xFFFF] {
			cell = 8;
			endianess = little-endian;
			granularity = 0;
		}

		range mData[0x0000..0xFFFF] {
			cell = 8;
			endianess = little-endian;
			granularity = 0;
		}

		range mStack[0x0000..0xFFFF] {
			cell = 8;
			endianess = little-endian;
			granularity = 0;
		}

	instructions:
		/* ---------------- TYPE ENCODINGS ---------------- */

		encode imm8		field = immediate[8] data;						/* generic data stored in 1 byte */
		encode imm16	field = immediate[16] data;						/* generic data stored in 2 bytes */
		encode imm32	field = immediate[32] data;						/* generic data stored in 4 bytes */
		encode imm64	field = immediate[64] data;						/* generic data stored in 8 bytes */

		encode ofs16  	field = immediate[16] offset;					/* memory offset (maximum is 0xFFFF, what is the size of any memory range) */


		/* BITS OF PARTS OF INSTRUCTION OPCODES DEFINITION 	*/

		/* For advanced description see ISA.txt 	*/

		encode efGroup field = cases {
			system 			= 000,
			stack 			= 111,
			flowctrl		= 101,
			jmpif 			= 100,
			arithmetic 		= 011,										
			input			= 001,
			output 			= 010
		};

		//<type: b/w/d/q>
		encode efValType field = cases {
			bt = 00,
			wt = 01,
			dt = 10,
			qt = 11
		};

		encode esValType sequence = alternatives {
			bt = { efValType.bt },
			wt = { efValType.wt },
			dt = { efValType.dt },
			qt = { efValType.qt }
		};


		encode esValTypeAndNum sequence = alternatives {
			bval = { efValType.bt, imm8 as num },
			wval = { efValType.wt, imm16 as num },
			dval = { efValType.dt, imm32 as num },
			qval = { efValType.qt, imm64 as num }
		};

		encode esValTypeAndOfs sequence = alternatives {
			bval = { efValType.bt, ofs16 as ofs },
			wval = { efValType.wt, ofs16 as ofs },
			dval = { efValType.dt, ofs16 as ofs },
			qval = { efValType.qt, ofs16 as ofs }	
		};

		encode efOfs field = cases {
			deref	= 0,
			pop		= 1
		};


		encode numOr0 sequence = alternatives {
			defined = { imm8 as num },
			default = { 0000 0000 }
		};

		/* -------------- STACK INSTRUCTIONS -------------- */

		instruction push_plain		= { efGroup.stack, 0, 1, 0, sequence esValTypeAndNum };
		instruction push_by_ofs		= { efGroup.stack, 0, 0, efOfs.deref, sequence esValTypeAndOfs };
		instruction push_by_ofs_pop = { efGroup.stack, 0, 0, efOfs.pop, sequence esValType };

		instruction pop_discard  	= { 1100 0010 };
		instruction pop_by_ofs		= { efGroup.stack, 1, 0, efOfs.deref, sequence esValTypeAndOfs};
		instruction pop_by_ofs_pop	= { efGroup.stack, 1, 0, efOfs.pop, sequence esValType};

		instruction sav_by_ofs		= { efGroup.stack, 1, 1, efOfs.deref, sequence esValTypeAndOfs};
		instruction sav_by_ofs_pop	= { efGroup.stack, 1, 1, efOfs.pop, sequence esValType};

		instruction swp			 	= { 1100 0000 };
		instruction dpl				= { 1100 0001, sequence numOr1 };
		

		/* ----------- FLOW CONTROL INSTRUCTIONS ---------- */

		encode esZero sequence = alternatives {
			twoOpds 	= { 0 },
			withZero	= { 1 }
		};

		encode esComparator sequence = alternatives {
			greater = { 00 },
			greaterequal = { 01 },
			less = { 10 },
			lessequal = { 11 }
		};

		// Opcode construction may get really messy here and further.
		// Check ISA.txt for resolving each field's meaning.

		instruction jmp_if_plain		= { efGroup.jmpif, 1, 0, sequence esZero, sequence esComparator, ofs16 as targetLabel };
		instruction jmp_if_deref		= { efGroup.jmpif, 0, efOfs.deref, sequence esZero, sequence esComparator, ofs16 as targetOfsVarPtr };
		instruction jmp_if_pop			= { efGroup.jmpif, 0, efOfs.pop, sequence esZero, sequence esComparator };

		instruction jmp_if_equal_plain	= { efGroup.flowctrl, 0 0, 1, 0, sequence esZero, ofs16 as targetLabel };
		instruction jmp_if_equal_deref 	= { efGroup.flowctrl, 0 0, 0, efOfs.deref, sequence esZero, ofs16 as targetOfsVarPtr };
		instruction jmp_if_equal_pop	= { efGroup.flowctrl, 0 0, 0, efOfs.pop, sequence esZero };

		instruction jmp_plain 			= { efGroup.flowctrl, 0 10, 1, 0, ofs16 as targetLabel };
		instruction jmp_deref 			= { efGroup.flowctrl, 0 10, 0, efOfs.deref, ofs16 as targetOfsVarPtr };
		instruction jmp_pop 			= { efGroup.flowctrl, 0 10, 0, efOfs.pop };

		encode numOr0AndOfs sequence = alternatives {
			num_not_defined = { 0000 0000, ofs16 as ofs },
			defined = { imm8 as num, ofs16 as ofs }
		};

		encode numOr1 sequence = alternatives {
			defined = { imm8 as num },
			default = { 0000 0001 }
		};

		instruction call 				= { efGroup.flowctrl, 0 1100, sequence numOr0AndOfs }; // numOr0AndOfs(num as argsNumber, ofs as subroutineLabel) };
		
		instruction ret 				= { efGroup.flowctrl, 0 1101, sequence numOr0 };


		/* ------------ ARITHMETIC INSTRUCTIONS ----------- */

		instruction add 			= { efGroup.arithmetic, 0 0000 };
		instruction sub 			= { efGroup.arithmetic, 0 0001 };
		instruction inc 			= { efGroup.arithmetic, 0 0010 };
		instruction dec 			= { efGroup.arithmetic, 0 0011 };
		instruction mlt 			= { efGroup.arithmetic, 0 0100 };
		instruction div 			= { efGroup.arithmetic, 0 0101 };
		instruction mod 			= { efGroup.arithmetic, 0 0110 };


		/* ------------- BITWISE INSTRUCTIONS ------------- */

		instruction band	 		= { efGroup.arithmetic, 1 0111 };
		instruction bor	 			= { efGroup.arithmetic, 1 1000 };
		instruction bxor	 		= { efGroup.arithmetic, 1 1001 };


		/* ----------- INPUT/OUTPUT INSTRUCTIONS ---------- */

		encode efMode field = cases {
			in = 0,
			out = 1
		};

		instruction inp_deref			= { efGroup.input, 0, 0, 1, sequence esValTypeAndOfs };
		instruction inp_deref_char		= { efGroup.input, 0, 1, 1, 00, ofs16 as ofs};
		instruction inp_pop				= { efGroup.input, 0, 0, 0, sequence esValType };
		instruction inp_pop_char		= { efGroup.input, 0, 1, 0, 00 };
		instruction inp_stack 			= { efGroup.input, 1, 0, 0, sequence esValType  };
		instruction inp_stack_char 		= { efGroup.input, 1, 1, 000 };

		instruction out_deref			= { efGroup.output, 0, 0, 1, sequence esValTypeAndOfs };
		instruction out_deref_char		= { efGroup.output, 0, 1, 1, 00, ofs16 as ofs };
		instruction out_pop				= { efGroup.output, 0, 0, 0, sequence esValType };
		instruction out_pop_char		= { efGroup.output, 0, 1, 0, 00 };
		instruction out_stack 			= { efGroup.output, 1, 0, 0, sequence esValType };
		instruction out_stack_char 		= { efGroup.output, 1, 1, 000 };

		/* -------------- OTHER INSTRUCTIONS -------------- */

		instruction nop 			= { efGroup.system, 0 0000 };
		instruction brk				= { efGroup.system, 0 0001 };
		instruction stop 			= { efGroup.system, 0 0010, sequence numOr0 };
		instruction stop_ecstack 	= { efGroup.system, 0 0011 };



	
	mnemonics:

		/* --------- ARGUMENT FORMAT DEFINITIONS ---------- */

		format arg_plain is "{1}";
		format arg_dereference is "*{1}";
		format arg_pop is "*(pop)";

		format argValType 		of	() "b" 	when bt,
									() "w" 	when wt,
									() "d" 	when dt,
									() "q" 	when qt;

		format argPlainNumAndVal of (num) "b {1}" 	when bval,
									(num) "w {1}" 	when wval,
									(num) "d {1}" 	when dval,
									(num) "q {1}" 	when qval;

		format argDerefOfsAndVal of (ofs) "b *{1}"  when bval,
									(ofs) "w *{1}"  when wval,
									(ofs) "d *{1}"  when dval,
									(ofs) "q *{1}"  when qval;

		format argPopOfsAndVal of 	() "b *(pop)" 	when bt,
									() "w *(pop)" 	when wt,
									() "d *(pop)" 	when dt,
									() "q *(pop)" 	when qt;

		format argCountDef1		of 	() when default,
									(num) "{1}" when defined;


		/* ------------ FOR STACK INSTRUCTIONS ------------- */

		mnemonic push 		for push_plain 		(...) argPlainNumAndVal,
							for push_by_ofs		(...) argDerefOfsAndVal,
							for push_by_ofs_pop	(...) argPopOfsAndVal;

		mnemonic pop 		for pop_by_ofs 		(...) argDerefOfsAndVal,
							for pop_by_ofs_pop 	(...) argPopOfsAndVal,
							for pop_discard 	();

		mnemonic sav 		for sav_by_ofs 		(...) argDerefOfsAndVal,
							for sav_by_ofs_pop	(...) argPopOfsAndVal;
						
		mnemonic swp	();
		mnemonic dpl	(...) argCountDef1;

		/* --------- FOR FLOW CONTROL INSTRUCTIONS --------- */

		mnemonic jmp 	for jmp_plain (targetLabel) arg_plain,
						for jmp_deref (targetOfsVarPtr) arg_dereference,
						for jmp_pop () arg_pop;

		mnemonic jez 	for jmp_if_equal_plain (targetLabel) arg_plain 				when withZero,
						for jmp_if_equal_deref (targetOfsVarPtr) arg_dereference 	when withZero,
						for jmp_if_equal_pop () arg_pop 							when withZero;

		mnemonic je 	for jmp_if_equal_plain (targetLabel) arg_plain 				when twoOpds,
						for jmp_if_equal_deref (targetOfsVarPtr) arg_dereference 	when twoOpds,
						for jmp_if_equal_pop () arg_pop 							when twoOpds;

		mnemonic jl 	for jmp_if_plain (targetLabel) arg_plain 					when twoOpds and less,
						for jmp_if_deref (targetOfsVarPtr) arg_dereference 			when twoOpds and less,
						for jmp_if_pop () arg_pop 									when twoOpds and less;

		mnemonic jlz 	for jmp_if_plain (targetLabel) arg_plain 					when withZero and less,
						for jmp_if_deref (targetOfsVarPtr) arg_dereference 			when withZero and less,
						for jmp_if_pop () arg_pop 									when withZero and less;

		mnemonic jg 	for jmp_if_plain (targetLabel) arg_plain 					when twoOpds and greater,
						for jmp_if_deref (targetOfsVarPtr) arg_dereference 			when twoOpds and greater,
						for jmp_if_pop () arg_pop 									when twoOpds and greater;

		mnemonic jgz 	for jmp_if_plain (targetLabel) arg_plain 					when withZero and greater,
						for jmp_if_deref (targetOfsVarPtr) arg_dereference 			when withZero and greater,
						for jmp_if_pop () arg_pop 									when withZero and greater;

		mnemonic jle 	for jmp_if_plain (targetLabel) arg_plain 					when twoOpds and lessequal,
						for jmp_if_deref (targetOfsVarPtr) arg_dereference 			when twoOpds and lessequal,
						for jmp_if_pop () arg_pop 									when twoOpds and lessequal;

		mnemonic jlez 	for jmp_if_plain (targetLabel) arg_plain 					when withZero and lessequal,
						for jmp_if_deref (targetOfsVarPtr) arg_dereference 			when withZero and lessequal,
						for jmp_if_pop () arg_pop 									when withZero and lessequal;

		mnemonic jge 	for jmp_if_plain (targetLabel) arg_plain 					when twoOpds and greaterequal,
						for jmp_if_deref (targetOfsVarPtr) arg_dereference 			when twoOpds and greaterequal,
						for jmp_if_pop () arg_pop 									when twoOpds and greaterequal;

		mnemonic jgez 	for jmp_if_plain (targetLabel) arg_plain 					when withZero and greaterequal,
						for jmp_if_deref (targetOfsVarPtr) arg_dereference 			when withZero and greaterequal,
						for jmp_if_pop () arg_pop 									when withZero and greaterequal;

		mnemonic call 	(ofs) arg_plain when num_not_defined,
 						(ofs, num) "{1} {2}" when defined; // call with n args put onto subroutine's stack

		mnemonic ret 	() when default,
						(num) arg_plain when defined; // return with n top vals put onto caller's stack ("returned")


		/* ---------- FOR ARITHMETIC INSTRUCTIONS ---------- */

		mnemonic add();
		mnemonic sub();
		mnemonic inc();
		mnemonic dec();
		mnemonic mlt();
		mnemonic div();
		mnemonic mod();


		/* ----------- FOR BITWISE INSTRUCTIONS ----------- */

		mnemonic band();
		mnemonic bor();
		mnemonic bxor();


		/* --------- FOR INPUT/OUTPUT INSTRUCTIONS -------- */

		mnemonic inp 	for inp_deref (...) argDerefOfsAndVal,
						for inp_deref_char (ofs) "c *{1}",
						for inp_pop (...) argPopOfsAndVal,
						for inp_pop_char () "c *(pop)",
						for inp_stack (...) argValType,
						for inp_stack_char () "c";

		mnemonic out 	for out_deref (...) argDerefOfsAndVal,
						for out_deref_char (ofs) "c *{1}",
						for out_pop (...) argPopOfsAndVal,
						for out_pop_char () "c *(pop)",
						for out_stack (...) argValType,
						for out_stack_char () "c";


		/* ----------- FOR OTHER INSTRUCTIONS ------------- */

		mnemonic nop 	();
		mnemonic stop 	(num) arg_plain when defined,
						() when default,
						for stop_ecstack () "*(pop)";

        // cpy: copy value from constants to data

		mnemonic brk	();
}