Method LongObject

src/pystack/_pystack/pytypes.cpp:148–217

}

LongObject::LongObject(
        const std::shared_ptr<const AbstractProcessManager>& manager,
        remote_addr_t addr,
        bool is_bool)
: d_is_bool(is_bool)
{
#ifdef ENVIRONMENT64
    constexpr unsigned int shift = 30;
#else
    constexpr unsigned int shift = 15;
#endif

    Structure<py_long_v> longobj(manager, addr);
    ssize_t size;
    bool negative;

    Py_ssize_t ob_size = longobj.getField(&py_long_v::o_ob_size);
    if (manager->versionIsAtLeast(3, 12)) {
        auto lv_tag = *reinterpret_cast<uintptr_t*>(&ob_size);
        negative = (lv_tag & 3) == 2;
        size = lv_tag >> 3;
    } else {
        negative = ob_size < 0;
        size = std::abs(ob_size);
    }

    if (size == 0) {
        d_value = 0;
        return;
    }

    /* Python's Include/longobjrep.h has this declaration:
     *      struct _longobject {
     *          PyObject_VAR_HEAD
     *          digit ob_digit[1];
     *      };
     *
     *  with this description:
     *    The absolute value of a number is equal to
     *          SUM(for i=0 through abs(ob_size)-1) ob_digit[i] * 2**(SHIFT*i)
     *    Negative numbers are represented with ob_size < 0;
     *    zero is represented by ob_size == 0.
     *
     *  where SHIFT can be either:
     *       #define PyLong_SHIFT        30
     *       #define PyLong_SHIFT        15
     */

    std::vector<digit> digits;
    digits.resize(size);
    manager->copyMemoryFromProcess(
            longobj.getFieldRemoteAddress(&py_long_v::o_ob_digit),
            sizeof(digit) * size,
            digits.data());
    for (ssize_t i = 0; i < size; ++i) {
        long long factor;
        if (__builtin_mul_overflow(digits[i], (1Lu << (ssize_t)(shift * i)), &factor)) {
            d_overflowed = true;