[Bug ipa/102059] Incorrect always_inline diagnostic in LTO mode with #pragma GCC target("cpu=power10")

[marxin at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=102059

--- Comment #4 from Martin Liška <marxin at gcc dot gnu.org> ---
Reduced test-case:

$ cat /tmp/basic_op.ii
enum { Unaligned, Aligned };
enum { ColMajor };
enum { ReadOnlyAccessors, DefaultProduct };
template <typename> struct traits;
struct accessors_level {
  enum { has_direct_access, has_write_access };
};
template <typename, int _Rows, int _Cols, int, int = _Rows, int = _Cols>
class Matrix;
template <typename> class MatrixBase;
template <typename> class NoAlias;
template <typename, typename, int = DefaultProduct> class Product;
template <typename, int = accessors_level::has_write_access> class MapBase;
template <typename, int, typename = int> class Map;
template <typename Derived> struct dense_xpr_base {
  typedef MatrixBase<Derived> type;
};
template <typename> struct assign_op {};
struct DenseBase {
  typedef int Scalar;
  enum { Flags };
};
template <typename Derived> struct MatrixBase : DenseBase {
  NoAlias<Derived> noalias();
};
template <int> class ProductImpl;
template <typename _Lhs, typename _Rhs, int Option>
struct Product : ProductImpl<Option> {
  _Lhs lhs();
  _Rhs rhs();
};
template <int> struct ProductImpl : dense_xpr_base<int>::type {};
template <typename, typename, typename> struct Assignment;
template <typename Dst, typename Src, typename Func>
void call_assignment_no_alias(Dst dst, Src src, Func func) {
  Assignment<Dst, Src, Func>::run(dst, src, func);
}
template <typename, typename, bool, typename, bool, int, int>
struct general_matrix_matrix_product;
template <typename, typename, int> class blas_data_mapper;
template <typename Scalar, typename Index>
struct blas_data_mapper<Scalar, Index, 1> {
  blas_data_mapper(Scalar *, Index, Index);
};
template <typename ExpressionType> struct NoAlias {
  template <typename OtherDerived> void operator=(OtherDerived) {
    Product<Map<Matrix<float, -1, -1, 2>, 1>, Map<Matrix<float, -1, -1, 2>, 1>>
        __trans_tmp_4;
    call_assignment_no_alias(m_expression, __trans_tmp_4,
                             assign_op<typename OtherDerived::Scalar>());
  }
  ExpressionType m_expression;
};
template <typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows,
          int _MaxCols>
struct traits<Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>> {
  typedef _Scalar Scalar;
};
template <typename Derived>
struct MapBase<Derived, ReadOnlyAccessors> : dense_xpr_base<Derived>::type {
  typedef typename traits<Derived>::Scalar *PointerType;
};
template <typename Derived>
struct MapBase<Derived> : MapBase<Derived, ReadOnlyAccessors> {};
template <typename PlainObjectType, int MapOptions, typename StrideType>
struct traits<Map<PlainObjectType, MapOptions, StrideType>>
    : traits<PlainObjectType> {};
template <typename, int MapOptions, typename>
struct Map : MapBase<Map<Matrix<float, -1, -1, 2>, MapOptions>> {
  typedef Map Base;
  Map(typename Base::PointerType, long, long);
};
struct gebp_traits {
  enum { nr, mr };
};
template <typename, typename, typename, int, int, bool, bool>
struct gebp_kernel;
long parallelize_gemm_cols;
template <int, typename Functor, typename Index>
void parallelize_gemm(Functor func, Index, bool) {
  func(0, parallelize_gemm_cols);
}
template <typename, typename> struct generic_product_impl;
template <typename DstXprType, typename Lhs, typename Rhs, int Options,
          typename Scalar>
struct Assignment<DstXprType, Product<Lhs, Rhs, Options>, assign_op<Scalar>> {
  static void run(DstXprType dst, Product<Lhs, Rhs> src, assign_op<Scalar>) {
    Map __trans_tmp_5 = src.rhs();
    generic_product_impl<Lhs, Rhs>::evalTo(dst, src.lhs(), __trans_tmp_5);
  }
};
template <typename Index, typename LhsScalar, bool ConjugateLhs,
          typename RhsScalar, bool ConjugateRhs, int ResInnerStride>
struct general_matrix_matrix_product<Index, LhsScalar, ConjugateLhs, RhsScalar,
                                     ConjugateRhs, ColMajor, ResInnerStride> {
  typedef LhsScalar ResScalar;
  static void run(ResScalar *_res, ResScalar alpha) {
    Index resStride, resIncr, actual_mc, actual_kc, actual_nc;
    typedef blas_data_mapper<ResScalar, Index, ResInnerStride> ResMapper;
    ResMapper res(_res, resStride, resIncr);
    gebp_kernel<RhsScalar, Index, ResMapper, gebp_traits::mr, gebp_traits::nr,
                ConjugateLhs, ConjugateRhs>
        gebp;
    LhsScalar blockA, blockB;
    gebp(res, &blockA, &blockB, actual_mc, actual_kc, actual_nc, alpha);
  }
};
struct gemm_blocking_space;
struct gemm_functor {
  gemm_functor(Map<Matrix<float, -1, -1, 2>, 1>,
               Map<Matrix<float, -1, -1, 2>, 1>,
               Map<Matrix<float, -1, -1, 2>, 1>, float, gemm_blocking_space);
  void operator()(int, int) {
    general_matrix_matrix_product<long, float, false, float, false, 0, 1>::run(
        0, m_actualAlpha);
  }
  float m_actualAlpha;
};
struct gemm_blocking_space {
  gemm_blocking_space(long, long, long, long, bool);
};
int scaleAndAddTo___trans_tmp_3;
template <typename Lhs, typename Rhs> struct generic_product_impl {
  template <typename Dst> static void evalTo(Dst dst, Lhs lhs, Rhs rhs) {
    scaleAndAddTo(dst, lhs, rhs);
  }
  template <typename Dest>
  static void scaleAndAddTo(Dest dst, Lhs a_lhs, Rhs a_rhs) {
    Map lhs(a_lhs);
    Map rhs(a_rhs);
    typedef gemm_functor GemmFunctor;
    gemm_blocking_space blocking(0, 0, 0, 1, true);
    parallelize_gemm<0>(GemmFunctor(lhs, rhs, dst, 0, blocking),
                        scaleAndAddTo___trans_tmp_3, Dest::Flags);
  }
};
template <typename Packet> Packet bmask();
#pragma GCC target "cpu=power10"
template <typename, typename, typename Packet, typename, typename DataMapper,
          int, int>
void gemmMMA(const DataMapper &, const float *, const float *, long, long,
long,
             float, long, long, long, long) {
  bmask<Packet>();
}
#pragma GCC reset_options
struct quad_traits {
  enum { size, rows };
};
template <typename Packet> __attribute__((always_inline)) Packet bmask() {}
template <typename Index, typename DataMapper, int mr, int nr,
          bool ConjugateLhs, bool ConjugateRhs>
struct gebp_kernel<float, Index, DataMapper, mr, nr, ConjugateLhs,
                   ConjugateRhs> {
  void operator()(const DataMapper &, const float *, const float *, Index,
                  Index, Index, float, Index = 1, Index = 1, Index = 0,
                  Index = 0);
};
template <typename Index, typename DataMapper, int mr, int nr,
          bool ConjugateLhs, bool ConjugateRhs>
void gebp_kernel<float, Index, DataMapper, mr, nr, ConjugateLhs,
                 ConjugateRhs>::operator()(const DataMapper &, const float *,
                                           const float *, Index, Index, Index,
                                           float, Index, Index, Index, Index) {
  void (*gemm_function)(const DataMapper &, const float *, const float *,
Index,
                        Index, Index, float, Index, Index, Index, Index) =
      gemmMMA<float, Index, int, int, DataMapper, quad_traits::rows,
              quad_traits::size>;
}
template <class> struct Data_ {
  float &operator[](long);
  Data_ *MatrixOp();
};
Product<int, int> __trans_tmp_7;
template <class Sp> Data_<Sp> *Data_<Sp>::MatrixOp() {
  long NbCol0, NbRow1;
  Data_ res;
  Map<int, Aligned> m2(&res[0], NbCol0, NbRow1);
  m2.noalias() = __trans_tmp_7;
}
template class Data_<int>;