OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [gcc/] [testsuite/] [gcc.target/] [arm/] [eabi1.c] - Blame information for rev 691

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 691 jeremybenn
/* { dg-do run { target arm*-*-symbianelf* arm*-*-eabi* } } */
2
/* { dg-options "" } */
3
 
4
/* This file tests most of the non-C++ run-time helper functions
5
   described in Section 4 of the "Run-Time ABI for the ARM
6
   Architecture".  These are basic tests; they do not try to validate
7
   all of the corner cases in these routines.
8
 
9
   The functions not tested here are:
10
 
11
     __aeabi_cdcmpeq
12
     __aeabi_cdcmple
13
     __aeabi_cdrcmple
14
     __aeabi_cfcmpeq
15
     __aeabi_cfcmple
16
     __aeabi_cfrcmple
17
     __aeabi_ldivmod
18
     __aeabi_uldivmod
19
     __aeabi_idivmod
20
     __aeabi_uidivmod
21
 
22
   These functions have non-standard calling conventions that would
23
   require the use of inline assembly to test.  It would be good to
24
   add such tests, but they have not yet been implemented.
25
 
26
   There are also no tests for the "division by zero", "memory copying,
27
   clearing, and setting" functions.  */
28
 
29
#include <stdio.h>
30
#include <stdlib.h>
31
#include <math.h>
32
 
33
/* All these functions are defined to use the base ABI, so use the
34
   attribute to ensure the tests use the base ABI to call them even
35
   when the VFP ABI is otherwise in effect.  */
36
#define PCS __attribute__((pcs("aapcs")))
37
 
38
#define decl_float(code, type)                                          \
39
  extern type __aeabi_ ## code ## add (type, type) PCS;                 \
40
  extern type __aeabi_ ## code ## div (type, type) PCS;                 \
41
  extern type __aeabi_ ## code ## mul (type, type) PCS;                 \
42
  extern type __aeabi_ ## code ## neg (type) PCS;                       \
43
  extern type __aeabi_ ## code ## rsub (type, type) PCS;                \
44
  extern type __aeabi_ ## code ## sub (type, type) PCS;                 \
45
  extern int __aeabi_ ## code ## cmpeq (type, type) PCS;                \
46
  extern int __aeabi_ ## code ## cmplt (type, type) PCS;                \
47
  extern int __aeabi_ ## code ## cmple (type, type) PCS;                \
48
  extern int __aeabi_ ## code ## cmpge (type, type) PCS;                \
49
  extern int __aeabi_ ## code ## cmpgt (type, type) PCS;                \
50
  extern int __aeabi_ ## code ## cmpun (type, type) PCS;                \
51
  extern int __aeabi_ ## code ## 2iz (type) PCS;                        \
52
  extern unsigned int __aeabi_ ## code ## 2uiz (type) PCS;              \
53
  extern long long __aeabi_ ## code ## 2lz (type) PCS;                  \
54
  extern unsigned long long __aeabi_ ## code ## 2ulz (type) PCS;        \
55
  extern type __aeabi_i2 ## code (int) PCS;                             \
56
  extern type __aeabi_ui2 ## code (int) PCS;                            \
57
  extern type __aeabi_l2 ## code (long long) PCS;                       \
58
  extern type __aeabi_ul2 ## code (unsigned long long) PCS;             \
59
                                                                        \
60
  type code ## zero = 0.0;                                              \
61
  type code ## one = 1.0;                                               \
62
  type code ## two = 2.0;                                               \
63
  type code ## four = 4.0;                                              \
64
  type code ## minus_one = -1.0;                                        \
65
  type code ## minus_two = -2.0;                                        \
66
  type code ## minus_four = -4.0;                                       \
67
  type code ## epsilon = 1E-32;                                         \
68
  type code ## NaN = 0.0 / 0.0;
69
 
70
decl_float (d, double)
71
decl_float (f, float)
72
 
73
extern float __aeabi_d2f (double) PCS;
74
extern double __aeabi_f2d (float) PCS;
75
extern long long __aeabi_lmul (long long, long long);
76
extern long long __aeabi_llsl (long long, int);
77
extern long long __aeabi_llsr (long long, int);
78
extern long long __aeabi_lasr (long long, int);
79
extern int __aeabi_lcmp (long long, long long);
80
extern int __aeabi_ulcmp (unsigned long long, unsigned long long);
81
extern int __aeabi_idiv (int, int);
82
extern unsigned int __aeabi_uidiv (unsigned int, unsigned int);
83
extern int __aeabi_uread4 (void *);
84
extern int __aeabi_uwrite4 (int, void *);
85
extern long long __aeabi_uread8 (void *);
86
extern long long __aeabi_uwrite8 (long long, void *);
87
 
88
#define eq(a, b, type, abs, epsilon, format)                    \
89
  {                                                             \
90
    type a1;                                                    \
91
    type b1;                                                    \
92
                                                                \
93
    a1 = a;                                                     \
94
    b1 = b;                                                     \
95
    if (abs (a1 - b1) > epsilon)                                \
96
    {                                                           \
97
      fprintf (stderr, "%d: Test %s == %s\n", __LINE__, #a, #b);        \
98
      fprintf (stderr, "%d: " format " != " format "\n",        \
99
               __LINE__, a1, b1);                               \
100
      abort ();                                                 \
101
    }                                                           \
102
  }
103
 
104
#define ieq(a, b) eq (a, b, int, abs, 0, "%d")
105
#define ueq(a, b) eq (a, b, unsigned int, abs, 0, "%u")
106
#define leq(a, b) eq (a, b, long long, abs, 0, "%lld")
107
#define uleq(a, b) eq (a, b, unsigned long long, abs, 0, "%llu")
108
#define feq(a, b) eq (a, b, float, fabs, fepsilon, "%f")
109
#define deq(a, b) eq (a, b, double, fabs, depsilon, "%g")
110
 
111
#define NUM_CMP_VALUES 6
112
 
113
/* Values picked to cover a range of small, large, positive and negative.  */
114
static unsigned int cmp_val[NUM_CMP_VALUES] =
115
{
116
  0,
117
  1,
118
  0x40000000,
119
  0x80000000,
120
  0xc0000000,
121
  0xffffffff
122
};
123
 
124
/* All combinations for each of the above values. */
125
#define ulcmp(l, s, m) \
126
    s, l, l, l, l, l,  m, s, l, l, l, l, \
127
    m, m, s, l, l, l,  m, m, m, s, l, l, \
128
    m, m, m, m, s, l,  m, m, m, m, m, s
129
 
130
#define lcmp(l, s, m) \
131
    s, l, l, m, m, m,  m, s, l, m, m, m, \
132
    m, m, s, m, m, m,  l, l, l, s, l, l, \
133
    l, l, l, m, s, l,  l, l, l, m, m, s
134
 
135
/* All combinations of the above for high/low words.  */
136
static int lcmp_results[] =
137
{
138
  lcmp(ulcmp(-1, -1, -1), ulcmp(-1, 0, 1), ulcmp(1, 1, 1))
139
};
140
 
141
static int ulcmp_results[] =
142
{
143
  ulcmp(ulcmp(-1, -1, -1), ulcmp(-1, 0, 1), ulcmp(1, 1, 1))
144
};
145
 
146
static int signof(int i)
147
{
148
  if (i < 0)
149
    return -1;
150
 
151
  if (i == 0)
152
    return 0;
153
 
154
  return 1;
155
}
156
 
157
int main () {
158
  unsigned char bytes[256];
159
  int i, j, k, n;
160
  int *result;
161
 
162
  /* Table 2.  Double-precision floating-point arithmetic.  */
163
  deq (__aeabi_dadd (dzero, done), done);
164
  deq (__aeabi_dadd (done, done), dtwo);
165
  deq (__aeabi_ddiv (dminus_four, dminus_two), dtwo);
166
  deq (__aeabi_ddiv (dminus_two, dtwo), dminus_one);
167
  deq (__aeabi_dmul (dtwo, dtwo), dfour);
168
  deq (__aeabi_dmul (dminus_one, dminus_two), dtwo);
169
  deq (__aeabi_dneg (dminus_one), done);
170
  deq (__aeabi_dneg (dfour), dminus_four);
171
  deq (__aeabi_drsub (done, dzero), dminus_one);
172
  deq (__aeabi_drsub (dtwo, dminus_two), dminus_four);
173
  deq (__aeabi_dsub (dzero, done), dminus_one);
174
  deq (__aeabi_dsub (dminus_two, dtwo), dminus_four);
175
 
176
  /* Table 3.  Double-precision floating-point comparisons.  */
177
  ieq (__aeabi_dcmpeq (done, done), 1);
178
  ieq (__aeabi_dcmpeq (done, dzero), 0);
179
  ieq (__aeabi_dcmpeq (dNaN, dzero), 0);
180
  ieq (__aeabi_dcmpeq (dNaN, dNaN), 0);
181
 
182
  ieq (__aeabi_dcmplt (dzero, done), 1);
183
  ieq (__aeabi_dcmplt (done, dzero), 0);
184
  ieq (__aeabi_dcmplt (dzero, dzero), 0);
185
  ieq (__aeabi_dcmplt (dzero, dNaN), 0);
186
  ieq (__aeabi_dcmplt (dNaN, dNaN), 0);
187
 
188
  ieq (__aeabi_dcmple (dzero, done), 1);
189
  ieq (__aeabi_dcmple (done, dzero), 0);
190
  ieq (__aeabi_dcmple (dzero, dzero), 1);
191
  ieq (__aeabi_dcmple (dzero, dNaN), 0);
192
  ieq (__aeabi_dcmple (dNaN, dNaN), 0);
193
 
194
  ieq (__aeabi_dcmpge (dzero, done), 0);
195
  ieq (__aeabi_dcmpge (done, dzero), 1);
196
  ieq (__aeabi_dcmpge (dzero, dzero), 1);
197
  ieq (__aeabi_dcmpge (dzero, dNaN), 0);
198
  ieq (__aeabi_dcmpge (dNaN, dNaN), 0);
199
 
200
  ieq (__aeabi_dcmpgt (dzero, done), 0);
201
  ieq (__aeabi_dcmpgt (done, dzero), 1);
202
  ieq (__aeabi_dcmplt (dzero, dzero), 0);
203
  ieq (__aeabi_dcmpgt (dzero, dNaN), 0);
204
  ieq (__aeabi_dcmpgt (dNaN, dNaN), 0);
205
 
206
  ieq (__aeabi_dcmpun (done, done), 0);
207
  ieq (__aeabi_dcmpun (done, dzero), 0);
208
  ieq (__aeabi_dcmpun (dNaN, dzero), 1);
209
  ieq (__aeabi_dcmpun (dNaN, dNaN), 1);
210
 
211
  /* Table 4.  Single-precision floating-point arithmetic.  */
212
  feq (__aeabi_fadd (fzero, fone), fone);
213
  feq (__aeabi_fadd (fone, fone), ftwo);
214
  feq (__aeabi_fdiv (fminus_four, fminus_two), ftwo);
215
  feq (__aeabi_fdiv (fminus_two, ftwo), fminus_one);
216
  feq (__aeabi_fmul (ftwo, ftwo), ffour);
217
  feq (__aeabi_fmul (fminus_one, fminus_two), ftwo);
218
  feq (__aeabi_fneg (fminus_one), fone);
219
  feq (__aeabi_fneg (ffour), fminus_four);
220
  feq (__aeabi_frsub (fone, fzero), fminus_one);
221
  feq (__aeabi_frsub (ftwo, fminus_two), fminus_four);
222
  feq (__aeabi_fsub (fzero, fone), fminus_one);
223
  feq (__aeabi_fsub (fminus_two, ftwo), fminus_four);
224
 
225
  /* Table 5.  Single-precision floating-point comparisons.  */
226
  ieq (__aeabi_fcmpeq (fone, fone), 1);
227
  ieq (__aeabi_fcmpeq (fone, fzero), 0);
228
  ieq (__aeabi_fcmpeq (fNaN, fzero), 0);
229
  ieq (__aeabi_fcmpeq (fNaN, fNaN), 0);
230
 
231
  ieq (__aeabi_fcmplt (fzero, fone), 1);
232
  ieq (__aeabi_fcmplt (fone, fzero), 0);
233
  ieq (__aeabi_fcmplt (fzero, fzero), 0);
234
  ieq (__aeabi_fcmplt (fzero, fNaN), 0);
235
  ieq (__aeabi_fcmplt (fNaN, fNaN), 0);
236
 
237
  ieq (__aeabi_fcmple (fzero, fone), 1);
238
  ieq (__aeabi_fcmple (fone, fzero), 0);
239
  ieq (__aeabi_fcmple (fzero, fzero), 1);
240
  ieq (__aeabi_fcmple (fzero, fNaN), 0);
241
  ieq (__aeabi_fcmple (fNaN, fNaN), 0);
242
 
243
  ieq (__aeabi_fcmpge (fzero, fone), 0);
244
  ieq (__aeabi_fcmpge (fone, fzero), 1);
245
  ieq (__aeabi_fcmpge (fzero, fzero), 1);
246
  ieq (__aeabi_fcmpge (fzero, fNaN), 0);
247
  ieq (__aeabi_fcmpge (fNaN, fNaN), 0);
248
 
249
  ieq (__aeabi_fcmpgt (fzero, fone), 0);
250
  ieq (__aeabi_fcmpgt (fone, fzero), 1);
251
  ieq (__aeabi_fcmplt (fzero, fzero), 0);
252
  ieq (__aeabi_fcmpgt (fzero, fNaN), 0);
253
  ieq (__aeabi_fcmpgt (fNaN, fNaN), 0);
254
 
255
  ieq (__aeabi_fcmpun (fone, fone), 0);
256
  ieq (__aeabi_fcmpun (fone, fzero), 0);
257
  ieq (__aeabi_fcmpun (fNaN, fzero), 1);
258
  ieq (__aeabi_fcmpun (fNaN, fNaN), 1);
259
 
260
  /* Table 6.  Floating-point to integer conversions.  */
261
  ieq (__aeabi_d2iz (dminus_one), -1);
262
  ueq (__aeabi_d2uiz (done), 1);
263
  leq (__aeabi_d2lz (dminus_two), -2LL);
264
  uleq (__aeabi_d2ulz (dfour), 4LL);
265
  ieq (__aeabi_f2iz (fminus_one), -1);
266
  ueq (__aeabi_f2uiz (fone), 1);
267
  leq (__aeabi_f2lz (fminus_two), -2LL);
268
  uleq (__aeabi_f2ulz (ffour), 4LL);
269
 
270
  /* Table 7.  Conversions between floating types.  */
271
  feq (__aeabi_d2f (dtwo), ftwo);
272
  deq (__aeabi_f2d (fminus_four), dminus_four);
273
 
274
  /* Table 8.  Integer to floating-point conversions.  */
275
  deq (__aeabi_i2d (-1), dminus_one);
276
  deq (__aeabi_ui2d (2), dtwo);
277
  deq (__aeabi_l2d (-1), dminus_one);
278
  deq (__aeabi_ul2d (2ULL), dtwo);
279
  feq (__aeabi_i2f (-1), fminus_one);
280
  feq (__aeabi_ui2f (2), ftwo);
281
  feq (__aeabi_l2f (-1), fminus_one);
282
  feq (__aeabi_ul2f (2ULL), ftwo);
283
 
284
  /* Table 9.  Long long functions.  */
285
  leq (__aeabi_lmul (4LL, -1LL), -4LL);
286
  leq (__aeabi_llsl (2LL, 1), 4LL);
287
  leq (__aeabi_llsr (-1LL, 63), 1);
288
  leq (__aeabi_lasr (-1LL, 63), -1);
289
 
290
  result = lcmp_results;
291
  for (i = 0; i < NUM_CMP_VALUES; i++)
292
    for (j = 0; j < NUM_CMP_VALUES; j++)
293
      for (k = 0; k < NUM_CMP_VALUES; k++)
294
        for (n = 0; n < NUM_CMP_VALUES; n++)
295
          {
296
            ieq (signof (__aeabi_lcmp
297
                          (((long long)cmp_val[i] << 32) | cmp_val[k],
298
                           ((long long)cmp_val[j] << 32) | cmp_val[n])),
299
                           *result);
300
            result++;
301
          }
302
  result = ulcmp_results;
303
  for (i = 0; i < NUM_CMP_VALUES; i++)
304
    for (j = 0; j < NUM_CMP_VALUES; j++)
305
      for (k = 0; k < NUM_CMP_VALUES; k++)
306
        for (n = 0; n < NUM_CMP_VALUES; n++)
307
          {
308
            ieq (signof (__aeabi_ulcmp
309
                          (((long long)cmp_val[i] << 32) | cmp_val[k],
310
                           ((long long)cmp_val[j] << 32) | cmp_val[n])),
311
                           *result);
312
            result++;
313
          }
314
 
315
  ieq (__aeabi_idiv (-550, 11), -50);
316
  ueq (__aeabi_uidiv (4000000000U, 1000000U), 4000U);
317
 
318
  for (i = 0; i < 256; i++)
319
    bytes[i] = i;
320
 
321
#ifdef __ARMEB__
322
  ieq (__aeabi_uread4 (bytes + 1), 0x01020304U);
323
  leq (__aeabi_uread8 (bytes + 3), 0x030405060708090aLL);
324
  ieq (__aeabi_uwrite4 (0x66778899U, bytes + 5), 0x66778899U);
325
  leq (__aeabi_uwrite8 (0x2030405060708090LL, bytes + 15),
326
       0x2030405060708090LL);
327
#else
328
  ieq (__aeabi_uread4 (bytes + 1), 0x04030201U);
329
  leq (__aeabi_uread8 (bytes + 3), 0x0a09080706050403LL);
330
  ieq (__aeabi_uwrite4 (0x99887766U, bytes + 5), 0x99887766U);
331
  leq (__aeabi_uwrite8 (0x9080706050403020LL, bytes + 15),
332
       0x9080706050403020LL);
333
#endif
334
 
335
  for (i = 0; i < 4; i++)
336
    ieq (bytes[5 + i], (6 + i) * 0x11);
337
 
338
  for (i = 0; i < 8; i++)
339
    ieq (bytes[15 + i], (2 + i) * 0x10);
340
 
341
  exit (0);
342
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.