← Back to branch summary

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

« back to all changes in this revision

Viewing changes to daemon/libs/pjproject-2.1.0/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.1.0/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