summaryrefslogtreecommitdiff
path: root/gcc/testsuite/gcc.dg/fixed-point/operator-logical.c
blob: 3873b258870fb824183f6ea5a1dca1f1b09e349c (plain)
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;
}