[mirror_qemu.git] / target-arm / nwfpe / double_cpdo.c

/*
    NetWinder Floating Point Emulator
    (c) Rebel.COM, 1998,1999

    Direct questions, comments to Scott Bambrough <scottb@netwinder.org>

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

#include "fpa11.h"
#include "softfloat.h"
#include "fpopcode.h"

float64 float64_exp(float64 Fm);
float64 float64_ln(float64 Fm);
float64 float64_sin(float64 rFm);
float64 float64_cos(float64 rFm);
float64 float64_arcsin(float64 rFm);
float64 float64_arctan(float64 rFm);
float64 float64_log(float64 rFm);
float64 float64_tan(float64 rFm);
float64 float64_arccos(float64 rFm);
float64 float64_pow(float64 rFn,float64 rFm);
float64 float64_pol(float64 rFn,float64 rFm);

unsigned int DoubleCPDO(const unsigned int opcode)
{
   FPA11 *fpa11 = GET_FPA11();
   float64 rFm, rFn = 0;
   unsigned int Fd, Fm, Fn, nRc = 1;

   //printk("DoubleCPDO(0x%08x)\n",opcode);

   Fm = getFm(opcode);
   if (CONSTANT_FM(opcode))
   {
     rFm = getDoubleConstant(Fm);
   }
   else
   {
     switch (fpa11->fType[Fm])
     {
        case typeSingle:
          rFm = float32_to_float64(fpa11->fpreg[Fm].fSingle, &fpa11->fp_status);
        break;

        case typeDouble:
          rFm = fpa11->fpreg[Fm].fDouble;
          break;

        case typeExtended:
            // !! patb
	    //printk("not implemented! why not?\n");
            //!! ScottB
            // should never get here, if extended involved
            // then other operand should be promoted then
            // ExtendedCPDO called.
            break;

        default: return 0;
     }
   }

   if (!MONADIC_INSTRUCTION(opcode))
   {
      Fn = getFn(opcode);
      switch (fpa11->fType[Fn])
      {
        case typeSingle:
          rFn = float32_to_float64(fpa11->fpreg[Fn].fSingle, &fpa11->fp_status);
        break;

        case typeDouble:
          rFn = fpa11->fpreg[Fn].fDouble;
        break;

        default: return 0;
      }
   }

   Fd = getFd(opcode);
   /* !! this switch isn't optimized; better (opcode & MASK_ARITHMETIC_OPCODE)>>24, sort of */
   switch (opcode & MASK_ARITHMETIC_OPCODE)
   {
      /* dyadic opcodes */
      case ADF_CODE:
         fpa11->fpreg[Fd].fDouble = float64_add(rFn,rFm, &fpa11->fp_status);
      break;

      case MUF_CODE:
      case FML_CODE:
         fpa11->fpreg[Fd].fDouble = float64_mul(rFn,rFm, &fpa11->fp_status);
      break;

      case SUF_CODE:
         fpa11->fpreg[Fd].fDouble = float64_sub(rFn,rFm, &fpa11->fp_status);
      break;

      case RSF_CODE:
         fpa11->fpreg[Fd].fDouble = float64_sub(rFm,rFn, &fpa11->fp_status);
      break;

      case DVF_CODE:
      case FDV_CODE:
         fpa11->fpreg[Fd].fDouble = float64_div(rFn,rFm, &fpa11->fp_status);
      break;

      case RDF_CODE:
      case FRD_CODE:
         fpa11->fpreg[Fd].fDouble = float64_div(rFm,rFn, &fpa11->fp_status);
      break;

#if 0
      case POW_CODE:
         fpa11->fpreg[Fd].fDouble = float64_pow(rFn,rFm);
      break;

      case RPW_CODE:
         fpa11->fpreg[Fd].fDouble = float64_pow(rFm,rFn);
      break;
#endif

      case RMF_CODE:
         fpa11->fpreg[Fd].fDouble = float64_rem(rFn,rFm, &fpa11->fp_status);
      break;

#if 0
      case POL_CODE:
         fpa11->fpreg[Fd].fDouble = float64_pol(rFn,rFm);
      break;
#endif

      /* monadic opcodes */
      case MVF_CODE:
         fpa11->fpreg[Fd].fDouble = rFm;
      break;

      case MNF_CODE:
      {
         unsigned int *p = (unsigned int*)&rFm;
#ifdef WORDS_BIGENDIAN
         p[0] ^= 0x80000000;
#else
         p[1] ^= 0x80000000;
#endif
         fpa11->fpreg[Fd].fDouble = rFm;
      }
      break;

      case ABS_CODE:
      {
         unsigned int *p = (unsigned int*)&rFm;
#ifdef WORDS_BIGENDIAN
         p[0] &= 0x7fffffff;
#else
         p[1] &= 0x7fffffff;
#endif
         fpa11->fpreg[Fd].fDouble = rFm;
      }
      break;

      case RND_CODE:
      case URD_CODE:
         fpa11->fpreg[Fd].fDouble = float64_round_to_int(rFm, &fpa11->fp_status);
      break;

      case SQT_CODE:
         fpa11->fpreg[Fd].fDouble = float64_sqrt(rFm, &fpa11->fp_status);
      break;

#if 0
      case LOG_CODE:
         fpa11->fpreg[Fd].fDouble = float64_log(rFm);
      break;

      case LGN_CODE:
         fpa11->fpreg[Fd].fDouble = float64_ln(rFm);
      break;

      case EXP_CODE:
         fpa11->fpreg[Fd].fDouble = float64_exp(rFm);
      break;

      case SIN_CODE:
         fpa11->fpreg[Fd].fDouble = float64_sin(rFm);
      break;

      case COS_CODE:
         fpa11->fpreg[Fd].fDouble = float64_cos(rFm);
      break;

      case TAN_CODE:
         fpa11->fpreg[Fd].fDouble = float64_tan(rFm);
      break;

      case ASN_CODE:
         fpa11->fpreg[Fd].fDouble = float64_arcsin(rFm);
      break;

      case ACS_CODE:
         fpa11->fpreg[Fd].fDouble = float64_arccos(rFm);
      break;

      case ATN_CODE:
         fpa11->fpreg[Fd].fDouble = float64_arctan(rFm);
      break;
#endif

      case NRM_CODE:
      break;

      default:
      {
        nRc = 0;
      }
   }

   if (0 != nRc) fpa11->fType[Fd] = typeDouble;
   return nRc;
}

#if 0
float64 float64_exp(float64 rFm)
{
  return rFm;
//series
}

float64 float64_ln(float64 rFm)
{
  return rFm;
//series
}

float64 float64_sin(float64 rFm)
{
  return rFm;
//series
}

float64 float64_cos(float64 rFm)
{
   return rFm;
   //series
}

#if 0
float64 float64_arcsin(float64 rFm)
{
//series
}

float64 float64_arctan(float64 rFm)
{
  //series
}
#endif

float64 float64_log(float64 rFm)
{
  return float64_div(float64_ln(rFm),getDoubleConstant(7));
}

float64 float64_tan(float64 rFm)
{
  return float64_div(float64_sin(rFm),float64_cos(rFm));
}

float64 float64_arccos(float64 rFm)
{
return rFm;
   //return float64_sub(halfPi,float64_arcsin(rFm));
}

float64 float64_pow(float64 rFn,float64 rFm)
{
  return float64_exp(float64_mul(rFm,float64_ln(rFn)));
}

float64 float64_pol(float64 rFn,float64 rFm)
{
  return float64_arctan(float64_div(rFn,rFm));
}
#endif
Commit	Line	Data
00406dff FB	1	/*
	2	NetWinder Floating Point Emulator
	3	(c) Rebel.COM, 1998,1999
	4
	5	Direct questions, comments to Scott Bambrough <scottb@netwinder.org>
	6
	7	This program is free software; you can redistribute it and/or modify
	8	it under the terms of the GNU General Public License as published by
	9	the Free Software Foundation; either version 2 of the License, or
	10	(at your option) any later version.
	11
	12	This program is distributed in the hope that it will be useful,
	13	but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	GNU General Public License for more details.
	16
	17	You should have received a copy of the GNU General Public License
	18	along with this program; if not, write to the Free Software
	19	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
	20	*/
	21
	22	#include "fpa11.h"
	23	#include "softfloat.h"
	24	#include "fpopcode.h"
	25
	26	float64 float64_exp(float64 Fm);
	27	float64 float64_ln(float64 Fm);
	28	float64 float64_sin(float64 rFm);
	29	float64 float64_cos(float64 rFm);
	30	float64 float64_arcsin(float64 rFm);
	31	float64 float64_arctan(float64 rFm);
	32	float64 float64_log(float64 rFm);
	33	float64 float64_tan(float64 rFm);
	34	float64 float64_arccos(float64 rFm);
	35	float64 float64_pow(float64 rFn,float64 rFm);
	36	float64 float64_pol(float64 rFn,float64 rFm);
	37
	38	unsigned int DoubleCPDO(const unsigned int opcode)
	39	{
	40	FPA11 *fpa11 = GET_FPA11();
526ff7de	41	float64 rFm, rFn = 0;
00406dff FB	42	unsigned int Fd, Fm, Fn, nRc = 1;
	43
	44	//printk("DoubleCPDO(0x%08x)\n",opcode);
3b46e624	45
00406dff FB	46	Fm = getFm(opcode);
	47	if (CONSTANT_FM(opcode))
	48	{
	49	rFm = getDoubleConstant(Fm);
	50	}
	51	else
3b46e624	52	{
00406dff FB	53	switch (fpa11->fType[Fm])
	54	{
	55	case typeSingle:
20495218	56	rFm = float32_to_float64(fpa11->fpreg[Fm].fSingle, &fpa11->fp_status);
00406dff FB	57	break;
	58
	59	case typeDouble:
	60	rFm = fpa11->fpreg[Fm].fDouble;
	61	break;
	62
	63	case typeExtended:
	64	// !! patb
	65	//printk("not implemented! why not?\n");
	66	//!! ScottB
	67	// should never get here, if extended involved
	68	// then other operand should be promoted then
	69	// ExtendedCPDO called.
	70	break;
	71
	72	default: return 0;
	73	}
	74	}
	75
	76	if (!MONADIC_INSTRUCTION(opcode))
	77	{
	78	Fn = getFn(opcode);
	79	switch (fpa11->fType[Fn])
	80	{
	81	case typeSingle:
20495218	82	rFn = float32_to_float64(fpa11->fpreg[Fn].fSingle, &fpa11->fp_status);
00406dff FB	83	break;
	84
	85	case typeDouble:
	86	rFn = fpa11->fpreg[Fn].fDouble;
	87	break;
3b46e624	88
00406dff FB	89	default: return 0;
	90	}
	91	}
	92
	93	Fd = getFd(opcode);
	94	/* !! this switch isn't optimized; better (opcode & MASK_ARITHMETIC_OPCODE)>>24, sort of */
	95	switch (opcode & MASK_ARITHMETIC_OPCODE)
	96	{
	97	/* dyadic opcodes */
	98	case ADF_CODE:
20495218	99	fpa11->fpreg[Fd].fDouble = float64_add(rFn,rFm, &fpa11->fp_status);
00406dff FB	100	break;
	101
	102	case MUF_CODE:
	103	case FML_CODE:
20495218	104	fpa11->fpreg[Fd].fDouble = float64_mul(rFn,rFm, &fpa11->fp_status);
00406dff FB	105	break;
	106
	107	case SUF_CODE:
20495218	108	fpa11->fpreg[Fd].fDouble = float64_sub(rFn,rFm, &fpa11->fp_status);
00406dff FB	109	break;
	110
	111	case RSF_CODE:
20495218	112	fpa11->fpreg[Fd].fDouble = float64_sub(rFm,rFn, &fpa11->fp_status);
00406dff FB	113	break;
	114
	115	case DVF_CODE:
	116	case FDV_CODE:
20495218	117	fpa11->fpreg[Fd].fDouble = float64_div(rFn,rFm, &fpa11->fp_status);
00406dff FB	118	break;
	119
	120	case RDF_CODE:
	121	case FRD_CODE:
20495218	122	fpa11->fpreg[Fd].fDouble = float64_div(rFm,rFn, &fpa11->fp_status);
00406dff FB	123	break;
	124
	125	#if 0
	126	case POW_CODE:
	127	fpa11->fpreg[Fd].fDouble = float64_pow(rFn,rFm);
	128	break;
	129
	130	case RPW_CODE:
	131	fpa11->fpreg[Fd].fDouble = float64_pow(rFm,rFn);
	132	break;
	133	#endif
	134
	135	case RMF_CODE:
20495218	136	fpa11->fpreg[Fd].fDouble = float64_rem(rFn,rFm, &fpa11->fp_status);
00406dff FB	137	break;
	138
	139	#if 0
	140	case POL_CODE:
	141	fpa11->fpreg[Fd].fDouble = float64_pol(rFn,rFm);
	142	break;
	143	#endif
	144
	145	/* monadic opcodes */
	146	case MVF_CODE:
	147	fpa11->fpreg[Fd].fDouble = rFm;
	148	break;
	149
	150	case MNF_CODE:
	151	{
	152	unsigned int p = (unsigned int)&rFm;
a8d3431a FB	153	#ifdef WORDS_BIGENDIAN
	154	p[0] ^= 0x80000000;
	155	#else
00406dff	156	p[1] ^= 0x80000000;
a8d3431a	157	#endif
00406dff FB	158	fpa11->fpreg[Fd].fDouble = rFm;
	159	}
	160	break;
	161
	162	case ABS_CODE:
	163	{
	164	unsigned int p = (unsigned int)&rFm;
a8d3431a FB	165	#ifdef WORDS_BIGENDIAN
	166	p[0] &= 0x7fffffff;
	167	#else
00406dff	168	p[1] &= 0x7fffffff;
a8d3431a	169	#endif
00406dff FB	170	fpa11->fpreg[Fd].fDouble = rFm;
	171	}
	172	break;
	173
	174	case RND_CODE:
	175	case URD_CODE:
20495218	176	fpa11->fpreg[Fd].fDouble = float64_round_to_int(rFm, &fpa11->fp_status);
00406dff FB	177	break;
	178
	179	case SQT_CODE:
20495218	180	fpa11->fpreg[Fd].fDouble = float64_sqrt(rFm, &fpa11->fp_status);
00406dff FB	181	break;
	182
	183	#if 0
	184	case LOG_CODE:
	185	fpa11->fpreg[Fd].fDouble = float64_log(rFm);
	186	break;
	187
	188	case LGN_CODE:
	189	fpa11->fpreg[Fd].fDouble = float64_ln(rFm);
	190	break;
	191
	192	case EXP_CODE:
	193	fpa11->fpreg[Fd].fDouble = float64_exp(rFm);
	194	break;
	195
	196	case SIN_CODE:
	197	fpa11->fpreg[Fd].fDouble = float64_sin(rFm);
	198	break;
	199
	200	case COS_CODE:
	201	fpa11->fpreg[Fd].fDouble = float64_cos(rFm);
	202	break;
	203
	204	case TAN_CODE:
	205	fpa11->fpreg[Fd].fDouble = float64_tan(rFm);
	206	break;
	207
	208	case ASN_CODE:
	209	fpa11->fpreg[Fd].fDouble = float64_arcsin(rFm);
	210	break;
	211
	212	case ACS_CODE:
	213	fpa11->fpreg[Fd].fDouble = float64_arccos(rFm);
	214	break;
	215
	216	case ATN_CODE:
	217	fpa11->fpreg[Fd].fDouble = float64_arctan(rFm);
	218	break;
	219	#endif
	220
	221	case NRM_CODE:
	222	break;
3b46e624	223
00406dff FB	224	default:
	225	{
	226	nRc = 0;
	227	}
	228	}
	229
	230	if (0 != nRc) fpa11->fType[Fd] = typeDouble;
	231	return nRc;
	232	}
	233
	234	#if 0
	235	float64 float64_exp(float64 rFm)
	236	{
	237	return rFm;
	238	//series
	239	}
	240
	241	float64 float64_ln(float64 rFm)
	242	{
	243	return rFm;
	244	//series
	245	}
	246
	247	float64 float64_sin(float64 rFm)
	248	{
	249	return rFm;
	250	//series
	251	}
	252
	253	float64 float64_cos(float64 rFm)
	254	{
	255	return rFm;
	256	//series
	257	}
	258
	259	#if 0
	260	float64 float64_arcsin(float64 rFm)
	261	{
	262	//series
	263	}
	264
	265	float64 float64_arctan(float64 rFm)
	266	{
	267	//series
	268	}
	269	#endif
	270
	271	float64 float64_log(float64 rFm)
	272	{
	273	return float64_div(float64_ln(rFm),getDoubleConstant(7));
	274	}
	275
	276	float64 float64_tan(float64 rFm)
	277	{
	278	return float64_div(float64_sin(rFm),float64_cos(rFm));
	279	}
	280
	281	float64 float64_arccos(float64 rFm)
	282	{
	283	return rFm;
	284	//return float64_sub(halfPi,float64_arcsin(rFm));
	285	}
	286
	287	float64 float64_pow(float64 rFn,float64 rFm)
288	{
5fafdf24	289	return float64_exp(float64_mul(rFm,float64_ln(rFn)));
00406dff FB	290	}
	291
	292	float64 float64_pol(float64 rFn,float64 rFm)
	293	{
5fafdf24	294	return float64_arctan(float64_div(rFn,rFm));
00406dff FB	295	}
00406dff FB	296	#endif