我不知道之前是否有人问过这个问题，这个问题背后的根源是标准C或C++中的错误（在我看来），即整数乘积相乘后的隐式字宽与整数乘数和被乘数的字宽中的较大者相同。
所以，如果在C中，int32_t乘以int32_t会隐式地产生int64_t，这不会是一个问题。但事实并非如此。我所知道的几乎每个整数CPU和定点DSP都将两个N位操作数相乘到一个2N位宽的寄存器（或寄存器对）中，我希望C能做到这一点（没有某种内联汇编）。
现在我知道这是可行的（这是一个简单的定点直接形式1双二阶滤波器，在唯一的量化点周围保存分数）：

int64_t accumulator;
int64_t a1, a2, b0, b1, b2;   /* 2nd-order IIR coefficients */
int32_t state_x1, state_x2, state_y1, state_y2, state_fraction;
int32_t x, y;
int32_t get_input(void);
void put_output(int32_t y);
int i, num_samples;
         /* num_samples is the number of samples per block */
/*  load up your coefficients, cast all to int64_t */
/*  load up your states from wherever */
accumulator = (int64_t)state_fraction;
for (i=0; i<num_samples; i++)
    {
    x = get_input();
    accumulator += b0*x;
    accumulator += b1*state_x1;
    accumulator += b2*state_x2;
    accumulator += a1*state_y1;
    accumulator += a2*state_y2;
    if (accumulator > 0x1FFFFFFFFFFFFFFF)
       {
       accumulator = 0x1FFFFFFFFFFFFFFF;     /* clip value */
       }
    if (accumulator < -0x2000000000000000)
       {
       accumulator = -0x2000000000000000;    /* clip value */
       }
    y =  (int32_t)(accumulator>>30);   /* always rounding down */
    state_x2 = state_x1;             /* bump the states over */
    state_x1 = x;
    state_y2 = state_y1;
    state_y1 = y;
    accumulator = accumulator & 0x000000003FFFFFFF;
    /* keep the fractional bits that you dropped for the next sample
       otherwise clear the accumulator */
    put_output(y);
    }
state_fraction = (int32_t)accumulator;
/*  save your states back to wherever  */

字符串
但是我不想浪费MIPS来乘以int64_t乘以int32_t，因为我知道这两个值都是32位的数字。但是我也知道结果 * 必须 * 是64位宽的，否则会有麻烦。
假设我这样做：

int64_t accumulator;
int32_t a1, a2, b0, b1, b2;   /* 2nd-order IIR coefficients */
int32_t state_x1, state_x2, state_y1, state_y2, state_fraction;
int32_t x, y;
int32_t get_input(void);
void put_output(int32_t y);
int i, num_samples;
         /* num_samples is the number of samples per block */
/*  load up your coefficients, (leaving as int32_t) */
/*  load up your states from wherever */
accumulator = (int64_t)state_fraction;
for (i=0; i<num_samples; i++)
    {
    x = get_input();
    accumulator += (int64_t)b0*x;
    accumulator += (int64_t)b1*state_x1;
    accumulator += (int64_t)b2*state_x2;
    accumulator += (int64_t)a1*state_y1;
    accumulator += (int64_t)a2*state_y2;
    if (accumulator > 0x1FFFFFFFFFFFFFFF)
       {
       accumulator = 0x1FFFFFFFFFFFFFFF;     /* clip value */
       }
    if (accumulator < -0x2000000000000000)
       {
       accumulator = -0x2000000000000000;    /* clip value */
       }
    y =  (int32_t)(accumulator>>30);   /* always rounding down */
    state_x2 = state_x1;             /* bump the states over */
    state_x1 = x;
    state_y2 = state_y1;
    state_y1 = y;
    accumulator = accumulator & 0x000000003FFFFFFF;
    /* keep the fractional bits that you dropped for the next sample
       otherwise clear the accumulator */
    put_output(y);
    }
state_fraction = (int32_t)accumulator;
/*  save your states back to wherever  */

型
编译器是否足够聪明，能够理解我想要的是什么？将两个32位有符号整数相乘，并将64位结果添加到64位累加器 * 中，而不将任何内容 * 转换到64位寄存器中？（即没有符号扩展操作，也没有64 x 64位乘法？）
我希望我可以用C语言编写代码，而不用担心ARM编译器会产生非最优的代码。我是不是必须用汇编代码来确保它是正确的？