include/am-utility.h
author David Anderson <danderson@mozilla.com>
Mon Aug 26 23:18:03 2013 -0700 (2013-08-26)
changeset 11 cfe800908837
parent 10 0ac292cc1467
permissions -rw-r--r--
Add tests.
danderson@0
     1
// vim: set sts=8 ts=2 sw=2 tw=99 et:
danderson@0
     2
//
danderson@0
     3
// Copyright (C) 2013, David Anderson and AlliedModders LLC
danderson@0
     4
// All rights reserved.
danderson@0
     5
// 
danderson@0
     6
// Redistribution and use in source and binary forms, with or without
danderson@0
     7
// modification, are permitted provided that the following conditions are met:
danderson@0
     8
// 
danderson@0
     9
//  * Redistributions of source code must retain the above copyright notice, this
danderson@0
    10
//    list of conditions and the following disclaimer.
danderson@0
    11
//  * Redistributions in binary form must reproduce the above copyright notice,
danderson@0
    12
//    this list of conditions and the following disclaimer in the documentation
danderson@0
    13
//    and/or other materials provided with the distribution.
danderson@0
    14
//  * Neither the name of AlliedModders LLC nor the names of its contributors
danderson@0
    15
//    may be used to endorse or promote products derived from this software
danderson@0
    16
//    without specific prior written permission.
danderson@0
    17
//
danderson@0
    18
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
danderson@0
    19
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
danderson@0
    20
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
danderson@0
    21
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
danderson@0
    22
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
danderson@0
    23
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
danderson@0
    24
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
danderson@0
    25
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
danderson@0
    26
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
danderson@0
    27
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
danderson@0
    28
// POSSIBILITY OF SUCH DAMAGE.
danderson@0
    29
danderson@0
    30
#ifndef _include_amtl_utility_h_
danderson@0
    31
#define _include_amtl_utility_h_
danderson@0
    32
danderson@0
    33
#include <assert.h>
danderson@0
    34
#include <stddef.h>
danderson@0
    35
#include <stdlib.h>
danderson@0
    36
#include <stdint.h>
danderson@0
    37
#if defined(_MSC_VER)
danderson@0
    38
# include <intrin.h>
danderson@0
    39
#endif
danderson@0
    40
danderson@0
    41
#define KE_32BIT
danderson@0
    42
danderson@0
    43
#if defined(_MSC_VER)
danderson@0
    44
# pragma warning(disable:4355)
danderson@0
    45
#endif
danderson@0
    46
danderson@0
    47
namespace ke {
danderson@0
    48
danderson@0
    49
static const size_t kMallocAlignment = sizeof(void *) * 2;
danderson@0
    50
danderson@0
    51
static const size_t kKB = 1024;
danderson@0
    52
static const size_t kMB = 1024 * kKB;
danderson@0
    53
static const size_t kGB = 1024 * kMB;
danderson@0
    54
dvander@10
    55
typedef uint8_t * Address;
dvander@10
    56
danderson@0
    57
template <typename T> T
danderson@0
    58
ReturnAndVoid(T &t)
danderson@0
    59
{
danderson@0
    60
    T saved = t;
danderson@0
    61
    t = T();
danderson@0
    62
    return saved;
danderson@0
    63
}
danderson@0
    64
danderson@0
    65
// Wrapper that automatically deletes its contents. The pointer can be taken
danderson@0
    66
// to avoid destruction.
danderson@0
    67
template <typename T>
danderson@0
    68
class AutoPtr
danderson@0
    69
{
danderson@0
    70
    T *t_;
danderson@0
    71
danderson@0
    72
  public:
danderson@0
    73
    AutoPtr()
danderson@0
    74
      : t_(NULL)
danderson@0
    75
    {
danderson@0
    76
    }
danderson@0
    77
    explicit AutoPtr(T *t)
danderson@0
    78
      : t_(t)
danderson@0
    79
    {
danderson@0
    80
    }
danderson@0
    81
    ~AutoPtr() {
danderson@0
    82
        delete t_;
danderson@0
    83
    }
danderson@0
    84
    T *take() {
danderson@0
    85
        return ReturnAndVoid(t_);
danderson@0
    86
    }
danderson@0
    87
    T *operator *() const {
danderson@0
    88
        return t_;
danderson@0
    89
    }
danderson@0
    90
    T *operator ->() const {
danderson@0
    91
        return t_;
danderson@0
    92
    }
danderson@0
    93
    operator T *() const {
danderson@0
    94
        return t_;
danderson@0
    95
    }
danderson@0
    96
    void operator =(T *t) {
danderson@0
    97
        delete t_;
danderson@0
    98
        t_ = t;
danderson@0
    99
    }
danderson@0
   100
    bool operator !() const {
danderson@0
   101
        return !t_;
danderson@0
   102
    }
danderson@0
   103
};
danderson@0
   104
dvander@5
   105
// Wrapper that automatically deletes its contents. The pointer can be taken
dvander@5
   106
// to avoid destruction.
dvander@5
   107
template <typename T>
dvander@5
   108
class AutoArray
danderson@0
   109
{
dvander@5
   110
    T *t_;
danderson@0
   111
danderson@0
   112
  public:
dvander@5
   113
    AutoArray()
dvander@5
   114
      : t_(NULL)
dvander@5
   115
    {
dvander@5
   116
    }
dvander@5
   117
    explicit AutoArray(T *t)
dvander@5
   118
      : t_(t)
dvander@5
   119
    {
dvander@5
   120
    }
dvander@5
   121
    ~AutoArray() {
dvander@5
   122
        delete [] t_;
dvander@5
   123
    }
dvander@5
   124
    T *take() {
dvander@5
   125
        return ReturnAndVoid(t_);
danderson@0
   126
    }
dvander@5
   127
    T *operator *() const {
dvander@5
   128
        return t_;
dvander@5
   129
    }
dvander@5
   130
    T &operator [](size_t index) {
dvander@5
   131
      return t_[index];
dvander@5
   132
    }
dvander@5
   133
    const T &operator [](size_t index) const {
dvander@5
   134
      return t_[index];
danderson@0
   135
    }
dvander@5
   136
    operator T *() const {
dvander@5
   137
        return t_;
dvander@5
   138
    }
dvander@5
   139
    void operator =(T *t) {
dvander@5
   140
        delete [] t_;
dvander@5
   141
        t_ = t;
dvander@5
   142
    }
dvander@5
   143
    bool operator !() const {
dvander@5
   144
        return !t_;
danderson@0
   145
    }
danderson@0
   146
};
danderson@0
   147
danderson@0
   148
static inline size_t
danderson@0
   149
Log2(size_t number)
danderson@0
   150
{
danderson@0
   151
    assert(number != 0);
danderson@0
   152
danderson@0
   153
#ifdef _MSC_VER
danderson@0
   154
    unsigned long rval;
danderson@0
   155
# ifdef _M_IX86
danderson@0
   156
    _BitScanReverse(&rval, number);
danderson@0
   157
# elif _M_X64
danderson@0
   158
    _BitScanReverse64(&rval, number);
danderson@0
   159
# endif
danderson@0
   160
    return rval;
danderson@0
   161
#else
danderson@0
   162
    size_t bit;
danderson@0
   163
    asm("bsr %1, %0\n"
danderson@0
   164
        : "=r" (bit)
danderson@0
   165
        : "rm" (number));
danderson@0
   166
    return bit;
danderson@0
   167
#endif
danderson@0
   168
}
danderson@0
   169
danderson@0
   170
static inline size_t
danderson@0
   171
FindRightmostBit(size_t number)
danderson@0
   172
{
danderson@0
   173
    assert(number != 0);
danderson@0
   174
danderson@0
   175
#ifdef _MSC_VER
danderson@0
   176
    unsigned long rval;
danderson@0
   177
# ifdef _M_IX86
danderson@0
   178
    _BitScanForward(&rval, number);
danderson@0
   179
# elif _M_X64
danderson@0
   180
    _BitScanForward64(&rval, number);
danderson@0
   181
# endif
danderson@0
   182
    return rval;
danderson@0
   183
#else
danderson@0
   184
    size_t bit;
danderson@0
   185
    asm("bsf %1, %0\n"
danderson@0
   186
        : "=r" (bit)
danderson@0
   187
        : "rm" (number));
danderson@0
   188
    return bit;
danderson@0
   189
#endif
danderson@0
   190
}
danderson@0
   191
danderson@0
   192
static inline bool
danderson@0
   193
IsPowerOfTwo(size_t value)
danderson@0
   194
{
danderson@0
   195
    if (value == 0)
danderson@0
   196
        return false;
danderson@0
   197
    return !(value & (value - 1));
danderson@0
   198
}
danderson@0
   199
danderson@0
   200
static inline size_t
danderson@0
   201
Align(size_t count, size_t alignment)
danderson@0
   202
{
danderson@0
   203
    assert(IsPowerOfTwo(alignment));
danderson@0
   204
    return count + (alignment - (count % alignment)) % alignment;
danderson@0
   205
}
danderson@0
   206
danderson@0
   207
static inline bool
danderson@0
   208
IsUint32AddSafe(unsigned a, unsigned b)
danderson@0
   209
{
danderson@0
   210
    if (!a || !b)
danderson@0
   211
        return true;
danderson@0
   212
    size_t log2_a = Log2(a);
danderson@0
   213
    size_t log2_b = Log2(b);
danderson@0
   214
    return (log2_a < sizeof(unsigned) * 8) &&
danderson@0
   215
           (log2_b < sizeof(unsigned) * 8);
danderson@0
   216
}
danderson@0
   217
danderson@0
   218
static inline bool
danderson@0
   219
IsUintPtrAddSafe(size_t a, size_t b)
danderson@0
   220
{
danderson@0
   221
    if (!a || !b)
danderson@0
   222
        return true;
danderson@0
   223
    size_t log2_a = Log2(a);
danderson@0
   224
    size_t log2_b = Log2(b);
danderson@0
   225
    return (log2_a < sizeof(size_t) * 8) &&
danderson@0
   226
           (log2_b < sizeof(size_t) * 8);
danderson@0
   227
}
danderson@0
   228
danderson@0
   229
static inline bool
danderson@0
   230
IsUint32MultiplySafe(unsigned a, unsigned b)
danderson@0
   231
{
danderson@0
   232
    if (a <= 1 || b <= 1)
danderson@0
   233
        return true;
danderson@0
   234
danderson@0
   235
    size_t log2_a = Log2(a);
danderson@0
   236
    size_t log2_b = Log2(b);
danderson@0
   237
    return log2_a + log2_b <= sizeof(unsigned) * 8;
danderson@0
   238
}
danderson@0
   239
danderson@0
   240
static inline bool
danderson@0
   241
IsUintPtrMultiplySafe(size_t a, size_t b)
danderson@0
   242
{
danderson@0
   243
    if (a <= 1 || b <= 1)
danderson@0
   244
        return true;
danderson@0
   245
danderson@0
   246
    size_t log2_a = Log2(a);
danderson@0
   247
    size_t log2_b = Log2(b);
danderson@0
   248
    return log2_a + log2_b <= sizeof(size_t) * 8;
danderson@0
   249
}
danderson@0
   250
danderson@0
   251
#define ARRAY_LENGTH(array) (sizeof(array) / sizeof(array[0]))
danderson@0
   252
#define STATIC_ASSERT(cond) extern int static_assert_f(int a[(cond) ? 1 : -1])
danderson@0
   253
danderson@0
   254
#define IS_ALIGNED(addr, alignment)    (!(uintptr_t(addr) & ((alignment) - 1)))
danderson@0
   255
danderson@0
   256
template <typename T>
danderson@0
   257
static inline bool
danderson@0
   258
IsAligned(T addr, size_t alignment)
danderson@0
   259
{
danderson@0
   260
    assert(IsPowerOfTwo(alignment));
danderson@0
   261
    return !(uintptr_t(addr) & (alignment - 1));
danderson@0
   262
}
danderson@0
   263
danderson@0
   264
static inline Address
danderson@0
   265
AlignedBase(Address addr, size_t alignment)
danderson@0
   266
{
danderson@0
   267
    assert(IsPowerOfTwo(alignment));
danderson@0
   268
    return Address(uintptr_t(addr) & ~(alignment - 1));
danderson@0
   269
}
danderson@0
   270
danderson@0
   271
template <typename T> static inline T
danderson@0
   272
Min(const T &t1, const T &t2)
danderson@0
   273
{
danderson@0
   274
    return t1 < t2 ? t1 : t2;
danderson@0
   275
}
danderson@0
   276
danderson@0
   277
template <typename T> static inline T
danderson@0
   278
Max(const T &t1, const T &t2)
danderson@0
   279
{
danderson@0
   280
    return t1 > t2 ? t1 : t2;
danderson@0
   281
}
danderson@0
   282
danderson@0
   283
template <typename T>
danderson@0
   284
class StorageBuffer
danderson@0
   285
{
danderson@0
   286
 public:
danderson@0
   287
  T *address() {
danderson@0
   288
    return reinterpret_cast<T *>(buffer_);
danderson@0
   289
  }
danderson@0
   290
  const T *address() const {
danderson@0
   291
    return reinterpret_cast<const T *>(buffer_);
danderson@0
   292
  }
danderson@0
   293
danderson@0
   294
 private:
danderson@0
   295
  union {
danderson@0
   296
    char buffer_[sizeof(T)];
danderson@0
   297
    uint64_t aligned_;
danderson@0
   298
  };
danderson@0
   299
};
danderson@0
   300
danderson@0
   301
#if __cplusplus >= 201103L
danderson@0
   302
# define KE_CXX11
danderson@0
   303
#endif
danderson@0
   304
danderson@0
   305
#if defined(KE_CXX11)
danderson@0
   306
# define KE_DELETE delete
danderson@0
   307
# define KE_OVERRIDE override
danderson@0
   308
#else
danderson@0
   309
# define KE_DELETE
danderson@0
   310
# define KE_OVERRIDE
danderson@0
   311
#endif
danderson@0
   312
danderson@0
   313
#if defined(_MSC_VER)
danderson@0
   314
# define KE_SIZET_FMT           "%Iu"
danderson@0
   315
#elif defined(__GNUC__)
danderson@0
   316
# define KE_SIZET_FMT           "%zu"
danderson@0
   317
#else
danderson@0
   318
# error "Implement format specifier string"
danderson@0
   319
#endif
danderson@0
   320
danderson@0
   321
#if defined(__GNUC__)
danderson@0
   322
# define KE_CRITICAL_LIKELY(x)  __builtin_expect(!!(x), 1)
danderson@0
   323
#else
danderson@0
   324
# define KE_CRITICAL_LIKELY(x)  x
danderson@0
   325
#endif
danderson@0
   326
danderson@0
   327
}
danderson@0
   328
danderson@0
   329
#endif // _include_amtl_utility_h_