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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gcc-4.2.2/] [gcc/] [testsuite/] [gcc.dg/] [vect/] [vect-all.c] - Blame information for rev 816

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 149 jeremybenn
/* { dg-require-effective-target vect_int } */
2
/* { dg-require-effective-target vect_float } */
3
 
4
#include <stdarg.h>
5
#include "tree-vect.h"
6
 
7
#define N 16
8
 
9
int iadd_results[N] = {0,6,12,18,24,30,36,42,48,54,60,66,72,78,84,90};
10
float fadd_results[N] = {0.0,6.0,12.0,18.0,24.0,30.0,36.0,42.0,48.0,54.0,60.0,66.0,72.0,78.0,84.0,90.0};
11
float fmul_results[N] = {0.0,3.0,12.0,27.0,48.0,75.0,108.0,147.0,192.0,243.0,300.0,363.0,432.0,507.0,588.0,675.0};
12
float fresults1[N] = {192.00,240.00,288.00,336.00,384.00,432.00,480.00,528.00,48.00,54.00,60.00,66.00,72.00,78.00,84.00,90.00};
13
float fresults2[N] = {0.00,6.00,12.00,18.00,24.00,30.00,36.00,42.00,0.00,54.00,120.00,198.00,288.00,390.00,504.00,630.00};
14
 
15
/****************************************************/
16
void icheck_results (int *a, int *results)
17
{
18
  int i;
19
  for (i = 0; i < N; i++)
20
    {
21
      if (a[i] != results[i])
22
        abort ();
23
    }
24
}
25
 
26
void fcheck_results (float *a, float *results)
27
{
28
  int i;
29
  for (i = 0; i < N; i++)
30
    {
31
      if (a[i] != results[i])
32
        abort ();
33
    }
34
}
35
 
36
void
37
fbar_mul (float *a)
38
{
39
  fcheck_results (a, fmul_results);
40
}
41
 
42
void
43
fbar_add (float *a)
44
{
45
  fcheck_results (a, fadd_results);
46
}
47
 
48
void
49
ibar_add (int *a)
50
{
51
  icheck_results (a, iadd_results);
52
}
53
 
54
void
55
fbar1 (float *a)
56
{
57
  fcheck_results (a, fresults1);
58
}
59
 
60
void
61
fbar2 (float *a)
62
{
63
  fcheck_results (a, fresults2);
64
}
65
 
66
 
67
/* All of the loops below are currently vectorizable.  */
68
 
69
int
70
main1 ()
71
{
72
  int i,j;
73
  float a[N];
74
  float e[N];
75
  float b[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
76
  float c[N] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
77
  float d[N] = {0,2,4,6,8,10,12,14,16,18,20,22,24,26,28,30};
78
  int ic[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
79
  int ib[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
80
  int ia[N];
81
  char cb[N] = {0,3,6,9,12,15,18,21,24,27,30,33,36,39,42,45};
82
  char ca[N];
83
  short sa[N];
84
 
85
  /* Test 1: copy chars.  */
86
  for (i = 0; i < N; i++)
87
    {
88
      ca[i] = cb[i];
89
    }
90
  /* check results:  */
91
  for (i = 0; i < N; i++)
92
    {
93
      if (ca[i] != cb[i])
94
        abort ();
95
    }
96
 
97
 
98
  /* Test 2: fp mult.  */
99
  for (i = 0; i < N; i++)
100
    {
101
      a[i] = b[i] * c[i];
102
    }
103
  fbar_mul (a);
104
 
105
 
106
  /* Test 3: mixed types (int, fp), same nunits in vector.  */
107
  for (i = 0; i < N; i++)
108
    {
109
      a[i] = b[i] + c[i] + d[i];
110
      e[i] = b[i] + c[i] + d[i];
111
      ia[i] = ib[i] + ic[i];
112
    }
113
  ibar_add (ia);
114
  fbar_add (a);
115
  fbar_add (e);
116
 
117
 
118
  /* Test 4: access with offset.  */
119
  for (i = 0; i < N/2; i++)
120
    {
121
      a[i] = b[i+N/2] * c[i+N/2] - b[i] * c[i];
122
      e[i+N/2] = b[i] * c[i+N/2] + b[i+N/2] * c[i];
123
    }
124
  fbar1 (a);
125
  fbar2 (e);
126
 
127
 
128
  /* Test 5: access with offset */
129
  for (i = 1; i <=N-4; i++)
130
    {
131
      a[i+3] = b[i-1];
132
    }
133
  /* check results:  */
134
  for (i = 1; i <=N-4; i++)
135
    {
136
      if (a[i+3] != b[i-1])
137
        abort ();
138
    }
139
 
140
 
141
  /* Test 6 - loop induction with stride != 1.  */
142
  i = 0;
143
  j = 0;
144
  while (i < 5*N)
145
    {
146
      a[j] = c[j];
147
      i += 5;
148
      j++;
149
    }
150
  /* check results:  */
151
  for (i = 0; i <N; i++)
152
    {
153
      if (a[i] != c[i])
154
        abort ();
155
    }
156
 
157
 
158
  /* Test 7 - reverse access.  */
159
  for (i = N; i > 0; i--)
160
    {
161
      a[N-i] = d[N-i];
162
    }
163
  /* check results:  */
164
  for (i = 0; i <N; i++)
165
    {
166
      if (a[i] != d[i])
167
        abort ();
168
    }
169
 
170
 
171
  /* Tests 8,9,10 - constants.  */
172
  for (i = 0; i < N; i++)
173
    {
174
      a[i] = 5.0;
175
    }
176
  /* check results:  */
177
  for (i = 0; i < N; i++)
178
    {
179
      if (a[i] != 5.0)
180
        abort ();
181
    }
182
 
183
  for (i = 0; i < N; i++)
184
    {
185
      sa[i] = 5;
186
    }
187
  /* check results:  */
188
  for (i = 0; i < N; i++)
189
    {
190
      if (sa[i] != 5)
191
        abort ();
192
    }
193
 
194
  for (i = 0; i < N; i++)
195
    {
196
      ia[i] = ib[i] + 5;
197
    }
198
  /* check results:  */
199
  for (i = 0; i < N; i++)
200
    {
201
      if (ia[i] != ib[i] + 5)
202
        abort ();
203
    }
204
 
205
  return 0;
206
}
207
 
208
int main (void)
209
{
210
  check_vect ();
211
 
212
  return main1 ();
213
}
214
 
215
/* { dg-final { scan-tree-dump-times "vectorized 10 loops" 1 "vect" } } */
216
/* { dg-final { scan-tree-dump-times "Vectorizing an unaligned access" 0 "vect" } } */
217
/* { dg-final { scan-tree-dump-times "Alignment of access forced using peeling" 0 "vect" } } */
218
/* { dg-final { cleanup-tree-dump "vect" } } */

powered by: WebSVN 2.1.0

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