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
|
/*****************************************************************************
Copyright (c) 1994, 2025, Oracle and/or its affiliates.
This program is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License, version 2.0, as published by the
Free Software Foundation.
This program is designed to work with certain software (including
but not limited to OpenSSL) that is licensed under separate terms,
as designated in a particular file or component or in included license
documentation. The authors of MySQL hereby grant you an additional
permission to link the program and your derivative works with the
separately licensed software that they have either included with
the program or referenced in the documentation.
This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0,
for more details.
You should have received a copy of the GNU General Public License along with
this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*****************************************************************************/
/** @file include/ut0byte.ic
Utilities for byte operations
Created 5/30/1994 Heikki Tuuri
*******************************************************************/
constexpr uint64_t ut_ull_create(uint32_t high, uint32_t low) {
return (uint64_t{high} << 32) | low;
}
static inline uint64_t ut_uint64_align_down(uint64_t n, ulint align_no) {
ut_ad(align_no > 0);
ut_ad(ut_is_2pow(align_no));
return (n & ~((uint64_t)align_no - 1));
}
static inline uint64_t ut_uint64_align_up(uint64_t n, ulint align_no) {
const uint64_t align_1 = (uint64_t)align_no - 1;
ut_ad(align_no > 0);
ut_ad(ut_is_2pow(align_no));
return (n + align_1) & ~align_1;
}
static inline void *ut_align(const void *ptr, ulint align_no) {
ut_ad(align_no > 0);
ut_ad(((align_no - 1) & align_no) == 0);
ut_ad(ptr);
static_assert(sizeof(void *) == sizeof(ulint));
return ((void *)((((ulint)ptr) + align_no - 1) & ~(align_no - 1)));
}
static inline void *ut_align_down(const void *ptr, ulint align_no) {
ut_ad(align_no > 0);
ut_ad(((align_no - 1) & align_no) == 0);
ut_ad(ptr);
static_assert(sizeof(void *) == sizeof(ulint));
return ((void *)((((ulint)ptr)) & ~(align_no - 1)));
}
static inline ulint ut_align_offset(const void *ptr, ulint align_no) {
ut_ad(align_no > 0);
ut_ad(((align_no - 1) & align_no) == 0);
ut_ad(ptr);
static_assert(sizeof(void *) == sizeof(ulint));
return (((ulint)ptr) & (align_no - 1));
}
static inline bool ut_bit_get_nth(ulint a, ulint n) {
ut_ad(n < 8 * sizeof(ulint));
return (1 & (a >> n));
}
static inline ulint ut_bit_set_nth(ulint a, ulint n, bool val) {
ut_ad(n < 8 * sizeof(ulint));
if (val) {
return (((ulint)1 << n) | a);
} else {
return (~((ulint)1 << n) & a);
}
}
|
