gcc/config/sh/divtab.c

   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 }