bitunion.hh revision 10640
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 const 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 const 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 const 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 const 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 const __DataType () const \ 308 { return __data; } \ 309 \ 310 inline const __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__ 334