diff options
Diffstat (limited to 'storage/xtradb/include/ut0byte.ic')
| -rw-r--r-- | storage/xtradb/include/ut0byte.ic | 413 |
1 files changed, 413 insertions, 0 deletions
diff --git a/storage/xtradb/include/ut0byte.ic b/storage/xtradb/include/ut0byte.ic new file mode 100644 index 00000000000..021a3a15009 --- /dev/null +++ b/storage/xtradb/include/ut0byte.ic @@ -0,0 +1,413 @@ +/***************************************************************************** + +Copyright (c) 1994, 2009, Innobase Oy. All Rights Reserved. + +This program is free software; you can redistribute it and/or modify it under +the terms of the GNU General Public License as published by the Free Software +Foundation; version 2 of the License. + +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 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., 59 Temple +Place, Suite 330, Boston, MA 02111-1307 USA + +*****************************************************************************/ + +/****************************************************************** +Utilities for byte operations + +Created 5/30/1994 Heikki Tuuri +*******************************************************************/ + +/*********************************************************** +Creates a 64-bit dulint out of two ulints. */ +UNIV_INLINE +dulint +ut_dulint_create( +/*=============*/ + /* out: created dulint */ + ulint high, /* in: high-order 32 bits */ + ulint low) /* in: low-order 32 bits */ +{ + dulint res; + + ut_ad(high <= 0xFFFFFFFF); + ut_ad(low <= 0xFFFFFFFF); + + res.high = high; + res.low = low; + + return(res); +} + +/*********************************************************** +Gets the high-order 32 bits of a dulint. */ +UNIV_INLINE +ulint +ut_dulint_get_high( +/*===============*/ + /* out: 32 bits in ulint */ + dulint d) /* in: dulint */ +{ + return(d.high); +} + +/*********************************************************** +Gets the low-order 32 bits of a dulint. */ +UNIV_INLINE +ulint +ut_dulint_get_low( +/*==============*/ + /* out: 32 bits in ulint */ + dulint d) /* in: dulint */ +{ + return(d.low); +} + +/*********************************************************** +Converts a dulint (a struct of 2 ulints) to ib_int64_t, which is a 64-bit +integer type. */ +UNIV_INLINE +ib_int64_t +ut_conv_dulint_to_longlong( +/*=======================*/ + /* out: value in ib_int64_t type */ + dulint d) /* in: dulint */ +{ + return((ib_int64_t)d.low + + (((ib_int64_t)d.high) << 32)); +} + +/*********************************************************** +Tests if a dulint is zero. */ +UNIV_INLINE +ibool +ut_dulint_is_zero( +/*==============*/ + /* out: TRUE if zero */ + dulint a) /* in: dulint */ +{ + if ((a.low == 0) && (a.high == 0)) { + + return(TRUE); + } + + return(FALSE); +} + +/*********************************************************** +Compares two dulints. */ +UNIV_INLINE +int +ut_dulint_cmp( +/*==========*/ + /* out: -1 if a < b, 0 if a == b, + 1 if a > b */ + dulint a, /* in: dulint */ + dulint b) /* in: dulint */ +{ + if (a.high > b.high) { + return(1); + } else if (a.high < b.high) { + return(-1); + } else if (a.low > b.low) { + return(1); + } else if (a.low < b.low) { + return(-1); + } else { + return(0); + } +} + +/*********************************************************** +Calculates the max of two dulints. */ +UNIV_INLINE +dulint +ut_dulint_get_max( +/*==============*/ + /* out: max(a, b) */ + dulint a, /* in: dulint */ + dulint b) /* in: dulint */ +{ + if (ut_dulint_cmp(a, b) > 0) { + + return(a); + } + + return(b); +} + +/*********************************************************** +Calculates the min of two dulints. */ +UNIV_INLINE +dulint +ut_dulint_get_min( +/*==============*/ + /* out: min(a, b) */ + dulint a, /* in: dulint */ + dulint b) /* in: dulint */ +{ + if (ut_dulint_cmp(a, b) > 0) { + + return(b); + } + + return(a); +} + +/*********************************************************** +Adds a ulint to a dulint. */ +UNIV_INLINE +dulint +ut_dulint_add( +/*==========*/ + /* out: sum a + b */ + dulint a, /* in: dulint */ + ulint b) /* in: ulint */ +{ + if (0xFFFFFFFFUL - b >= a.low) { + a.low += b; + + return(a); + } + + a.low = a.low - (0xFFFFFFFFUL - b) - 1; + + a.high++; + + return(a); +} + +/*********************************************************** +Subtracts a ulint from a dulint. */ +UNIV_INLINE +dulint +ut_dulint_subtract( +/*===============*/ + /* out: a - b */ + dulint a, /* in: dulint */ + ulint b) /* in: ulint, b <= a */ +{ + if (a.low >= b) { + a.low -= b; + + return(a); + } + + b -= a.low + 1; + + a.low = 0xFFFFFFFFUL - b; + + ut_ad(a.high > 0); + + a.high--; + + return(a); +} + +/*********************************************************** +Subtracts a dulint from another. NOTE that the difference must be positive +and smaller that 4G. */ +UNIV_INLINE +ulint +ut_dulint_minus( +/*============*/ + /* out: a - b */ + dulint a, /* in: dulint; NOTE a must be >= b and at most + 2 to power 32 - 1 greater */ + dulint b) /* in: dulint */ +{ + ulint diff; + + if (a.high == b.high) { + ut_ad(a.low >= b.low); + + return(a.low - b.low); + } + + ut_ad(a.high == b.high + 1); + + diff = (ulint)(0xFFFFFFFFUL - b.low); + diff += 1 + a.low; + + ut_ad(diff > a.low); + + return(diff); +} + +/************************************************************ +Rounds a dulint downward to a multiple of a power of 2. */ +UNIV_INLINE +dulint +ut_dulint_align_down( +/*=================*/ + /* out: rounded value */ + dulint n, /* in: number to be rounded */ + ulint align_no) /* in: align by this number which must be a + power of 2 */ +{ + ulint low, high; + + ut_ad(align_no > 0); + ut_ad(((align_no - 1) & align_no) == 0); + + low = ut_dulint_get_low(n); + high = ut_dulint_get_high(n); + + low = low & ~(align_no - 1); + + return(ut_dulint_create(high, low)); +} + +/************************************************************ +Rounds a dulint upward to a multiple of a power of 2. */ +UNIV_INLINE +dulint +ut_dulint_align_up( +/*===============*/ + /* out: rounded value */ + dulint n, /* in: number to be rounded */ + ulint align_no) /* in: align by this number which must be a + power of 2 */ +{ + return(ut_dulint_align_down(ut_dulint_add(n, align_no - 1), align_no)); +} + +/************************************************************ +Rounds ib_uint64_t downward to a multiple of a power of 2. */ +UNIV_INLINE +ib_uint64_t +ut_uint64_align_down( +/*=================*/ + /* out: rounded value */ + ib_uint64_t n, /* in: number to be rounded */ + ulint align_no) /* in: align by this number + which must be a power of 2 */ +{ + ut_ad(align_no > 0); + ut_ad(ut_is_2pow(align_no)); + + return(n & ~((ib_uint64_t) align_no - 1)); +} + +/************************************************************ +Rounds ib_uint64_t upward to a multiple of a power of 2. */ +UNIV_INLINE +ib_uint64_t +ut_uint64_align_up( +/*===============*/ + /* out: rounded value */ + ib_uint64_t n, /* in: number to be rounded */ + ulint align_no) /* in: align by this number + which must be a power of 2 */ +{ + ib_uint64_t align_1 = (ib_uint64_t) align_no - 1; + + ut_ad(align_no > 0); + ut_ad(ut_is_2pow(align_no)); + + return((n + align_1) & ~align_1); +} + +/************************************************************* +The following function rounds up a pointer to the nearest aligned address. */ +UNIV_INLINE +void* +ut_align( +/*=====*/ + /* out: aligned pointer */ + void* ptr, /* in: pointer */ + ulint align_no) /* in: align by this number */ +{ + ut_ad(align_no > 0); + ut_ad(((align_no - 1) & align_no) == 0); + ut_ad(ptr); + + ut_ad(sizeof(void*) == sizeof(ulint)); + + return((void*)((((ulint)ptr) + align_no - 1) & ~(align_no - 1))); +} + +/************************************************************* +The following function rounds down a pointer to the nearest +aligned address. */ +UNIV_INLINE +void* +ut_align_down( +/*==========*/ + /* out: aligned pointer */ + const void* ptr, /* in: pointer */ + ulint align_no) /* in: align by this number */ +{ + ut_ad(align_no > 0); + ut_ad(((align_no - 1) & align_no) == 0); + ut_ad(ptr); + + ut_ad(sizeof(void*) == sizeof(ulint)); + + return((void*)((((ulint)ptr)) & ~(align_no - 1))); +} + +/************************************************************* +The following function computes the offset of a pointer from the nearest +aligned address. */ +UNIV_INLINE +ulint +ut_align_offset( +/*============*/ + /* out: distance from + aligned pointer */ + const void* ptr, /* in: pointer */ + ulint align_no) /* in: align by this number */ +{ + ut_ad(align_no > 0); + ut_ad(((align_no - 1) & align_no) == 0); + ut_ad(ptr); + + ut_ad(sizeof(void*) == sizeof(ulint)); + + return(((ulint)ptr) & (align_no - 1)); +} + +/********************************************************************* +Gets the nth bit of a ulint. */ +UNIV_INLINE +ibool +ut_bit_get_nth( +/*===========*/ + /* out: TRUE if nth bit is 1; 0th bit is defined to + be the least significant */ + ulint a, /* in: ulint */ + ulint n) /* in: nth bit requested */ +{ + ut_ad(n < 8 * sizeof(ulint)); +#if TRUE != 1 +# error "TRUE != 1" +#endif + return(1 & (a >> n)); +} + +/********************************************************************* +Sets the nth bit of a ulint. */ +UNIV_INLINE +ulint +ut_bit_set_nth( +/*===========*/ + /* out: the ulint with the bit set as requested */ + ulint a, /* in: ulint */ + ulint n, /* in: nth bit requested */ + ibool val) /* in: value for the bit to set */ +{ + ut_ad(n < 8 * sizeof(ulint)); +#if TRUE != 1 +# error "TRUE != 1" +#endif + if (val) { + return(((ulint) 1 << n) | a); + } else { + return(~((ulint) 1 << n) & a); + } +} |