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.