如果属性不起作用，或者没有选择....
我不确定，但试试这个：

void vecadd (float * restrict a, float * restrict b, float * restrict c)
{
   a = __builtin_assume_aligned (a, 8);
   b = __builtin_assume_aligned (b, 8);
   c = __builtin_assume_aligned (c, 8);

   for ....

字符串
这应该告诉GCC指针是对齐的。从这一点来看，它是否做你想要的取决于编译器是否能有效地使用这些信息;它可能不够聪明：这些优化并不容易。
另一种选择可能是将浮点数 Package 在一个必须8字节对齐的联合体中：

typedef union {
  float f;
  long long dummy;
} aligned_float;

void vedadd (aligned_float * a, ......

型
我认为应该强制8字节对齐，但同样，我不知道编译器是否足够聪明，可以使用它。

根据我在系统上找到的一段示例代码，我尝试了以下解决方案，它结合了前面给出的一些答案的想法：基本上，创建一个具有64位类型的浮点数小数组的联合-在本例中是浮点数的SIMD向量-并使用操作数浮点数数组的强制转换调用函数：

typedef float f2 __attribute__((vector_size(8)));
typedef union { f2 v; float f[2]; } simdfu;

void vecadd(f2 * restrict a, f2 * restrict b, f2 * restrict c);

float a[16] __attribute__((aligned(8)));
float b[16] __attribute__((aligned(8)));
float c[16] __attribute__((aligned(8)));

int main()
{
    vecadd((f2 *) a, (f2 *) b, (f2 *) c);
    return 0;
}

字符串
现在编译器不生成4对齐的分支。
然而，__builtin_assume_aligned()将是更可取的解决方案，防止演员和可能的副作用，如果它只工作.
编辑：我注意到，内置函数在我们的实现中实际上是有缺陷的（即，它不仅不工作，而且会导致代码后面的计算错误。

如何告诉GCC指针参数总是双字对齐？
看起来较新版本的GCC有__builtin_assume_aligned：
内置函数：void * __builtin_assume_aligned (const void *exp, size_t align, ...)
这个函数返回它的第一个参数，并允许编译器假设返回的指针至少是对齐字节对齐的。这个内置的可以有两个或三个参数，如果它有三个，第三个参数应该是整数类型，如果它是非零的，则表示未对齐偏移量。例如：

void *x = __builtin_assume_aligned (arg, 16);

字符串
意味着编译器可以假设x（设置为arg）至少是16字节对齐的，而：

void *x = __builtin_assume_aligned (arg, 32, 8);

型
这意味着编译器可以假设x（设置为arg），（char *）x - 8是32字节对齐的。
根据2010年左右Stack Overflow上的一些其他问题和答案，似乎内置的在GCC 3和早期的GCC 4中不可用。但我不知道分界点在哪里。

对方式规范通常只适用于小于指针基类型的对方式，而不适用于大于指针基类型的对方式。
我认为最简单的方法是用对齐规范声明整个数组，

typedef float myvector[16];
typedef myvector alignedVector __attribute__((aligned (8));

字符串
(The语法可能不正确，我总是很难知道把这些__attribute__放在哪里）
并在整个代码中使用该类型。

void vecadd(alignedVector * restrict a, alignedVector * restrict b, alignedVector * restrict c);

型
这给了你一个额外的间接，但这只是语法。像*a只是一个noop，只把指针重新解释为指向第一个元素的指针。

gcc版本在简单类型定义和数组上的align（）是不可靠的。通常要做你想做的事情，你必须把浮点数 Package 在一个结构体中，并让包含的浮点数有对齐限制。
使用运算符重载，你几乎可以轻松地做到这一点，但它确实假设你可以使用c++语法。

#include <stdio.h>
#include <string.h>

#define restrict __restrict__

typedef float oldfloat8 __attribute__ ((aligned(8)));

struct float8
{
    float f __attribute__ ((aligned(8)));

    float8 &operator=(float _f) { f = _f; return *this; }
    float8 &operator=(double _f) { f = _f; return *this; }
    float8 &operator=(int _f) { f = _f; return *this; }

    operator float() { return f; }
};

int Myfunc(float8 * restrict a, float8 * restrict b, float8 * restrict c);

int MyFunc(float8 * restrict a, float8 * restrict b, float8 * restrict c)
{
    return *c = *a* *b;
}

int main(int argc, char **argv)
{
    float8 a, b, c;

    float8 p[4];

    printf("sizeof(oldfloat8) == %d\n", (int)sizeof(oldfloat8));
    printf("sizeof(float8) == %d\n", (int)sizeof(float8));

    printf("addr p[0] == %p\n", &p[0] );
    printf("addr p[1] == %p\n", &p[1] );

    a = 2.0;
    b = 7.0;
    MyFunc( &a, &b, &c );
    return 0;
}

字符串

我从来没有使用过它，但有*** 属性 *（（aligned（8）**
如果我正确阅读了文档，那么它是这样使用的：

void vecadd(float * restrict a __attribute__((aligned (8))), 
            float * restrict b __attribute__((aligned (8))), 
            float * restrict c __attribute__((aligned (8))));

字符串
见http://ohse.de/uwe/articles/gcc-attributes.html#type-aligned