← Back to branch summary

~ubuntu-branches/ubuntu/wily/sflphone/wily

« back to all changes in this revision

Viewing changes to daemon/libs/pjproject-2.0.1/third_party/speex/libspeex/fixed_debug.h

  • Committer: Package Import Robot
  • Author(s): Mark Purcell
  • Date: 2014-01-28 18:23:36 UTC
  • mfrom: (1.1.11)
  • mto: This revision was merged to the branch mainline in revision 24.
  • Revision ID: package-import@ubuntu.com-20140128182336-3xenud1kbnwmf3mz
http://bugs.debian.org/735846
http://bugs.debian.org/727164
http://bugs.debian.org/718178
http://bugs.debian.org/736583
http://bugs.debian.org/722040
http://bugs.debian.org/736746
* New upstream release 
  - Fixes "New Upstream Release" (Closes: #735846)
  - Fixes "Ringtone does not stop" (Closes: #727164)
  - Fixes "[sflphone-kde] crash on startup" (Closes: #718178)
  - Fixes "sflphone GUI crashes when call is hung up" (Closes: #736583)
* Build-Depends: ensure GnuTLS 2.6
  - libucommon-dev (>= 6.0.7-1.1), libccrtp-dev (>= 2.0.6-3)
  - Fixes "FTBFS Build-Depends libgnutls{26,28}-dev" (Closes: #722040)
* Fix "boost 1.49 is going away" unversioned Build-Depends: (Closes: #736746)
* Add Build-Depends: libsndfile-dev, nepomuk-core-dev

Show diffs side-by-side

added added

removed removed

Lines of Context:
daemon/libs/pjproject-2.0.1/third_party/speex/libspeex/fixed_debug.h
1
 
/* Copyright (C) 2003 Jean-Marc Valin */
2
 
/**
3
 
   @file fixed_debug.h
4
 
   @brief Fixed-point operations with debugging
5
 
*/
6
 
/*
7
 
   Redistribution and use in source and binary forms, with or without
8
 
   modification, are permitted provided that the following conditions
9
 
   are met:
10
 
 
11
 
   - Redistributions of source code must retain the above copyright
12
 
   notice, this list of conditions and the following disclaimer.
13
 
 
14
 
   - Redistributions in binary form must reproduce the above copyright
15
 
   notice, this list of conditions and the following disclaimer in the
16
 
   documentation and/or other materials provided with the distribution.
17
 
 
18
 
   - Neither the name of the Xiph.org Foundation nor the names of its
19
 
   contributors may be used to endorse or promote products derived from
20
 
   this software without specific prior written permission.
21
 
 
22
 
   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
23
 
   ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
24
 
   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
25
 
   A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR
26
 
   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
27
 
   EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
28
 
   PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
29
 
   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
30
 
   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
31
 
   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
32
 
   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
33
 
*/
34
 
 
35
 
#ifndef FIXED_DEBUG_H
36
 
#define FIXED_DEBUG_H
37
 
 
38
 
#include <stdio.h>
39
 
 
40
 
extern long long spx_mips;
41
 
#define MIPS_INC spx_mips++,
42
 
 
43
 
#define QCONST16(x,bits) ((spx_word16_t)(.5+(x)*(((spx_word32_t)1)<<(bits))))
44
 
#define QCONST32(x,bits) ((spx_word32_t)(.5+(x)*(((spx_word32_t)1)<<(bits))))
45
 
 
46
 
 
47
 
#define VERIFY_SHORT(x) ((x)<=32767&&(x)>=-32768)
48
 
#define VERIFY_INT(x) ((x)<=2147483647LL&&(x)>=-2147483648LL)
49
 
 
50
 
static inline short NEG16(int x)
51
 
{
52
 
   int res;
53
 
   if (!VERIFY_SHORT(x))
54
 
   {
55
 
      fprintf (stderr, "NEG16: input is not short: %d\n", (int)x);
56
 
   }
57
 
   res = -x;
58
 
   if (!VERIFY_SHORT(res))
59
 
      fprintf (stderr, "NEG16: output is not short: %d\n", (int)res);
60
 
   spx_mips++;
61
 
   return res;
62
 
}
63
 
static inline int NEG32(long long x)
64
 
{
65
 
   long long res;
66
 
   if (!VERIFY_INT(x))
67
 
   {
68
 
      fprintf (stderr, "NEG16: input is not int: %d\n", (int)x);
69
 
   }
70
 
   res = -x;
71
 
   if (!VERIFY_INT(res))
72
 
      fprintf (stderr, "NEG16: output is not int: %d\n", (int)res);
73
 
   spx_mips++;
74
 
   return res;
75
 
}
76
 
 
77
 
#define EXTRACT16(x) _EXTRACT16(x, __FILE__, __LINE__)
78
 
static inline short _EXTRACT16(int x, char *file, int line)
79
 
{
80
 
   int res;
81
 
   if (!VERIFY_SHORT(x))
82
 
   {
83
 
      fprintf (stderr, "EXTRACT16: input is not short: %d in %s: line %d\n", x, file, line);
84
 
   }
85
 
   res = x;
86
 
   spx_mips++;
87
 
   return res;
88
 
}
89
 
 
90
 
#define EXTEND32(x) _EXTEND32(x, __FILE__, __LINE__)
91
 
static inline int _EXTEND32(int x, char *file, int line)
92
 
{
93
 
   int res;
94
 
   if (!VERIFY_SHORT(x))
95
 
   {
96
 
      fprintf (stderr, "EXTEND32: input is not short: %d in %s: line %d\n", x, file, line);
97
 
   }
98
 
   res = x;
99
 
   spx_mips++;
100
 
   return res;
101
 
}
102
 
 
103
 
#define SHR16(a, shift) _SHR16(a, shift, __FILE__, __LINE__)
104
 
static inline short _SHR16(int a, int shift, char *file, int line)
105
 
{
106
 
   int res;
107
 
   if (!VERIFY_SHORT(a) || !VERIFY_SHORT(shift))
108
 
   {
109
 
      fprintf (stderr, "SHR16: inputs are not short: %d >> %d in %s: line %d\n", a, shift, file, line);
110
 
   }
111
 
   res = a>>shift;
112
 
   if (!VERIFY_SHORT(res))
113
 
      fprintf (stderr, "SHR16: output is not short: %d in %s: line %d\n", res, file, line);
114
 
   spx_mips++;
115
 
   return res;
116
 
}
117
 
#define SHL16(a, shift) _SHL16(a, shift, __FILE__, __LINE__)
118
 
static inline short _SHL16(int a, int shift, char *file, int line)
119
 
{
120
 
   int res;
121
 
   if (!VERIFY_SHORT(a) || !VERIFY_SHORT(shift))
122
 
   {
123
 
      fprintf (stderr, "SHL16: inputs are not short: %d %d in %s: line %d\n", a, shift, file, line);
124
 
   }
125
 
   res = a<<shift;
126
 
   if (!VERIFY_SHORT(res))
127
 
      fprintf (stderr, "SHL16: output is not short: %d in %s: line %d\n", res, file, line);
128
 
   spx_mips++;
129
 
   return res;
130
 
}
131
 
 
132
 
static inline int SHR32(long long a, int shift)
133
 
{
134
 
   long long  res;
135
 
   if (!VERIFY_INT(a) || !VERIFY_SHORT(shift))
136
 
   {
137
 
      fprintf (stderr, "SHR32: inputs are not int: %d %d\n", (int)a, shift);
138
 
   }
139
 
   res = a>>shift;
140
 
   if (!VERIFY_INT(res))
141
 
   {
142
 
      fprintf (stderr, "SHR32: output is not int: %d\n", (int)res);
143
 
   }
144
 
   spx_mips++;
145
 
   return res;
146
 
}
147
 
static inline int SHL32(long long a, int shift)
148
 
{
149
 
   long long  res;
150
 
   if (!VERIFY_INT(a) || !VERIFY_SHORT(shift))
151
 
   {
152
 
      fprintf (stderr, "SHL32: inputs are not int: %d %d\n", (int)a, shift);
153
 
   }
154
 
   res = a<<shift;
155
 
   if (!VERIFY_INT(res))
156
 
   {
157
 
      fprintf (stderr, "SHL32: output is not int: %d\n", (int)res);
158
 
   }
159
 
   spx_mips++;
160
 
   return res;
161
 
}
162
 
 
163
 
#define PSHR16(a,shift) (SHR16(ADD16((a),((1<<((shift))>>1))),shift))
164
 
#define PSHR32(a,shift) (SHR32(ADD32((a),((EXTEND32(1)<<((shift))>>1))),shift))
165
 
#define VSHR32(a, shift) (((shift)>0) ? SHR32(a, shift) : SHL32(a, -(shift)))
166
 
 
167
 
#define SATURATE16(x,a) (((x)>(a) ? (a) : (x)<-(a) ? -(a) : (x)))
168
 
#define SATURATE32(x,a) (((x)>(a) ? (a) : (x)<-(a) ? -(a) : (x)))
169
 
 
170
 
//#define SHR(a,shift) ((a) >> (shift))
171
 
//#define SHL(a,shift) ((a) << (shift))
172
 
 
173
 
#define ADD16(a, b) _ADD16(a, b, __FILE__, __LINE__)
174
 
static inline short _ADD16(int a, int b, char *file, int line)
175
 
{
176
 
   int res;
177
 
   if (!VERIFY_SHORT(a) || !VERIFY_SHORT(b))
178
 
   {
179
 
      fprintf (stderr, "ADD16: inputs are not short: %d %d in %s: line %d\n", a, b, file, line);
180
 
   }
181
 
   res = a+b;
182
 
   if (!VERIFY_SHORT(res))
183
 
   {
184
 
      fprintf (stderr, "ADD16: output is not short: %d+%d=%d in %s: line %d\n", a,b,res, file, line);
185
 
   }
186
 
   spx_mips++;
187
 
   return res;
188
 
}
189
 
 
190
 
#define SUB16(a, b) _SUB16(a, b, __FILE__, __LINE__)
191
 
static inline short _SUB16(int a, int b, char *file, int line)
192
 
{
193
 
   int res;
194
 
   if (!VERIFY_SHORT(a) || !VERIFY_SHORT(b))
195
 
   {
196
 
      fprintf (stderr, "SUB16: inputs are not short: %d %d in %s: line %d\n", a, b, file, line);
197
 
   }
198
 
   res = a-b;
199
 
   if (!VERIFY_SHORT(res))
200
 
      fprintf (stderr, "SUB16: output is not short: %d in %s: line %d\n", res, file, line);
201
 
   spx_mips++;
202
 
   return res;
203
 
}
204
 
 
205
 
#define ADD32(a, b) _ADD32(a, b, __FILE__, __LINE__)
206
 
static inline int _ADD32(long long a, long long b, char *file, int line)
207
 
{
208
 
   long long res;
209
 
   if (!VERIFY_INT(a) || !VERIFY_INT(b))
210
 
   {
211
 
      fprintf (stderr, "ADD32: inputs are not int: %d %d in %s: line %d\n", (int)a, (int)b, file, line);
212
 
   }
213
 
   res = a+b;
214
 
   if (!VERIFY_INT(res))
215
 
   {
216
 
      fprintf (stderr, "ADD32: output is not int: %d in %s: line %d\n", (int)res, file, line);
217
 
   }
218
 
   spx_mips++;
219
 
   return res;
220
 
}
221
 
 
222
 
static inline int SUB32(long long a, long long b)
223
 
{
224
 
   long long res;
225
 
   if (!VERIFY_INT(a) || !VERIFY_INT(b))
226
 
   {
227
 
      fprintf (stderr, "SUB32: inputs are not int: %d %d\n", (int)a, (int)b);
228
 
   }
229
 
   res = a-b;
230
 
   if (!VERIFY_INT(res))
231
 
      fprintf (stderr, "SUB32: output is not int: %d\n", (int)res);
232
 
   spx_mips++;
233
 
   return res;
234
 
}
235
 
 
236
 
#define ADD64(a,b) (MIPS_INC(a)+(b))
237
 
 
238
 
/* result fits in 16 bits */
239
 
static inline short MULT16_16_16(int a, int b)
240
 
{
241
 
   int res;
242
 
   if (!VERIFY_SHORT(a) || !VERIFY_SHORT(b))
243
 
   {
244
 
      fprintf (stderr, "MULT16_16_16: inputs are not short: %d %d\n", a, b);
245
 
   }
246
 
   res = a*b;
247
 
   if (!VERIFY_SHORT(res))
248
 
      fprintf (stderr, "MULT16_16_16: output is not short: %d\n", res);
249
 
   spx_mips++;
250
 
   return res;
251
 
}
252
 
 
253
 
#define MULT16_16(a, b) _MULT16_16(a, b, __FILE__, __LINE__)
254
 
static inline int _MULT16_16(int a, int b, char *file, int line)
255
 
{
256
 
   long long res;
257
 
   if (!VERIFY_SHORT(a) || !VERIFY_SHORT(b))
258
 
   {
259
 
      fprintf (stderr, "MULT16_16: inputs are not short: %d %d in %s: line %d\n", a, b, file, line);
260
 
   }
261
 
   res = ((long long)a)*b;
262
 
   if (!VERIFY_INT(res))
263
 
      fprintf (stderr, "MULT16_16: output is not int: %d in %s: line %d\n", (int)res, file, line);
264
 
   spx_mips++;
265
 
   return res;
266
 
}
267
 
 
268
 
#define MAC16_16(c,a,b)     (spx_mips--,ADD32((c),MULT16_16((a),(b))))
269
 
#define MAC16_16_Q11(c,a,b)     (EXTRACT16(ADD16((c),EXTRACT16(SHR32(MULT16_16((a),(b)),11)))))
270
 
#define MAC16_16_Q13(c,a,b)     (EXTRACT16(ADD16((c),EXTRACT16(SHR32(MULT16_16((a),(b)),13)))))
271
 
#define MAC16_16_P13(c,a,b)     (EXTRACT16(ADD32((c),SHR32(ADD32(4096,MULT16_16((a),(b))),13))))
272
 
 
273
 
 
274
 
#define MULT16_32_QX(a, b, Q) _MULT16_32_QX(a, b, Q, __FILE__, __LINE__)
275
 
static inline int _MULT16_32_QX(int a, long long b, int Q, char *file, int line)
276
 
{
277
 
   long long res;
278
 
   if (!VERIFY_SHORT(a) || !VERIFY_INT(b))
279
 
   {
280
 
      fprintf (stderr, "MULT16_32_Q%d: inputs are not short+int: %d %d in %s: line %d\n", Q, (int)a, (int)b, file, line);
281
 
   }
282
 
   if (ABS32(b)>=(EXTEND32(1)<<(15+Q)))
283
 
      fprintf (stderr, "MULT16_32_Q%d: second operand too large: %d %d in %s: line %d\n", Q, (int)a, (int)b, file, line);
284
 
   res = (((long long)a)*(long long)b) >> Q;
285
 
   if (!VERIFY_INT(res))
286
 
      fprintf (stderr, "MULT16_32_Q%d: output is not int: %d*%d=%d in %s: line %d\n", Q, (int)a, (int)b,(int)res, file, line);
287
 
   spx_mips+=5;
288
 
   return res;
289
 
}
290
 
 
291
 
static inline int MULT16_32_PX(int a, long long b, int Q)
292
 
{
293
 
   long long res;
294
 
   if (!VERIFY_SHORT(a) || !VERIFY_INT(b))
295
 
   {
296
 
      fprintf (stderr, "MULT16_32_P%d: inputs are not short+int: %d %d\n", Q, (int)a, (int)b);
297
 
   }
298
 
   if (ABS32(b)>=(EXTEND32(1)<<(15+Q)))
299
 
      fprintf (stderr, "MULT16_32_Q%d: second operand too large: %d %d\n", Q, (int)a, (int)b);
300
 
   res = ((((long long)a)*(long long)b) + ((EXTEND32(1)<<Q)>>1))>> Q;
301
 
   if (!VERIFY_INT(res))
302
 
      fprintf (stderr, "MULT16_32_P%d: output is not int: %d*%d=%d\n", Q, (int)a, (int)b,(int)res);
303
 
   spx_mips+=5;
304
 
   return res;
305
 
}
306
 
 
307
 
 
308
 
#define MULT16_32_Q11(a,b) MULT16_32_QX(a,b,11)
309
 
#define MAC16_32_Q11(c,a,b) ADD32((c),MULT16_32_Q11((a),(b)))
310
 
#define MULT16_32_Q12(a,b) MULT16_32_QX(a,b,12)
311
 
#define MULT16_32_Q13(a,b) MULT16_32_QX(a,b,13)
312
 
#define MULT16_32_Q14(a,b) MULT16_32_QX(a,b,14)
313
 
#define MULT16_32_Q15(a,b) MULT16_32_QX(a,b,15)
314
 
#define MULT16_32_P15(a,b) MULT16_32_PX(a,b,15)
315
 
#define MAC16_32_Q15(c,a,b) ADD32((c),MULT16_32_Q15((a),(b)))
316
 
 
317
 
static inline int SATURATE(int a, int b)
318
 
{
319
 
   if (a>b)
320
 
      a=b;
321
 
   if (a<-b)
322
 
      a = -b;
323
 
   return a;
324
 
}
325
 
 
326
 
static inline int MULT16_16_Q11_32(int a, int b)
327
 
{
328
 
   long long res;
329
 
   if (!VERIFY_SHORT(a) || !VERIFY_SHORT(b))
330
 
   {
331
 
      fprintf (stderr, "MULT16_16_Q11: inputs are not short: %d %d\n", a, b);
332
 
   }
333
 
   res = ((long long)a)*b;
334
 
   res >>= 11;
335
 
   if (!VERIFY_INT(res))
336
 
      fprintf (stderr, "MULT16_16_Q11: output is not short: %d*%d=%d\n", (int)a, (int)b, (int)res);
337
 
   spx_mips+=3;
338
 
   return res;
339
 
}
340
 
static inline short MULT16_16_Q13(int a, int b)
341
 
{
342
 
   long long res;
343
 
   if (!VERIFY_SHORT(a) || !VERIFY_SHORT(b))
344
 
   {
345
 
      fprintf (stderr, "MULT16_16_Q13: inputs are not short: %d %d\n", a, b);
346
 
   }
347
 
   res = ((long long)a)*b;
348
 
   res >>= 13;
349
 
   if (!VERIFY_SHORT(res))
350
 
      fprintf (stderr, "MULT16_16_Q13: output is not short: %d*%d=%d\n", a, b, (int)res);
351
 
   spx_mips+=3;
352
 
   return res;
353
 
}
354
 
static inline short MULT16_16_Q14(int a, int b)
355
 
{
356
 
   long long res;
357
 
   if (!VERIFY_SHORT(a) || !VERIFY_SHORT(b))
358
 
   {
359
 
      fprintf (stderr, "MULT16_16_Q14: inputs are not short: %d %d\n", a, b);
360
 
   }
361
 
   res = ((long long)a)*b;
362
 
   res >>= 14;
363
 
   if (!VERIFY_SHORT(res))
364
 
      fprintf (stderr, "MULT16_16_Q14: output is not short: %d\n", (int)res);
365
 
   spx_mips+=3;
366
 
   return res;
367
 
}
368
 
static inline short MULT16_16_Q15(int a, int b)
369
 
{
370
 
   long long res;
371
 
   if (!VERIFY_SHORT(a) || !VERIFY_SHORT(b))
372
 
   {
373
 
      fprintf (stderr, "MULT16_16_Q15: inputs are not short: %d %d\n", a, b);
374
 
   }
375
 
   res = ((long long)a)*b;
376
 
   res >>= 15;
377
 
   if (!VERIFY_SHORT(res))
378
 
   {
379
 
      fprintf (stderr, "MULT16_16_Q15: output is not short: %d\n", (int)res);
380
 
   }
381
 
   spx_mips+=3;
382
 
   return res;
383
 
}
384
 
 
385
 
static inline short MULT16_16_P13(int a, int b)
386
 
{
387
 
   long long res;
388
 
   if (!VERIFY_SHORT(a) || !VERIFY_SHORT(b))
389
 
   {
390
 
      fprintf (stderr, "MULT16_16_P13: inputs are not short: %d %d\n", a, b);
391
 
   }
392
 
   res = ((long long)a)*b;
393
 
   res += 4096;
394
 
   if (!VERIFY_INT(res))
395
 
      fprintf (stderr, "MULT16_16_P13: overflow: %d*%d=%d\n", a, b, (int)res);
396
 
   res >>= 13;
397
 
   if (!VERIFY_SHORT(res))
398
 
      fprintf (stderr, "MULT16_16_P13: output is not short: %d*%d=%d\n", a, b, (int)res);
399
 
   spx_mips+=4;
400
 
   return res;
401
 
}
402
 
static inline short MULT16_16_P14(int a, int b)
403
 
{
404
 
   long long res;
405
 
   if (!VERIFY_SHORT(a) || !VERIFY_SHORT(b))
406
 
   {
407
 
      fprintf (stderr, "MULT16_16_P14: inputs are not short: %d %d\n", a, b);
408
 
   }
409
 
   res = ((long long)a)*b;
410
 
   res += 8192;
411
 
   if (!VERIFY_INT(res))
412
 
      fprintf (stderr, "MULT16_16_P14: overflow: %d*%d=%d\n", a, b, (int)res);
413
 
   res >>= 14;
414
 
   if (!VERIFY_SHORT(res))
415
 
      fprintf (stderr, "MULT16_16_P14: output is not short: %d*%d=%d\n", a, b, (int)res);
416
 
   spx_mips+=4;
417
 
   return res;
418
 
}
419
 
static inline short MULT16_16_P15(int a, int b)
420
 
{
421
 
   long long res;
422
 
   if (!VERIFY_SHORT(a) || !VERIFY_SHORT(b))
423
 
   {
424
 
      fprintf (stderr, "MULT16_16_P15: inputs are not short: %d %d\n", a, b);
425
 
   }
426
 
   res = ((long long)a)*b;
427
 
   res += 16384;
428
 
   if (!VERIFY_INT(res))
429
 
      fprintf (stderr, "MULT16_16_P15: overflow: %d*%d=%d\n", a, b, (int)res);
430
 
   res >>= 15;
431
 
   if (!VERIFY_SHORT(res))
432
 
      fprintf (stderr, "MULT16_16_P15: output is not short: %d*%d=%d\n", a, b, (int)res);
433
 
   spx_mips+=4;
434
 
   return res;
435
 
}
436
 
 
437
 
#define DIV32_16(a, b) _DIV32_16(a, b, __FILE__, __LINE__)
438
 
 
439
 
static inline int _DIV32_16(long long a, long long b, char *file, int line)
440
 
{
441
 
   long long res;
442
 
   if (b==0)
443
 
   {
444
 
      fprintf(stderr, "DIV32_16: divide by zero: %d/%d in %s: line %d\n", (int)a, (int)b, file, line);
445
 
      return 0;
446
 
   }
447
 
   if (!VERIFY_INT(a) || !VERIFY_SHORT(b))
448
 
   {
449
 
      fprintf (stderr, "DIV32_16: inputs are not int/short: %d %d in %s: line %d\n", (int)a, (int)b, file, line);
450
 
   }
451
 
   res = a/b;
452
 
   if (!VERIFY_SHORT(res))
453
 
   {
454
 
      fprintf (stderr, "DIV32_16: output is not short: %d / %d = %d in %s: line %d\n", (int)a,(int)b,(int)res, file, line);
455
 
      if (res>32767)
456
 
         res = 32767;
457
 
      if (res<-32768)
458
 
         res = -32768;
459
 
   }
460
 
   spx_mips+=20;
461
 
   return res;
462
 
}
463
 
 
464
 
#define DIV32(a, b) _DIV32(a, b, __FILE__, __LINE__)
465
 
static inline int _DIV32(long long a, long long b, char *file, int line)
466
 
{
467
 
   long long res;
468
 
   if (b==0)
469
 
   {
470
 
      fprintf(stderr, "DIV32: divide by zero: %d/%d in %s: line %d\n", (int)a, (int)b, file, line);
471
 
      return 0;
472
 
   }
473
 
 
474
 
   if (!VERIFY_INT(a) || !VERIFY_INT(b))
475
 
   {
476
 
      fprintf (stderr, "DIV32: inputs are not int/short: %d %d in %s: line %d\n", (int)a, (int)b, file, line);
477
 
   }
478
 
   res = a/b;
479
 
   if (!VERIFY_INT(res))
480
 
      fprintf (stderr, "DIV32: output is not int: %d in %s: line %d\n", (int)res, file, line);
481
 
   spx_mips+=36;
482
 
   return res;
483
 
}
484
 
#define PDIV32(a,b) DIV32(ADD32((a),(b)>>1),b)
485
 
#define PDIV32_16(a,b) DIV32_16(ADD32((a),(b)>>1),b)
486
 
 
487
 
#endif