properly separate code built with different CPU settings

Trying to write smart code and mixing different CPU flags doesn't play
nice together. Those global variables are not runtime-protected by
a CPU check, and so may crash with illegal instruction error.
And those inline functions may not get inlined and the compiler is
free to choose just one copy, any of them, so it may be the one
requiring the most demanding CPU settings.
So use only dumb code in files compiled with CPU intrinsics.

Change-Id: I8200fd4d9f991fab6fdc741120e7aa96ff9b470d
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/121929
Tested-by: Jenkins
Reviewed-by: Dante DM <dante19031999@gmail.com>
Reviewed-by: Luboš Luňák <l.lunak@collabora.com>

3 files changed, 43 insertions, 24 deletions

diff --git a/sc/inc/arraysumfunctor.hxx b/sc/inc/arraysumfunctor.hxx
index ecd428e9f037..d251b4a6f9fb 100644
--- a/sc/inc/arraysumfunctor.hxx
+++ b/sc/inc/arraysumfunctor.hxx
@@ -12,35 +12,17 @@
 
 #include <cmath>
 #include "kahan.hxx"
-#include "scdllapi.h"
+#include "arraysumfunctorinternal.hxx"
 #include <tools/cpuid.hxx>
 #include <formula/errorcodes.hxx>
 
 namespace sc::op
 {
 /* Checkout available optimization options */
-SC_DLLPUBLIC extern const bool hasAVX512F;
 const bool hasAVX = cpuid::hasAVX();
 const bool hasSSE2 = cpuid::hasSSE2();
 
 /**
-  * Performs one step of the Neumanier sum between doubles
-  * Overwrites the summand and error
-  * @parma sum
-  * @param err
-  * @param value
-  */
-inline void sumNeumanierNormal(double& sum, double& err, const double& value)
-{
-    double t = sum + value;
-    if (std::abs(sum) >= std::abs(value))
-        err += (sum - t) + value;
-    else
-        err += (value - t) + sum;
-    sum = t;
-}
-
-/**
   * If no boosts available, Unrolled KahanSum.
   * Most likely to use on android.
   */
@@ -69,11 +51,6 @@ static inline KahanSum executeUnrolled(size_t& i, size_t nSize, const double* pC
     return 0.0;
 }
 
-/* Available methods */
-SC_DLLPUBLIC KahanSum executeAVX512F(size_t& i, size_t nSize, const double* pCurrent);
-SC_DLLPUBLIC KahanSum executeAVX(size_t& i, size_t nSize, const double* pCurrent);
-SC_DLLPUBLIC KahanSum executeSSE2(size_t& i, size_t nSize, const double* pCurrent);
-
 /**
   * This function task is to choose the fastest method available to perform the sum.
   * @param i
diff --git a/sc/inc/arraysumfunctorinternal.hxx b/sc/inc/arraysumfunctorinternal.hxx
new file mode 100644
index 000000000000..a06e3fc17439
--- /dev/null
+++ b/sc/inc/arraysumfunctorinternal.hxx
@@ -0,0 +1,34 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+#pragma once
+
+#include "scdllapi.h"
+
+namespace sc::op
+{
+SC_DLLPUBLIC extern const bool hasAVX512F;
+
+// Plain old data structure, to be used by code compiled with CPU intrinsics without generating any
+// code for it (so that code requiring intrinsics doesn't get accidentally selected as the one copy
+// when merging duplicates).
+struct KahanSumSimple
+{
+    double m_fSum;
+    double m_fError;
+};
+
+/* Available methods */
+SC_DLLPUBLIC KahanSumSimple executeAVX512F(size_t& i, size_t nSize, const double* pCurrent);
+SC_DLLPUBLIC KahanSumSimple executeAVX(size_t& i, size_t nSize, const double* pCurrent);
+SC_DLLPUBLIC KahanSumSimple executeSSE2(size_t& i, size_t nSize, const double* pCurrent);
+
+} // namespace
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */
diff --git a/sc/inc/kahan.hxx b/sc/inc/kahan.hxx
index 3404fb6d14a6..ded7bd78d70e 100644
--- a/sc/inc/kahan.hxx
+++ b/sc/inc/kahan.hxx
@@ -11,6 +11,8 @@
 
 #include <cmath>
 
+#include "arraysumfunctorinternal.hxx"
+
 /**
   * This class provides LO with Kahan summation algorithm
   * About this algorithm: https://en.wikipedia.org/wiki/Kahan_summation_algorithm
@@ -34,6 +36,12 @@ public:
     {
     }
 
+    constexpr KahanSum(const sc::op::KahanSumSimple& sum)
+        : m_fSum(sum.m_fSum)
+        , m_fError(sum.m_fError)
+    {
+    }
+
     constexpr KahanSum(const KahanSum& fSum) = default;
 
 public: