gdb/gmp-utils.h

   1 /* Miscellaneous routines making it easier to use GMP within GDB's framework.
   2
   3    Copyright (C) 2019-2020 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #ifndef GMP_UTILS_H
  21 #define GMP_UTILS_H
  22
  23 #include "defs.h"
  24
  25 /* Include <stdio.h> and <stdarg.h> ahead of <gmp.h>, so as to get
  26    access to GMP's various formatting functions.  */
  27 #include <stdio.h>
  28 #include <stdarg.h>
  29 #include <gmp.h>
  30 #include "gdbsupport/traits.h"
  31
  32 /* Same as gmp_asprintf, but returning an std::string.  */
  33
  34 std::string gmp_string_printf (const char *fmt, ...);
  35
  36 /* A class to make it easier to use GMP's mpz_t values within GDB.  */
  37
  38 struct gdb_mpz
  39 {
  40   mpz_t val;
  41
  42   /* Constructors.  */
  43   gdb_mpz () { mpz_init (val); }
  44
  45   explicit gdb_mpz (const mpz_t &from_val)
  46   {
  47     mpz_init (val);
  48     mpz_set (val, from_val);
  49   }
  50
  51   gdb_mpz (const gdb_mpz &from)
  52   {
  53     mpz_init (val);
  54     mpz_set (val, from.val);
  55   }
  56
  57   /* Initialize using the given integral value.
  58
  59      The main advantage of this method is that it handles both signed
  60      and unsigned types, with no size restriction.  */
  61   template<typename T, typename = gdb::Requires<std::is_integral<T>>>
  62   explicit gdb_mpz (T src)
  63   {
  64     mpz_init (val);
  65     set (src);
  66   }
  67
  68   explicit gdb_mpz (gdb_mpz &&from)
  69   {
  70     mpz_init (val);
  71     mpz_swap (val, from.val);
  72   }
  73
  74
  75   gdb_mpz &operator= (const gdb_mpz &from)
  76   {
  77     mpz_set (val, from.val);
  78     return *this;
  79   }
  80
  81   gdb_mpz &operator= (gdb_mpz &&other)
  82   {
  83     mpz_swap (val, other.val);
  84     return *this;
  85   }
  86
  87   template<typename T, typename = gdb::Requires<std::is_integral<T>>>
  88   gdb_mpz &operator= (T src)
  89   {
  90     set (src);
  91     return *this;
  92   }
  93
  94   /* Convert VAL to an integer of the given type.
  95
  96      The return type can signed or unsigned, with no size restriction.  */
  97   template<typename T> T as_integer () const;
  98
  99   /* Set VAL by importing the number stored in the byte array (BUF),
 100      using the given BYTE_ORDER.  The size of the data to read is
 101      the byte array's size.
 102
 103      UNSIGNED_P indicates whether the number has an unsigned type.  */
 104   void read (gdb::array_view<const gdb_byte> buf, enum bfd_endian byte_order,
 105              bool unsigned_p);
 106
 107   /* Write VAL into BUF as a number whose byte size is the size of BUF,
 108      using the given BYTE_ORDER.
 109
 110      UNSIGNED_P indicates whether the number has an unsigned type.  */
 111   void write (gdb::array_view<gdb_byte> buf, enum bfd_endian byte_order,
 112               bool unsigned_p) const;
 113
 114   /* Return a string containing VAL.  */
 115   std::string str () const { return gmp_string_printf ("%Zd", val); }
 116
 117   /* The destructor.  */
 118   ~gdb_mpz () { mpz_clear (val); }
 119
 120 private:
 121
 122   /* Helper template for constructor and operator=.  */
 123   template<typename T> void set (T src);
 124 };
 125
 126 /* A class to make it easier to use GMP's mpq_t values within GDB.  */
 127
 128 struct gdb_mpq
 129 {
 130   mpq_t val;
 131
 132   /* Constructors.  */
 133   gdb_mpq () { mpq_init (val); }
 134
 135   explicit gdb_mpq (const mpq_t &from_val)
 136   {
 137     mpq_init (val);
 138     mpq_set (val, from_val);
 139   }
 140
 141   gdb_mpq (const gdb_mpq &from)
 142   {
 143     mpq_init (val);
 144     mpq_set (val, from.val);
 145   }
 146
 147   explicit gdb_mpq (gdb_mpq &&from)
 148   {
 149     mpq_init (val);
 150     mpq_swap (val, from.val);
 151   }
 152
 153   /* Copy assignment operator.  */
 154   gdb_mpq &operator= (const gdb_mpq &from)
 155   {
 156     mpq_set (val, from.val);
 157     return *this;
 158   }
 159
 160   gdb_mpq &operator= (gdb_mpq &&from)
 161   {
 162     mpq_swap (val, from.val);
 163     return *this;
 164   }
 165
 166   /* Return a string representing VAL as "<numerator> / <denominator>".  */
 167   std::string str () const { return gmp_string_printf ("%Qd", val); }
 168
 169   /* Return VAL rounded to the nearest integer.  */
 170   gdb_mpz get_rounded () const;
 171
 172   /* Set VAL from the contents of the given byte array (BUF), which
 173      contains the unscaled value of a fixed point type object.
 174      The byte size of the data is the size of BUF.
 175
 176      BYTE_ORDER provides the byte_order to use when reading the data.
 177
 178      UNSIGNED_P indicates whether the number has an unsigned type.
 179      SCALING_FACTOR is the scaling factor to apply after having
 180      read the unscaled value from our buffer.  */
 181   void read_fixed_point (gdb::array_view<const gdb_byte> buf,
 182                          enum bfd_endian byte_order, bool unsigned_p,
 183                          const gdb_mpq &scaling_factor);
 184
 185   /* Write VAL into BUF as fixed point value following the given BYTE_ORDER.
 186      The size of BUF is used as the length to write the value into.
 187
 188      UNSIGNED_P indicates whether the number has an unsigned type.
 189      SCALING_FACTOR is the scaling factor to apply before writing
 190      the unscaled value to our buffer.  */
 191   void write_fixed_point (gdb::array_view<gdb_byte> buf,
 192                           enum bfd_endian byte_order, bool unsigned_p,
 193                           const gdb_mpq &scaling_factor) const;
 194
 195   /* The destructor.  */
 196   ~gdb_mpq () { mpq_clear (val); }
 197 };
 198
 199 /* A class to make it easier to use GMP's mpf_t values within GDB.
 200
 201    Should MPFR become a required dependency, we should probably
 202    drop this class in favor of using MPFR.  */
 203
 204 struct gdb_mpf
 205 {
 206   mpf_t val;
 207
 208   /* Constructors.  */
 209   gdb_mpf () { mpf_init (val); }
 210
 211   DISABLE_COPY_AND_ASSIGN (gdb_mpf);
 212
 213   /* Set VAL from the contents of the given buffer (BUF), which
 214      contains the unscaled value of a fixed point type object
 215      with the given size (LEN) and byte order (BYTE_ORDER).
 216
 217      UNSIGNED_P indicates whether the number has an unsigned type.
 218      SCALING_FACTOR is the scaling factor to apply after having
 219      read the unscaled value from our buffer.  */
 220   void read_fixed_point (gdb::array_view<const gdb_byte> buf,
 221                          enum bfd_endian byte_order, bool unsigned_p,
 222                          const gdb_mpq &scaling_factor)
 223   {
 224     gdb_mpq tmp_q;
 225
 226     tmp_q.read_fixed_point (buf, byte_order, unsigned_p, scaling_factor);
 227     mpf_set_q (val, tmp_q.val);
 228   }
 229
 230   /* The destructor.  */
 231   ~gdb_mpf () { mpf_clear (val); }
 232 };
 233
 234 /* See declaration above.  */
 235
 236 template<typename T>
 237 void
 238 gdb_mpz::set (T src)
 239 {
 240   mpz_import (val, 1 /* count */, -1 /* order */,
 241               sizeof (T) /* size */, 0 /* endian (0 = native) */,
 242               0 /* nails */, &src /* op */);
 243   if (std::is_signed<T>::value && src < 0)
 244     {
 245       /* mpz_import does not handle the sign, so our value was imported
 246          as an unsigned. Adjust that imported value so as to make it
 247          the correct negative value.  */
 248       gdb_mpz neg_offset;
 249
 250       mpz_ui_pow_ui (neg_offset.val, 2, sizeof (T) * HOST_CHAR_BIT);
 251       mpz_sub (val, val, neg_offset.val);
 252     }
 253 }
 254
 255 /* See declaration above.  */
 256
 257 template<typename T>
 258 T
 259 gdb_mpz::as_integer () const
 260 {
 261   /* Initialize RESULT, because mpz_export only write the minimum
 262      number of bytes, including none if our value is zero!  */
 263   T result = 0;
 264
 265   gdb_mpz exported_val (val);
 266   if (std::is_signed<T>::value && mpz_cmp_ui (val, 0) < 0)
 267     {
 268       /* We want to use mpz_export to set the return value, but
 269          this function does not handle the sign. So give exported_val
 270          a value which is at the same time positive, and has the same
 271          bit representation as our negative value.  */
 272       gdb_mpz neg_offset;
 273
 274       mpz_ui_pow_ui (neg_offset.val, 2, sizeof (T) * HOST_CHAR_BIT);
 275       mpz_add (exported_val.val, exported_val.val, neg_offset.val);
 276     }
 277
 278   mpz_export (&result, NULL /* count */, -1 /* order */,
 279               sizeof (T) /* size */, 0 /* endian (0 = native) */,
 280               0 /* nails */, exported_val.val);
 281   return result;
 282 }
 283
 284 #endif