:Title[linst.mc, December 6, 1982  1:43 PM, Masinter];

* variable opcodes, including free variable lookup

   knowrbase[LTEMP0];
   TOP LEVEL;
   InsSet[LispInsSet, 1];
*--------------------------------------------------------------------
opIVAR:
*--------------------------------------------------------------------
   T_ (ifetch_ IVAR) + 1;
   T_ Md, ifetch_ T, branch[PUSHTMD];

regOP1[100, StackBR, opIVAR, 0];		* IVAR
regOP1[101, StackBR, opIVAR, 2];
regOP1[102, StackBR, opIVAR, 4];
regOP1[103, StackBR, opIVAR, 6];
regOP1[104, StackBR, opIVAR, 10];
regOP1[105, StackBR, opIVAR, 12];
regOP1[106, StackBR, opIVAR, 14];
regOP2[107, StackBR, opIVAR, noNData];	* PVARX

*--------------------------------------------------------------------
opPVAR:
*--------------------------------------------------------------------
   T_ (ifetch_ PVAR) + 1;
   T_ Md, ifetch_ T, branch[PUSHTMD];

regOP1[110, StackBR, opPVAR, 0];		* PVAR
regOP1[111, StackBR, opPVAR, 2];
regOP1[112, StackBR, opPVAR, 4];
regOP1[113, StackBR, opPVAR, 6];
regOP1[114, StackBR, opPVAR, 10];
regOP1[115, StackBR, opPVAR, 12];
regOP1[116, StackBR, opPVAR, 14];
regOP2[117, StackBR, opPVAR, noNData];	* PVARX

*--------------------------------------------------------------------
opFVAR:
*--------------------------------------------------------------------
   T_ (ifetch_ PVAR) + 1;
   LTEMP0_ Md, ifetch_ T;
.retryfvar:
   memBase_ ScratchLZBR, branch[.+2, R even], T_ Md, LTEMP0;
	T_ Id, branch[.FVFAIL];

* KLUDGE: LH IS DUPLICATED!!!!
   T_ T and (rhmask);
   BRHi_ T;

	PAGEFAULTOK;

   LTEMP0_ (FETCH_ LTEMP0) + 1;
   T_ MD, fetch_ LTEMP0, branch[PUSHTMD];	* can fault

.FVFAIL:		* T = offset of free variable, fill in and continue
   LTEMP0_ T, call[FVLOOKUP];	* T passed and smashed by FVLOOKUP
   T_ LTEMP0;
   T_ T + (PVAR);
   T_ (fetch_ T) + 1;
   LTEMP0_ Md, fetch_ T, branch[.retryfvar];

regOP1[120, StackBR, opFVAR, 0];		* FVAR
regOP1[121, StackBR, opFVAR, 2];
regOP1[122, StackBR, opFVAR, 4];
regOP1[123, StackBR, opFVAR, 6];
regOP1[124, StackBR, opFVAR, 10];
regOP1[125, StackBR, opFVAR, 12];
regOP1[126, StackBR, opFVAR, 14];

regOP2[127, StackBR, opFVAR, noNData];		* FVARX
*--------------------------------------------------------------------
opGVAR:	* alpha + beta form atom number of global to fetch
*--------------------------------------------------------------------
   T_ Id;				* hi bits
   T_ LSH[T,10];			* shift left
   LTEMP0_ ((Id) + T) lsh 1;

	PAGEFAULTOK;

   LTEMP0_ (FETCH_ LTEMP0) + 1;
   T_ MD, fetch_ LTEMP0, branch[PUSHTMD];

regOP3[140, ValSpaceBR, opGVAR, noNData];
*--------------------------------------------------------------------
opSETPVAR:
*--------------------------------------------------------------------
   T_ (fetch_ TSP) - 1, flipMemBase;
   T_ Md, fetch_ T;
   LTEMP0_ (Id) + (PVAR), branch[TL.ST0TMD];

regOP1[130, StackM2BR, opSETPVAR, 0];		* PVAR_
regOP1[131, StackM2BR, opSETPVAR, 2];
regOP1[132, StackM2BR, opSETPVAR, 4];
regOP1[133, StackM2BR, opSETPVAR, 6];
regOP1[134, StackM2BR, opSETPVAR, 10];
regOP1[135, StackM2BR, opSETPVAR, 12];
regOP1[136, StackM2BR, opSETPVAR, 14];

regOP2[137, StackM2BR, opSETPVAR, noNData];	* PVARX_

*--------------------------------------------------------------------
opSETPVARPOP:
*--------------------------------------------------------------------
   T_ (fetch_ TSP) - 1, flipMemBase;	* fetch TSP-2
   T_ Md, TSP_ (fetch_ T) - 1;		* fetch TSP-1, TSP_ TSP-2
   LTEMP0_ (Id) + (PVAR);
   LEFT_ (LEFT) + 1, BRANCH[TL.ST0TMD];

regOP1[270, StackM2BR, opSETPVARPOP, 0];
regOP1[271, StackM2BR, opSETPVARPOP, 2];
regOP1[272, StackM2BR, opSETPVARPOP, 4];
regOP1[273, StackM2BR, opSETPVARPOP, 6];
regOP1[274, StackM2BR, opSETPVARPOP, 10];
regOP1[275, StackM2BR, opSETPVARPOP, 12];
regOP1[276, StackM2BR, opSETPVARPOP, 14];

*--------------------------------------------------------------------
opSETIVAR:
*--------------------------------------------------------------------
   T_ (fetch_ TSP) - 1, flipMemBase;
   T_ Md, fetch_ T;
   LTEMP0_ (Id) + (IVAR), branch[TL.ST0TMD];

regOP2[142, StackM2BR, opSETIVAR, noNData];	* IVARX_


*--------------------------------------------------------------------
opFVARgets: 
*--------------------------------------------------------------------
   T_ (ifetch_ PVAR) + 1;
   LTEMP0_ Md, ifetch_ T;

.retrysetfvar:
   branch[.+2, R even], T_ Md, LTEMP0, memBase_ StackM2BR;
	T_ Id, branch[.setffail];


*   KLUDGE	*	*	* TOP BYTE IS FILLED IN TOO

   T_ T and (rhmask);
   pd_ T xor (StackHi);
   branch[.setfglobal, alu#0], TSP_ (fetch_ TSP) - 1, flipMemBase;
   T_ Md, TSP_ (fetch_ TSP) + 1, branch[TL.ST0TMD];

:if[Reduced];
.setfglobal:
   TSP_ (TSP) + 1, memBase_ StackBR, call[SUB.PUSHT];
   T_ LTEMP0, call[SUB.PUSHT];
   DEFLO_ AT.SETFVAR;
   NARGS _ 2c, branch[DOCALLPUNT];

:else;
.setfglobal:
   TSP_ (TSP) + 1, memBase_ LScratchBR, branch[.setglobal];
:endif;
   
.setffail:
   LTEMP0_ T, call[FVLOOKUP];
   T_ LTEMP0;
   T_ T + (PVAR);
   T_ (fetch_ T) + 1;
   LTEMP0_ Md, fetch_ T, branch[.retrysetfvar];

regOP2[143, StackBR, opFVARgets, noNData];

*--------------------------------------------------------------------
*   GVAR_	 alpha + beta form atom number of global to store TOS
*--------------------------------------------------------------------

:if[Reduced];
	UfnOps[27];
:else;

opGVARgets:
   LTEMP0_ Id, memBase_ LScratchBR;
   LTEMP0_ LSH[LTEMP0, 10];
   LTEMP0_ ((Id) + (LTEMP0)) lsh 1;
   T_ VALspace;

.setglobal:
   BrLo_ LTEMP0;
   BrHi_ T;

	PAGEFAULTOK;

   T_ (FETCH_ 0s) + 1;
   Case_ 1c, call[GCLOOKUP];	* deleteref old pointer

   memBase_ StackM2BR, branch[RPLPTRTAIL];

regOP3[27, ifuBR, opGVARgets, noNData];
:endif;


*--------------------------------------------------------------------
opNIL:
*--------------------------------------------------------------------
   branch[.+2, R>=0], LEFT_ (LEFT) - 1, memBase_ StackBR;
	  StackCheck;
   TSP_ (store_ TSP) + 1, dbuf_ 0c, branch[TL.PUSHNIL];

regOP1[150, StackBR, opNIL, noNData];

*--------------------------------------------------------------------
opKT:
*--------------------------------------------------------------------
   branch[.+2, R>=0], LEFT_ (LEFT) - 1, memBase_ StackBR;
		StackCheck;
   TSP_ (store_ TSP) + 1, dbuf_ 0c, branch[TL.PUSHTRUE];

regOP1[151, StackBR, opKT, noNData];

*--------------------------------------------------------------------
op01SIC:
*--------------------------------------------------------------------
   branch[.+2, R>=0], LEFT_ (LEFT) - 1, memBase_ StackBR;
		StackCheck;
   TSP_ (store_ TSP) + 1, dbuf_ SmallHi;
   TSP_ (store_ TSP) + 1, dbuf_ T, TisID, NextOpCode;

regOP1[152, StackBR, op01SIC, 0];		* '0
regOP1[153, StackBR, op01SIC, 1];		* '1
regOP2[154, StackBR, op01SIC, noNData];	* SIC

*--------------------------------------------------------------------
opSNIC:
*--------------------------------------------------------------------
   T_ (Id) - (400c);
   branch[.+2, R>=0], LEFT_ (LEFT) - 1, memBase_ StackBR;
		StackCheck;
   TSP_ (store_ TSP) + 1, dbuf_ SmallNegHi, branch[TL.PUSHT];

regOP2[155, StackBR, opSNIC, noNData];		* SNIC

*--------------------------------------------------------------------
opSICX:
*--------------------------------------------------------------------
   T_ Id;
   T_ LSH[T,10];
   T_ Id or T, branch[PUSHSMALLT];

regOP3[156, StackBR, opSICX, noNData];		* SICX
regOP3[160, StackBR, opSICX, noNData];		* ATOMNUMBER
*--------------------------------------------------------------------
opACONST: 
*--------------------------------------------------------------------
   T_ Id;
   T_ LSH[T,10];
   T_ (Id) + (T);
   branch[.+2, R>=0], LEFT_ (LEFT) - 1, memBase_ StackBR;
		StackCheck;
   TSP_ (store_ TSP) + 1, dbuf_ 0c, branch[TL.PUSHT];

regOP3[147, StackBR, opACONST, noNData];

*--------------------------------------------------------------------
opGCONST:
*--------------------------------------------------------------------
* push 24 bit inline constant
* coded as a one byte jump opcode which jumps to .+4

   LTEMP0_ not (PCX');	* current pc
   LTEMP0_ (LTEMP0) + 1;* byte# of hi byte
   T_ (LTEMP0) rsh 1;	* word# of hi byte

	PAGEFAULTOK;

   T_ (FETCH_ T) + 1;			* fetch it & next word
   branch[.GConstOdd, R even], LTEMP0, T_ MD, FETCH_ T;

.GConstEven:
   T_ T and (rhmask), branch[PUSHTMD];

.GConstOdd:	* rh T,,lh Md has low word, lh T has hi word.
   LTEMP0_ MD;

	PAGEFAULTNOTOK;

   LTEMP0_ rcy[T, LTEMP0, 10];
   T_ rsh[T, 10], branch[PUSHT0];

IFUjmp[157, 1, ifuBR, 0, opGCONST, 4];

*--------------------------------------------------------------------
opCOPY:
*--------------------------------------------------------------------
   T_ (fetch_ TSP) - 1, flipMemBase;
   T_ Md, fetch_ T, branch[PUSHTMD];

regOP1[144, StackM2BR, opCOPY, noNData];
(1792)\375f8 7f0 496f8 7f0 738f8 7f0 897f8 7f0 5748f8 7f0 414f8 7f0