如何安全地将 uint32_t 中的带符号字段提取为带符号的数字(int 或 uint32_t)

How to safely extract a signed field from a uint32_t into a signed number (int or uint32_t)

我有一个项目,其中我正在获取 32 位 ARM 指令的向量,并且部分指令(偏移值)需要读取为有符号(二进制补码)数字而不是无符号数字。

我使用了一个 uint32_t 向量,因为所有的操作码和寄存器都被读取为无符号的并且整个指令是 32 位的。

例如:

我有这个 32 位 ARM 指令编码:

uint32_t addr = 0b00110001010111111111111111110110

后19位是我需要读取的分支偏移量,作为有符号整数分支位移。 这部分:1111111111111110110


我有这个函数,参数是整条32位指令: 我向左移动 13 个位置,然后再次向右移动 13 个位置,以仅具有偏移值并移动指令的其他部分。

我已经尝试将此函数转换为不同的带符号变量,使用不同的转换方式和使用其他 C++ 函数,但它打印的数字是无符号的。

int getCat1BrOff(uint32_t inst)
{
    uint32_t temp = inst << 13;
    uint32_t brOff = temp >> 13;
    return (int)brOff;
}

我得到十进制数 524278 而不是 -10

我认为最后一个选项不是最好的选项,但它可能工作是将所有二进制值设置为一个字符串。反转位并加 1 以转换它们,然后将新的二进制数转换回十进制数。正如我在论文中所做的那样,但这不是一个好的解决方案。

它归结为进行符号扩展,其中符号位是第 19 位。 有两种方法。

  1. 使用算术移位。
  2. 检测符号位和/或高位。

在 C++ 中没有可移植的方法来执行 1.。但是可以在编译时检查。如果下面的代码是 UB,请纠正我,但我相信它只是实现定义的 - 我们在编译时检查。 唯一有问题的是无符号到有符号的转换溢出和右移,但这应该由实现定义。

int getCat1BrOff(uint32_t inst)
{
    if constexpr (int32_t(0xFFFFFFFFu) >> 1 == int32_t(0xFFFFFFFFu))
    {
        return int32_t(inst << uint32_t{13}) >> int32_t{13};
    }
    else
    {
        int32_t offset = inst & 0x0007FFFF;
        if (offset & 0x00040000)
        {
            offset |= 0xFFF80000;
        }
        return offset;
    }
}

或更通用的解决方案

template <uint32_t N>
int32_t signExtend(uint32_t value)
{
    static_assert(N > 0 && N <= 32);
    constexpr uint32_t unusedBits = (uint32_t(32) - N);
    if constexpr (int32_t(0xFFFFFFFFu) >> 1 == int32_t(0xFFFFFFFFu))
    {
        return int32_t(value << unusedBits) >> int32_t(unusedBits);
    }
    else
    {
        constexpr uint32_t mask = uint32_t(0xFFFFFFFFu) >> unusedBits;
        value &= mask;
        if (value & (uint32_t(1) << (N-1)))
        {
            value |= ~mask;
        }
        return int32_t(value);
    }
}

https://godbolt.org/z/rb-rRB

实际上,你只需要将 temp 声明为已签名:

int getCat1BrOff(uint32_t inst)
{
    int32_t temp = inst << 13;
    return temp >> 13;
}

很遗憾,这是 not portable:

For negative a, the value of a >> b is implementation-defined (in most implementations, this performs arithmetic right shift, so that the result remains negative).

但我还没有遇到一个编译器没有做这里显而易见的事情。