attest.hpp

Go to the documentation of this file.

#ifndef SANISIZER_ATTEST_HPP
#define SANISIZER_ATTEST_HPP
 
#include <limits>
#include <type_traits>
#include <cassert>
#include <stdexcept>
 
#include "utils.hpp"
 
namespace sanisizer {
 
template<typename Integer_, Integer_ max_>
struct Attestation {
    static_assert(std::is_integral<Integer_>::value);
    static_assert(max_ >= 0);
 
    constexpr Attestation(Integer_ x) : value(x) {
        assert(x <= max_);
    }
 
    typedef Integer_ Integer;
 
    static constexpr Integer_ max = max_;
 
    Integer_ value;
};
 
template<typename Value_>
struct is_Attestation {
    static constexpr bool value = false;
};
 
template<typename Integer_, Integer_ max_>
struct is_Attestation<Attestation<Integer_, max_> > {
    static constexpr bool value = true;
};
 
template<typename Value_>
struct is_integral_or_Attestation {
    static constexpr bool value = std::is_integral<Value_>::value || is_Attestation<Value_>::value;
};
 
template<typename Value_>
constexpr auto get_value(Value_ x) {
    if constexpr(std::is_integral<Value_>::value) {
        return x;
    } else {
        static_assert(is_Attestation<Value_>::value);
        return x.value;
    }
}
 
template<typename Value_>
constexpr auto get_max() {
    if constexpr(std::is_integral<Value_>::value) {
        return std::numeric_limits<Value_>::max();
    } else {
        static_assert(is_Attestation<Value_>::value);
        return Value_::max;
    }
}
 
template<typename Max_, Max_ new_max_, typename Value_>
constexpr auto attest_max(Value_ x) {
    constexpr auto unsigned_new_limit = static_cast<typename std::make_unsigned<Max_>::type>(new_max_);
    if constexpr(std::is_integral<Value_>::value) {
        constexpr auto max_value = static_cast<typename std::make_unsigned<Value_>::type>(std::numeric_limits<Value_>::max());
        if constexpr(max_value <= unsigned_new_limit) {
            return x; 
        } else {
            return Attestation<Value_, static_cast<Value_>(new_max_)>(x);
        }
    } else {
        static_assert(is_Attestation<Value_>::value);
        typedef typename Value_::Integer WrappedInteger;
        constexpr auto max_value = static_cast<typename std::make_unsigned<WrappedInteger>::type>(Value_::max);
        if constexpr(max_value <= unsigned_new_limit) {
            return x;
        } else {
            return Attestation<WrappedInteger, static_cast<WrappedInteger>(new_max_)>(x.value);
        }
    }
}
 
template<typename Max_, typename Value_>
constexpr auto attest_max_by_type(Value_ x) {
    return attest_max<Max_, std::numeric_limits<Max_>::max()>(x);
}
 
template<typename Dest_, typename Value_>
constexpr bool check_overflow(Value_ x) {
    static_assert(std::is_integral<Dest_>::value);
    constexpr auto umaxed = as_unsigned(std::numeric_limits<Dest_>::max());
    static_assert(is_integral_or_Attestation<Value_>::value);
    if constexpr(umaxed < as_unsigned(get_max<Value_>())) {
        if (umaxed < as_unsigned(get_value(x))) {
            throw std::overflow_error("overflow detected when casting size-like values in sanisizer");
        }
    }
    return false;
}
 
template<typename Value_>
Value_ attest_gez(Value_ x) { return x; }
}
 
#endif