1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
|
// Copyright 2019 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef V8_BASE_BIT_FIELD_H_
#define V8_BASE_BIT_FIELD_H_
#include <stdint.h>
#include "src/base/macros.h"
namespace v8 {
namespace base {
// ----------------------------------------------------------------------------
// BitField is a help template for encoding and decode bitfield with
// unsigned content.
// Instantiate them via 'using', which is cheaper than deriving a new class:
// using MyBitField = base::BitField<MyEnum, 4, 2>;
// The BitField class is final to enforce this style over derivation.
template <class T, int shift, int size, class U = uint32_t>
class BitField final {
public:
static_assert(std::is_unsigned<U>::value);
static_assert(shift < 8 * sizeof(U)); // Otherwise shifts by {shift} are UB.
static_assert(size < 8 * sizeof(U)); // Otherwise shifts by {size} are UB.
static_assert(shift + size <= 8 * sizeof(U));
static_assert(size > 0);
using FieldType = T;
// A type U mask of bit field. To use all bits of a type U of x bits
// in a bitfield without compiler warnings we have to compute 2^x
// without using a shift count of x in the computation.
static constexpr int kShift = shift;
static constexpr int kSize = size;
static constexpr U kMask = ((U{1} << kShift) << kSize) - (U{1} << kShift);
static constexpr int kLastUsedBit = kShift + kSize - 1;
static constexpr U kNumValues = U{1} << kSize;
// Value for the field with all bits set.
// If clang complains
// "constexpr variable 'kMax' must be initialized by a constant expression"
// on this line, then you're creating a BitField for an enum with more bits
// than needed for the enum values. Either reduce the BitField size,
// or give the enum an explicit underlying type.
static constexpr T kMax = static_cast<T>(kNumValues - 1);
template <class T2, int size2>
using Next = BitField<T2, kShift + kSize, size2, U>;
// Tells whether the provided value fits into the bit field.
static constexpr bool is_valid(T value) {
return (static_cast<U>(value) & ~static_cast<U>(kMax)) == 0;
}
// Returns a type U with the bit field value encoded.
static constexpr U encode(T value) {
DCHECK(is_valid(value));
return static_cast<U>(value) << kShift;
}
// Returns a type U with the bit field value updated.
static constexpr U update(U previous, T value) {
return (previous & ~kMask) | encode(value);
}
// Extracts the bit field from the value.
static constexpr T decode(U value) {
return static_cast<T>((value & kMask) >> kShift);
}
};
template <class T, int shift, int size>
using BitField8 = BitField<T, shift, size, uint8_t>;
template <class T, int shift, int size>
using BitField16 = BitField<T, shift, size, uint16_t>;
template <class T, int shift, int size>
using BitField64 = BitField<T, shift, size, uint64_t>;
// Helper macros for defining a contiguous sequence of bit fields. Example:
// (backslashes at the ends of respective lines of this multi-line macro
// definition are omitted here to please the compiler)
//
// #define MAP_BIT_FIELD1(V, _)
// V(IsAbcBit, bool, 1, _)
// V(IsBcdBit, bool, 1, _)
// V(CdeBits, int, 5, _)
// V(DefBits, MutableMode, 1, _)
//
// DEFINE_BIT_FIELDS(MAP_BIT_FIELD1)
// or
// DEFINE_BIT_FIELDS_64(MAP_BIT_FIELD1)
//
#define DEFINE_BIT_FIELD_RANGE_TYPE(Name, Type, Size, _) \
k##Name##Start, k##Name##End = k##Name##Start + Size - 1,
#define DEFINE_BIT_RANGES(LIST_MACRO) \
struct LIST_MACRO##_Ranges { \
enum { LIST_MACRO(DEFINE_BIT_FIELD_RANGE_TYPE, _) kBitsCount }; \
};
#define DEFINE_BIT_FIELD_TYPE(Name, Type, Size, RangesName) \
using Name = base::BitField<Type, RangesName::k##Name##Start, Size>;
#define DEFINE_BIT_FIELD_64_TYPE(Name, Type, Size, RangesName) \
using Name = base::BitField64<Type, RangesName::k##Name##Start, Size>;
#define DEFINE_BIT_FIELDS(LIST_MACRO) \
DEFINE_BIT_RANGES(LIST_MACRO) \
LIST_MACRO(DEFINE_BIT_FIELD_TYPE, LIST_MACRO##_Ranges)
#define DEFINE_BIT_FIELDS_64(LIST_MACRO) \
DEFINE_BIT_RANGES(LIST_MACRO) \
LIST_MACRO(DEFINE_BIT_FIELD_64_TYPE, LIST_MACRO##_Ranges)
// ----------------------------------------------------------------------------
// BitSetComputer is a help template for encoding and decoding information for
// a variable number of items in an array.
//
// To encode boolean data in a smi array you would use:
// using BoolComputer = BitSetComputer<bool, 1, kSmiValueSize, uint32_t>;
//
template <class T, int kBitsPerItem, int kBitsPerWord, class U>
class BitSetComputer {
public:
static const int kItemsPerWord = kBitsPerWord / kBitsPerItem;
static const int kMask = (1 << kBitsPerItem) - 1;
// The number of array elements required to embed T information for each item.
static int word_count(int items) {
if (items == 0) return 0;
return (items - 1) / kItemsPerWord + 1;
}
// The array index to look at for item.
static int index(int base_index, int item) {
return base_index + item / kItemsPerWord;
}
// Extract T data for a given item from data.
static T decode(U data, int item) {
return static_cast<T>((data >> shift(item)) & kMask);
}
// Return the encoding for a store of value for item in previous.
static U encode(U previous, int item, T value) {
int shift_value = shift(item);
int set_bits = (static_cast<int>(value) << shift_value);
return (previous & ~(kMask << shift_value)) | set_bits;
}
static int shift(int item) { return (item % kItemsPerWord) * kBitsPerItem; }
};
} // namespace base
} // namespace v8
#endif // V8_BASE_BIT_FIELD_H_
|
