formats/ctf/types/float.c

   1 /*
   2  * Common Trace Format
   3  *
   4  * Floating point read/write functions.
   5  *
   6  * Copyright 2010-2011 EfficiOS Inc. and Linux Foundation
   7  *
   8  * Author: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
   9  *
  10  * Permission is hereby granted, free of charge, to any person obtaining a copy
  11  * of this software and associated documentation files (the "Software"), to deal
  12  * in the Software without restriction, including without limitation the rights
  13  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  14  * copies of the Software, and to permit persons to whom the Software is
  15  * furnished to do so, subject to the following conditions:
  16  *
  17  * The above copyright notice and this permission notice shall be included in
  18  * all copies or substantial portions of the Software.
  19  *
  20  * Reference: ISO C99 standard 5.2.4
  21  */
  22
  23 #include <babeltrace/ctf/types.h>
  24 #include <glib.h>
  25 #include <float.h>      /* C99 floating point definitions */
  26 #include <limits.h>     /* C99 limits */
  27 #include <endian.h>
  28
  29 /*
  30  * This library is limited to binary representation of floating point values.
  31  * Sign-extension of the exponents is assumed to keep the NaN, +inf, -inf
  32  * values, but this should be double-checked (TODO).
  33  */
  34
  35 /*
  36  * Aliasing float/double and unsigned long is not strictly permitted by strict
  37  * aliasing, but in practice declaration prunning is well supported, and this permits
  38  * us to use per-word read/writes rather than per-byte.
  39  */
  40
  41 #if defined(__GNUC__) || defined(__MINGW32__) || defined(_MSC_VER)
  42 #define HAS_TYPE_PRUNING
  43 #endif
  44
  45 #if (FLT_RADIX != 2)
  46
  47 #error "Unsupported floating point radix"
  48
  49 #endif
  50
  51 union doubleIEEE754 {
  52         double v;
  53 #ifdef HAS_TYPE_PRUNING
  54         unsigned long bits[(sizeof(double) + sizeof(unsigned long) - 1) / sizeof(unsigned long)];
  55 #else
  56         unsigned char bits[sizeof(double)];
  57 #endif
  58 };
  59
  60 union ldoubleIEEE754 {
  61         long double v;
  62 #ifdef HAS_TYPE_PRUNING
  63         unsigned long bits[(sizeof(long double) + sizeof(unsigned long) - 1) / sizeof(unsigned long)];
  64 #else
  65         unsigned char bits[sizeof(long double)];
  66 #endif
  67 };
  68
  69 static struct declaration_float *static_ldouble_declaration;
  70
  71 struct pos_len {
  72         size_t sign_start, exp_start, mantissa_start, len;
  73 };
  74
  75 int _ctf_float_copy(struct stream_pos *destp,
  76                     struct definition_float *dest_definition,
  77                     struct stream_pos *srcp,
  78                     const struct definition_float *src_definition)
  79 {
  80         int ret;
  81
  82         /* Read */
  83         if (src_definition->declaration->byte_order == LITTLE_ENDIAN) {
  84                 ret = ctf_integer_read(srcp, &src_definition->mantissa->p);
  85                 if (ret)
  86                         return ret;
  87                 ret = ctf_integer_read(srcp, &src_definition->exp->p);
  88                 if (ret)
  89                         return ret;
  90                 ret = ctf_integer_read(srcp, &src_definition->sign->p);
  91                 if (ret)
  92                         return ret;
  93         } else {
  94                 ret = ctf_integer_read(srcp, &src_definition->sign->p);
  95                 if (ret)
  96                         return ret;
  97                 ret = ctf_integer_read(srcp, &src_definition->exp->p);
  98                 if (ret)
  99                         return ret;
 100                 ret = ctf_integer_read(srcp, &src_definition->mantissa->p);
 101                 if (ret)
 102                         return ret;
 103         }
 104
 105         dest_definition->mantissa->value._unsigned =
 106                 src_definition->mantissa->value._unsigned;
 107         dest_definition->exp->value._signed =
 108                 src_definition->exp->value._signed;
 109         dest_definition->sign->value._unsigned =
 110                 src_definition->sign->value._unsigned;
 111
 112         /* Write */
 113         if (dest_definition->declaration->byte_order == LITTLE_ENDIAN) {
 114                 ret = ctf_integer_write(destp, &dest_definition->mantissa->p);
 115                 if (ret)
 116                         return ret;
 117                 ret = ctf_integer_write(destp, &dest_definition->exp->p);
 118                 if (ret)
 119                         return ret;
 120                 ret = ctf_integer_write(destp, &dest_definition->sign->p);
 121                 if (ret)
 122                         return ret;
 123         } else {
 124                 ret = ctf_integer_write(destp, &dest_definition->sign->p);
 125                 if (ret)
 126                         return ret;
 127                 ret = ctf_integer_write(destp, &dest_definition->exp->p);
 128                 if (ret)
 129                         return ret;
 130                 ret = ctf_integer_write(destp, &dest_definition->mantissa->p);
 131                 if (ret)
 132                         return ret;
 133         }
 134         return 0;
 135 }
 136
 137 int ctf_float_read(struct stream_pos *ppos, struct definition *definition)
 138 {
 139         struct definition_float *float_definition =
 140                 container_of(definition, struct definition_float, p);
 141         const struct declaration_float *float_declaration =
 142                 float_definition->declaration;
 143         struct ctf_stream_pos *pos = ctf_pos(ppos);
 144         union ldoubleIEEE754 u;
 145         struct definition *tmpdef =
 146                 static_ldouble_declaration->p.definition_new(&static_ldouble_declaration->p,
 147                                 NULL, 0, 0, NULL);
 148         struct definition_float *tmpfloat =
 149                 container_of(tmpdef, struct definition_float, p);
 150         struct ctf_stream_pos destp;
 151         int ret;
 152
 153         ctf_init_pos(&destp, -1, O_RDWR);
 154         destp.base = (char *) u.bits;
 155
 156         ctf_align_pos(pos, float_declaration->p.alignment);
 157         ret = _ctf_float_copy(&destp.parent, tmpfloat, ppos, float_definition);
 158         float_definition->value = u.v;
 159         definition_unref(tmpdef);
 160         return ret;
 161 }
 162
 163 int ctf_float_write(struct stream_pos *ppos, struct definition *definition)
 164 {
 165         struct definition_float *float_definition =
 166                 container_of(definition, struct definition_float, p);
 167         const struct declaration_float *float_declaration =
 168                 float_definition->declaration;
 169         struct ctf_stream_pos *pos = ctf_pos(ppos);
 170         union ldoubleIEEE754 u;
 171         struct definition *tmpdef =
 172                 static_ldouble_declaration->p.definition_new(&static_ldouble_declaration->p,
 173                                 NULL, 0, 0, NULL);
 174         struct definition_float *tmpfloat =
 175                 container_of(tmpdef, struct definition_float, p);
 176         struct ctf_stream_pos srcp;
 177         int ret;
 178
 179         ctf_init_pos(&srcp, -1, O_RDONLY);
 180         srcp.base = (char *) u.bits;
 181
 182         u.v = float_definition->value;
 183         ctf_align_pos(pos, float_declaration->p.alignment);
 184         ret = _ctf_float_copy(ppos, float_definition, &srcp.parent, tmpfloat);
 185         definition_unref(tmpdef);
 186         return ret;
 187 }
 188
 189 void __attribute__((constructor)) ctf_float_init(void)
 190 {
 191         static_ldouble_declaration =
 192                 float_declaration_new(LDBL_MANT_DIG,
 193                                 sizeof(long double) * CHAR_BIT - LDBL_MANT_DIG,
 194                                 BYTE_ORDER,
 195                                 __alignof__(long double));
 196 }
 197
 198 void __attribute__((destructor)) ctf_float_fini(void)
 199 {
 200         declaration_unref(&static_ldouble_declaration->p);
 201 }