gem5  v21.1.0.2
bitunion.hh
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2007-2008 The Regents of The University of Michigan
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions are
7  * met: redistributions of source code must retain the above copyright
8  * notice, this list of conditions and the following disclaimer;
9  * redistributions in binary form must reproduce the above copyright
10  * notice, this list of conditions and the following disclaimer in the
11  * documentation and/or other materials provided with the distribution;
12  * neither the name of the copyright holders nor the names of its
13  * contributors may be used to endorse or promote products derived from
14  * this software without specific prior written permission.
15  *
16  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
17  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
18  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
19  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
20  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
21  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
22  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
26  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27  */
28 
29 #ifndef __BASE_BITUNION_HH__
30 #define __BASE_BITUNION_HH__
31 
32 #include <functional>
33 #include <iostream>
34 #include <type_traits>
35 #include <typeinfo>
36 
37 #include "base/bitfield.hh"
38 #include "base/compiler.hh"
40 
41 namespace gem5
42 {
43 
44 // The following implements the BitUnion system of defining bitfields
45 //on top of an underlying class. This is done through the pervasive use of
46 //both named and unnamed unions which all contain the same actual storage.
47 //Since they're unioned with each other, all of these storage locations
48 //overlap. This allows all of the bitfields to manipulate the same data
49 //without having to have access to each other. More details are provided with
50 //the individual components.
51 
52 //This class wraps around another which defines getter/setter functions which
53 //manipulate the underlying data. The type of the underlying data and the type
54 //of the bitfield itself are inferred from the argument types of the setter
55 //function.
56 template<class Base>
57 class BitfieldTypeImpl : public Base
58 {
59  static_assert(std::is_empty<Base>::value,
60  "Bitfield base class must be empty.");
61 
62  private:
63 
64  struct TypeDeducer
65  {
66  template<typename>
67  struct T;
68 
69  template<typename C, typename Type1, typename Type2>
70  struct T<void (C::*)(Type1 &, Type2)>
71  {
72  typedef Type1 Storage;
73  typedef Type2 Type;
74  };
75 
76  struct Wrapper : public Base
77  {
78  using Base::setter;
79  };
80 
81  typedef typename T<decltype(&Wrapper::setter)>::Storage Storage;
82  typedef typename T<decltype(&Wrapper::setter)>::Type Type;
83  };
84 
85  protected:
86  typedef typename TypeDeducer::Storage Storage;
87  typedef typename TypeDeducer::Type Type;
88 
89  Type getter(const Storage &storage) const = delete;
90  void setter(Storage &storage, Type val) = delete;
91 
92  BitfieldTypeImpl() = default;
93  BitfieldTypeImpl(const BitfieldTypeImpl &) = default;
94 
96 
97  operator Type () const
98  {
99  return Base::getter(__storage);
100  }
101 
102  Type
104  {
105  Base::setter(__storage, val);
106  return val;
107  }
108 
109  Type
111  {
112  return *this = (Type)other;
113  }
114 };
115 
116 //A wrapper for the above class which allows setting and getting.
117 template<class Base>
118 class BitfieldType : public BitfieldTypeImpl<Base>
119 {
120  protected:
122  using typename Impl::Type;
123 
124  public:
125  BitfieldType() = default;
126  BitfieldType(const BitfieldType &) = default;
127 
128  operator Type () const { return Impl::operator Type(); }
129 
130  Type operator=(const Type val) { return Impl::operator=(val); }
131  Type
133  {
134  return Impl::operator=(other);
135  }
136 };
137 
138 //A wrapper which only supports getting.
139 template<class Base>
140 class BitfieldROType : public BitfieldTypeImpl<Base>
141 {
142  public:
144  using typename Impl::Type;
145 
146  BitfieldROType() = default;
147  BitfieldROType(const BitfieldROType &) = default;
148 
149  Type operator=(BitfieldROType<Base> const &other) = delete;
150  operator Type () const { return Impl::operator Type(); }
151 };
152 
153 //A wrapper which only supports setting.
154 template <class Base>
155 class BitfieldWOType : public BitfieldTypeImpl<Base>
156 {
157  protected:
159  using typename Impl::Type;
160 
161  public:
162  BitfieldWOType() = default;
163  BitfieldWOType(const BitfieldWOType &) = default;
164 
165  Type operator=(const Type val) { return Impl::operator=(val); }
166  Type
168  {
169  return Impl::operator=(other);
170  }
171 };
172 
173 //This namespace is for classes which implement the backend of the BitUnion
174 //stuff. Don't use any of these directly.
175 namespace bitfield_backend
176 {
177  template<class Storage, int first, int last>
178  class Unsigned
179  {
180  static_assert(first >= last,
181  "Bitfield ranges must be specified as <msb, lsb>");
182 
183  protected:
184  uint64_t
185  getter(const Storage &storage) const
186  {
187  return bits(storage, first, last);
188  }
189 
190  void
191  setter(Storage &storage, uint64_t val)
192  {
193  replaceBits(storage, first, last, val);
194  }
195  };
196 
197  template<class Storage, int first, int last>
198  class Signed
199  {
200  static_assert(first >= last,
201  "Bitfield ranges must be specified as <msb, lsb>");
202 
203  protected:
204  int64_t
205  getter(const Storage &storage) const
206  {
207  return sext<first - last + 1>(bits(storage, first, last));
208  }
209 
210  void
211  setter(Storage &storage, int64_t val)
212  {
213  replaceBits(storage, first, last, val);
214  }
215  };
216 
217  //This class contains the basic bitfield types which are automatically
218  //available within a BitUnion. They inherit their Storage type from the
219  //containing BitUnion.
220  template<class Storage>
222  {
223  protected:
224 
225  template<int first, int last=first>
227  template<int first, int last=first>
228  using BitfieldRO =
230  template<int first, int last=first>
231  using BitfieldWO =
233 
234  template<int first, int last=first>
235  using SignedBitfield =
237  template<int first, int last=first>
238  using SignedBitfieldRO =
240  template<int first, int last=first>
241  using SignedBitfieldWO =
243  };
244 
245  //When a BitUnion is set up, an underlying class is created which holds
246  //the actual union. This class then inherits from it, and provids the
247  //implementations for various operators. Setting things up this way
248  //prevents having to redefine these functions in every different BitUnion
249  //type. More operators could be implemented in the future, as the need
250  //arises.
251  template <class Base>
252  class BitUnionOperators : public Base
253  {
254  static_assert(sizeof(Base) == sizeof(typename Base::__StorageType),
255  "BitUnion larger than its storage type.");
256 
257  public:
258  BitUnionOperators(typename Base::__StorageType const &val)
259  {
260  Base::__storage = val;
261  }
262 
263  BitUnionOperators(const BitUnionOperators &) = default;
264 
266 
267  //Conversion operators.
268  operator const typename Base::__StorageType () const
269  {
270  return Base::__storage;
271  }
272 
273  //Basic assignment operators.
275  operator=(typename Base::__StorageType const &val)
276  {
277  Base::__storage = val;
278  return *this;
279  }
280 
283  {
284  return operator=(other.__storage);
285  }
286 
287  //Increment and decrement operators.
290  {
291  Base::__storage++;
292  return *this;
293  }
294 
297  {
298  BitUnionOperators ret = *this;
299  operator++();
300  return ret;
301  }
302 
305  {
306  Base::__storage--;
307  return *this;
308  }
309 
312  {
313  BitUnionOperators ret = *this;
314  operator--();
315  return ret;
316  }
317 
318  //Operation and assignment operators
320  operator+=(typename Base::__StorageType const &val)
321  {
322  Base::__storage += val;
323  return *this;
324  }
325 
327  operator-=(typename Base::__StorageType const &val)
328  {
329  Base::__storage -= val;
330  return *this;
331  }
332 
334  operator*=(typename Base::__StorageType const &val)
335  {
336  Base::__storage *= val;
337  return *this;
338  }
339 
341  operator/=(typename Base::__StorageType const &val)
342  {
343  Base::__storage /= val;
344  return *this;
345  }
346 
348  operator%=(typename Base::__StorageType const &val)
349  {
350  Base::__storage %= val;
351  return *this;
352  }
353 
355  operator&=(typename Base::__StorageType const &val)
356  {
357  Base::__storage &= val;
358  return *this;
359  }
360 
362  operator|=(typename Base::__StorageType const &val)
363  {
364  Base::__storage |= val;
365  return *this;
366  }
367 
369  operator^=(typename Base::__StorageType const &val)
370  {
371  Base::__storage ^= val;
372  return *this;
373  }
374 
376  operator<<=(typename Base::__StorageType const &val)
377  {
378  Base::__storage <<= val;
379  return *this;
380  }
381 
383  operator>>=(typename Base::__StorageType const &val)
384  {
385  Base::__storage >>= val;
386  return *this;
387  }
388  };
389 } // namespace bitfield_backend
390 
391 //This macro is a backend for other macros that specialize it slightly.
392 //First, it creates/extends a namespace "BitfieldUnderlyingClasses" and
393 //sticks the class which has the actual union in it, which
394 //BitfieldOperators above inherits from. Putting these classes in a special
395 //namespace ensures that there will be no collisions with other names as long
396 //as the BitUnion names themselves are all distinct and nothing else uses
397 //the BitfieldUnderlyingClasses namespace, which is unlikely. The class itself
398 //creates a typedef of the "type" parameter called __StorageType. This allows
399 //the type to propagate outside of the macro itself in a controlled way.
400 //Finally, the base storage is defined which BitfieldOperators will refer to
401 //in the operators it defines. This macro is intended to be followed by
402 //bitfield definitions which will end up inside it's union. As explained
403 //above, these is overlayed the __storage member in its entirety by each of the
404 //bitfields which are defined in the union, creating shared storage with no
405 //overhead.
406 #define __BitUnion(type, name) \
407  class BitfieldUnderlyingClasses##name : \
408  public gem5::bitfield_backend::BitfieldTypes<type> \
409  { \
410  protected: \
411  typedef type __StorageType; \
412  friend gem5::bitfield_backend::BitUnionBaseType< \
413  gem5::bitfield_backend::BitUnionOperators< \
414  BitfieldUnderlyingClasses##name> >; \
415  friend gem5::bitfield_backend::BitUnionBaseType< \
416  BitfieldUnderlyingClasses##name>; \
417  public: \
418  union { \
419  type __storage;
420 
429 #define EndBitUnion(name) \
430  }; \
431  }; \
432  typedef gem5::bitfield_backend::BitUnionOperators< \
433  BitfieldUnderlyingClasses##name> name;
434 
435 //This sets up a bitfield which has other bitfields nested inside of it. The
436 //__storage member functions like the "underlying storage" of the top level
437 //BitUnion. Like everything else, it overlays with the top level storage, so
438 //making it a regular bitfield type makes the entire thing function as a
439 //regular bitfield when referred to by itself.
440 #define __SubBitUnion(name, fieldType, ...) \
441  class \
442  { \
443  public: \
444  union { \
445  fieldType<__VA_ARGS__> __storage;
446 
456 #define EndSubBitUnion(name) \
457  }; \
458  inline operator __StorageType () const \
459  { return __storage; } \
460  \
461  inline __StorageType operator = (const __StorageType & _storage) \
462  { return __storage = _storage;} \
463  } name;
464 
471 #define SubBitUnion(name, first, last) \
472  __SubBitUnion(name, Bitfield, first, last)
473 
480 #define SignedSubBitUnion(name, first, last) \
481  __SubBitUnion(name, SignedBitfield, first, last)
482 
488 #define BitUnion(type, name) __BitUnion(type, name)
489 
495 #define BitUnion64(name) __BitUnion(uint64_t, name)
496 #define BitUnion32(name) __BitUnion(uint32_t, name)
497 #define BitUnion16(name) __BitUnion(uint16_t, name)
498 #define BitUnion8(name) __BitUnion(uint8_t, name)
499 
500 
501 //These templates make it possible to define other templates related to
502 //BitUnions without having to refer to internal typedefs or the
503 // bitfield_backend namespace.
504 
505 //To build a template specialization which works for all BitUnions, accept a
506 //template argument T, and then use BitUnionType<T> as an argument in the
507 //template. To refer to the basic type the BitUnion wraps, use
508 //BitUnionBaseType<T>.
509 
510 //For example:
511 //template <typename T>
512 //void func(BitUnionType<T> u) { BitUnionBaseType<T> b = u; }
513 
514 //Also, BitUnionBaseType can be used on a BitUnion type directly.
515 
519 template <typename T>
521 
522 namespace bitfield_backend
523 {
524  template<typename T>
526  {
528  };
529 
530  template<typename T>
532  {
534  };
535 } // namespace bitfield_backend
536 
540 template <typename T>
542 
543 namespace bitfield_backend
544 {
545  template<typename T>
546  static inline std::ostream &
547  bitfieldBackendPrinter(std::ostream &os, const T &t)
548  {
549  os << t;
550  return os;
551  }
552 
553  //Since BitUnions are generally numerical values and not character codes,
554  //these specializations attempt to ensure that they get cast to integers
555  //of the appropriate type before printing.
556  template <>
557  inline std::ostream &
558  bitfieldBackendPrinter(std::ostream &os, const char &t)
559  {
560  os << (int)t;
561  return os;
562  }
563 
564  template <>
565  inline std::ostream &
566  bitfieldBackendPrinter(std::ostream &os, const unsigned char &t)
567  {
568  os << (unsigned int)t;
569  return os;
570  }
571 } // namespace bitfield_backend
572 
579 template <typename T>
580 std::ostream &
581 operator << (std::ostream &os, const BitUnionType<T> &bu)
582 {
584  os, (BitUnionBaseType<T>)bu);
585 }
586 
587 // Specialization for BitUnion types.
588 template <class T>
590 {
591  static bool
592  parse(const std::string &s, BitUnionType<T> &value)
593  {
594  // Zero initialize storage to avoid leaking an uninitialized value
596  auto res = to_number(s, storage);
597  value = storage;
598  return res;
599  }
600 };
601 
602 template <class T>
604 {
605  static void
606  show(std::ostream &os, const BitUnionType<T> &value)
607  {
609  os, static_cast<const BitUnionBaseType<T> &>(value));
610  }
611 };
612 
613 } // namespace gem5
614 
615 //An STL style hash structure for hashing BitUnions based on their base type.
616 namespace std
617 {
618  template <typename T>
619  struct hash<gem5::BitUnionType<T>> : public hash<gem5::BitUnionBaseType<T>>
620  {
621  size_t
622  operator() (const gem5::BitUnionType<T> &val) const
623  {
624  return hash<gem5::BitUnionBaseType<T> >::operator()(val);
625  }
626  };
627 } // namespace std
628 
629 #endif // __BASE_BITUNION_HH__
gem5::bitfield_backend::Signed
Definition: bitunion.hh:198
gem5::operator<<
std::ostream & operator<<(std::ostream &os, const ArmSemihosting::InPlaceArg &ipa)
Definition: semihosting.cc:1045
gem5::bitfield_backend::BitUnionOperators::operator%=
BitUnionOperators & operator%=(typename Base::__StorageType const &val)
Definition: bitunion.hh:348
gem5::BitfieldTypeImpl::operator=
Type operator=(BitfieldTypeImpl< Base > const &other)
Definition: bitunion.hh:110
gem5::bitfield_backend::BitUnionBaseType< BitUnionType< T > >::Type
BitUnionType< T >::__StorageType Type
Definition: bitunion.hh:533
gem5::bitfield_backend::BitUnionOperators::operator=
BitUnionOperators & operator=(BitUnionOperators const &other)
Definition: bitunion.hh:282
gem5::bitfield_backend::BitUnionOperators::BitUnionOperators
BitUnionOperators()
Definition: bitunion.hh:265
gem5::bitfield_backend::Unsigned::setter
void setter(Storage &storage, uint64_t val)
Definition: bitunion.hh:191
gem5::BitfieldTypeImpl::TypeDeducer::T< void(C::*)(Type1 &, Type2)>::Type
Type2 Type
Definition: bitunion.hh:73
gem5::BitfieldWOType::BitfieldWOType
BitfieldWOType()=default
gem5::bitfield_backend::Signed::getter
int64_t getter(const Storage &storage) const
Definition: bitunion.hh:205
gem5::bitfield_backend::BitUnionOperators::operator>>=
BitUnionOperators & operator>>=(typename Base::__StorageType const &val)
Definition: bitunion.hh:383
gem5::bitfield_backend::BitUnionBaseType
Definition: bitunion.hh:525
gem5::BitUnionType
bitfield_backend::BitUnionOperators< T > BitUnionType
Definition: bitunion.hh:520
gem5::BitfieldTypeImpl::__storage
Storage __storage
Definition: bitunion.hh:95
gem5::replaceBits
constexpr void replaceBits(T &val, unsigned first, unsigned last, B bit_val)
A convenience function to replace bits first to last of val with bit_val in place.
Definition: bitfield.hh:197
gem5::sext
constexpr uint64_t sext(uint64_t val)
Sign-extend an N-bit value to 64 bits.
Definition: bitfield.hh:126
gem5::bitfield_backend::BitUnionOperators
Definition: bitunion.hh:252
gem5::bitfield_backend::BitUnionOperators::operator--
BitUnionOperators operator--(int)
Definition: bitunion.hh:311
gem5::X86ISA::val
Bitfield< 63 > val
Definition: misc.hh:775
gem5::ShowParam::show
static void show(std::ostream &os, const T &value)
Definition: serialize_handlers.hh:127
gem5::to_number
bool to_number(const std::string &value, Pixel &retval)
Definition: pixel.hh:217
gem5::bitfield_backend::BitUnionOperators::operator&=
BitUnionOperators & operator&=(typename Base::__StorageType const &val)
Definition: bitunion.hh:355
gem5::bitfield_backend::BitUnionOperators::BitUnionOperators
BitUnionOperators(typename Base::__StorageType const &val)
Definition: bitunion.hh:258
gem5::bitfield_backend::Unsigned::getter
uint64_t getter(const Storage &storage) const
Definition: bitunion.hh:185
gem5::ShowParam
Definition: serialize_handlers.hh:125
gem5::auxv::Base
@ Base
Definition: aux_vector.hh:76
gem5::BitUnionBaseType
typename bitfield_backend::BitUnionBaseType< T >::Type BitUnionBaseType
Definition: bitunion.hh:541
gem5::BitfieldTypeImpl::TypeDeducer::Storage
T< decltype(&Wrapper::setter)>::Storage Storage
Definition: bitunion.hh:81
gem5::BitfieldTypeImpl::TypeDeducer::T
Definition: bitunion.hh:67
gem5::bitfield_backend::bitfieldBackendPrinter
static std::ostream & bitfieldBackendPrinter(std::ostream &os, const T &t)
Definition: bitunion.hh:547
gem5::bitfield_backend::BitUnionOperators::operator+=
BitUnionOperators & operator+=(typename Base::__StorageType const &val)
Definition: bitunion.hh:320
gem5::ParseParam< BitUnionType< T > >::parse
static bool parse(const std::string &s, BitUnionType< T > &value)
Definition: bitunion.hh:592
bitfield.hh
gem5::BitfieldTypeImpl::operator=
Type operator=(const Type val)
Definition: bitunion.hh:103
gem5::bitfield_backend::BitUnionOperators::operator|=
BitUnionOperators & operator|=(typename Base::__StorageType const &val)
Definition: bitunion.hh:362
gem5::BitfieldTypeImpl
Definition: bitunion.hh:57
gem5::bitfield_backend::BitUnionOperators::operator-=
BitUnionOperators & operator-=(typename Base::__StorageType const &val)
Definition: bitunion.hh:327
gem5::BitfieldType
Definition: bitunion.hh:118
gem5::bitfield_backend::BitfieldTypes
Definition: bitunion.hh:221
gem5::ArmISA::s
Bitfield< 4 > s
Definition: misc_types.hh:561
gem5::bitfield_backend::BitUnionOperators::operator/=
BitUnionOperators & operator/=(typename Base::__StorageType const &val)
Definition: bitunion.hh:341
gem5::BitfieldTypeImpl::BitfieldTypeImpl
BitfieldTypeImpl()=default
gem5::BitfieldROType
Definition: bitunion.hh:140
gem5::bits
constexpr T bits(T val, unsigned first, unsigned last)
Extract the bitfield from position 'first' to 'last' (inclusive) from 'val' and right justify it.
Definition: bitfield.hh:76
compiler.hh
gem5::bitfield_backend::BitUnionOperators::operator--
BitUnionOperators & operator--()
Definition: bitunion.hh:304
gem5::bitfield_backend::BitUnionOperators::operator*=
BitUnionOperators & operator*=(typename Base::__StorageType const &val)
Definition: bitunion.hh:334
gem5::bitfield_backend::BitUnionOperators::operator^=
BitUnionOperators & operator^=(typename Base::__StorageType const &val)
Definition: bitunion.hh:369
gem5::ArmISA::t
Bitfield< 5 > t
Definition: misc_types.hh:70
gem5::BitfieldROType::operator=
Type operator=(BitfieldROType< Base > const &other)=delete
gem5::bitfield_backend::BitUnionBaseType::Type
BitUnionType< T >::__StorageType Type
Definition: bitunion.hh:527
gem5::bitfield_backend::Unsigned
Definition: bitunion.hh:178
gem5::BitfieldTypeImpl::TypeDeducer::Type
T< decltype(&Wrapper::setter)>::Type Type
Definition: bitunion.hh:82
gem5::BitfieldWOType::operator=
Type operator=(BitfieldWOType< Base > const &other)
Definition: bitunion.hh:167
gem5::bitfield_backend::BitUnionOperators::operator<<=
BitUnionOperators & operator<<=(typename Base::__StorageType const &val)
Definition: bitunion.hh:376
gem5::BitfieldType::BitfieldType
BitfieldType()=default
gem5::BitfieldWOType::operator=
Type operator=(const Type val)
Definition: bitunion.hh:165
gem5::BitfieldTypeImpl::TypeDeducer::Wrapper
Definition: bitunion.hh:76
serialize_handlers.hh
std
Overload hash function for BasicBlockRange type.
Definition: types.hh:111
gem5::X86ISA::os
Bitfield< 17 > os
Definition: misc.hh:809
gem5::BitfieldTypeImpl::getter
Type getter(const Storage &storage) const =delete
gem5::bitfield_backend::BitUnionOperators::operator++
BitUnionOperators & operator++()
Definition: bitunion.hh:289
gem5::BitfieldWOType
Definition: bitunion.hh:155
gem5::bitfield_backend::BitUnionOperators::operator=
BitUnionOperators & operator=(typename Base::__StorageType const &val)
Definition: bitunion.hh:275
gem5::BitfieldTypeImpl::TypeDeducer
Definition: bitunion.hh:64
gem5::BitfieldTypeImpl::setter
void setter(Storage &storage, Type val)=delete
gem5::BitfieldTypeImpl::TypeDeducer::T< void(C::*)(Type1 &, Type2)>::Storage
Type1 Storage
Definition: bitunion.hh:72
gem5::BitfieldType::operator=
Type operator=(const Type val)
Definition: bitunion.hh:130
gem5::ParseParam
Definition: serialize_handlers.hh:78
gem5::ShowParam< BitUnionType< T > >::show
static void show(std::ostream &os, const BitUnionType< T > &value)
Definition: bitunion.hh:606
gem5
Reference material can be found at the JEDEC website: UFS standard http://www.jedec....
Definition: decoder.cc:40
gem5::bitfield_backend::BitUnionOperators::operator++
BitUnionOperators operator++(int)
Definition: bitunion.hh:296
gem5::BitfieldType::operator=
Type operator=(BitfieldType< Base > const &other)
Definition: bitunion.hh:132
gem5::BitfieldTypeImpl::Storage
TypeDeducer::Storage Storage
Definition: bitunion.hh:86
gem5::bitfield_backend::Signed::setter
void setter(Storage &storage, int64_t val)
Definition: bitunion.hh:211
gem5::BitfieldTypeImpl::Type
TypeDeducer::Type Type
Definition: bitunion.hh:87
gem5::BitfieldROType::BitfieldROType
BitfieldROType()=default

Generated on Tue Sep 21 2021 12:24:52 for gem5 by doxygen 1.8.17