{File name: <>Klamath>SModeledRUM>FloatingPoint.dfn
  created : T.Tokuanga  21-Mar-85 13:38:53
 last edited:  T.Tokunaga  5-Apr-85 20:04:12 correct spelling mistake.
 last edited: T.Tokunaga   1-Apr-85 16:44:42	change the defs. of u-reg,
 last edited: T.Tokunaga   1-Apr-85 14:45:35 add the defs of U-reg for saving the R-register during float divide primitive
 last edited: T.Tokunaga 26-Mar-85 18:39:16  change the defs of R-reg,
  
}
	
	RegDef[floatT,		R,	2];  { temporary for float dividing }
	RegDef[floatTemp,	R,	3];
	RegDef[divCount,	R,	3];  { temporary for float dividing  }
	RegDef[divResult,	R,	4];  { temporary for float dividing  }
	RegDef[divisorHigh,	R,	5];  { temporary for float dividing  }
	RegDef[divisorLow,	R,	6];  { temporary for float dividing  }


	RegDef[uArg1Hi		,U,	14];	{ used in divide or compare }
	RegDef[uArg1Lo		,U,   	17];	{ used in devide or compare }
	
	RegDef[uHighHalf1	,U,	19];	{ divide }
	RegDef[uExp1		,U,	1A];	{ divide }
	RegDef[uLowHalf1	,U,	1B];	{ divide }
	RegDef[uExp2		,U,	1C];	{ divide }
	RegDef[uHighHalf2	,U,	1D];	{ divide }
	RegDef[uLowHalf2	,U,	1E];	{ divide }

	RegDef[uStickyReg	,U, 	24];	{ divide }

	RegDef[uStickyBit	,U,	31];	{ divide }
	RegDef[uSign1 		,U, 	34];	{ divide }
	RegDef[uSign2		,U,	35];	{ divide }
	RegDef[uFloatComResult	,U,  	37];	{ }
	RegDef[uPPsave,		U,	3C];

	RegDef[uFloat		,U, 	42];	{ AsFloat }
	RegDef[uSaveIPLow	,U,	43];	{ to save the ipLow during float divide primitive}
	RegDef[uFloatPlus	,U,	44];	{ Float Add }
	RegDef[uSaveStackLow	,U,	44];	{ to save the stacklow during float divide primitive}
	
	RegDef[uNewValHi,	U, 	4B];	{ Result of the floating point operatio nis stored -- High half }
	RegDef[uNewValLo,	U,	4C];	{ Result of the floating point operation is stored -- Low half }

	RegDef[uFloatMinus	,U,	55];	{ Float Subtract : A-B}
	RegDef[uSaveHomeLow	,U,	55];	{ to save the homeLow during float divide primitive}
	RegDef[uFloatMode	,U, 	58];	{ }
	RegDef[uArg2Hi		,U, 	5C];	{ }
	RegDef[uArg2Lo		,U,	5D];	{ }

	RegDef[uFloatMultiply	,U, 	60]; 	{ Multiply}
	RegDef[uFloatFix	,U,	63];	{ }



{ floating point constant      =Float=}
	Set[unaryMessage, 0];
	Set[binaryMessage, 1];
	
	Set[asFloat, 0];
	Set[floatAdd, 0];
	Set[floatTruncated, 1];
	Set[floatSub, 1];
	Set[floatFractional, 2];
	Set[floatLessThan, 2];
	Set[floatExponent, 3];
	Set[floatGreaterThan, 3];
	Set[RN.PI.IEEE, 4];
	Set[floatTwoTimes, 4];
	Set[floatLessOrEqual, 4];
	Set[floatGreaterOrEqual, 5];
	Set[floatEqual, 6];
	Set[floatNotEqual, 7];
	Set[floatMultiply, 8];
	Set[floatDivide, 9];
	
	Set[classFloatPointer,  14];	{ Oop for Class of the floating point,	=Float=}
{ for fptDivideLoop }
	Set[L3.divide1,  0]; {float divide }
	Set[L3.divide2,  1]; {float divide }

{ for deNorm }
	Set[L3.rePack1,  0]; {float divide }
	
{ for checkFloatType  ----}	
	Set[L1.checkResultType, 0];	{float compare}
	Set[L1.checkInfinity, 1];	{float Compare}
	Set[L1.checkInfinity1, 2];	{float Compare}
	Set[L1.checkReceiver,  3];	{float Divide}
	Set[L1.checkArgument,  4];	{float Divide}
	
{ for floatCompare subroutine }
	Set[L2.floatLessThan, 0];
	Set[L2.floatGreaterThan, 1];
	Set[L2.floatLessOrEqual, 2];
	Set[L2.floatGreaterOrEqual, 3];
	Set[L2.floatEqual, 4];
	Set[L2.floatNotEqual, 5];
	

	
	Set[floatZero, 0];	{ for floarcomapre,=Float=}
	Set[floatNormal, 1];	{ for floatcompare, =Float=}
	Set[floatInfinity, 2];	{ for floatcompare, =Float=}
	Set[floatNan, 3],	{ for floatcompare, =Float=}