arch/microblaze/include/asm/hash.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 #ifndef _ASM_HASH_H
   3 #define _ASM_HASH_H
   4
   5 /*
   6  * Fortunately, most people who want to run Linux on Microblaze enable
   7  * both multiplier and barrel shifter, but omitting them is technically
   8  * a supported configuration.
   9  *
  10  * With just a barrel shifter, we can implement an efficient constant
  11  * multiply using shifts and adds.  GCC can find a 9-step solution, but
  12  * this 6-step solution was found by Yevgen Voronenko's implementation
  13  * of the Hcub algorithm at http://spiral.ece.cmu.edu/mcm/gen.html.
  14  *
  15  * That software is really not designed for a single multiplier this large,
  16  * but if you run it enough times with different seeds, it'll find several
  17  * 6-shift, 6-add sequences for computing x * 0x61C88647.  They are all
  18  *      c = (x << 19) + x;
  19  *      a = (x <<  9) + c;
  20  *      b = (x << 23) + a;
  21  *      return (a<<11) + (b<<6) + (c<<3) - b;
  22  * with variations on the order of the final add.
  23  *
  24  * Without even a shifter, it's hopless; any hash function will suck.
  25  */
  26
  27 #if CONFIG_XILINX_MICROBLAZE0_USE_HW_MUL == 0
  28
  29 #define HAVE_ARCH__HASH_32 1
  30
  31 /* Multiply by GOLDEN_RATIO_32 = 0x61C88647 */
  32 static inline u32 __attribute_const__ __hash_32(u32 a)
  33 {
  34 #if CONFIG_XILINX_MICROBLAZE0_USE_BARREL
  35         unsigned int b, c;
  36
  37         /* Phase 1: Compute three intermediate values */
  38         b =  a << 23;
  39         c = (a << 19) + a;
  40         a = (a <<  9) + c;
  41         b += a;
  42
  43         /* Phase 2: Compute (a << 11) + (b << 6) + (c << 3) - b */
  44         a <<= 5;
  45         a += b;         /* (a << 5) + b */
  46         a <<= 3;
  47         a += c;         /* (a << 8) + (b << 3) + c */
  48         a <<= 3;
  49         return a - b;   /* (a << 11) + (b << 6) + (c << 3) - b */
  50 #else
  51         /*
  52          * "This is really going to hurt."
  53          *
  54          * Without a barrel shifter, left shifts are implemented as
  55          * repeated additions, and the best we can do is an optimal
  56          * addition-subtraction chain.  This one is not known to be
  57          * optimal, but at 37 steps, it's decent for a 31-bit multiplier.
  58          *
  59          * Question: given its size (37*4 = 148 bytes per instance),
  60          * and slowness, is this worth having inline?
  61          */
  62         unsigned int b, c, d;
  63
  64         b = a << 4;     /* 4    */
  65         c = b << 1;     /* 1  5 */
  66         b += a;         /* 1  6 */
  67         c += b;         /* 1  7 */
  68         c <<= 3;        /* 3 10 */
  69         c -= a;         /* 1 11 */
  70         d = c << 7;     /* 7 18 */
  71         d += b;         /* 1 19 */
  72         d <<= 8;        /* 8 27 */
  73         d += a;         /* 1 28 */
  74         d <<= 1;        /* 1 29 */
  75         d += b;         /* 1 30 */
  76         d <<= 6;        /* 6 36 */
  77         return d + c;   /* 1 37 total instructions*/
  78 #endif
  79 }
  80
  81 #endif /* !CONFIG_XILINX_MICROBLAZE0_USE_HW_MUL */
  82 #endif /* _ASM_HASH_H */