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 * Authors: Gabe Black
29 */
30
31#ifndef __BASE_BITUNION_HH__
32#define __BASE_BITUNION_HH__
33
34#include "base/bitfield.hh"
35#include "base/types.hh"
36
37// The following implements the BitUnion system of defining bitfields
38//on top of an underlying class. This is done through the pervasive use of
39//both named and unnamed unions which all contain the same actual storage.
40//Since they're unioned with each other, all of these storage locations
41//overlap. This allows all of the bitfields to manipulate the same data
42//without having to have access to each other. More details are provided with
43//the individual components.
44
45//This namespace is for classes which implement the backend of the BitUnion
46//stuff. Don't use any of these directly, except for the Bitfield classes in
47//the *BitfieldTypes class(es).
48namespace BitfieldBackend
49{
50 //A base class for all bitfields. It instantiates the actual storage,
51 //and provides getBits and setBits functions for manipulating it. The
52 //Data template parameter is type of the underlying storage.
53 template<class Data>
54 class BitfieldBase
55 {
56 protected:
57 Data __data;
58
59 //This function returns a range of bits from the underlying storage.
60 //It relies on the "bits" function above. It's the user's
61 //responsibility to make sure that there is a properly overloaded
62 //version of this function for whatever type they want to overlay.
63 inline uint64_t
64 getBits(int first, int last) const
65 {
66 return bits(__data, first, last);
67 }
68
69 //Similar to the above, but for settings bits with replaceBits.
70 inline void
71 setBits(int first, int last, uint64_t val)
72 {
73 replaceBits(__data, first, last, val);
74 }
75 };
76
77 //This class contains all the "regular" bitfield classes. It is inherited
78 //by all BitUnions which give them access to those types.
79 template<class Type>
80 class RegularBitfieldTypes
81 {
82 protected:
83 //This class implements ordinary bitfields, that is a span of bits
84 //who's msb is "first", and who's lsb is "last".
85 template<int first, int last=first>
86 class Bitfield : public BitfieldBase<Type>
87 {
88 static_assert(first >= last,
89 "Bitfield ranges must be specified as <msb, lsb>");
90
91 public:
92 operator uint64_t () const
93 {
94 return this->getBits(first, last);
95 }
96
97 uint64_t
98 operator=(const uint64_t _data)
99 {
100 this->setBits(first, last, _data);
101 return _data;
102 }
103
104 uint64_t
105 operator=(Bitfield<first, last> const & other)
106 {
107 return *this = (uint64_t)other;
108 }
109 };
110
111 //A class which specializes the above so that it can only be read
112 //from. This is accomplished explicitly making sure the assignment
113 //operator is blocked. The conversion operator is carried through
114 //inheritance. This will unfortunately need to be copied into each
115 //bitfield type due to limitations with how templates work
116 template<int first, int last=first>
117 class BitfieldRO : public Bitfield<first, last>
118 {
119 private:
120 uint64_t
121 operator=(const uint64_t _data);
122
123 uint64_t
124 operator=(const Bitfield<first, last>& other);
125 };
126
127 //Similar to the above, but only allows writing.
128 template<int first, int last=first>
129 class BitfieldWO : public Bitfield<first, last>
130 {
131 private:
132 operator uint64_t () const;
133
134 public:
135 using Bitfield<first, last>::operator=;
136 };
137 };
138
139 //This class contains all the "regular" bitfield classes. It is inherited
140 //by all BitUnions which give them access to those types.
141 template<class Type>
142 class SignedBitfieldTypes
143 {
144 protected:
145 //This class implements ordinary bitfields, that is a span of bits
146 //who's msb is "first", and who's lsb is "last".
147 template<int first, int last=first>
148 class SignedBitfield : public BitfieldBase<Type>
149 {
150 public:
151 operator int64_t () const
152 {
153 return sext<first - last + 1>(this->getBits(first, last));
154 }
155
156 int64_t
157 operator=(const int64_t _data)
158 {
159 this->setBits(first, last, _data);
160 return _data;
161 }
162
163 int64_t
164 operator=(SignedBitfield<first, last> const & other)
165 {
166 return *this = (int64_t)other;
167 }
168 };
169
170 //A class which specializes the above so that it can only be read
171 //from. This is accomplished explicitly making sure the assignment
172 //operator is blocked. The conversion operator is carried through
173 //inheritance. This will unfortunately need to be copied into each
174 //bitfield type due to limitations with how templates work
175 template<int first, int last=first>
176 class SignedBitfieldRO : public SignedBitfield<first, last>
177 {
178 private:
179 int64_t
180 operator=(const int64_t _data);
181
182 int64_t
183 operator=(const SignedBitfield<first, last>& other);
184 };
185
186 //Similar to the above, but only allows writing.
187 template<int first, int last=first>
188 class SignedBitfieldWO : public SignedBitfield<first, last>
189 {
190 private:
191 operator int64_t () const;
192
193 public:
194 using SignedBitfield<first, last>::operator=;
195 };
196 };
197
198 template<class Type>
199 class BitfieldTypes : public RegularBitfieldTypes<Type>,
200 public SignedBitfieldTypes<Type>
201 {};
202
203 //When a BitUnion is set up, an underlying class is created which holds
204 //the actual union. This class then inherits from it, and provids the
205 //implementations for various operators. Setting things up this way
206 //prevents having to redefine these functions in every different BitUnion
207 //type. More operators could be implemented in the future, as the need
208 //arises.
209 template <class Type, class Base>
210 class BitUnionOperators : public Base
211 {
212 public:
213 BitUnionOperators(Type const & _data)
214 {
215 Base::__data = _data;
216 }
217
218 BitUnionOperators() {}
219
220 operator const Type () const
221 {
222 return Base::__data;
223 }
224
225 Type
226 operator=(Type const & _data)
227 {
228 Base::__data = _data;
229 return _data;
230 }
231
232 Type
233 operator=(BitUnionOperators const & other)
234 {
235 Base::__data = other;
236 return Base::__data;
237 }
238
239 bool
240 operator<(Base const & base) const
241 {
242 return Base::__data < base.__data;
243 }
244
245 bool
246 operator==(Base const & base) const
247 {
248 return Base::__data == base.__data;
249 }
250 };
251}
252
253//This macro is a backend for other macros that specialize it slightly.
254//First, it creates/extends a namespace "BitfieldUnderlyingClasses" and
255//sticks the class which has the actual union in it, which
256//BitfieldOperators above inherits from. Putting these classes in a special
257//namespace ensures that there will be no collisions with other names as long
258//as the BitUnion names themselves are all distinct and nothing else uses
259//the BitfieldUnderlyingClasses namespace, which is unlikely. The class itself
260//creates a typedef of the "type" parameter called __DataType. This allows
261//the type to propagate outside of the macro itself in a controlled way.
262//Finally, the base storage is defined which BitfieldOperators will refer to
263//in the operators it defines. This macro is intended to be followed by
264//bitfield definitions which will end up inside it's union. As explained
265//above, these is overlayed the __data member in its entirety by each of the
266//bitfields which are defined in the union, creating shared storage with no
267//overhead.
268#define __BitUnion(type, name) \
269 class BitfieldUnderlyingClasses##name : \
270 public BitfieldBackend::BitfieldTypes<type> \
271 { \
272 public: \
273 typedef type __DataType; \
274 union { \
275 type __data;\
276
277//This closes off the class and union started by the above macro. It is
278//followed by a typedef which makes "name" refer to a BitfieldOperator
279//class inheriting from the class and union just defined, which completes
280//building up the type for the user.
281#define EndBitUnion(name) \
282 }; \
283 }; \
284 typedef BitfieldBackend::BitUnionOperators< \
285 BitfieldUnderlyingClasses##name::__DataType, \
286 BitfieldUnderlyingClasses##name> name;
287
288//This sets up a bitfield which has other bitfields nested inside of it. The
289//__data member functions like the "underlying storage" of the top level
290//BitUnion. Like everything else, it overlays with the top level storage, so
291//making it a regular bitfield type makes the entire thing function as a
292//regular bitfield when referred to by itself.
293#define __SubBitUnion(fieldType, first, last, name) \
294 class : public BitfieldBackend::BitfieldTypes<__DataType> \
295 { \
296 public: \
297 union { \
298 fieldType<first, last> __data;
299
300//This closes off the union created above and gives it a name. Unlike the top
301//level BitUnion, we're interested in creating an object instead of a type.
302//The operators are defined in the macro itself instead of a class for
303//technical reasons. If someone determines a way to move them to one, please
304//do so.
305#define EndSubBitUnion(name) \
306 }; \
307 inline operator __DataType () const \
308 { return __data; } \
309 \
310 inline __DataType operator = (const __DataType & _data) \
311 { return __data = _data;} \
312 } name;
313
314//Regular bitfields
315//These define macros for read/write regular bitfield based subbitfields.
316#define SubBitUnion(name, first, last) \
317 __SubBitUnion(Bitfield, first, last, name)
318
319//Regular bitfields
320//These define macros for read/write regular bitfield based subbitfields.
321#define SignedSubBitUnion(name, first, last) \
322 __SubBitUnion(SignedBitfield, first, last, name)
323
324//Use this to define an arbitrary type overlayed with bitfields.
325#define BitUnion(type, name) __BitUnion(type, name)
326
327//Use this to define conveniently sized values overlayed with bitfields.
328#define BitUnion64(name) __BitUnion(uint64_t, name)
329#define BitUnion32(name) __BitUnion(uint32_t, name)
330#define BitUnion16(name) __BitUnion(uint16_t, name)
331#define BitUnion8(name) __BitUnion(uint8_t, name)
332
333#endif // __BASE_BITUNION_HH__