gdbsupport/enum-flags.h

   1 /* Copyright (C) 2015-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 GDBSUPPORT_ENUM_FLAGS_H
  19 #define GDBSUPPORT_ENUM_FLAGS_H
  20
  21 #include "traits.h"
  22
  23 /* Type-safe wrapper for enum flags.  enum flags are enums where the
  24    values are bits that are meant to be ORed together.
  25
  26    This allows writing code like the below, while with raw enums this
  27    would fail to compile without casts to enum type at the assignments
  28    to 'f':
  29
  30     enum some_flag
  31     {
  32        flag_val1 = 1 << 1,
  33        flag_val2 = 1 << 2,
  34        flag_val3 = 1 << 3,
  35        flag_val4 = 1 << 4,
  36     };
  37     DEF_ENUM_FLAGS_TYPE(enum some_flag, some_flags);
  38
  39     some_flags f = flag_val1 | flag_val2;
  40     f |= flag_val3;
  41
  42    It's also possible to assign literal zero to an enum flags variable
  43    (meaning, no flags), dispensing adding an awkward explicit "no
  44    value" value to the enumeration.  For example:
  45
  46     some_flags f = 0;
  47     f |= flag_val3 | flag_val4;
  48
  49    Note that literal integers other than zero fail to compile:
  50
  51     some_flags f = 1; // error
  52 */
  53
  54 /* Use this to mark an enum as flags enum.  It defines FLAGS_TYPE as
  55    enum_flags wrapper class for ENUM, and enables the global operator
  56    overloads for ENUM.  */
  57 #define DEF_ENUM_FLAGS_TYPE(enum_type, flags_type)      \
  58   using flags_type = enum_flags<enum_type>;             \
  59   void is_enum_flags_enum_type (enum_type *)
  60
  61 /* To enable the global enum_flags operators for enum, declare an
  62    "is_enum_flags_enum_type" overload that has exactly one parameter,
  63    of type a pointer to that enum class.  E.g.,:
  64
  65      void is_enum_flags_enum_type (enum some_flag *);
  66
  67    The function does not need to be defined, only declared.
  68    DEF_ENUM_FLAGS_TYPE declares this.
  69
  70    A function declaration is preferred over a traits type, because the
  71    former allows calling the DEF_ENUM_FLAGS_TYPE macro inside a
  72    namespace to define the corresponding enum flags type in that
  73    namespace.  The compiler finds the corresponding
  74    is_enum_flags_enum_type function via ADL.  */
  75
  76 namespace enum_flags_detail
  77 {
  78
  79 /* Private type used to support initializing flag types with zero:
  80
  81    foo_flags f = 0;
  82
  83    but not other integers:
  84
  85    foo_flags f = 1;
  86
  87    The way this works is that we define an implicit constructor that
  88    takes a pointer to this private type.  Since nothing can
  89    instantiate an object of this type, the only possible pointer to
  90    pass to the constructor is the NULL pointer, or, zero.  */
  91 struct zero_type;
  92
  93 /* gdb::Requires trait helpers.  */
  94 template <typename enum_type>
  95 using EnumIsUnsigned
  96   = std::is_unsigned<typename std::underlying_type<enum_type>::type>;
  97
  98 /* Helper to detect whether an enum has a fixed underlying type. This can be
  99    achieved by using a scoped enum (in which case the type is "int") or
 100    an explicit underlying type. C-style enums that are unscoped or do not
 101    have an explicit underlying type have an implementation-defined underlying
 102    type.
 103
 104    https://timsong-cpp.github.io/cppwp/n4659/dcl.enum#5
 105
 106    We need this trait in order to ensure that operator~ below does NOT
 107    operate on old-style enums. This is because we apply operator~ on
 108    the value and then cast the result to the enum_type. This is however
 109    Undefined Behavior if the result does not fit in the range of possible
 110    values for the enum. For enums with fixed underlying type, the entire
 111    range of the integer is available. However, for old-style enums, the range
 112    is only the smallest bit-field that can hold all the values of the
 113    enumeration, typically much smaller than the underlying integer:
 114
 115    https://timsong-cpp.github.io/cppwp/n4659/expr.static.cast#10
 116    https://timsong-cpp.github.io/cppwp/n4659/dcl.enum#8
 117
 118    To implement this, we leverage the fact that, since C++17, enums with
 119    fixed underlying type can be list-initialized from an integer:
 120    https://timsong-cpp.github.io/cppwp/n4659/dcl.init.list#3.7
 121
 122    Old-style enums cannot be initialized like that, leading to ill-formed
 123    code.
 124
 125    We then use this together with SFINAE to create the desired trait.
 126
 127 */
 128 template <typename enum_type, typename = void>
 129 struct EnumHasFixedUnderlyingType : std::false_type
 130 {
 131   static_assert(std::is_enum<enum_type>::value);
 132 };
 133
 134 /* Specialization that is active only if enum_type can be
 135    list-initialized from an integer (0).  Only enums with fixed
 136    underlying type satisfy this property in C++17.  */
 137 template <typename enum_type>
 138 struct EnumHasFixedUnderlyingType<enum_type, std::void_t<decltype(enum_type{0})>> : std::true_type
 139 {
 140   static_assert(std::is_enum<enum_type>::value);
 141 };
 142
 143 template <typename enum_type>
 144 using EnumIsSafeForBitwiseComplement = std::conjunction<
 145   EnumIsUnsigned<enum_type>,
 146   EnumHasFixedUnderlyingType<enum_type>
 147 >;
 148
 149 template <typename enum_type>
 150 using EnumIsUnsafeForBitwiseComplement = std::negation<EnumIsSafeForBitwiseComplement<enum_type>>;
 151
 152 }
 153
 154 template <typename E>
 155 class enum_flags
 156 {
 157 public:
 158   using enum_type = E;
 159   using underlying_type = typename std::underlying_type<enum_type>::type;
 160
 161   /* For to_string.  Maps one enumerator of E to a string.  */
 162   struct string_mapping
 163   {
 164     E flag;
 165     const char *str;
 166   };
 167
 168   /* Convenience for to_string implementations, to build a
 169      string_mapping array.  */
 170 #define MAP_ENUM_FLAG(ENUM_FLAG) { ENUM_FLAG, #ENUM_FLAG }
 171
 172 public:
 173   /* Allow default construction.  */
 174   constexpr enum_flags ()
 175     : m_enum_value ((enum_type) 0)
 176   {}
 177
 178   /* The default move/copy ctor/assignment do the right thing.  */
 179
 180   /* If you get an error saying these two overloads are ambiguous,
 181      then you tried to mix values of different enum types.  */
 182   constexpr enum_flags (enum_type e)
 183     : m_enum_value (e)
 184   {}
 185   constexpr enum_flags (enum_flags_detail::zero_type *zero)
 186     : m_enum_value ((enum_type) 0)
 187   {}
 188
 189   enum_flags &operator&= (enum_flags e) &
 190   {
 191     m_enum_value = (enum_type) (m_enum_value & e.m_enum_value);
 192     return *this;
 193   }
 194   enum_flags &operator|= (enum_flags e) &
 195   {
 196     m_enum_value = (enum_type) (m_enum_value | e.m_enum_value);
 197     return *this;
 198   }
 199   enum_flags &operator^= (enum_flags e) &
 200   {
 201     m_enum_value = (enum_type) (m_enum_value ^ e.m_enum_value);
 202     return *this;
 203   }
 204
 205   /* Delete rval versions.  */
 206   void operator&= (enum_flags e) && = delete;
 207   void operator|= (enum_flags e) && = delete;
 208   void operator^= (enum_flags e) && = delete;
 209
 210   /* Like raw enums, allow conversion to the underlying type.  */
 211   constexpr operator underlying_type () const
 212   {
 213     return m_enum_value;
 214   }
 215
 216   /* Get the underlying value as a raw enum.  */
 217   constexpr enum_type raw () const
 218   {
 219     return m_enum_value;
 220   }
 221
 222   /* Binary operations involving some unrelated type (which would be a
 223      bug) are implemented as non-members, and deleted.  */
 224
 225   /* Convert this object to a std::string, using MAPPING as
 226      enumerator-to-string mapping array.  This is not meant to be
 227      called directly.  Instead, enum_flags specializations should have
 228      their own to_string function wrapping this one, thus hiding the
 229      mapping array from callers.
 230
 231      Note: this is defined outside the template class so it can use
 232      the global operators for enum_type, which are only defined after
 233      the template class.  */
 234   template<size_t N>
 235   std::string to_string (const string_mapping (&mapping)[N]) const;
 236
 237 private:
 238   /* Stored as enum_type because GDB knows to print the bit flags
 239      neatly if the enum values look like bit flags.  */
 240   enum_type m_enum_value;
 241 };
 242
 243 template <typename E>
 244 using is_enum_flags_enum_type_t
 245   = decltype (is_enum_flags_enum_type (std::declval<E *> ()));
 246
 247 /* Global operator overloads.  */
 248
 249 /* Generate binary operators.  */
 250
 251 #define ENUM_FLAGS_GEN_BINOP(OPERATOR_OP, OP)                           \
 252                                                                         \
 253   /* Raw enum on both LHS/RHS.  Returns raw enum type.  */              \
 254   template <typename enum_type,                                         \
 255             typename = is_enum_flags_enum_type_t<enum_type>>            \
 256   constexpr enum_type                                                   \
 257   OPERATOR_OP (enum_type e1, enum_type e2)                              \
 258   {                                                                     \
 259     using underlying = typename enum_flags<enum_type>::underlying_type; \
 260     return (enum_type) (underlying (e1) OP underlying (e2));            \
 261   }                                                                     \
 262                                                                         \
 263   /* enum_flags on the LHS.  */                                         \
 264   template <typename enum_type,                                         \
 265             typename = is_enum_flags_enum_type_t<enum_type>>            \
 266   constexpr enum_flags<enum_type>                                       \
 267   OPERATOR_OP (enum_flags<enum_type> e1, enum_type e2)                  \
 268   { return e1.raw () OP e2; }                                           \
 269                                                                         \
 270   /* enum_flags on the RHS.  */                                         \
 271   template <typename enum_type,                                         \
 272             typename = is_enum_flags_enum_type_t<enum_type>>            \
 273   constexpr enum_flags<enum_type>                                       \
 274   OPERATOR_OP (enum_type e1, enum_flags<enum_type> e2)                  \
 275   { return e1 OP e2.raw (); }                                           \
 276                                                                         \
 277   /* enum_flags on both LHS/RHS.  */                                    \
 278   template <typename enum_type,                                         \
 279             typename = is_enum_flags_enum_type_t<enum_type>>            \
 280   constexpr enum_flags<enum_type>                                       \
 281   OPERATOR_OP (enum_flags<enum_type> e1, enum_flags<enum_type> e2)      \
 282   { return e1.raw () OP e2.raw (); }                                    \
 283                                                                         \
 284   /* Delete cases involving unrelated types.  */                        \
 285                                                                         \
 286   template <typename enum_type, typename unrelated_type,                \
 287             typename = is_enum_flags_enum_type_t<enum_type>>            \
 288   constexpr enum_flags<enum_type>                                       \
 289   OPERATOR_OP (enum_type e1, unrelated_type e2) = delete;               \
 290                                                                         \
 291   template <typename enum_type, typename unrelated_type,                \
 292             typename = is_enum_flags_enum_type_t<enum_type>>            \
 293   constexpr enum_flags<enum_type>                                       \
 294   OPERATOR_OP (unrelated_type e1, enum_type e2) = delete;               \
 295                                                                         \
 296   template <typename enum_type, typename unrelated_type,                \
 297             typename = is_enum_flags_enum_type_t<enum_type>>            \
 298   constexpr enum_flags<enum_type>                                       \
 299   OPERATOR_OP (enum_flags<enum_type> e1, unrelated_type e2) = delete;   \
 300                                                                         \
 301   template <typename enum_type, typename unrelated_type,                \
 302             typename = is_enum_flags_enum_type_t<enum_type>>            \
 303   constexpr enum_flags<enum_type>                                       \
 304   OPERATOR_OP (unrelated_type e1, enum_flags<enum_type> e2) = delete;
 305
 306 /* Generate non-member compound assignment operators.  Only the raw
 307    enum versions are defined here.  The enum_flags versions are
 308    defined as member functions, simply because it's less code that
 309    way.
 310
 311    Note we delete operators that would allow e.g.,
 312
 313      "enum_type | 1" or "enum_type1 | enum_type2"
 314
 315    because that would allow a mistake like :
 316      enum flags1 { F1_FLAGS1 = 1 };
 317      enum flags2 { F2_FLAGS2 = 2 };
 318      enum flags1 val;
 319      switch (val) {
 320        case F1_FLAGS1 | F2_FLAGS2:
 321      ...
 322
 323    If you really need to 'or' enumerators of different flag types,
 324    cast to integer first.
 325 */
 326 #define ENUM_FLAGS_GEN_COMPOUND_ASSIGN(OPERATOR_OP, OP)                 \
 327   /* lval reference version.  */                                        \
 328   template <typename enum_type,                                         \
 329             typename = is_enum_flags_enum_type_t<enum_type>>            \
 330   constexpr enum_type &                                                 \
 331   OPERATOR_OP (enum_type &e1, enum_type e2)                             \
 332   { return e1 = e1 OP e2; }                                             \
 333                                                                         \
 334   /* rval reference version.  */                                        \
 335   template <typename enum_type,                                         \
 336             typename = is_enum_flags_enum_type_t<enum_type>>            \
 337   void                                                                  \
 338   OPERATOR_OP (enum_type &&e1, enum_type e2) = delete;                  \
 339                                                                         \
 340   /* Delete compound assignment from unrelated types.  */               \
 341                                                                         \
 342   template <typename enum_type, typename other_enum_type,               \
 343             typename = is_enum_flags_enum_type_t<enum_type>>            \
 344   constexpr enum_type &                                                 \
 345   OPERATOR_OP (enum_type &e1, other_enum_type e2) = delete;             \
 346                                                                         \
 347   template <typename enum_type, typename other_enum_type,               \
 348             typename = is_enum_flags_enum_type_t<enum_type>>            \
 349   void                                                                  \
 350   OPERATOR_OP (enum_type &&e1, other_enum_type e2) = delete;
 351
 352 ENUM_FLAGS_GEN_BINOP (operator|, |)
 353 ENUM_FLAGS_GEN_BINOP (operator&, &)
 354 ENUM_FLAGS_GEN_BINOP (operator^, ^)
 355
 356 ENUM_FLAGS_GEN_COMPOUND_ASSIGN (operator|=, |)
 357 ENUM_FLAGS_GEN_COMPOUND_ASSIGN (operator&=, &)
 358 ENUM_FLAGS_GEN_COMPOUND_ASSIGN (operator^=, ^)
 359
 360 /* Allow comparison with enum_flags, raw enum, and integers, only.
 361    The latter case allows "== 0".  As side effect, it allows comparing
 362    with integer variables too, but that's not a common mistake to
 363    make.  It's important to disable comparison with unrelated types to
 364    prevent accidentally comparing with unrelated enum values, which
 365    are convertible to integer, and thus coupled with enum_flags
 366    conversion to underlying type too, would trigger the built-in 'bool
 367    operator==(unsigned, int)' operator.  */
 368
 369 #define ENUM_FLAGS_GEN_COMP(OPERATOR_OP, OP)                            \
 370                                                                         \
 371   /* enum_flags OP enum_flags */                                        \
 372                                                                         \
 373   template <typename enum_type>                                         \
 374   constexpr bool                                                        \
 375   OPERATOR_OP (enum_flags<enum_type> lhs, enum_flags<enum_type> rhs)    \
 376   { return lhs.raw () OP rhs.raw (); }                                  \
 377                                                                         \
 378   /* enum_flags OP other */                                             \
 379                                                                         \
 380   template <typename enum_type>                                         \
 381   constexpr bool                                                        \
 382   OPERATOR_OP (enum_flags<enum_type> lhs, enum_type rhs)                \
 383   { return lhs.raw () OP rhs; }                                         \
 384                                                                         \
 385   template <typename enum_type>                                         \
 386   constexpr bool                                                        \
 387   OPERATOR_OP (enum_flags<enum_type> lhs, int rhs)                      \
 388   { return lhs.raw () OP rhs; }                                         \
 389                                                                         \
 390   template <typename enum_type, typename U>                             \
 391   constexpr bool                                                        \
 392   OPERATOR_OP (enum_flags<enum_type> lhs, U rhs) = delete;              \
 393                                                                         \
 394   /* other OP enum_flags */                                             \
 395                                                                         \
 396   template <typename enum_type>                                         \
 397   constexpr bool                                                        \
 398   OPERATOR_OP (enum_type lhs, enum_flags<enum_type> rhs)                \
 399   { return lhs OP rhs.raw (); }                                         \
 400                                                                         \
 401   template <typename enum_type>                                         \
 402   constexpr bool                                                        \
 403   OPERATOR_OP (int lhs, enum_flags<enum_type> rhs)                      \
 404   { return lhs OP rhs.raw (); }                                         \
 405                                                                         \
 406   template <typename enum_type, typename U>                             \
 407   constexpr bool                                                        \
 408   OPERATOR_OP (U lhs, enum_flags<enum_type> rhs) = delete;
 409
 410 ENUM_FLAGS_GEN_COMP (operator==, ==)
 411 ENUM_FLAGS_GEN_COMP (operator!=, !=)
 412
 413 /* Unary operators for the raw flags enum.  */
 414
 415 /* We require underlying type to be unsigned when using operator~ --
 416    if it were not unsigned, undefined behavior could result.  However,
 417    asserting this in the class itself would require too many
 418    unnecessary changes to usages of otherwise OK enum types.  */
 419 template <typename enum_type,
 420           typename = is_enum_flags_enum_type_t<enum_type>,
 421           typename
 422             = gdb::Requires<enum_flags_detail::EnumIsSafeForBitwiseComplement<enum_type>>>
 423 constexpr enum_type
 424 operator~ (enum_type e)
 425 {
 426   using underlying = typename enum_flags<enum_type>::underlying_type;
 427   /* Cast to ULONGEST first, to prevent integer promotions from enums
 428      with fixed underlying type std::uint8_t or std::uint16_t to
 429      signed int.  This ensures we apply the bitwise complement on an
 430      unsigned type.  */
 431   return (enum_type)(underlying) ~ULONGEST (e);
 432 }
 433
 434 template <typename enum_type,
 435           typename = is_enum_flags_enum_type_t<enum_type>,
 436           typename = gdb::Requires<enum_flags_detail::EnumIsUnsafeForBitwiseComplement<enum_type>>>
 437 constexpr void operator~ (enum_type e) = delete;
 438
 439 template <typename enum_type,
 440           typename = is_enum_flags_enum_type_t<enum_type>,
 441           typename
 442             = gdb::Requires<enum_flags_detail::EnumIsSafeForBitwiseComplement<enum_type>>>
 443 constexpr enum_flags<enum_type>
 444 operator~ (enum_flags<enum_type> e)
 445 {
 446   using underlying = typename enum_flags<enum_type>::underlying_type;
 447   /* Cast to ULONGEST first, to prevent integer promotions from enums
 448      with fixed underlying type std::uint8_t or std::uint16_t to
 449      signed int.  This ensures we apply the bitwise complement on an
 450      unsigned type.  */
 451   return (enum_type)(underlying) ~ULONGEST (e);
 452 }
 453
 454 template <typename enum_type,
 455           typename = is_enum_flags_enum_type_t<enum_type>,
 456           typename = gdb::Requires<enum_flags_detail::EnumIsUnsafeForBitwiseComplement<enum_type>>>
 457 constexpr void operator~ (enum_flags<enum_type> e) = delete;
 458
 459 /* Delete operator<< and operator>>.  */
 460
 461 template <typename enum_type, typename any_type,
 462           typename = is_enum_flags_enum_type_t<enum_type>>
 463 void operator<< (const enum_type &, const any_type &) = delete;
 464
 465 template <typename enum_type, typename any_type,
 466           typename = is_enum_flags_enum_type_t<enum_type>>
 467 void operator<< (const enum_flags<enum_type> &, const any_type &) = delete;
 468
 469 template <typename enum_type, typename any_type,
 470           typename = is_enum_flags_enum_type_t<enum_type>>
 471 void operator>> (const enum_type &, const any_type &) = delete;
 472
 473 template <typename enum_type, typename any_type,
 474           typename = is_enum_flags_enum_type_t<enum_type>>
 475 void operator>> (const enum_flags<enum_type> &, const any_type &) = delete;
 476
 477 template<typename E>
 478 template<size_t N>
 479 std::string
 480 enum_flags<E>::to_string (const string_mapping (&mapping)[N]) const
 481 {
 482   enum_type flags = raw ();
 483   std::string res = hex_string (flags);
 484   res += " [";
 485
 486   bool need_space = false;
 487   for (const auto &entry : mapping)
 488     {
 489       if ((flags & entry.flag) != 0)
 490         {
 491           /* Work with an unsigned version of the underlying type,
 492              because if enum_type's underlying type is signed, op~
 493              won't be defined for it, and, bitwise operations on
 494              signed types are implementation defined.  */
 495           using uns = typename std::make_unsigned<underlying_type>::type;
 496           flags &= (enum_type) ~(uns) entry.flag;
 497
 498           if (need_space)
 499             res += " ";
 500           res += entry.str;
 501
 502           need_space = true;
 503         }
 504     }
 505
 506   /* If there were flags not included in the mapping, print them as
 507      a hex number.  */
 508   if (flags != 0)
 509     {
 510       if (need_space)
 511         res += " ";
 512       res += hex_string (flags);
 513     }
 514
 515   res += "]";
 516
 517   return res;
 518 }
 519
 520 #endif /* GDBSUPPORT_ENUM_FLAGS_H */