diff options
Diffstat (limited to 'storage/innobase/include/ut0byte.h')
| -rw-r--r-- | storage/innobase/include/ut0byte.h | 270 |
1 files changed, 270 insertions, 0 deletions
diff --git a/storage/innobase/include/ut0byte.h b/storage/innobase/include/ut0byte.h new file mode 100644 index 00000000000..a2687e62f08 --- /dev/null +++ b/storage/innobase/include/ut0byte.h @@ -0,0 +1,270 @@ +/***************************************************************************** + +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 + +*****************************************************************************/ + +/******************************************************************//** +@file include/ut0byte.h +Utilities for byte operations + +Created 1/20/1994 Heikki Tuuri +***********************************************************************/ + +#ifndef ut0byte_h +#define ut0byte_h + + +#include "univ.i" + +/** Pair of ulint integers. */ +typedef struct dulint_struct dulint; +/** Type definition for a 64-bit unsigned integer, which works also +in 32-bit machines. NOTE! Access the fields only with the accessor +functions. This definition appears here only for the compiler to +know the size of a dulint. */ +struct dulint_struct{ + ulint high; /*!< most significant 32 bits */ + ulint low; /*!< least significant 32 bits */ +}; + +/** Zero value for a dulint */ +extern const dulint ut_dulint_zero; + +/** Maximum value for a dulint */ +extern const dulint ut_dulint_max; + +/*******************************************************//** +Creates a 64-bit dulint out of two ulints. +@return created dulint */ +UNIV_INLINE +dulint +ut_dulint_create( +/*=============*/ + ulint high, /*!< in: high-order 32 bits */ + ulint low); /*!< in: low-order 32 bits */ +/*******************************************************//** +Gets the high-order 32 bits of a dulint. +@return 32 bits in ulint */ +UNIV_INLINE +ulint +ut_dulint_get_high( +/*===============*/ + dulint d); /*!< in: dulint */ +/*******************************************************//** +Gets the low-order 32 bits of a dulint. +@return 32 bits in ulint */ +UNIV_INLINE +ulint +ut_dulint_get_low( +/*==============*/ + dulint d); /*!< in: dulint */ +/*******************************************************//** +Converts a dulint (a struct of 2 ulints) to ib_int64_t, which is a 64-bit +integer type. +@return value in ib_int64_t type */ +UNIV_INLINE +ib_int64_t +ut_conv_dulint_to_longlong( +/*=======================*/ + dulint d); /*!< in: dulint */ +/*******************************************************//** +Tests if a dulint is zero. +@return TRUE if zero */ +UNIV_INLINE +ibool +ut_dulint_is_zero( +/*==============*/ + dulint a); /*!< in: dulint */ +/*******************************************************//** +Compares two dulints. +@return -1 if a < b, 0 if a == b, 1 if a > b */ +UNIV_INLINE +int +ut_dulint_cmp( +/*==========*/ + dulint a, /*!< in: dulint */ + dulint b); /*!< in: dulint */ +/*******************************************************//** +Calculates the max of two dulints. +@return max(a, b) */ +UNIV_INLINE +dulint +ut_dulint_get_max( +/*==============*/ + dulint a, /*!< in: dulint */ + dulint b); /*!< in: dulint */ +/*******************************************************//** +Calculates the min of two dulints. +@return min(a, b) */ +UNIV_INLINE +dulint +ut_dulint_get_min( +/*==============*/ + dulint a, /*!< in: dulint */ + dulint b); /*!< in: dulint */ +/*******************************************************//** +Adds a ulint to a dulint. +@return sum a + b */ +UNIV_INLINE +dulint +ut_dulint_add( +/*==========*/ + dulint a, /*!< in: dulint */ + ulint b); /*!< in: ulint */ +/*******************************************************//** +Subtracts a ulint from a dulint. +@return a - b */ +UNIV_INLINE +dulint +ut_dulint_subtract( +/*===============*/ + dulint a, /*!< in: dulint */ + ulint b); /*!< in: ulint, b <= a */ +/*******************************************************//** +Subtracts a dulint from another. NOTE that the difference must be positive +and smaller that 4G. +@return a - b */ +UNIV_INLINE +ulint +ut_dulint_minus( +/*============*/ + dulint a, /*!< in: dulint; NOTE a must be >= b and at most + 2 to power 32 - 1 greater */ + dulint b); /*!< in: dulint */ +/********************************************************//** +Rounds a dulint downward to a multiple of a power of 2. +@return rounded value */ +UNIV_INLINE +dulint +ut_dulint_align_down( +/*=================*/ + dulint n, /*!< in: number to be rounded */ + ulint align_no); /*!< in: align by this number which must be a + power of 2 */ +/********************************************************//** +Rounds a dulint upward to a multiple of a power of 2. +@return rounded value */ +UNIV_INLINE +dulint +ut_dulint_align_up( +/*===============*/ + dulint n, /*!< in: number to be rounded */ + ulint align_no); /*!< in: align by this number which must be a + power of 2 */ +/********************************************************//** +Rounds a dulint downward to a multiple of a power of 2. +@return rounded value */ +UNIV_INLINE +ib_uint64_t +ut_uint64_align_down( +/*=================*/ + ib_uint64_t n, /*!< in: number to be rounded */ + ulint align_no); /*!< in: align by this number + which must be a power of 2 */ +/********************************************************//** +Rounds ib_uint64_t upward to a multiple of a power of 2. +@return rounded value */ +UNIV_INLINE +ib_uint64_t +ut_uint64_align_up( +/*===============*/ + ib_uint64_t n, /*!< in: number to be rounded */ + ulint align_no); /*!< in: align by this number + which must be a power of 2 */ +/*******************************************************//** +Increments a dulint variable by 1. */ +#define UT_DULINT_INC(D)\ +{\ + if ((D).low == 0xFFFFFFFFUL) {\ + (D).high = (D).high + 1;\ + (D).low = 0;\ + } else {\ + (D).low = (D).low + 1;\ + }\ +} +/*******************************************************//** +Tests if two dulints are equal. */ +#define UT_DULINT_EQ(D1, D2) (((D1).low == (D2).low)\ + && ((D1).high == (D2).high)) +#ifdef notdefined +/************************************************************//** +Sort function for dulint arrays. */ +UNIV_INTERN +void +ut_dulint_sort( +/*===========*/ + dulint* arr, /*!< in/out: array to be sorted */ + dulint* aux_arr,/*!< in/out: auxiliary array (same size as arr) */ + ulint low, /*!< in: low bound of sort interval, inclusive */ + ulint high); /*!< in: high bound of sort interval, noninclusive */ +#endif /* notdefined */ + +/*********************************************************//** +The following function rounds up a pointer to the nearest aligned address. +@return aligned pointer */ +UNIV_INLINE +void* +ut_align( +/*=====*/ + void* ptr, /*!< in: pointer */ + ulint align_no); /*!< in: align by this number */ +/*********************************************************//** +The following function rounds down a pointer to the nearest +aligned address. +@return aligned pointer */ +UNIV_INLINE +void* +ut_align_down( +/*==========*/ + const void* ptr, /*!< in: pointer */ + ulint align_no) /*!< in: align by this number */ + __attribute__((const)); +/*********************************************************//** +The following function computes the offset of a pointer from the nearest +aligned address. +@return distance from aligned pointer */ +UNIV_INLINE +ulint +ut_align_offset( +/*============*/ + const void* ptr, /*!< in: pointer */ + ulint align_no) /*!< in: align by this number */ + __attribute__((const)); +/*****************************************************************//** +Gets the nth bit of a ulint. +@return TRUE if nth bit is 1; 0th bit is defined to be the least significant */ +UNIV_INLINE +ibool +ut_bit_get_nth( +/*===========*/ + ulint a, /*!< in: ulint */ + ulint n); /*!< in: nth bit requested */ +/*****************************************************************//** +Sets the nth bit of a ulint. +@return the ulint with the bit set as requested */ +UNIV_INLINE +ulint +ut_bit_set_nth( +/*===========*/ + ulint a, /*!< in: ulint */ + ulint n, /*!< in: nth bit requested */ + ibool val); /*!< in: value for the bit to set */ + +#ifndef UNIV_NONINL +#include "ut0byte.ic" +#endif + +#endif |