From 9040a0dfc3931bbce8523de678e70238c9e37501 Mon Sep 17 00:00:00 2001
From: Sam James <sam@gentoo.org>
Date: Tue, 29 Oct 2024 05:34:44 +0000
Subject: testsuite: tree-ssa: fix PR98265 filename

.C is for C++ testcases and gcc.dg's dg.exp ignores .c. The test
was not being run.

gcc/testsuite/ChangeLog:
	PR ipa/98265

	* gcc.dg/tree-ssa/pr98265.C: Move to...
	* g++.dg/tree-ssa/pr98265.C: ...here.
---
 gcc/testsuite/g++.dg/tree-ssa/pr98265.C | 348 ++++++++++++++++++++++++++++++++
 gcc/testsuite/gcc.dg/tree-ssa/pr98265.C | 348 --------------------------------
 2 files changed, 348 insertions(+), 348 deletions(-)
 create mode 100644 gcc/testsuite/g++.dg/tree-ssa/pr98265.C
 delete mode 100644 gcc/testsuite/gcc.dg/tree-ssa/pr98265.C

(limited to 'gcc')

diff --git a/gcc/testsuite/g++.dg/tree-ssa/pr98265.C b/gcc/testsuite/g++.dg/tree-ssa/pr98265.C
new file mode 100644
index 0000000..9c798e6
--- /dev/null
+++ b/gcc/testsuite/g++.dg/tree-ssa/pr98265.C
@@ -0,0 +1,348 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-optimized" } */
+extern void __assert_fail(const char*, const char*, int, const char*);
+namespace Eigen {
+enum { AutoAlign };
+template <int, typename>
+struct conditional;
+template <typename Else>
+struct conditional<false, Else> {
+  typedef Else type;
+};
+template <typename T>
+struct remove_reference {
+  typedef T type;
+};
+struct is_arithmetic {
+  enum { value };
+};
+template <typename>
+struct traits;
+template <typename T>
+struct traits<const T> : traits<T> {};
+template <typename>
+struct evaluator;
+template <typename>
+struct EigenBase;
+template <typename>
+class PlainObjectBase;
+template <typename, int _Rows, int _Cols, int = AutoAlign, int = _Rows,
+          int = _Cols>
+class Matrix;
+template <typename>
+class MatrixBase;
+template <typename, typename>
+class CwiseNullaryOp;
+template <typename, typename, typename>
+class CwiseBinaryOp;
+template <typename>
+struct scalar_constant_op;
+template <int _Rows>
+struct size_at_compile_time {
+  enum { ret = _Rows };
+};
+struct ref_selector {
+  typedef const Matrix<float, 3, 1>& type;
+};
+template <typename Derived>
+struct dense_xpr_base {
+  typedef MatrixBase<Derived> type;
+};
+template <typename Derived, typename = typename traits<Derived>::XprKind>
+struct generic_xpr_base {
+  typedef typename dense_xpr_base<Derived>::type type;
+};
+template <typename Expr, typename Scalar = typename Expr::Scalar>
+struct plain_constant_type {
+  ;
+  typedef CwiseNullaryOp<scalar_constant_op<Scalar>,
+                         Matrix<Scalar, traits<Expr>::ColsAtCompileTime,
+                                traits<Expr>::MaxRowsAtCompileTime,
+                                traits<Expr>::MaxColsAtCompileTime>>
+      type;
+};
+struct scalar_product_op {
+  float operator()(float a, float b) { return a * b; }
+};
+template <typename>
+struct scalar_constant_op {
+  scalar_constant_op(float other) : m_other(other) {}
+  float operator()() { return m_other; }
+  float m_other;
+};
+struct assign_op {
+  void assignCoeff(float& a, float b) { a = b; }
+};
+template <typename Derived>
+class DenseCoeffsBase : public EigenBase<Derived> {
+ public:
+  typedef typename traits<Derived>::Scalar Scalar;
+  typedef
+      typename conditional<is_arithmetic::value, Scalar>::type CoeffReturnType;
+};
+template <typename Derived>
+class DenseBase : public DenseCoeffsBase<Derived> {
+ public:
+  enum {
+    RowsAtCompileTime = traits<Derived>::RowsAtCompileTime,
+    SizeAtCompileTime = size_at_compile_time<RowsAtCompileTime>::ret,
+    MaxSizeAtCompileTime
+  };
+};
+template <typename Derived>
+class MatrixBase : public DenseBase<Derived> {
+ public:
+  using DenseBase<Derived>::derived;
+  template <typename T>
+  CwiseBinaryOp<scalar_product_op, const Derived,
+                const typename plain_constant_type<Derived, T>::type>
+  operator*(T& scalar) {
+    return CwiseBinaryOp<scalar_product_op, const Derived,
+                         const typename plain_constant_type<Derived>::type>(
+        derived(), typename plain_constant_type<Derived>::type(derived().rows(),
+                                                               0, scalar));
+  }
+};
+template <typename Derived>
+struct EigenBase {
+  const Derived& derived() const { return *static_cast<const Derived*>(this); }
+  Derived& const_cast_derived() const {
+    return *static_cast<Derived*>(const_cast<EigenBase*>(this));
+  }
+};
+template <typename>
+struct binary_evaluator;
+template <typename T>
+struct evaluator<const T> : evaluator<T> {
+  evaluator(const T& xpr) : evaluator<T>(xpr) {}
+};
+template <typename Derived>
+struct evaluator {
+  typedef Derived PlainObjectType;
+  typedef typename PlainObjectType::Scalar Scalar;
+  evaluator(const PlainObjectType& m) : m_data(m.data()) {}
+  typename PlainObjectType::CoeffReturnType coeff(long row, long) {
+    return m_data[row];
+  }
+  Scalar& coeffRef(long row, long) { return const_cast<Scalar*>(m_data)[row]; }
+  const Scalar* m_data;
+};
+template <typename Scalar, int Rows, int Cols, int Options, int MaxRows,
+          int MaxCols>
+struct evaluator<Matrix<Scalar, Rows, Cols, Options, MaxRows, MaxCols>>
+    : evaluator<PlainObjectBase<Matrix<Scalar, Rows, Cols>>> {
+  typedef Matrix<Scalar, Rows, Cols> XprType;
+  evaluator(const XprType& m) : evaluator<PlainObjectBase<XprType>>(m) {}
+};
+struct nullary_wrapper {
+  template <typename IndexType>
+  float operator()(scalar_constant_op<float> op, IndexType, IndexType) const {
+    return op();
+  }
+};
+template <typename NullaryOp, typename PlainObjectType>
+struct evaluator<CwiseNullaryOp<NullaryOp, PlainObjectType>> {
+  typedef CwiseNullaryOp<NullaryOp, PlainObjectType> XprType;
+  evaluator(XprType n) : m_functor(n.functor()) {}
+  template <typename IndexType>
+  typename XprType::CoeffReturnType coeff(IndexType row, IndexType col) {
+    return m_wrapper(m_functor, row, col);
+  }
+  NullaryOp m_functor;
+  nullary_wrapper m_wrapper;
+};
+template <typename BinaryOp, typename Lhs, typename Rhs>
+struct evaluator<CwiseBinaryOp<BinaryOp, Lhs, Rhs>>
+    : binary_evaluator<CwiseBinaryOp<BinaryOp, Lhs, Rhs>> {
+  evaluator(CwiseBinaryOp<BinaryOp, Lhs, Rhs> xpr)
+      : binary_evaluator<CwiseBinaryOp<BinaryOp, Lhs, Rhs>>(xpr) {}
+};
+template <typename BinaryOp, typename Lhs, typename Rhs>
+struct binary_evaluator<CwiseBinaryOp<BinaryOp, Lhs, Rhs>> {
+  typedef CwiseBinaryOp<BinaryOp, Lhs, Rhs> XprType;
+  binary_evaluator(XprType xpr) : m_lhsImpl(xpr.lhs()), m_rhsImpl(xpr.rhs()) {}
+  typename XprType::CoeffReturnType coeff(long row, long col) {
+    return m_functor(m_lhsImpl.coeff(row, col), m_rhsImpl.coeff(row, col));
+  }
+  BinaryOp m_functor;
+  evaluator<Lhs> m_lhsImpl;
+  evaluator<Rhs> m_rhsImpl;
+};
+template <typename Kernel, int Index, int Stop>
+struct copy_using_evaluator_DefaultTraversal_CompleteUnrolling {
+  enum { outer, inner = Index };
+  static void run(Kernel kernel) {
+    kernel.assignCoeffByOuterInner(outer, inner);
+    copy_using_evaluator_DefaultTraversal_CompleteUnrolling<Kernel, Index + 1,
+                                                            Stop>::run(kernel);
+  }
+};
+template <typename Kernel, int Stop>
+struct copy_using_evaluator_DefaultTraversal_CompleteUnrolling<Kernel, Stop,
+                                                               Stop> {
+  static void run(Kernel) {}
+};
+template <typename Kernel>
+struct dense_assignment_loop {
+  static void run(Kernel kernel) {
+    typedef typename Kernel::DstEvaluatorType::XprType DstXprType;
+    enum { size = DstXprType::SizeAtCompileTime, alignedSize = 0 };
+    copy_using_evaluator_DefaultTraversal_CompleteUnrolling<Kernel, alignedSize,
+                                                            size>::run(kernel);
+  }
+};
+template <typename DstEvaluatorTypeT, typename SrcEvaluatorTypeT,
+          typename Functor>
+class generic_dense_assignment_kernel {
+  typedef typename DstEvaluatorTypeT::XprType DstXprType;
+
+ public:
+  typedef DstEvaluatorTypeT DstEvaluatorType;
+  typedef SrcEvaluatorTypeT SrcEvaluatorType;
+  generic_dense_assignment_kernel(DstEvaluatorType dst, SrcEvaluatorType src,
+                                  Functor, DstXprType& dstExpr)
+      : m_dst(dst), m_src(src), m_dstExpr(dstExpr) {}
+  long assignCoeff_col;
+  void assignCoeffByOuterInner(long, long inner) {
+    long __trans_tmp_1 = inner;
+    m_functor.assignCoeff(m_dst.coeffRef(__trans_tmp_1, assignCoeff_col),
+                          m_src.coeff(__trans_tmp_1, assignCoeff_col));
+  }
+  DstEvaluatorType m_dst;
+  SrcEvaluatorType m_src;
+  Functor m_functor;
+  DstXprType& m_dstExpr;
+};
+template <typename DstXprType, typename SrcXprType, typename Functor>
+void call_dense_assignment_loop(DstXprType& dst, SrcXprType src, Functor func) {
+  typedef evaluator<DstXprType> DstEvaluatorType;
+  typedef evaluator<SrcXprType> SrcEvaluatorType;
+  SrcEvaluatorType srcEvaluator(src);
+  DstEvaluatorType dstEvaluator(dst);
+  typedef generic_dense_assignment_kernel<DstEvaluatorType, SrcEvaluatorType,
+                                          Functor>
+      Kernel;
+  Kernel kernel(dstEvaluator, srcEvaluator, func, dst.const_cast_derived());
+  dense_assignment_loop<Kernel>::run(kernel);
+}
+template <typename Dst, typename Src, typename Func>
+void call_assignment_no_alias(Dst& dst, Src src, Func func) {
+  enum { NeedToTranspose };
+  typename conditional<NeedToTranspose, Dst&>::type actualDst(dst);
+  CwiseBinaryOp<scalar_product_op, const Matrix<float, 3, 1>,
+                const CwiseNullaryOp<scalar_constant_op<float>,
+                                     const Matrix<float, 3, 1, 0, 2, 3>>>
+      __trans_tmp_4 = src;
+  call_dense_assignment_loop(actualDst, __trans_tmp_4, func);
+}
+template <int Size>
+struct plain_array {
+  float array[Size];
+};
+template <int Size, int _Rows>
+class DenseStorage {
+  plain_array<Size> m_data;
+
+ public:
+  DenseStorage() {}
+  DenseStorage(const DenseStorage&);
+  static long rows() { return _Rows; }
+  const float* data() const { return m_data.array; }
+  float* data() { return m_data.array; }
+};
+template <typename Derived>
+class PlainObjectBase : public dense_xpr_base<Derived>::type {
+ public:
+  typedef typename dense_xpr_base<Derived>::type Base;
+  typedef typename traits<Derived>::Scalar Scalar;
+  DenseStorage<Base::MaxSizeAtCompileTime, Base::RowsAtCompileTime> m_storage;
+  long rows() const { return m_storage.rows(); }
+  const Scalar* data() const { return m_storage.data(); }
+  PlainObjectBase() {}
+  template <typename OtherDerived>
+  PlainObjectBase(const DenseBase<OtherDerived>& other) {
+    _set_noalias(other);
+  }
+  template <typename OtherDerived>
+  void _set_noalias(const DenseBase<OtherDerived>& other) {
+    call_assignment_no_alias(this->derived(), other.derived(), assign_op());
+  }
+};
+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;
+  typedef int XprKind;
+  enum {
+    RowsAtCompileTime = _Rows,
+    ColsAtCompileTime,
+    MaxRowsAtCompileTime,
+    MaxColsAtCompileTime,
+  };
+};
+template <typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows,
+          int _MaxCols>
+class Matrix
+    : public PlainObjectBase<
+          Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>> {
+ public:
+  typedef PlainObjectBase<Matrix> Base;
+  typedef typename traits<Matrix>::Scalar Scalar;
+  Matrix(Scalar& x, Scalar& y, Scalar& z) {
+    m_storage.data()[0] = x;
+    m_storage.data()[1] = y;
+    m_storage.data()[2] = z;
+  }
+  template <typename OtherDerived>
+  Matrix(const EigenBase<OtherDerived>& other) : Base(other.derived()) {}
+  using Base::m_storage;
+};
+template <typename BinaryOp, typename Lhs, typename Rhs>
+struct traits<CwiseBinaryOp<BinaryOp, Lhs, Rhs>> {
+  typedef typename traits<Lhs>::XprKind XprKind;
+  enum { RowsAtCompileTime };
+  typedef float Scalar;
+};
+template <typename>
+class CwiseBinaryOpImpl;
+template <typename, typename, typename RhsType>
+class CwiseBinaryOp : public CwiseBinaryOpImpl<RhsType> {
+ public:
+  typedef ref_selector::type LhsNested;
+  typedef RhsType RhsNested;
+  CwiseBinaryOp(const Matrix<float, 3, 1>& aLhs, RhsType& aRhs)
+      : m_lhs(aLhs), m_rhs(aRhs) {}
+  remove_reference<LhsNested>::type& lhs() { return m_lhs; }
+  typename remove_reference<RhsNested>::type& rhs() { return m_rhs; }
+  LhsNested m_lhs;
+  RhsNested m_rhs;
+};
+template <typename>
+class CwiseBinaryOpImpl
+    : public generic_xpr_base<CwiseBinaryOp<
+          scalar_product_op, const Matrix<float, 3, 1>,
+          const CwiseNullaryOp<scalar_constant_op<float>,
+                               const Matrix<float, 3, 1, 0, 2, 3>>>>::type {};
+template <typename NullaryOp, typename PlainObjectType>
+struct traits<CwiseNullaryOp<NullaryOp, PlainObjectType>>
+    : traits<PlainObjectType> {};
+template <typename, typename PlainObjectType>
+class CwiseNullaryOp
+    : public dense_xpr_base<CwiseNullaryOp<int, PlainObjectType>>::type {
+ public:
+  CwiseNullaryOp(long rows, long, scalar_constant_op<float> func)
+      : m_functor(func) {
+    rows ? void() : __assert_fail("", "", 1, __PRETTY_FUNCTION__);
+  }
+  scalar_constant_op<float> functor() { return m_functor; }
+  scalar_constant_op<float> m_functor;
+};
+}  // namespace Eigen
+Eigen::Matrix<float, 3, 1> should_inline(float x, float y, float z,
+                                         float scale) {
+  return Eigen::Matrix<float, 3, 1>(x, y, z) * scale;
+}
+
+// We should inline everything to should_inline
+
+/* { dg-final { scan-tree-dump-times "Function" "optimized" } } */
diff --git a/gcc/testsuite/gcc.dg/tree-ssa/pr98265.C b/gcc/testsuite/gcc.dg/tree-ssa/pr98265.C
deleted file mode 100644
index 9c798e6..0000000
--- a/gcc/testsuite/gcc.dg/tree-ssa/pr98265.C
+++ /dev/null
@@ -1,348 +0,0 @@
-/* { dg-do compile } */
-/* { dg-options "-O2 -fdump-tree-optimized" } */
-extern void __assert_fail(const char*, const char*, int, const char*);
-namespace Eigen {
-enum { AutoAlign };
-template <int, typename>
-struct conditional;
-template <typename Else>
-struct conditional<false, Else> {
-  typedef Else type;
-};
-template <typename T>
-struct remove_reference {
-  typedef T type;
-};
-struct is_arithmetic {
-  enum { value };
-};
-template <typename>
-struct traits;
-template <typename T>
-struct traits<const T> : traits<T> {};
-template <typename>
-struct evaluator;
-template <typename>
-struct EigenBase;
-template <typename>
-class PlainObjectBase;
-template <typename, int _Rows, int _Cols, int = AutoAlign, int = _Rows,
-          int = _Cols>
-class Matrix;
-template <typename>
-class MatrixBase;
-template <typename, typename>
-class CwiseNullaryOp;
-template <typename, typename, typename>
-class CwiseBinaryOp;
-template <typename>
-struct scalar_constant_op;
-template <int _Rows>
-struct size_at_compile_time {
-  enum { ret = _Rows };
-};
-struct ref_selector {
-  typedef const Matrix<float, 3, 1>& type;
-};
-template <typename Derived>
-struct dense_xpr_base {
-  typedef MatrixBase<Derived> type;
-};
-template <typename Derived, typename = typename traits<Derived>::XprKind>
-struct generic_xpr_base {
-  typedef typename dense_xpr_base<Derived>::type type;
-};
-template <typename Expr, typename Scalar = typename Expr::Scalar>
-struct plain_constant_type {
-  ;
-  typedef CwiseNullaryOp<scalar_constant_op<Scalar>,
-                         Matrix<Scalar, traits<Expr>::ColsAtCompileTime,
-                                traits<Expr>::MaxRowsAtCompileTime,
-                                traits<Expr>::MaxColsAtCompileTime>>
-      type;
-};
-struct scalar_product_op {
-  float operator()(float a, float b) { return a * b; }
-};
-template <typename>
-struct scalar_constant_op {
-  scalar_constant_op(float other) : m_other(other) {}
-  float operator()() { return m_other; }
-  float m_other;
-};
-struct assign_op {
-  void assignCoeff(float& a, float b) { a = b; }
-};
-template <typename Derived>
-class DenseCoeffsBase : public EigenBase<Derived> {
- public:
-  typedef typename traits<Derived>::Scalar Scalar;
-  typedef
-      typename conditional<is_arithmetic::value, Scalar>::type CoeffReturnType;
-};
-template <typename Derived>
-class DenseBase : public DenseCoeffsBase<Derived> {
- public:
-  enum {
-    RowsAtCompileTime = traits<Derived>::RowsAtCompileTime,
-    SizeAtCompileTime = size_at_compile_time<RowsAtCompileTime>::ret,
-    MaxSizeAtCompileTime
-  };
-};
-template <typename Derived>
-class MatrixBase : public DenseBase<Derived> {
- public:
-  using DenseBase<Derived>::derived;
-  template <typename T>
-  CwiseBinaryOp<scalar_product_op, const Derived,
-                const typename plain_constant_type<Derived, T>::type>
-  operator*(T& scalar) {
-    return CwiseBinaryOp<scalar_product_op, const Derived,
-                         const typename plain_constant_type<Derived>::type>(
-        derived(), typename plain_constant_type<Derived>::type(derived().rows(),
-                                                               0, scalar));
-  }
-};
-template <typename Derived>
-struct EigenBase {
-  const Derived& derived() const { return *static_cast<const Derived*>(this); }
-  Derived& const_cast_derived() const {
-    return *static_cast<Derived*>(const_cast<EigenBase*>(this));
-  }
-};
-template <typename>
-struct binary_evaluator;
-template <typename T>
-struct evaluator<const T> : evaluator<T> {
-  evaluator(const T& xpr) : evaluator<T>(xpr) {}
-};
-template <typename Derived>
-struct evaluator {
-  typedef Derived PlainObjectType;
-  typedef typename PlainObjectType::Scalar Scalar;
-  evaluator(const PlainObjectType& m) : m_data(m.data()) {}
-  typename PlainObjectType::CoeffReturnType coeff(long row, long) {
-    return m_data[row];
-  }
-  Scalar& coeffRef(long row, long) { return const_cast<Scalar*>(m_data)[row]; }
-  const Scalar* m_data;
-};
-template <typename Scalar, int Rows, int Cols, int Options, int MaxRows,
-          int MaxCols>
-struct evaluator<Matrix<Scalar, Rows, Cols, Options, MaxRows, MaxCols>>
-    : evaluator<PlainObjectBase<Matrix<Scalar, Rows, Cols>>> {
-  typedef Matrix<Scalar, Rows, Cols> XprType;
-  evaluator(const XprType& m) : evaluator<PlainObjectBase<XprType>>(m) {}
-};
-struct nullary_wrapper {
-  template <typename IndexType>
-  float operator()(scalar_constant_op<float> op, IndexType, IndexType) const {
-    return op();
-  }
-};
-template <typename NullaryOp, typename PlainObjectType>
-struct evaluator<CwiseNullaryOp<NullaryOp, PlainObjectType>> {
-  typedef CwiseNullaryOp<NullaryOp, PlainObjectType> XprType;
-  evaluator(XprType n) : m_functor(n.functor()) {}
-  template <typename IndexType>
-  typename XprType::CoeffReturnType coeff(IndexType row, IndexType col) {
-    return m_wrapper(m_functor, row, col);
-  }
-  NullaryOp m_functor;
-  nullary_wrapper m_wrapper;
-};
-template <typename BinaryOp, typename Lhs, typename Rhs>
-struct evaluator<CwiseBinaryOp<BinaryOp, Lhs, Rhs>>
-    : binary_evaluator<CwiseBinaryOp<BinaryOp, Lhs, Rhs>> {
-  evaluator(CwiseBinaryOp<BinaryOp, Lhs, Rhs> xpr)
-      : binary_evaluator<CwiseBinaryOp<BinaryOp, Lhs, Rhs>>(xpr) {}
-};
-template <typename BinaryOp, typename Lhs, typename Rhs>
-struct binary_evaluator<CwiseBinaryOp<BinaryOp, Lhs, Rhs>> {
-  typedef CwiseBinaryOp<BinaryOp, Lhs, Rhs> XprType;
-  binary_evaluator(XprType xpr) : m_lhsImpl(xpr.lhs()), m_rhsImpl(xpr.rhs()) {}
-  typename XprType::CoeffReturnType coeff(long row, long col) {
-    return m_functor(m_lhsImpl.coeff(row, col), m_rhsImpl.coeff(row, col));
-  }
-  BinaryOp m_functor;
-  evaluator<Lhs> m_lhsImpl;
-  evaluator<Rhs> m_rhsImpl;
-};
-template <typename Kernel, int Index, int Stop>
-struct copy_using_evaluator_DefaultTraversal_CompleteUnrolling {
-  enum { outer, inner = Index };
-  static void run(Kernel kernel) {
-    kernel.assignCoeffByOuterInner(outer, inner);
-    copy_using_evaluator_DefaultTraversal_CompleteUnrolling<Kernel, Index + 1,
-                                                            Stop>::run(kernel);
-  }
-};
-template <typename Kernel, int Stop>
-struct copy_using_evaluator_DefaultTraversal_CompleteUnrolling<Kernel, Stop,
-                                                               Stop> {
-  static void run(Kernel) {}
-};
-template <typename Kernel>
-struct dense_assignment_loop {
-  static void run(Kernel kernel) {
-    typedef typename Kernel::DstEvaluatorType::XprType DstXprType;
-    enum { size = DstXprType::SizeAtCompileTime, alignedSize = 0 };
-    copy_using_evaluator_DefaultTraversal_CompleteUnrolling<Kernel, alignedSize,
-                                                            size>::run(kernel);
-  }
-};
-template <typename DstEvaluatorTypeT, typename SrcEvaluatorTypeT,
-          typename Functor>
-class generic_dense_assignment_kernel {
-  typedef typename DstEvaluatorTypeT::XprType DstXprType;
-
- public:
-  typedef DstEvaluatorTypeT DstEvaluatorType;
-  typedef SrcEvaluatorTypeT SrcEvaluatorType;
-  generic_dense_assignment_kernel(DstEvaluatorType dst, SrcEvaluatorType src,
-                                  Functor, DstXprType& dstExpr)
-      : m_dst(dst), m_src(src), m_dstExpr(dstExpr) {}
-  long assignCoeff_col;
-  void assignCoeffByOuterInner(long, long inner) {
-    long __trans_tmp_1 = inner;
-    m_functor.assignCoeff(m_dst.coeffRef(__trans_tmp_1, assignCoeff_col),
-                          m_src.coeff(__trans_tmp_1, assignCoeff_col));
-  }
-  DstEvaluatorType m_dst;
-  SrcEvaluatorType m_src;
-  Functor m_functor;
-  DstXprType& m_dstExpr;
-};
-template <typename DstXprType, typename SrcXprType, typename Functor>
-void call_dense_assignment_loop(DstXprType& dst, SrcXprType src, Functor func) {
-  typedef evaluator<DstXprType> DstEvaluatorType;
-  typedef evaluator<SrcXprType> SrcEvaluatorType;
-  SrcEvaluatorType srcEvaluator(src);
-  DstEvaluatorType dstEvaluator(dst);
-  typedef generic_dense_assignment_kernel<DstEvaluatorType, SrcEvaluatorType,
-                                          Functor>
-      Kernel;
-  Kernel kernel(dstEvaluator, srcEvaluator, func, dst.const_cast_derived());
-  dense_assignment_loop<Kernel>::run(kernel);
-}
-template <typename Dst, typename Src, typename Func>
-void call_assignment_no_alias(Dst& dst, Src src, Func func) {
-  enum { NeedToTranspose };
-  typename conditional<NeedToTranspose, Dst&>::type actualDst(dst);
-  CwiseBinaryOp<scalar_product_op, const Matrix<float, 3, 1>,
-                const CwiseNullaryOp<scalar_constant_op<float>,
-                                     const Matrix<float, 3, 1, 0, 2, 3>>>
-      __trans_tmp_4 = src;
-  call_dense_assignment_loop(actualDst, __trans_tmp_4, func);
-}
-template <int Size>
-struct plain_array {
-  float array[Size];
-};
-template <int Size, int _Rows>
-class DenseStorage {
-  plain_array<Size> m_data;
-
- public:
-  DenseStorage() {}
-  DenseStorage(const DenseStorage&);
-  static long rows() { return _Rows; }
-  const float* data() const { return m_data.array; }
-  float* data() { return m_data.array; }
-};
-template <typename Derived>
-class PlainObjectBase : public dense_xpr_base<Derived>::type {
- public:
-  typedef typename dense_xpr_base<Derived>::type Base;
-  typedef typename traits<Derived>::Scalar Scalar;
-  DenseStorage<Base::MaxSizeAtCompileTime, Base::RowsAtCompileTime> m_storage;
-  long rows() const { return m_storage.rows(); }
-  const Scalar* data() const { return m_storage.data(); }
-  PlainObjectBase() {}
-  template <typename OtherDerived>
-  PlainObjectBase(const DenseBase<OtherDerived>& other) {
-    _set_noalias(other);
-  }
-  template <typename OtherDerived>
-  void _set_noalias(const DenseBase<OtherDerived>& other) {
-    call_assignment_no_alias(this->derived(), other.derived(), assign_op());
-  }
-};
-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;
-  typedef int XprKind;
-  enum {
-    RowsAtCompileTime = _Rows,
-    ColsAtCompileTime,
-    MaxRowsAtCompileTime,
-    MaxColsAtCompileTime,
-  };
-};
-template <typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows,
-          int _MaxCols>
-class Matrix
-    : public PlainObjectBase<
-          Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>> {
- public:
-  typedef PlainObjectBase<Matrix> Base;
-  typedef typename traits<Matrix>::Scalar Scalar;
-  Matrix(Scalar& x, Scalar& y, Scalar& z) {
-    m_storage.data()[0] = x;
-    m_storage.data()[1] = y;
-    m_storage.data()[2] = z;
-  }
-  template <typename OtherDerived>
-  Matrix(const EigenBase<OtherDerived>& other) : Base(other.derived()) {}
-  using Base::m_storage;
-};
-template <typename BinaryOp, typename Lhs, typename Rhs>
-struct traits<CwiseBinaryOp<BinaryOp, Lhs, Rhs>> {
-  typedef typename traits<Lhs>::XprKind XprKind;
-  enum { RowsAtCompileTime };
-  typedef float Scalar;
-};
-template <typename>
-class CwiseBinaryOpImpl;
-template <typename, typename, typename RhsType>
-class CwiseBinaryOp : public CwiseBinaryOpImpl<RhsType> {
- public:
-  typedef ref_selector::type LhsNested;
-  typedef RhsType RhsNested;
-  CwiseBinaryOp(const Matrix<float, 3, 1>& aLhs, RhsType& aRhs)
-      : m_lhs(aLhs), m_rhs(aRhs) {}
-  remove_reference<LhsNested>::type& lhs() { return m_lhs; }
-  typename remove_reference<RhsNested>::type& rhs() { return m_rhs; }
-  LhsNested m_lhs;
-  RhsNested m_rhs;
-};
-template <typename>
-class CwiseBinaryOpImpl
-    : public generic_xpr_base<CwiseBinaryOp<
-          scalar_product_op, const Matrix<float, 3, 1>,
-          const CwiseNullaryOp<scalar_constant_op<float>,
-                               const Matrix<float, 3, 1, 0, 2, 3>>>>::type {};
-template <typename NullaryOp, typename PlainObjectType>
-struct traits<CwiseNullaryOp<NullaryOp, PlainObjectType>>
-    : traits<PlainObjectType> {};
-template <typename, typename PlainObjectType>
-class CwiseNullaryOp
-    : public dense_xpr_base<CwiseNullaryOp<int, PlainObjectType>>::type {
- public:
-  CwiseNullaryOp(long rows, long, scalar_constant_op<float> func)
-      : m_functor(func) {
-    rows ? void() : __assert_fail("", "", 1, __PRETTY_FUNCTION__);
-  }
-  scalar_constant_op<float> functor() { return m_functor; }
-  scalar_constant_op<float> m_functor;
-};
-}  // namespace Eigen
-Eigen::Matrix<float, 3, 1> should_inline(float x, float y, float z,
-                                         float scale) {
-  return Eigen::Matrix<float, 3, 1>(x, y, z) * scale;
-}
-
-// We should inline everything to should_inline
-
-/* { dg-final { scan-tree-dump-times "Function" "optimized" } } */
-- 
cgit v1.1