> That's exactly what I was guessing.

in order to be complete, here is a simplistic example with full source code showing well the full compiler behavior

source:

#define INLINE _forceinline

class V8Double
{
__m512d m7_0;
INLINE V8Double (const __m512d &vm512d) : m7_0(vm512d) {}
public:
INLINE explicit V8Double (double val) : m7_0( _mm512_set1_pd(val)) {}
INLINE explicit V8Double (const double *v) : m7_0(_mm512_load_pd(v)) {}
INLINE friend V8Double operator + (const V8Double &a, const V8Double &b) {return _mm512_add_pd(a.m7_0,b.m7_0);}
INLINE friend V8Double operator * (const V8Double &a, const V8Double &b) {return _mm512_mul_pd(a.m7_0,b.m7_0);}
INLINE friend void Store (void *v, const V8Double &a) {_mm512_store_pd((float *)v,a.m7_0);}
};

class V8Poly3
{
const V8Double a3,a2,a1,a0; // a3*x^3 + a2*x^2 + a1*x + a0
public:
INLINE V8Poly3 (REAL c3, REAL c2, REAL c1, REAL c0) : a3(c3), a2(c2), a1(c1), a0(c0) {}
INLINE V8Double val (const V8Double &x) const {return ((a3*x+a2)*x+a1)*x+a0;}
};

void Demo (const double *src, double *dst, int size)
{
const V8Poly3 poly(1.2,3.4,5.6,7.8);
for (int i=0; i<size; i+=8) Store(dst+i,poly.val(V8Double(src+i)));
}


ASM:

xor eax, eax ;71.13
movsxd r8, r8d ;69.1
vbroadcastsd zmm3, QWORD PTR [_2il0floatpacket.260] ;70.34
vbroadcastsd zmm2, QWORD PTR [_2il0floatpacket.261] ;70.34
vbroadcastsd zmm1, QWORD PTR [_2il0floatpacket.262] ;70.34
vbroadcastsd zmm0, QWORD PTR [_2il0floatpacket.263] ;70.34
test r8, r8 ;71.19
jle .B2.5 ; Prob 10% ;71.19
vmovups zmm4, ZMMWORD PTR [rcx+rax*8] ;71.61
vfmadd213pd zmm4, zmm3, zmm2 ;71.48
vfmadd132pd zmm4, zmm1, ZMMWORD PTR [rcx+rax*8] ;71.48
vfmadd132pd zmm4, zmm0, ZMMWORD PTR [rcx+rax*8] ;71.48
vmovups ZMMWORD PTR [rdx+rax*8], zmm4 ;71.31
add rax, 8 ;71.25
cmp rax, r8 ;71.19
jl .B2.3 ; Prob 82% ;71.19
ret



[rcx+rax*8] is used redundantly, even more with higher order polynomials