big_int_util.h

/*
 * SPDX-FileCopyrightText: 2013 Barefoot Networks, Inc.
 * Copyright 2013-present Barefoot Networks, Inc.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef LIB_BIG_INT_UTIL_H_
#define LIB_BIG_INT_UTIL_H_
 
#include "big_int.h"
#include "hash.h"
 
namespace P4::Util {
 
// Useful functions for manipulating GMP values
// (arbitrary-precision values)
 
big_int ripBits(big_int &value, int bits);
 
struct BitRange {
    unsigned lowIndex;
    unsigned highIndex;
    big_int value;
};
 
// Find a consecutive scan of 1 bits at the "bottom"
BitRange findOnes(const big_int &value);
 
big_int cvtInt(const char *s, unsigned base);
big_int shift_left(const big_int &v, unsigned bits);
big_int shift_right(const big_int &v, unsigned bits);
// Convert a slice [m:l] into a mask
big_int maskFromSlice(unsigned m, unsigned l);
big_int mask(unsigned bits);
 
inline unsigned scan0_positive(const boost::multiprecision::cpp_int &val, unsigned pos) {
    while (boost::multiprecision::bit_test(val, pos)) ++pos;
    return pos;
}
inline unsigned scan1_positive(const boost::multiprecision::cpp_int &val, unsigned pos) {
    if (val == 0 || pos > boost::multiprecision::msb(val)) return ~0U;
    unsigned lsb = boost::multiprecision::lsb(val);
    if (lsb >= pos) return lsb;
    while (!boost::multiprecision::bit_test(val, pos)) ++pos;
    return pos;
}
inline unsigned scan0(const boost::multiprecision::cpp_int &val, unsigned pos) {
    if (val < 0) return scan1_positive(-val - 1, pos);
    return scan0_positive(val, pos);
}
inline unsigned scan1(const boost::multiprecision::cpp_int &val, unsigned pos) {
    if (val < 0) return scan0_positive(-val - 1, pos);
    return scan1_positive(val, pos);
}
 
}  // namespace P4::Util
 
namespace P4 {
 
static inline unsigned bitcount(big_int v) {
    if (v < 0) return ~0U;
    unsigned rv = 0;
    while (v != 0) {
        v &= v - 1;
        ++rv;
    }
    return rv;
}
 
static inline int ffs(big_int v) {
    if (v <= 0) return -1;
    return boost::multiprecision::lsb(v);
}
 
static inline int floor_log2(big_int v) {
    int rv = -1;
    while (v > 0) {
        rv++;
        v /= 2;
    }
    return rv;
}
 
static inline int ceil_log2(big_int v) { return v ? floor_log2(v - 1) + 1 : -1; }
 
template <>
struct Util::Hasher<big_int> : Detail::StdHasher {};
 
}  // namespace P4
 
#endif /* LIB_BIG_INT_UTIL_H_ */