gdbsupport/packed.h

   1 /* Copyright (C) 2022-2024 Free Software Foundation, Inc.
   2
   3    This file is part of GDB.
   4
   5    This program is free software; you can redistribute it and/or modify
   6    it under the terms of the GNU General Public License as published by
   7    the Free Software Foundation; either version 3 of the License, or
   8    (at your option) any later version.
   9
  10    This program is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13    GNU General Public License for more details.
  14
  15    You should have received a copy of the GNU General Public License
  16    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  17
  18 #ifndef PACKED_H
  19 #define PACKED_H
  20
  21 #include "traits.h"
  22 #include <atomic>
  23
  24 /* Each instantiation and full specialization of the packed template
  25    defines a type that behaves like a given scalar type, but that has
  26    byte alignment, and, may optionally have a smaller size than the
  27    given scalar type.  This is typically used as alternative to
  28    bit-fields (and ENUM_BITFIELD), when the fields must have separate
  29    memory locations to avoid data races.  */
  30
  31 /* There are two implementations here -- one standard compliant, using
  32    a byte array for internal representation, and another that relies
  33    on bitfields and attribute packed (and attribute gcc_struct on
  34    Windows).  The latter is preferable, as it is more convenient when
  35    debugging GDB -- printing a struct packed variable prints its field
  36    using its natural type, which is particularly useful if the type is
  37    an enum -- but may not work on all compilers.  */
  38
  39 /* Clang targeting Windows does not support attribute gcc_struct, so
  40    we use the alternative byte array implementation there. */
  41 #if defined _WIN32 && defined __clang__
  42 # define PACKED_USE_ARRAY 1
  43 #else
  44 # define PACKED_USE_ARRAY 0
  45 #endif
  46
  47 /* For the preferred implementation, we need gcc_struct on Windows, as
  48    otherwise the size of e.g., "packed<int, 1>" will be larger than
  49    what we want.  Clang targeting Windows does not support attribute
  50    gcc_struct.  */
  51 #if !PACKED_USE_ARRAY && defined _WIN32 && !defined __clang__
  52 # define ATTRIBUTE_GCC_STRUCT __attribute__((__gcc_struct__))
  53 #else
  54 # define ATTRIBUTE_GCC_STRUCT
  55 #endif
  56
  57 template<typename T, size_t Bytes = sizeof (T)>
  58 struct ATTRIBUTE_GCC_STRUCT packed
  59 {
  60 public:
  61   packed () noexcept = default;
  62
  63   packed (T val)
  64   {
  65     static_assert (sizeof (ULONGEST) >= sizeof (T));
  66
  67 #if PACKED_USE_ARRAY
  68     ULONGEST tmp = val;
  69     for (int i = (Bytes - 1); i >= 0; --i)
  70       {
  71         m_bytes[i] = (gdb_byte) tmp;
  72         tmp >>= HOST_CHAR_BIT;
  73       }
  74 #else
  75     m_val = val;
  76 #endif
  77
  78     /* Ensure size and aligment are what we expect.  */
  79     static_assert (sizeof (packed) == Bytes);
  80     static_assert (alignof (packed) == 1);
  81
  82     /* Make sure packed can be wrapped with std::atomic.  */
  83     static_assert (std::is_trivially_copyable<packed>::value);
  84     static_assert (std::is_copy_constructible<packed>::value);
  85     static_assert (std::is_move_constructible<packed>::value);
  86     static_assert (std::is_copy_assignable<packed>::value);
  87     static_assert (std::is_move_assignable<packed>::value);
  88   }
  89
  90   operator T () const noexcept
  91   {
  92 #if PACKED_USE_ARRAY
  93     ULONGEST tmp = 0;
  94     for (int i = 0;;)
  95       {
  96         tmp |= m_bytes[i];
  97         if (++i == Bytes)
  98           break;
  99         tmp <<= HOST_CHAR_BIT;
 100       }
 101     return (T) tmp;
 102 #else
 103     return m_val;
 104 #endif
 105   }
 106
 107 private:
 108 #if PACKED_USE_ARRAY
 109   gdb_byte m_bytes[Bytes];
 110 #else
 111   T m_val : (Bytes * HOST_CHAR_BIT) ATTRIBUTE_PACKED;
 112 #endif
 113 };
 114
 115 /* Add some comparisons between std::atomic<packed<T>> and packed<T>
 116    and T.  We need this because even though std::atomic<T> doesn't
 117    define these operators, the relational expressions still work via
 118    implicit conversions.  Those wouldn't work when wrapped in packed
 119    without these operators, because they'd require two implicit
 120    conversions to go from T to packed<T> to std::atomic<packed<T>>
 121    (and back), and C++ only does one.  */
 122
 123 #define PACKED_ATOMIC_OP(OP)                                            \
 124   template<typename T, size_t Bytes>                                    \
 125   bool operator OP (const std::atomic<packed<T, Bytes>> &lhs,           \
 126                     const std::atomic<packed<T, Bytes>> &rhs)           \
 127   {                                                                     \
 128     return lhs.load () OP rhs.load ();                                  \
 129   }                                                                     \
 130                                                                         \
 131   template<typename T, size_t Bytes>                                    \
 132   bool operator OP (T lhs, const std::atomic<packed<T, Bytes>> &rhs)    \
 133   {                                                                     \
 134     return lhs OP rhs.load ();                                          \
 135   }                                                                     \
 136                                                                         \
 137   template<typename T, size_t Bytes>                                    \
 138   bool operator OP (const std::atomic<packed<T, Bytes>> &lhs, T rhs)    \
 139   {                                                                     \
 140     return lhs.load () OP rhs;                                          \
 141   }                                                                     \
 142                                                                         \
 143   template<typename T, size_t Bytes>                                    \
 144   bool operator OP (const std::atomic<packed<T, Bytes>> &lhs,           \
 145                     packed<T, Bytes> rhs)                               \
 146   {                                                                     \
 147     return lhs.load () OP rhs;                                          \
 148   }                                                                     \
 149                                                                         \
 150   template<typename T, size_t Bytes>                                    \
 151   bool operator OP (packed<T, Bytes> lhs,                               \
 152                     const std::atomic<packed<T, Bytes>> &rhs)           \
 153   {                                                                     \
 154     return lhs OP rhs.load ();                                          \
 155   }
 156
 157 PACKED_ATOMIC_OP (==)
 158 PACKED_ATOMIC_OP (!=)
 159 PACKED_ATOMIC_OP (>)
 160 PACKED_ATOMIC_OP (<)
 161 PACKED_ATOMIC_OP (>=)
 162 PACKED_ATOMIC_OP (<=)
 163
 164 #undef PACKED_ATOMIC_OP
 165
 166 #endif