0

不同大小的数字可以是 10 位或 12 位或 15 位。我想对立即位进行符号扩展，以便 16 位整数具有与 10、12 或 15 位值相同的值。

编辑

对不起，我没有发布我写的代码，那是行不通的。这里是：

switch (instr):
{
    case IMMI_10:
    int bits_to_cover = 16 - 10;
    signed short amount = (instr & 15);
    if (amount & (1 << bits_to_cover >> 1))
    {
        amount -= 1 << bits_to_cover;
    }
    break;


    case IMMI_12:
    int bits_to_cover = 16 - 12;
    signed short amount = (instr & 15);
    if (amount & (1 << bits_to_cover >> 1))
    {
        amount -= 1 << bits_to_cover;
    }
    break;


    case IMMI_15:
    int bits_to_cover = 16 - 15;
    signed short amount = (instr & 15);
    if (amount & (1 << bits_to_cover >> 1))
    {
        amount -= 1 << bits_to_cover;
    }
    break;
}

这是在为我在学校的 CSE 课程建造的特殊机器上运行的。它没有运行 x86 架构。它被称为 CSE 410 机器。文档：https ://courses.cs.washington.edu/courses/cse410/18sp/410machine/isaManual.html

4

1 回答 1

3

我的工作基础是，例如，如果您有一个 10 位数字要符号扩展为 16 位，那么您有两种情况需要考虑：

zzzzzz1x xxxxxxxx
zzzzzz0x xxxxxxxx

x 是结果中的“无关 - 必须复制”位。前导 z 是“不关心 - 将覆盖”位。在这两个示例中，在 0 和 1 之间切换的位是符号位，必须将其复制到前导 z 中。我还假设这些位的编号从 0（最低有效位或 LSB）到 15（最高有效位或 MSB）。如果您需要从 1 到 16 对位进行编号，则需要进行一些调整。

给定一个函数签名：

uint16_t sign_extend(uint16_t value, uint16_t bits)

我们可以通过以下方式确定符号位：

uint16_t sign = (1 << (bits - 1)) & value;

我们可以通过使用位掩码将值与值相加，来对具有正 (0) 符号位的值进行 0 扩展：

00000001 11111111

我们可以通过将值与位掩码进行或运算来对具有负 (1) 符号位的值进行 1 扩展：

11111110 00000000

在下面的代码中，我生成了第二个掩码：

uint16_t mask = ((~0U) >> (bits - 1)) << (bits - 1);

并使用按位反转来生成另一个。

该代码避免对右移负值时发生的情况做出假设。（参见samgak的评论。）C 标准说这是实现定义的行为，通常的情况是“将 MSB（符号）位复制到空出的位”（也称为算术右移）或“将空出的位设置为零” '（又名逻辑右移）。两者都是允许的，但给定的编译器必须使用其中一个。无论编译器做什么，这段代码都可以工作，因为它避免了有符号数量的右移。（为了弥补这一点，它假设您可以将有符号整数分配给相应的无符号整数类型，反之亦然，即使有符号值是负数。正式地，标准只要求它适用于值的公共子集 - 从0到<signed-type>_MAX，但我没有听说过有问题的系统，而我听说过换档处理方式不同的系统。）

综上所述，这是我在测试工具中使用的功能：

#include <assert.h>
#include <stdint.h>

extern uint16_t sign_extend(uint16_t value, uint16_t bits);

uint16_t sign_extend(uint16_t value, uint16_t bits)
{
    assert(bits > 0 && bits < 16);
    uint16_t sign = (1 << (bits - 1)) & value;
    uint16_t mask = ((~0U) >> (bits - 1)) << (bits - 1);
    if (sign != 0)
        value |= mask;
    else
        value &= ~mask;
    return value;
}

#ifdef TEST

#include <stdio.h>

struct TestSignExtend
{
    uint16_t    value;
    uint16_t    bits;
    uint16_t    result;
};

static int test_sign_extend(const struct TestSignExtend *test)
{
    uint16_t result = sign_extend(test->value, test->bits);
    const char *pass = (result == test->result) ? "** PASS **" : "== FAIL ==";
    printf("%s: value = 0x%.4X, bits = %2d, wanted = 0x%.4X, actual = 0x%.4X\n",
            pass, test->value, test->bits, test->result, result);
    return(result == test->result);
}

int main(void)
{
    struct TestSignExtend tests[] =
    {
        { 0x0123, 10, 0x0123 },
        { 0x0323, 10, 0xFF23 },
        { 0x0323, 11, 0x0323 },
        { 0x0723, 11, 0xFF23 },
        { 0x0323, 12, 0x0323 },
        { 0x0C23, 12, 0xFC23 },
        { 0x0323, 13, 0x0323 },
        { 0x1723, 13, 0xF723 },
        { 0x1323, 14, 0x1323 },
        { 0x3723, 14, 0xF723 },
        { 0x0323, 15, 0x0323 },
        { 0xC723, 15, 0xC723 },
        { 0x0123,  9, 0xFF23 },
        { 0x0223,  9, 0x0023 },
        { 0x0129,  8, 0x0029 },
        { 0x03E9,  8, 0xFFE9 },
    };
    enum { NUM_TESTS = sizeof(tests) / sizeof(tests[0]) };
    int pass = 0;

    for (int i = 0; i < NUM_TESTS; i++)
        pass += test_sign_extend(&tests[i]);
    if (pass == NUM_TESTS)
        printf("PASS - All %d tests passed\n", NUM_TESTS);
    else
        printf("FAIL - %d tests failed out of %d run\n", NUM_TESTS - pass, NUM_TESTS);

    return(pass != NUM_TESTS);  /* Process logic is inverted! */
}

#endif /* TEST */

样本输出：

** PASS **: value = 0x0123, bits = 10, wanted = 0x0123, actual = 0x0123
** PASS **: value = 0x0323, bits = 10, wanted = 0xFF23, actual = 0xFF23
** PASS **: value = 0x0323, bits = 11, wanted = 0x0323, actual = 0x0323
** PASS **: value = 0x0723, bits = 11, wanted = 0xFF23, actual = 0xFF23
** PASS **: value = 0x0323, bits = 12, wanted = 0x0323, actual = 0x0323
** PASS **: value = 0x0C23, bits = 12, wanted = 0xFC23, actual = 0xFC23
** PASS **: value = 0x0323, bits = 13, wanted = 0x0323, actual = 0x0323
** PASS **: value = 0x1723, bits = 13, wanted = 0xF723, actual = 0xF723
** PASS **: value = 0x1323, bits = 14, wanted = 0x1323, actual = 0x1323
** PASS **: value = 0x3723, bits = 14, wanted = 0xF723, actual = 0xF723
** PASS **: value = 0x0323, bits = 15, wanted = 0x0323, actual = 0x0323
** PASS **: value = 0xC723, bits = 15, wanted = 0xC723, actual = 0xC723
** PASS **: value = 0x0123, bits =  9, wanted = 0xFF23, actual = 0xFF23
** PASS **: value = 0x0223, bits =  9, wanted = 0x0023, actual = 0x0023
** PASS **: value = 0x0129, bits =  8, wanted = 0x0029, actual = 0x0029
** PASS **: value = 0x03E9, bits =  8, wanted = 0xFFE9, actual = 0xFFE9
PASS - All 16 tests passed

在一切顺利通过后，我确实在其中一个测试中故意犯了错误，只是为了确保发现失败。

在您的代码中，您可以像这样使用它：

signed short value = …;

switch (instr):
{
case IMMI_10:
    value = sign_extend(value, 10);
    break;
case IMMI_12:
    value = sign_extend(value, 12);
    break;
case IMMI_15:
    value = sign_extend(value, 15);
    break;
default:
    assert(0 && "can't happen!");
}

如果 case 标签IMMI_10,IMMI_12并且IMMI_15具有值10, 12, 15，那么您可以避免切换并简单地使用赋值：

signed short value = …;   // Get the value from somewhere
value = sign_extend(value, instr);
于 2018-04-14T23:17:31.283 回答