release/src/router/mysql/storage/innodb_plugin/include/ut0byte.h

   1 /*****************************************************************************
   2
   3 Copyright (c) 1994, 2009, Innobase Oy. All Rights Reserved.
   4
   5 This program is free software; you can redistribute it and/or modify it under
   6 the terms of the GNU General Public License as published by the Free Software
   7 Foundation; version 2 of the License.
   8
   9 This program is distributed in the hope that it will be useful, but WITHOUT
  10 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  11 FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
  12
  13 You should have received a copy of the GNU General Public License along with
  14 this program; if not, write to the Free Software Foundation, Inc.,
  15 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  16
  17 *****************************************************************************/
  18
  19 /******************************************************************//**
  20 @file include/ut0byte.h
  21 Utilities for byte operations
  22
  23 Created 1/20/1994 Heikki Tuuri
  24 ***********************************************************************/
  25
  26 #ifndef ut0byte_h
  27 #define ut0byte_h
  28
  29
  30 #include "univ.i"
  31
  32 /** Pair of ulint integers. */
  33 typedef struct dulint_struct    dulint;
  34 /** Type definition for a 64-bit unsigned integer, which works also
  35 in 32-bit machines. NOTE! Access the fields only with the accessor
  36 functions. This definition appears here only for the compiler to
  37 know the size of a dulint. */
  38 struct dulint_struct{
  39         ulint   high;   /*!< most significant 32 bits */
  40         ulint   low;    /*!< least significant 32 bits */
  41 };
  42
  43 /** Zero value for a dulint */
  44 extern const dulint     ut_dulint_zero;
  45
  46 /** Maximum value for a dulint */
  47 extern const dulint     ut_dulint_max;
  48
  49 /*******************************************************//**
  50 Creates a 64-bit dulint out of two ulints.
  51 @return created dulint */
  52 UNIV_INLINE
  53 dulint
  54 ut_dulint_create(
  55 /*=============*/
  56         ulint   high,   /*!< in: high-order 32 bits */
  57         ulint   low);   /*!< in: low-order 32 bits */
  58 /*******************************************************//**
  59 Gets the high-order 32 bits of a dulint.
  60 @return 32 bits in ulint */
  61 UNIV_INLINE
  62 ulint
  63 ut_dulint_get_high(
  64 /*===============*/
  65         dulint  d);     /*!< in: dulint */
  66 /*******************************************************//**
  67 Gets the low-order 32 bits of a dulint.
  68 @return 32 bits in ulint */
  69 UNIV_INLINE
  70 ulint
  71 ut_dulint_get_low(
  72 /*==============*/
  73         dulint  d);     /*!< in: dulint */
  74 /*******************************************************//**
  75 Converts a dulint (a struct of 2 ulints) to ib_int64_t, which is a 64-bit
  76 integer type.
  77 @return value in ib_int64_t type */
  78 UNIV_INLINE
  79 ib_int64_t
  80 ut_conv_dulint_to_longlong(
  81 /*=======================*/
  82         dulint  d);     /*!< in: dulint */
  83 /*******************************************************//**
  84 Tests if a dulint is zero.
  85 @return TRUE if zero */
  86 UNIV_INLINE
  87 ibool
  88 ut_dulint_is_zero(
  89 /*==============*/
  90         dulint  a);     /*!< in: dulint */
  91 /*******************************************************//**
  92 Compares two dulints.
  93 @return -1 if a < b, 0 if a == b, 1 if a > b */
  94 UNIV_INLINE
  95 int
  96 ut_dulint_cmp(
  97 /*==========*/
  98         dulint  a,      /*!< in: dulint */
  99         dulint  b);     /*!< in: dulint */
 100 /*******************************************************//**
 101 Calculates the max of two dulints.
 102 @return max(a, b) */
 103 UNIV_INLINE
 104 dulint
 105 ut_dulint_get_max(
 106 /*==============*/
 107         dulint  a,      /*!< in: dulint */
 108         dulint  b);     /*!< in: dulint */
 109 /*******************************************************//**
 110 Calculates the min of two dulints.
 111 @return min(a, b) */
 112 UNIV_INLINE
 113 dulint
 114 ut_dulint_get_min(
 115 /*==============*/
 116         dulint  a,      /*!< in: dulint */
 117         dulint  b);     /*!< in: dulint */
 118 /*******************************************************//**
 119 Adds a ulint to a dulint.
 120 @return sum a + b */
 121 UNIV_INLINE
 122 dulint
 123 ut_dulint_add(
 124 /*==========*/
 125         dulint  a,      /*!< in: dulint */
 126         ulint   b);     /*!< in: ulint */
 127 /*******************************************************//**
 128 Subtracts a ulint from a dulint.
 129 @return a - b */
 130 UNIV_INLINE
 131 dulint
 132 ut_dulint_subtract(
 133 /*===============*/
 134         dulint  a,      /*!< in: dulint */
 135         ulint   b);     /*!< in: ulint, b <= a */
 136 /*******************************************************//**
 137 Subtracts a dulint from another. NOTE that the difference must be positive
 138 and smaller that 4G.
 139 @return a - b */
 140 UNIV_INLINE
 141 ulint
 142 ut_dulint_minus(
 143 /*============*/
 144         dulint  a,      /*!< in: dulint; NOTE a must be >= b and at most
 145                         2 to power 32 - 1 greater */
 146         dulint  b);     /*!< in: dulint */
 147 /********************************************************//**
 148 Rounds a dulint downward to a multiple of a power of 2.
 149 @return rounded value */
 150 UNIV_INLINE
 151 dulint
 152 ut_dulint_align_down(
 153 /*=================*/
 154         dulint   n,             /*!< in: number to be rounded */
 155         ulint    align_no);     /*!< in: align by this number which must be a
 156                                 power of 2 */
 157 /********************************************************//**
 158 Rounds a dulint upward to a multiple of a power of 2.
 159 @return rounded value */
 160 UNIV_INLINE
 161 dulint
 162 ut_dulint_align_up(
 163 /*===============*/
 164         dulint   n,             /*!< in: number to be rounded */
 165         ulint    align_no);     /*!< in: align by this number which must be a
 166                                 power of 2 */
 167 /********************************************************//**
 168 Rounds a dulint downward to a multiple of a power of 2.
 169 @return rounded value */
 170 UNIV_INLINE
 171 ib_uint64_t
 172 ut_uint64_align_down(
 173 /*=================*/
 174         ib_uint64_t      n,             /*!< in: number to be rounded */
 175         ulint            align_no);     /*!< in: align by this number
 176                                         which must be a power of 2 */
 177 /********************************************************//**
 178 Rounds ib_uint64_t upward to a multiple of a power of 2.
 179 @return rounded value */
 180 UNIV_INLINE
 181 ib_uint64_t
 182 ut_uint64_align_up(
 183 /*===============*/
 184         ib_uint64_t      n,             /*!< in: number to be rounded */
 185         ulint            align_no);     /*!< in: align by this number
 186                                         which must be a power of 2 */
 187 /*******************************************************//**
 188 Increments a dulint variable by 1. */
 189 #define UT_DULINT_INC(D)\
 190 {\
 191         if ((D).low == 0xFFFFFFFFUL) {\
 192                 (D).high = (D).high + 1;\
 193                 (D).low = 0;\
 194         } else {\
 195                 (D).low = (D).low + 1;\
 196         }\
 197 }
 198 /*******************************************************//**
 199 Tests if two dulints are equal. */
 200 #define UT_DULINT_EQ(D1, D2)    (((D1).low == (D2).low)\
 201                                                 && ((D1).high == (D2).high))
 202 #ifdef notdefined
 203 /************************************************************//**
 204 Sort function for dulint arrays. */
 205 UNIV_INTERN
 206 void
 207 ut_dulint_sort(
 208 /*===========*/
 209         dulint* arr,    /*!< in/out: array to be sorted */
 210         dulint* aux_arr,/*!< in/out: auxiliary array (same size as arr) */
 211         ulint   low,    /*!< in: low bound of sort interval, inclusive */
 212         ulint   high);  /*!< in: high bound of sort interval, noninclusive */
 213 #endif /* notdefined */
 214
 215 /*********************************************************//**
 216 The following function rounds up a pointer to the nearest aligned address.
 217 @return aligned pointer */
 218 UNIV_INLINE
 219 void*
 220 ut_align(
 221 /*=====*/
 222         const void*     ptr,            /*!< in: pointer */
 223         ulint           align_no);      /*!< in: align by this number */
 224 /*********************************************************//**
 225 The following function rounds down a pointer to the nearest
 226 aligned address.
 227 @return aligned pointer */
 228 UNIV_INLINE
 229 void*
 230 ut_align_down(
 231 /*==========*/
 232         const void*     ptr,            /*!< in: pointer */
 233         ulint           align_no)       /*!< in: align by this number */
 234                 __attribute__((const));
 235 /*********************************************************//**
 236 The following function computes the offset of a pointer from the nearest
 237 aligned address.
 238 @return distance from aligned pointer */
 239 UNIV_INLINE
 240 ulint
 241 ut_align_offset(
 242 /*============*/
 243         const void*     ptr,            /*!< in: pointer */
 244         ulint           align_no)       /*!< in: align by this number */
 245                         __attribute__((const));
 246 /*****************************************************************//**
 247 Gets the nth bit of a ulint.
 248 @return TRUE if nth bit is 1; 0th bit is defined to be the least significant */
 249 UNIV_INLINE
 250 ibool
 251 ut_bit_get_nth(
 252 /*===========*/
 253         ulint   a,      /*!< in: ulint */
 254         ulint   n);     /*!< in: nth bit requested */
 255 /*****************************************************************//**
 256 Sets the nth bit of a ulint.
 257 @return the ulint with the bit set as requested */
 258 UNIV_INLINE
 259 ulint
 260 ut_bit_set_nth(
 261 /*===========*/
 262         ulint   a,      /*!< in: ulint */
 263         ulint   n,      /*!< in: nth bit requested */
 264         ibool   val);   /*!< in: value for the bit to set */
 265
 266 #ifndef UNIV_NONINL
 267 #include "ut0byte.ic"
 268 #endif
 269
 270 #endif