|
0
|
1 /* Copyright (C) 2003, 2009 Free Software Foundation, Inc.
|
|
|
2
|
|
|
3 This file is free software; you can redistribute it and/or modify it
|
|
|
4 under the terms of the GNU General Public License as published by the
|
|
|
5 Free Software Foundation; either version 3, or (at your option) any
|
|
|
6 later version.
|
|
|
7
|
|
|
8 This file is distributed in the hope that it will be useful, but
|
|
|
9 WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
10 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
11 General Public License for more details.
|
|
|
12
|
|
|
13 Under Section 7 of GPL version 3, you are granted additional
|
|
|
14 permissions described in the GCC Runtime Library Exception, version
|
|
|
15 3.1, as published by the Free Software Foundation.
|
|
|
16
|
|
|
17 You should have received a copy of the GNU General Public License and
|
|
|
18 a copy of the GCC Runtime Library Exception along with this program;
|
|
|
19 see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
|
|
|
20 <http://www.gnu.org/licenses/>. */
|
|
|
21
|
|
|
22
|
|
|
23 /* Calculate division table for SH5Media integer division
|
|
|
24 Contributed by Joern Rennecke
|
|
|
25 joern.rennecke@superh.com */
|
|
|
26
|
|
|
27 #include <stdio.h>
|
|
|
28 #include <math.h>
|
|
|
29
|
|
|
30 #define BITS 5
|
|
|
31 #define N_ENTRIES (1 << BITS)
|
|
|
32 #define CUTOFF_BITS 20
|
|
|
33
|
|
|
34 #define BIAS (-330)
|
|
|
35
|
|
|
36 double max_defect = 0.;
|
|
|
37 double max_defect_x;
|
|
|
38
|
|
|
39 double min_defect = 1e9;
|
|
|
40 double min_defect_x;
|
|
|
41
|
|
|
42 double max_defect2 = 0.;
|
|
|
43 double max_defect2_x;
|
|
|
44
|
|
|
45 double min_defect2 = 0.;
|
|
|
46 double min_defect2_x;
|
|
|
47
|
|
|
48 double min_defect3 = 01e9;
|
|
|
49 double min_defect3_x;
|
|
|
50 int min_defect3_val;
|
|
|
51
|
|
|
52 double max_defect3 = 0.;
|
|
|
53 double max_defect3_x;
|
|
|
54 int max_defect3_val;
|
|
|
55
|
|
|
56 static double note_defect3 (int val, double d2, double y2d, double x)
|
|
|
57 {
|
|
|
58 int cutoff_val = val >> CUTOFF_BITS;
|
|
|
59 double cutoff;
|
|
|
60 double defect;
|
|
|
61
|
|
|
62 if (val < 0)
|
|
|
63 cutoff_val++;
|
|
|
64 cutoff = (cutoff_val * (1<<CUTOFF_BITS) - val) * y2d;
|
|
|
65 defect = cutoff + val * d2;
|
|
|
66 if (val < 0)
|
|
|
67 defect = - defect;
|
|
|
68 if (defect > max_defect3)
|
|
|
69 {
|
|
|
70 max_defect3 = defect;
|
|
|
71 max_defect3_x = x;
|
|
|
72 max_defect3_val = val;
|
|
|
73 }
|
|
|
74 if (defect < min_defect3)
|
|
|
75 {
|
|
|
76 min_defect3 = defect;
|
|
|
77 min_defect3_x = x;
|
|
|
78 min_defect3_val = val;
|
|
|
79 }
|
|
|
80 }
|
|
|
81
|
|
|
82 /* This function assumes 32-bit integers. */
|
|
|
83 static double
|
|
|
84 calc_defect (double x, int constant, int factor)
|
|
|
85 {
|
|
|
86 double y0 = (constant - (int) floor ((x * factor * 64.))) / 16384.;
|
|
|
87 double y1 = 2 * y0 -y0 * y0 * (x + BIAS / (1.*(1LL<<30)));
|
|
|
88 double y2d0, y2d;
|
|
|
89 int y2d1;
|
|
|
90 double d, d2;
|
|
|
91
|
|
|
92 y1 = floor (y1 * (1024 * 1024 * 1024)) / (1024 * 1024 * 1024);
|
|
|
93 d = y1 - 1 / x;
|
|
|
94 if (d > max_defect)
|
|
|
95 {
|
|
|
96 max_defect = d;
|
|
|
97 max_defect_x = x;
|
|
|
98 }
|
|
|
99 if (d < min_defect)
|
|
|
100 {
|
|
|
101 min_defect = d;
|
|
|
102 min_defect_x = x;
|
|
|
103 }
|
|
|
104 y2d0 = floor (y1 * x * (1LL << 60-16));
|
|
|
105 y2d1 = (int) (long long) y2d0;
|
|
|
106 y2d = - floor ((y1 - y0 / (1<<30-14)) * y2d1) / (1LL<<44);
|
|
|
107 d2 = y1 + y2d - 1/x;
|
|
|
108 if (d2 > max_defect2)
|
|
|
109 {
|
|
|
110 max_defect2 = d2;
|
|
|
111 max_defect2_x = x;
|
|
|
112 }
|
|
|
113 if (d2 < min_defect2)
|
|
|
114 {
|
|
|
115 min_defect2 = d2;
|
|
|
116 min_defect2_x = x;
|
|
|
117 }
|
|
|
118 /* zero times anything is trivially zero. */
|
|
|
119 note_defect3 ((1 << CUTOFF_BITS) - 1, d2, y2d, x);
|
|
|
120 note_defect3 (1 << CUTOFF_BITS, d2, y2d, x);
|
|
|
121 note_defect3 ((1U << 31) - (1 << CUTOFF_BITS), d2, y2d, x);
|
|
|
122 note_defect3 ((1U << 31) - 1, d2, y2d, x);
|
|
|
123 note_defect3 (-1, d2, y2d, x);
|
|
|
124 note_defect3 (-(1 << CUTOFF_BITS), d2, y2d, x);
|
|
|
125 note_defect3 ((1U << 31) - (1 << CUTOFF_BITS) + 1, d2, y2d, x);
|
|
|
126 note_defect3 (-(1U << 31), d2, y2d, x);
|
|
|
127 return d;
|
|
|
128 }
|
|
|
129
|
|
|
130 int
|
|
|
131 main ()
|
|
|
132 {
|
|
|
133 int i;
|
|
|
134 unsigned char factors[N_ENTRIES];
|
|
|
135 short constants[N_ENTRIES];
|
|
|
136 int steps = N_ENTRIES / 2;
|
|
|
137 double step = 1. / steps;
|
|
|
138 double eps30 = 1. / (1024 * 1024 * 1024);
|
|
|
139
|
|
|
140 for (i = 0; i < N_ENTRIES; i++)
|
|
|
141 {
|
|
|
142 double x_low = (i < steps ? 1. : -3.) + i * step;
|
|
|
143 double x_high = x_low + step - eps30;
|
|
|
144 double x_med;
|
|
|
145 int factor, constant;
|
|
|
146 double low_defect, med_defect, high_defect, max_defect;
|
|
|
147
|
|
|
148 factor = (1./x_low- 1./x_high) / step * 256. + 0.5;
|
|
|
149 if (factor == 256)
|
|
|
150 factor = 255;
|
|
|
151 factors[i] = factor;
|
|
|
152 /* Use minimum of error function for x_med. */
|
|
|
153 x_med = sqrt (256./factor);
|
|
|
154 if (x_low < 0)
|
|
|
155 x_med = - x_med;
|
|
|
156 low_defect = 1. / x_low + x_low * factor / 256.;
|
|
|
157 high_defect = 1. / x_high + x_high * factor / 256.;
|
|
|
158 med_defect = 1. / x_med + x_med * factor / 256.;
|
|
|
159 max_defect
|
|
|
160 = ((low_defect > high_defect) ^ (x_med < 0)) ? low_defect : high_defect;
|
|
|
161 constant = (med_defect + max_defect) * 0.5 * 16384. + 0.5;
|
|
|
162 if (constant < -32768 || constant > 32767)
|
|
|
163 abort ();
|
|
|
164 constants[i] = constant;
|
|
|
165 calc_defect (x_low, constant, factor);
|
|
|
166 calc_defect (x_med, constant, factor);
|
|
|
167 calc_defect (x_high, constant, factor);
|
|
|
168 }
|
|
|
169 printf ("/* This table has been generated by divtab.c .\n");
|
|
|
170 printf ("Defects for bias %d:\n", BIAS);
|
|
|
171 printf (" Max defect: %e at %e\n", max_defect, max_defect_x);
|
|
|
172 printf (" Min defect: %e at %e\n", min_defect, min_defect_x);
|
|
|
173 printf (" Max 2nd step defect: %e at %e\n", max_defect2, max_defect2_x);
|
|
|
174 printf (" Min 2nd step defect: %e at %e\n", min_defect2, min_defect2_x);
|
|
|
175 printf (" Max div defect: %e at %d:%e\n", max_defect3, max_defect3_val, max_defect3_x);
|
|
|
176 printf (" Min div defect: %e at %d:%e\n", min_defect3, min_defect3_val, min_defect3_x);
|
|
|
177 printf (" Defect at 1: %e\n",
|
|
|
178 calc_defect (1., constants[0], factors[0]));
|
|
|
179 printf (" Defect at -2: %e */\n",
|
|
|
180 calc_defect (-2., constants[steps], factors[steps]));
|
|
|
181 printf ("\t.section\t.rodata\n");
|
|
|
182 printf ("\t.balign 2\n");
|
|
|
183 printf ("/* negative division constants */\n");
|
|
|
184 for (i = steps; i < 2 * steps; i++)
|
|
|
185 printf ("\t.word\t%d\n", constants[i]);
|
|
|
186 printf ("/* negative division factors */\n");
|
|
|
187 for (i = steps; i < 2*steps; i++)
|
|
|
188 printf ("\t.byte\t%d\n", factors[i]);
|
|
|
189 printf ("\t.skip %d\n", steps);
|
|
|
190 printf ("\t.global GLOBAL(div_table):\n");
|
|
|
191 printf ("GLOBAL(div_table):\n");
|
|
|
192 printf ("\t.skip %d\n", steps);
|
|
|
193 printf ("/* positive division factors */\n");
|
|
|
194 for (i = 0; i < steps; i++)
|
|
|
195 printf ("\t.byte\t%d\n", factors[i]);
|
|
|
196 printf ("/* positive division constants */\n");
|
|
|
197 for (i = 0; i < steps; i++)
|
|
|
198 printf ("\t.word\t%d\n", constants[i]);
|
|
|
199 exit (0);
|
|
|
200 }
|
