algorithm - 汇编语言使用有符号整数乘法数学来执行移位

Question

这是一个转变。

通常人们会尝试使用移位来执行乘法，而不是相反。

在 Hitachi/Motorola 6309 上没有 n 位移位。仅移位 1 位。

但是有一个 16 位 x 16 位有符号乘法(提供 32 位有符号结果)。

(编辑)使用它进行 16 位移位(左)没有问题，但是我正在尝试使用 2 x 16x16 有符号乘数来进行 32 位移位。低位词移位结果的高位词是问题所在。 (这有意义吗？)

一些伪代码可能会有所帮助:

result.highword = low word of (val.highword * shiftmulttable[shift])
temp = val.lowword * shiftmulttable[shift]
result.lowword = temp.lowword
result.highword = or (result.highword, temp.highword)
(with some magic on temp.highword to consider signed values)

我一直在锻炼我的逻辑，试图使用这条指令来执行轮类，但到目前为止我失败了。

我可以很容易地将任何正值移动 0 到 14，但是当涉及到移动 15 位(乘以 0x8000)或移动任何负值时，某些值的组合需要:

• 将结果补1
• 将结果补2
• 将结果加1
• 对结果什么都不做

我只是看不到这些值的任何模式。

任何想法表示赞赏!

Answer 1

我从问题描述中可以看出，通过使用 unsigned 16x16->32 位乘法，实现 32 位移位将按预期工作。这可以很容易地通过利用二进制补码整数表示从带符号的 16x16->32 乘法指令合成。如果两个因数是a和b，当a为负数，当b为负数时，将a加到有符号乘积的高16位上，得到无符号乘积。

下面的 C 代码实现了这种方法并对其进行了详尽的测试:

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>

/* signed 16x16->32 bit multiply. Hardware instruction */
int32_t mul16_wide (int16_t a, int16_t b)
{
    return (int32_t)a * (int32_t)b;
}

/* unsigned 16x16->32 bit multiply (synthetic) */
int32_t umul16_wide (int16_t a, int16_t b)
{
    int32_t p = mul16_wide (a, b); // signed 16x16->32 bit multiply
    if (a < 0) p = p + (b << 16);  // add 'b' to upper 16 bits of product
    if (b < 0) p = p + (a << 16);  // add 'a' to upper 16 bits of product
    return p;
}

/* unsigned 16x16->32 bit multiply (reference) */
uint32_t umul16_wide_ref (uint16_t a, uint16_t b)
{
     return (uint32_t)a * (uint32_t)b;
}

/* test synthetic unsigned multiply exhaustively */
int main (void)
{
    int16_t a, b;
    int32_t res, ref;
    uint64_t count = 0;

    a = -32768;
    do {
        b = -32768;
        do {
            res = umul16_wide (a, b);
            ref = umul16_wide_ref (a, b);
            count++;
            if (res != ref) {
                printf ("!!!! a=%d b=%d res=%d ref=%d\n", a, b, res, ref);
                return EXIT_FAILURE;
            }
            if (b == 32767) break;
            b = b + 1;
        } while (1);
        if (a == 32767) break;
        a = a + 1;
    } while (1);
    printf ("test cases passed: %llx\n", count);
    return EXIT_SUCCESS;
}

我不熟悉 Hitachi/Motorola 6309 架构。我假设它使用一个特殊的 32 位寄存器来保存宽乘法的结果，从中可以提取高和低一半到 16 位通用寄存器中，然后可以将条件更正应用于保存高 16 位。