libgo/runtime/go-type-complex.c

   1 /* go-type-complex.c -- hash and equality complex functions.
   2
   3    Copyright 2012 The Go Authors. All rights reserved.
   4    Use of this source code is governed by a BSD-style
   5    license that can be found in the LICENSE file.  */
   6
   7 #include <complex.h>
   8 #include <math.h>
   9 #include <stdint.h>
  10 #include <string.h>
  11 #include "runtime.h"
  12 #include "go-type.h"
  13
  14 /* Hash function for float types.  */
  15
  16 uintptr_t
  17 __go_type_hash_complex (const void *vkey, uintptr_t key_size)
  18 {
  19   if (key_size == 8)
  20     {
  21       const complex float *cfp;
  22       complex float cf;
  23       float cfr;
  24       float cfi;
  25       uint64_t fi;
  26
  27       cfp = (const complex float *) vkey;
  28       cf = *cfp;
  29
  30       cfr = crealf (cf);
  31       cfi = cimagf (cf);
  32
  33       if (isinf (cfr) || isinf (cfi))
  34         return 0;
  35
  36       /* NaN != NaN, so the hash code of a NaN is irrelevant.  Make it
  37          random so that not all NaNs wind up in the same place.  */
  38       if (isnan (cfr) || isnan (cfi))
  39         return runtime_fastrand1 ();
  40
  41       /* Avoid negative zero.  */
  42       if (cfr == 0 && cfi == 0)
  43         return 0;
  44       else if (cfr == 0)
  45         cf = cfi * I;
  46       else if (cfi == 0)
  47         cf = cfr;
  48
  49       memcpy (&fi, &cf, 8);
  50       return (uintptr_t) cfi;
  51     }
  52   else if (key_size == 16)
  53     {
  54       const complex double *cdp;
  55       complex double cd;
  56       double cdr;
  57       double cdi;
  58       uint64_t di[2];
  59
  60       cdp = (const complex double *) vkey;
  61       cd = *cdp;
  62
  63       cdr = creal (cd);
  64       cdi = cimag (cd);
  65
  66       if (isinf (cdr) || isinf (cdi))
  67         return 0;
  68
  69       if (isnan (cdr) || isnan (cdi))
  70         return runtime_fastrand1 ();
  71
  72       /* Avoid negative zero.  */
  73       if (cdr == 0 && cdi == 0)
  74         return 0;
  75       else if (cdr == 0)
  76         cd = cdi * I;
  77       else if (cdi == 0)
  78         cd = cdr;
  79
  80       memcpy (&di, &cd, 16);
  81       return di[0] ^ di[1];
  82     }
  83   else
  84     runtime_throw ("__go_type_hash_complex: invalid complex size");
  85 }
  86
  87 const FuncVal __go_type_hash_complex_descriptor =
  88   { (void *) __go_type_hash_complex };
  89
  90 /* Equality function for complex types.  */
  91
  92 _Bool
  93 __go_type_equal_complex (const void *vk1, const void *vk2, uintptr_t key_size)
  94 {
  95   if (key_size == 8)
  96     {
  97       const complex float *cfp1;
  98       const complex float *cfp2;
  99
 100       cfp1 = (const complex float *) vk1;
 101       cfp2 = (const complex float *) vk2;
 102
 103       return *cfp1 == *cfp2;
 104     }
 105   else if (key_size == 16)
 106     {
 107       const complex double *cdp1;
 108       const complex double *cdp2;
 109
 110       cdp1 = (const complex double *) vk1;
 111       cdp2 = (const complex double *) vk2;
 112
 113       return *cdp1 == *cdp2;
 114     }
 115   else
 116     runtime_throw ("__go_type_equal_complex: invalid complex size");
 117 }
 118
 119 const FuncVal __go_type_equal_complex_descriptor =
 120   { (void *) __go_type_equal_complex };