← Back to branch summary

~jderose/ubuntu/raring/qemu/vde-again

« back to all changes in this revision

Viewing changes to target-arm/nwfpe/extended_cpdo.c

  • Committer: Bazaar Package Importer
  • Author(s): Aurelien Jarno, Aurelien Jarno
  • Date: 2008-08-25 04:38:35 UTC
  • mfrom: (1.1.8 upstream)
  • Revision ID: james.westby@ubuntu.com-20080825043835-8e3tftavy8bujdch
Tags: 0.9.1-6
http://bugs.debian.org/488339
[ Aurelien Jarno ]
* debian/control: 
  - Update list of supported targets (Closes: bug#488339).
* debian/qemu-make-debian-root:
  - Use mktemp instead of $$ to create temporary directories (Closes: 
    bug#496394).
* debian/links:
  - Add missing links to manpages.

Show diffs side-by-side

added added

removed removed

Lines of Context:
target-arm/nwfpe/extended_cpdo.c
42
42
   unsigned int Fd, Fm, Fn, nRc = 1;
43
43
 
44
44
   //printk("ExtendedCPDO(0x%08x)\n",opcode);
45
 
   
 
45
 
46
46
   Fm = getFm(opcode);
47
47
   if (CONSTANT_FM(opcode))
48
48
   {
49
49
     rFm = getExtendedConstant(Fm);
50
50
   }
51
51
   else
52
 
   {  
 
52
   {
53
53
     switch (fpa11->fType[Fm])
54
54
     {
55
55
        case typeSingle:
56
 
          rFm = float32_to_floatx80(fpa11->fpreg[Fm].fSingle);
 
56
          rFm = float32_to_floatx80(fpa11->fpreg[Fm].fSingle, &fpa11->fp_status);
57
57
        break;
58
58
 
59
59
        case typeDouble:
60
 
          rFm = float64_to_floatx80(fpa11->fpreg[Fm].fDouble);
 
60
          rFm = float64_to_floatx80(fpa11->fpreg[Fm].fDouble, &fpa11->fp_status);
61
61
        break;
62
 
        
 
62
 
63
63
        case typeExtended:
64
64
          rFm = fpa11->fpreg[Fm].fExtended;
65
65
        break;
66
 
        
 
66
 
67
67
        default: return 0;
68
68
     }
69
69
   }
70
 
   
 
70
 
71
71
   if (!MONADIC_INSTRUCTION(opcode))
72
72
   {
73
73
      Fn = getFn(opcode);
74
74
      switch (fpa11->fType[Fn])
75
75
      {
76
76
        case typeSingle:
77
 
          rFn = float32_to_floatx80(fpa11->fpreg[Fn].fSingle);
 
77
          rFn = float32_to_floatx80(fpa11->fpreg[Fn].fSingle, &fpa11->fp_status);
78
78
        break;
79
79
 
80
80
        case typeDouble:
81
 
          rFn = float64_to_floatx80(fpa11->fpreg[Fn].fDouble);
 
81
          rFn = float64_to_floatx80(fpa11->fpreg[Fn].fDouble, &fpa11->fp_status);
82
82
        break;
83
 
        
 
83
 
84
84
        case typeExtended:
85
85
          rFn = fpa11->fpreg[Fn].fExtended;
86
86
        break;
87
 
        
 
87
 
88
88
        default: return 0;
89
89
      }
90
90
   }
94
94
   {
95
95
      /* dyadic opcodes */
96
96
      case ADF_CODE:
97
 
         fpa11->fpreg[Fd].fExtended = floatx80_add(rFn,rFm);
 
97
         fpa11->fpreg[Fd].fExtended = floatx80_add(rFn,rFm, &fpa11->fp_status);
98
98
      break;
99
99
 
100
100
      case MUF_CODE:
101
101
      case FML_CODE:
102
 
         fpa11->fpreg[Fd].fExtended = floatx80_mul(rFn,rFm);
 
102
         fpa11->fpreg[Fd].fExtended = floatx80_mul(rFn,rFm, &fpa11->fp_status);
103
103
      break;
104
104
 
105
105
      case SUF_CODE:
106
 
         fpa11->fpreg[Fd].fExtended = floatx80_sub(rFn,rFm);
 
106
         fpa11->fpreg[Fd].fExtended = floatx80_sub(rFn,rFm, &fpa11->fp_status);
107
107
      break;
108
108
 
109
109
      case RSF_CODE:
110
 
         fpa11->fpreg[Fd].fExtended = floatx80_sub(rFm,rFn);
 
110
         fpa11->fpreg[Fd].fExtended = floatx80_sub(rFm,rFn, &fpa11->fp_status);
111
111
      break;
112
112
 
113
113
      case DVF_CODE:
114
114
      case FDV_CODE:
115
 
         fpa11->fpreg[Fd].fExtended = floatx80_div(rFn,rFm);
 
115
         fpa11->fpreg[Fd].fExtended = floatx80_div(rFn,rFm, &fpa11->fp_status);
116
116
      break;
117
117
 
118
118
      case RDF_CODE:
119
119
      case FRD_CODE:
120
 
         fpa11->fpreg[Fd].fExtended = floatx80_div(rFm,rFn);
 
120
         fpa11->fpreg[Fd].fExtended = floatx80_div(rFm,rFn, &fpa11->fp_status);
121
121
      break;
122
122
 
123
123
#if 0
131
131
#endif
132
132
 
133
133
      case RMF_CODE:
134
 
         fpa11->fpreg[Fd].fExtended = floatx80_rem(rFn,rFm);
 
134
         fpa11->fpreg[Fd].fExtended = floatx80_rem(rFn,rFm, &fpa11->fp_status);
135
135
      break;
136
136
 
137
137
#if 0
157
157
 
158
158
      case RND_CODE:
159
159
      case URD_CODE:
160
 
         fpa11->fpreg[Fd].fExtended = floatx80_round_to_int(rFm);
 
160
         fpa11->fpreg[Fd].fExtended = floatx80_round_to_int(rFm, &fpa11->fp_status);
161
161
      break;
162
162
 
163
163
      case SQT_CODE:
164
 
         fpa11->fpreg[Fd].fExtended = floatx80_sqrt(rFm);
 
164
         fpa11->fpreg[Fd].fExtended = floatx80_sqrt(rFm, &fpa11->fp_status);
165
165
      break;
166
166
 
167
167
#if 0
204
204
 
205
205
      case NRM_CODE:
206
206
      break;
207
 
      
 
207
 
208
208
      default:
209
209
      {
210
210
        nRc = 0;
211
211
      }
212
212
   }
213
 
   
 
213
 
214
214
   if (0 != nRc) fpa11->fType[Fd] = typeExtended;
215
215
   return nRc;
216
216
}
263
263
 
264
264
floatx80 floatx80_pow(floatx80 rFn,floatx80 rFm)
265
265
{
266
 
  return floatx80_exp(floatx80_mul(rFm,floatx80_ln(rFn))); 
 
266
  return floatx80_exp(floatx80_mul(rFm,floatx80_ln(rFn)));
267
267
}
268
268
 
269
269
floatx80 floatx80_pol(floatx80 rFn,floatx80 rFm)
270
270
{
271
 
  return floatx80_arctan(floatx80_div(rFn,rFm)); 
 
271
  return floatx80_arctan(floatx80_div(rFn,rFm));
272
272
}
273
273
#endif