1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
|
/* { dg-do run } */
/* { dg-options "-std=gnu99" } */
/* C99 Logical AND operator.
C99 Logical OR operator.
Test with fixed-point operands.
Based on the test from ../dfp/. */
extern void abort (void);
#define OPERATE(OPRD1,OPRT,OPRD2,RLT) \
do \
{ \
if (( (OPRD1) OPRT (OPRD2) )!= RLT) \
abort (); \
} while (0)
#define FIXED_POINT_LOGICAL(OPRD) \
do \
{ \
OPRD = 0.1; \
OPERATE(1,||,OPRD,1); \
OPERATE(0,||,OPRD,1); \
OPERATE(OPRD,||,1,1); \
OPERATE(OPRD,||,0,1); \
OPRD = 0; \
OPERATE(1,||,OPRD,1); \
OPERATE(0,||,OPRD,0); \
OPERATE(OPRD,||,1,1); \
OPERATE(OPRD,||,0,0); \
OPRD = 0.1; \
OPERATE(1,&&,OPRD,1); \
OPERATE(0,&&,OPRD,0); \
OPERATE(OPRD,&&,1,1); \
OPERATE(OPRD,&&,0,0); \
OPRD = 0; \
OPERATE(1,&&,OPRD,0); \
OPERATE(0,&&,OPRD,0); \
OPERATE(OPRD,&&,1,0); \
OPERATE(OPRD,&&,0,0); \
} while (0)
int
main ()
{
short _Fract sf;
_Fract f;
long _Fract lf;
long long _Fract llf;
unsigned short _Fract usf;
unsigned _Fract uf;
unsigned long _Fract ulf;
unsigned long long _Fract ullf;
_Sat short _Fract Ssf;
_Sat _Fract Sf;
_Sat long _Fract Slf;
_Sat long long _Fract Sllf;
_Sat unsigned short _Fract Susf;
_Sat unsigned _Fract Suf;
_Sat unsigned long _Fract Sulf;
_Sat unsigned long long _Fract Sullf;
short _Accum sa;
_Accum a;
long _Accum la;
long long _Accum lla;
unsigned short _Accum usa;
unsigned _Accum ua;
unsigned long _Accum ula;
unsigned long long _Accum ulla;
_Sat short _Accum Ssa;
_Sat _Accum Sa;
_Sat long _Accum Sla;
_Sat long long _Accum Slla;
_Sat unsigned short _Accum Susa;
_Sat unsigned _Accum Sua;
_Sat unsigned long _Accum Sula;
_Sat unsigned long long _Accum Sulla;
/* C99 Section 6.5.{13,14} Logical operator. Constraints Each of the
operands shall have scalar type. Fixed-point types would obey this. */
FIXED_POINT_LOGICAL (sf);
FIXED_POINT_LOGICAL (f);
FIXED_POINT_LOGICAL (lf);
FIXED_POINT_LOGICAL (llf);
FIXED_POINT_LOGICAL (usf);
FIXED_POINT_LOGICAL (uf);
FIXED_POINT_LOGICAL (ulf);
FIXED_POINT_LOGICAL (ullf);
FIXED_POINT_LOGICAL (Ssf);
FIXED_POINT_LOGICAL (Sf);
FIXED_POINT_LOGICAL (Slf);
FIXED_POINT_LOGICAL (Sllf);
FIXED_POINT_LOGICAL (Susf);
FIXED_POINT_LOGICAL (Suf);
FIXED_POINT_LOGICAL (Sulf);
FIXED_POINT_LOGICAL (Sullf);
FIXED_POINT_LOGICAL (sa);
FIXED_POINT_LOGICAL (a);
FIXED_POINT_LOGICAL (la);
FIXED_POINT_LOGICAL (lla);
FIXED_POINT_LOGICAL (usa);
FIXED_POINT_LOGICAL (ua);
FIXED_POINT_LOGICAL (ula);
FIXED_POINT_LOGICAL (ulla);
FIXED_POINT_LOGICAL (Ssa);
FIXED_POINT_LOGICAL (Sa);
FIXED_POINT_LOGICAL (Sla);
FIXED_POINT_LOGICAL (Slla);
FIXED_POINT_LOGICAL (Susa);
FIXED_POINT_LOGICAL (Sua);
FIXED_POINT_LOGICAL (Sula);
FIXED_POINT_LOGICAL (Sulla);
return 0;
}
|
