非sse2 arch上128位值的逐位操作

我正在用C编写一个面向嵌入式平台的例程。
在该例程中，我需要对128位值执行按位

XOR

和

SHIFT RIGHT

操作
目标arch没有SSE2，因此不支持本机128位操作。
我遇到了模拟软件中的

SHIFT

操作的答案。

---

我的问题是，有没有更好的方法来实现这一点，我的意思是使用更好的数据结构来表示128位的值，以及使用比使用递归更好的方法来模拟移位和异或操作（如链接中的答案所示）。我希望尽量减少有限堆栈内存的使用。

您可以使用一种结构来存储128位数据，如下所示

typedef struct
{
    uint32_t a;
    uint32_t b;
    uint32_t c;
    uint32_t d;
} Type_128bit;

int leftshift(Type_128bit in, Type_128bit out, int value)
{
    int val;
    if (value >= 128)
    {
        return (-1); // error condition
    }
    else if (value < 32)
    {
        out->a = (in->a << value) | (in->b >> value);
        out->b = (in->b << value) | (in->c >> value);
        out->c = (in->c << value) | (in->d >> value);
        out->d = in->d << value;
    }
    else if (value < 64)
    {
        val = value - 32;
        out->a = (in->b << val) | (in->c >> val);
        out->b = (in->c << val) | (in->d >> val);
        out->c = (in->d << val);
        out->d = 0x00;
    }
    else if (value < 96)
    {
        val = value - 64;
        out->a = (in->c << val) | (in->d >> val);
        out->b = (in->d << val);
        out->c = 0x00;
        out->d = 0x00;
    }
    else // value < 128
    {
        val = value - 96;
        out->a = (in->d << val);
        out->b = 0x00;
        out->c = 0x00;
        out->d = 0x00;
    }
    return (0); //success
}

然后您可以编写一个左移位函数，如下所示

typedef struct
{
    uint32_t a;
    uint32_t b;
    uint32_t c;
    uint32_t d;
} Type_128bit;

int leftshift(Type_128bit in, Type_128bit out, int value)
{
    int val;
    if (value >= 128)
    {
        return (-1); // error condition
    }
    else if (value < 32)
    {
        out->a = (in->a << value) | (in->b >> value);
        out->b = (in->b << value) | (in->c >> value);
        out->c = (in->c << value) | (in->d >> value);
        out->d = in->d << value;
    }
    else if (value < 64)
    {
        val = value - 32;
        out->a = (in->b << val) | (in->c >> val);
        out->b = (in->c << val) | (in->d >> val);
        out->c = (in->d << val);
        out->d = 0x00;
    }
    else if (value < 96)
    {
        val = value - 64;
        out->a = (in->c << val) | (in->d >> val);
        out->b = (in->d << val);
        out->c = 0x00;
        out->d = 0x00;
    }
    else // value < 128
    {
        val = value - 96;
        out->a = (in->d << val);
        out->b = 0x00;
        out->c = 0x00;
        out->d = 0x00;
    }
    return (0); //success
}

int leftshift（输入\ 128位，输出\ 128位，int值）
{
int-val；
如果（值>=128）
{
返回（-1）；//错误条件
}
else if（值<32）
{
out->a=（in->ab>>值）；
out->b=（in->b c>>值）；
out->c=（in->cd>>值）；
out->d=in->d a=（in->b c>>val）；
out->b=（in->cd>>val）；
out->c=（in->d=0x00；
}
否则如果（值<96）
{
val=值-64；
out->a=（in->cd>>val）；
out->b=（in->d c=0x00；
out->d=0x00；
}
else//value<128
{
val=值-96；
out->a=（in->db=0x00；
输出->c=0x00；
out->d=0x00；
}
返回（0）；//成功
}

这将避免上述解决方案的递归，并提供更好的运行时间。但代码大小将增加，您需要仔细测试代码。

uint32\u t*shiftL（uint32\u t*val，const size\u t size，const size\u t nbits）//
uint32_t *shiftL(uint32_t *val, const size_t size, const size_t nbits)  // <= 32
{
    uint32_t mask = (1 << nbits) - 1;

    mask <<= 32 - nbits;

    for(size_t cword = size; cword - 1 ; cword --)
    {
        uint32_t temp = (val[cword - 2] & mask) >> nbits
        val[cword - 1] <<= nbits;
        val |= temp;
    }
    val[0] <<= nbits;
    return val;
}